JavaScript常见笔试题整理

已于 2022-12-12 15:46:00 修改
阅读量271 收藏
点赞数
文章标签： javascript 开发语言
于 2022-10-09 10:49:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33172017/article/details/127222641
版权

手写 快排实现

      const quickSort = (arr, low, high) => {
        if (low < high) {
          let par = partition(arr, low, high)
          quickSort(arr, low, par - 1) //注意下标起始，否则会造成死循环
          quickSort(arr, par + 1, high)
        }
        return arr
      }

      const partition = (arr, low, high) => {
        let pivot = arr[low]
        while (low < high) {
          while (arr[high] > pivot && high > low) {
            high--
          }
          arr[low] = arr[high]
          while (arr[low] <= pivot && high > low) {
            low++
          }
          arr[high] = arr[low]
        }
        arr[low] = pivot
        return low
      }

手写冒泡排序实现以及优化

      const bubbleSort = (arr) => {
        for (let j = 0; j < arr.length; j++) {
          let flag = false
          for (let i = 0; i < arr.length - 1 - j; i++) {
            if (arr[i] > arr[i + 1]) {
              flag = true
              let tmp = arr[i]
              arr[i] = arr[i + 1]
              arr[i + 1] = tmp
            }
          }
          if (!flag) break
        }
        return arr
      }

判断一颗树是否为搜索二叉树和完全二叉树

function judgeIt( root ) {
    let leftVal = Number.MIN_VALUE
    let rightVal = Number.MAX_VALUE
    let res  = []
    res[0] = searchTree(root,leftVal,rightVal)
    res[1] = CBT(root)
    return res
}

const searchTree = (root,leftVal,rightVal)=>{
    if(!root) return true
    if(root.val <= leftVal || root.val >= rightVal) return false
    return searchTree(root.left,leftVal,root.val) && searchTree(root.right,root.val,rightVal)
}

const CBT = (root)=>{
    if(!root) return true
    const queue = []
    let flag = false
    queue.push(root)
    while(queue.length){
        let tmp = queue.shift()
        let left = tmp.left
        let right = tmp.right
        if(!left && right) return false
        if(flag && !(!left && !right)) return false
        if(left) queue.push(left)
        if(right) queue.push(right)
        if(!flag && (!left || !right)) flag = true
    }
    return true
}

手写 instanceof 实现


      const myInstanceof = (A, B) => {
        let p1 = A._proto_
        let p2 = B.prototype
        while (true) {
          if (p1 == null) {
            return false
          }
          if (p1 == p2) {
            return true
          }
          p1 = p1._proto_
        }
      }

在这里插入图片描述

手写一个基于发布订阅模式的js事件处理中心(EventEmitter)

class EventEmitter {
  constructor() {
    this.events = {}
  }
  on = (event, callback) => {
    if (this.events[event]) {
      this.events[event].push(callback)
    } else {
      this.events[event] = [callback]
    }
  }
  off = (event, callback) => {
    const eventArr = this.events[event]
    eventArr.filter((name) => name != callback)
    this.events[event] = eventArr
  }
  once = (event, callback) => {
    function one() {
      callback.apply(this, arguments)
      this.off(event, one)
    }

    this.on(event, one)
  }

  emit = (event, arguments) => {
    this.events[event].forEach((callback) => {
      callback.apply(this, arguments)
    })
  }
}

手写render函数

  <body>
    <div id="text"></div>
  </body>
  <script>
    var vnode = {
      tag: 'ul',
      props: {
        class: 'list',
        on: {
          // 传入点击事件
          click: (e) => {
            console.log(e)
          },
        },
      },
      text: '',
      children: [
        {
          tag: 'li',
          props: {
            class: 'item',
          },
          text: '',
          children: [
            {
              tag: undefined,
              props: {},
              text: '牛客网',
              children: [],
            },
          ],
        },
        {
          tag: 'li',
          props: {},
          text: '',
          children: [
            {
              tag: undefined,
              props: {},
              text: 'nowcoder',
              children: [],
            },
          ],
        },
      ],
    }
    const _createElm = (vnode) => {
      const { tag, props, text, children } = vnode
      let node = document.createElement(tag)
      for (let prop in props) {
        if (prop === 'on') {
          let events = props[prop]
          for (let key in events) {
            node.addEventListener(key, (e) => {
              events[key](e)
            })
          }
        } else {
          node.setAttribute(prop, props[prop])
        }
      }
      node.innerHtml = text
      children.forEach((element) => {
        node.appendChild(_createElm(element))
      })
      return node
    }
    let text = document.querySelector('#text')
    text.appendChild(_createElm(vnode))
  </script>

手写lodash_get方法

    //手写lodash get 方法
    const object = { a: [{ b: { c: 3 } }] }
    const path = ['a', '0', 'b', 'c']

    function myGet(obj, path, defaultValue) {
      let res = obj
      path.forEach((k) => {
        let value = res[k]
        if (value) {
          res = value
        } else {
          res = defaultValue
        }
      })
      return res
    }
    console.log(myGet(object, path, 'NULL'))

手写call apply bind函数

    Function.prototype.myCall = function (context, ...args) {
      context = context === 'undefined' ? window : Object(context)
      let res = null
      let fn = Symbol()
      context[fn] = this
      res = context[fn](...args)
      delete context[fn]
      return res
    }

    Function.prototype.myApply = function (context, arguments) {
      context = context === 'undefined' ? window : Object(context)
      let res = null
      let fn = Symbol()
      context[fn] = this
      res = context[fn](...arguments)
      delete context[fn]
      return res
    }

      Function.prototype.myBind = function () {
        let arr = Array.prototype.slice.call(arguments)
        let self = arr.shift()
        let fn = this
        return function () {
          return fn.apply(self, arr)
        }
      }

手写节流防抖函数

// 防抖——事件触发的N秒时间后才执行回调

function debounce(fn, delay) {
  var timer
  return function () {
    let that = this
    let args = arguments
    if (timer) {
      clearTimeout(timer)
    }
    timer = setTimeout(function () {
      fn.apply(that, args)
    }, delay)
  }
}

//节流——事件触发的N秒内只执行一次

function throttle(fn, delay) {
  var timer
  return function () {
    let that = this
    let args = arguments
    if (timer) {
      return
    }
    timer = setTimeout(function () {
      fn.apply(that, args)
      timer = null
    }, delay)
  }
}

手写AJAX

  • axio是对XMLHttpRequest的封装，需要引入axios库
  • fetch是一种新的获取接口资源的方式，原生浏览器支持
  • axios总体优于fetch
    //ajax简易写法
    function ajax1(url) {
      const request = new XMLHttpRequest()
      request.open('GET', url)
      request.onreadystatechange = function () {
        if (request.readyState === 4) {
          if (request.status >= 200 && request.status < 300) {
            let res = request.responseText()
            return JSON.parse(res)
          }
        }
      }
      request.send()
    }

    //ajax promise封装
    function ajax2(url) {
      return new Promise((resolve, reject) => {
        const xhr = new XMLHttpRequest()
        xhr.open('GET', url)
        xhr.onreadystatechange = () => {
          if (xhr.readyState !== 4) return
          if (xhr.status >= 200 && xhr.status < 300) {
            resolve(xhr.response)
          } else {
            reject(new Error(xhr.response))
          }
        }
        xhr.send()
      })
    }

手写promise

    class MyPromise {
      constructor(func) {
        this.value = null
        this.error = null
        this.status = 'pending'
        this.resolveStacks = []
        this.rejectStacks = []
        try {
          func(this.resolve, this.reject)
        } catch (error) {
          this.reject(error)
        }
      }
      resolve = (value) => {
        if (this.status === 'pending') {
          this.status = 'fulfilled'
          this.value = value
          this.resolveStacks.forEach((cb) => cb())
        }
      }
      reject = (error) => {
        if (this.status === 'pending') {
          this.status = 'rejected'
          this.error = error
          this.rejectStacks.forEach((cb) => cb())
        }
      }
      then = (onFulfilled, onRejected) => {
        return new MyPromise((resolve, reject) => {
          onFulfilled =
            typeof onFulfilled === 'function' ? onFulfilled : () => {}
          onRejected = typeof onRejected === 'function' ? onRejected : () => {}
          if (this.status === 'pending') {
            this.resolveStacks.push(() => {
              onFulfilled(this.value)
            })
            this.rejectStacks.push(() => {
              onRejected(this.error)
            })
          }
          if (this.status === 'fulfilled') {
            onFulfilled(this.value)
          }
          if (this.status === 'rejected') {
            onRejected(this.error)
          }
        })
      }
    }

    const promise = new MyPromise((resolve, reject) => {
      setTimeout(() => {
        resolve('成功')
      }, 1000)
    })
    promise.then((data) => {
      console.log(data)
    })

手写promise.all promise.race

    let promise1 = new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve(0)
      }, 0)
    })
    let promise2 = new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve(1)
      }, 1000)
    })
    let promise3 = new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve(2)
      }, 2000)
    })
    let promise4 = new Promise((resolve, reject) => {
      reject('error')
    })

    Promise.myAll = (arr) => {
      return new Promise((resolve, reject) => {
        let res = []
        if (!arr.length) {
          resolve(res)
        } else {
          let count = 0
          for (let i = 0; i < arr.length; i++) {
            Promise.resolve(arr[i]).then(
              (data) => {
                res[i] = data
                if (count++ === arr.length - 1) {
                  resolve(res)
                }
              },
              (err) => {
                reject(err)
              }
            )
          }
        }
      })
    }

    Promise.myRace = (arr) => {
      return new Promise((resolve, reject) => {
        if (!arr.length) {
          resolve([])
        } else {
          for (let i = 0; i < arr.length; i++) {
            Promise.resolve(arr[i]).then(
              (data) => {
                resolve(data)
              },
              (err) => {
                reject(err)
              }
            )
          }
        }
      })
    }

    let arr = [promise1, promise2, promise3, promise4, 4]
    Promise.myAll(arr)
      .then((data) => {
        console.log(data)
      })
      .catch((err) => {
        console.log(err)
      })
    Promise.myRace(arr)
      .then((data) => {
        console.log(data)
      })
      .catch((err) => {
        console.log(err)
      })

promise js事件循环执行顺序

const promise = new Promise((resolve,reject)=>{
    console.log(1);
    resolve();
    console.log(2);
    reject()
})
setTimeout(()=>{console.log(5)},0)
promise.then(()=>{console.log(3)})
.then(()=>{console.log(6)})
.catch(()=>{console.log(7)})
console.log(4)

// 1 2 4 3 6 5

const first = () => (new Promise((resolve, reject) => {
    console.log(3);
    let p = new Promise((resolve, reject) => {
        console.log(7);
        setTimeout(() => {
            console.log(5);
            resolve();
        }, 0);
        resolve(1);
    });
    resolve(2);
    p.then((arg) => {
        console.log(arg);
    });
}));
first().then((arg) => {
    console.log(arg);
});
console.log(4);


//3 7 4 1 2 5

console.log(1);
new Promise(resolve => {
    resolve();
    console.log(2);
}).then(() => {
    console.log(3);
})
setTimeout(() => {
    console.log(4);
}, 0);
console.log(5);
// 1 2 5 3 4

Promise.resolve()
.then(() => {
    console.log('1');
})
.then(() => {
    console.log('2');
});


setTimeout(() => {
    Promise.resolve()
    .then(() => {
        console.log('3');
    })
    .then(() => {
        console.log('4');
    });
    setInterval(() => {
        console.log('5');
    }, 3000);
    console.log('6');
}, 0);

//1 2 6 3 4 5 5...

setTimeout(function() {
    console.log(1);
}, 0);
console.log(2);
async function s1() {
    console.log(7)
    await s2();
    console.log(8);
}
asycn function s2() {
    console.log(9);
}
s1();
new Promise((resolve, reject) => {
    console.log(3);
    resolve();
    console.log(6);
}).then(() => console.log(4))
console.log(5);

//2 7 9 3 6 5 8 4 1

手写 setTimeout实现

      const mySetTimeout = (fn, timeout, arguments) => {
        let start = new Date()
        const loop = () => {
          let now = new Date()
          let timer = window.requestAnimationFrame(loop)
          if (now - start >= timeout) {
            fn.apply(this, arguments)
            window.cancelAnimationFrame(timer)
          }
        }
        window.requestAnimationFrame(loop)
      }

      function showName() {
        console.log('Hello')
      }
      let timerID = mySetTimeout(showName, 1000)

      //注：这种写法会造成主线程死锁，不建议
      // const mySetTimeout = (fn, timeout, arguments) => {
      //   const start = new Date()
      //   while (1) {
      //     if (new Date() - start >= timeout) {
      //       fn.apply(this, arguments)
      //       break
      //     }
      //   }
      // }

数组扁平化

      arr = [1, [2, [3, [4]]]]

      const _flatten1 = function (arr) {
        return arr
          .toString()
          .split(',')
          .map((item) => {
            Number(item)
          })
      }
      const _flatten2 = function (arr) {
        let res = []
        for (let item of arr) {
          if (Array.isArray(item)) {
            res = res.concat(_flatten2(item))
          } else {
            res = res.concat(item)
          }
        }
        return res
      }
      const _flatten3 = function (arr) {
        return arr.reduce((pre, cur) => {
          return pre.concat(Array.isArray(cur) ? _flatten3(cur) : cur)
        }, [])
      }

不产生新数组删除原数组中的重复数字

      const remove = (arr) => {
        for (let i = 0; i < arr.length; i++) {
          if (arr.indexOf(arr[i]) !== i) {
            arr.splice(i, 1)
            i--
          }
        }
        return arr
      }

翻转字符串里的单词

      const strReverse = (str) => {
        let left = 0,
          right = str.length - 1
        let res = []
        let tmp = ''
        while (str.charAt(left) === ' ') left++
        while (str.charAt(right) === ' ') right--
        while (left <= right) {
          if (str.charAt(left) === ' ' && tmp !== '') {
            res.unshift(tmp)
            tmp = ''
          } else if (str.charAt(left) !== ' ') {
            tmp += str.charAt(left)
          }
          left++
        }
        res.unshift(tmp)
        return res.join(' ')
      }
      let str = ' hello   world! Bye'
      console.log(strReverse(str))

实现单例模式并实现一个单例的注册弹窗

  <body>
    <button id="but">login</button>
  </body>
  <script>
    
    function SingleTon(name) {
      this.name = name
    }
    SingleTon.prototype.getName = function () {
      console.log(this.name)
    }
    const getInstance = (function () {
      var instance
      return function (name) {
        if (!instance) {
          instance = new SingleTon(name)
        }
        return instance
      }
    })()
    const a = getInstance('a')
    const b = getInstance('b')
    console.log(a === b)

    document.getElementById('but').onclick = function () {
      let div = createSingle()
    }
    function createDiv() {
      let div = document.createElement('div')
      div.innerHTML = 'LOGIN'
      document.body.appendChild(div)
      return div
    }

    function getSingle(fn) {
      var result
      return function () {
        if (!result) {
          result = fn.apply(this, arguments)
        }
        return result
      }
    }
    let createSingle = getSingle(createDiv)

继承方式整理

原型链继承

      //原型链继承
      function Father() {
        this.name = 'father'
        this.nums = [1, 2]
        this.sayHi = function () {
          console.log('hi')
        }
      }
      function Son() {
        this.name = 'son'
        this.sayBye = function () {
          console.log('bye')
        }
      }

      Son.prototype = new Father()
      let son1 = new Son()
      console.log(son1.name) //son
      son1.sayHi() //hi
      son1.sayBye() //bye

      //缺点 1：原型中包含的引用值在实例中共享
      //2：子类型在实例时不能传参
      son1.nums.push(3)
      let son2 = new Son()
      console.log(son1.nums, son2.nums) //[1,2,3][1,2,3]

构造函数继承

    // 构造函数继承
      function Father(name) {
        this.name = 'father'
        this.nums = [1, 2]
        this.sayHi = function () {
          console.log('hi')
        }
      }
      function Son() {
        Father.call(this)
      }
      let son1 = new Son()
      son1.nums.push(3)
      let son2 = new Son()
      console.log(son1.nums, son2.nums) //[1,2,3][1,2]
      //优点：1.解决了原型中的引用值在实例中共享的问题。2.子类型在实例时可传参
      //缺点：1.方式必须在构造函数中定义

组合继承

     //组合继承
      function Father(name) {
        this.name = name
        this.nums = [1, 2]
      }
      Father.prototype.sayHi = function () {
        console.log('hi')
      }
      function Son(name, age) {
        Father.call(this, name)
        this.age = age
      }
      Son.prototype = new Father()
      Son.prototype.sayBye = function () {
        console.log('bye')
      }
      //优点：1.通过原型链继承原型上的属性和方法。2.通过构造函数继承实例属性
      //缺点：继承过程中父类构造函数会执行两次，子类实例和子类原型对象会存在两个相同的属性
      let son1 = new Son('A', 3)
      let son2 = new Son('B', 4)
      son1.nums.push(3)
      console.log(son1.nums, son2.nums) //[1,2,3] [1,2]
      son1.sayBye() //bye
      son1.sayHi() //hi

寄生式组合继承

      //寄生式组合继承
      //优化思路：不通过父类构造函数给子类原型赋值
      function Father(name) {
        this.name = name
        this.nums = [1, 2]
      }
      function Son(name, age) {
        Father.call(this, name)
        this.age = age
      }
      Father.prototype.sayHi = function () {
        console.log('hi')
      }

      // let F = function () {}
      // F.prototype = Father.prototype
      // Son.prototype = new F()
      //封装
      function inheritPrototype(Son, Father) {
        let prototype = Object(Father.prototype)
        prototype.constructor = Son
        Son.prototype = prototype
      }
      inheritPrototype(Son, Father)

      Son.prototype.sayBye = function () {
        console.log('bye')
      }

      let son1 = new Son('A', 3)
      console.log(son1)

类继承

      //类继承
      class Father {
        constructor(name) {
          this.name = name
          this.nums = [1, 2]
        }
        sayHi() {
          console.log('hi')
        }
      }
      class Son extends Father {
        constructor(name, age) {
          super(name)
          this.age = age
        }
        sayBye() {
          console.log('bye')
        }
      }
      let son1 = new Son('A', 3)
      console.log(son1)

CSS实现一个三角形

  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
    <style>
      #triangle {
        width: 0px;
        height: 0px;
        border: 40px solid transparent;
        border-bottom: 80px solid red;
      }
    </style>
  </head>
  <body>
    <div id="triangle"></div>
  </body>
suuuuuki98
关注
最新前端常见笔试题整理
weixin_30537451的博客
04-02 142
1写出五大主流浏览器的内核名称 　　Trident(IE浏览器)，Gecko(firefox：火狐浏览器)，webkit（safari,曾经的chrome），Presto（opera浏览器），blink（现今的chrome） 2 JSON数据与JS对象的区别 　　JSON （JavaScript Object Notation）一种简单的数据格式，JSON的属性名必须有双引号，如果值是字符...
常见C++笔试面试题整理
热门推荐
ljh0302的专栏
07-19 9万+
1、C和C++的区别 1）C是面向过程的语言，是一个结构化的语言，考虑如何通过一个过程对输入进行处理得到输出；C++是面向对象的语言，主要特征是“封装、继承和多态”。封装隐藏了实现细节，使得代码模块化；派生类可以继承父类的数据和方法，扩展了已经存在的模块，实现了代码重用；多态则是“一个接口，多种实现”，通过派生类重写父类的虚函数，实现了接口的重用。 2）C和C++动态管理内存的方法不一样，C是...
JavaScript笔试知识点整理
m0_38021769的博客
11-15 249
JavaScript笔试知识点整理 2018.09.28 定义函数 在Javascript定义一个函数f有三种方式：第1种最常用,后两种都是把一个匿名函数复制给变量f 函数关键字: function f(x){ alert(x); } 函数字面量： var f = function(x){ alert(x); } 构造函数： var f = new Function(‘x’, ‘aler...
2023前端面试题整理总结~
LJJONESEED的博客
08-13 3万+
前端面试题
web前端常见面试题整理(JS)
kksw1121
05-29 1288
JS 1.JS基本数据类型 Number String boolean null undefined Object null类型进行typeof操作符后，结果是object，原因在于，null类型被当做一个空对象引用。 2.typeof的返回值类型 number：NaN boolean string undefined：undefined 不存在的变量 object：对象，数组，null Function：Array Date symbol：typeof Symbol() // ES6提供的新的类型 3.
jQuery面试笔试题汇总整理
Boboy
03-04 2万+
1、你为什么要使用jQuery？你觉得jquery有哪些好处？ 1、因为jQuery是轻量级的框架，大小不到30kb 2、它有强大的选择器，出色的DOM操作的封装 3、有可靠的事件处理机制(jQuery在处理事件绑定的时候相当的可靠) 4、完善的ajax(它的ajax封装的非常的好，不需要考虑复杂浏览器的兼容性和XMLHttpRequest对象的创建和使用的问题。) 5、出色的浏览器的兼容性 6...
JavaScript基础，持续更新大厂面试笔试题
m0_58397123的博客
04-21 716
整理面试题，不是让大家去只刷面试题，而是熟悉目前实际面试中常见的考察方式和知识点，做到心中有数，也可以用来自查及完善知识体系。《前端基础面试题》，《前端校招面试题精编解析大全》，《前端面试题宝典》，《前端面试题：常用算法》网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注前端）一个人可以走的很快，但一群人才能走的更远！
2024年Javascript最常见的面试题以及答案
2301_82243626的博客
04-28 792
原型链是就是实例对象在查找属性时，如果查找不到，就会沿着__proto__去与对象关联的原型上查找，有则返回，如果找不到，就去找原型的原型，直至查到最顶层Object函数的原型，其原型对象的_proto__已经没有可以指向的上层原型，因此其值为null，返回undefind;就是对象的浅拷贝只会对“主”对象进行拷贝，拷贝的是对象属性的基本类型的值，如果属性是引用类型，拷贝的就是内存地址，拷贝的不深，所以称为浅拷贝；函数作用域就是在函数内部定义的变量或者函数，并且定义的变量或者函数只能在函数内部被访问。
web前端笔试题整合
ass_ace
12-13 1915
1.一个200 * 200的格在不同分辨率屏幕上下左右居中，用CSS实现 div{ width: 200px; height: 200px; background-color: red; position:absolute; top:50%; ...
(完整word版)javascript笔试题参考整理(答案).doc
11-17
这份文档整理了关于JavaScript的一些常见笔试题目及答案，涵盖了基础语法、DOM操作、事件处理、对象属性等多个方面。 1. **获取窗口位置**：在IE浏览器中，要获取当前窗口的位置，可以使用`window`对象的`...
IT公司面试笔试题库-腾讯Javascript面试题.doc
06-27
根据提供的文档内容，我们可以整理出一系列与JavaScript相关的面试题及其解析。这些题目涵盖了JavaScript的基础概念、变量作用域、事件处理、函数定义、数据类型检查、运算符比较等多个方面。接下来，我们将逐一分析...
HPH笔试题整理
07-20
在32位系统上的MySQL 5.0+，常见字段类型的字节数和最大范围如下： - `int`：4字节，无符号范围0到4294967295，有符号范围-2147483648到2147483647。 - `bigint`：8字节，无符号范围0到18446744073709551615，有符号...
跟着尚硅谷学vue2—进阶版2.0—使用 Vue 脚手架1.0
zhzijun的博客
11-13 410
分析脚手架 、ref和props、mixin混入、插件、scoped样式、总结TodoList案例、浏览器本地存储-webStorage、TodoList_本地存储
Javascript中Map与Set以及其常见遍历方式
警警的博客
11-12 746
在JavaScript中，Map和Set是两种非常重要的集合类型，它们提供了比传统对象（Object）和数组（Array）更强大和灵活的数据存储和操作方法。下面是对Map和Set的详细解释。
解决@ant-design-vue/nuxt模块加载到许多没用到的组件，影响开发下加载速度的问题
清晰编程
11-12 154
升级命令：npm up @ant-design-vue/nuxt。解决方法：将该模块版本升级到1.4.6。
Vue中的常用指令
m0_62388400的博客
11-12 1144
指令（Directives）是 Vue 提供的带有的 特殊 标签。为啥要学：提高程序员操作 DOM 的效率。vue 中的指令按照不同的用途可以分为如下 6 大类：内容渲染指令（v-html、v-text）条件渲染指令（v-show、v-if、v-else、v-else-if）事件绑定指令（v-on）属性绑定指令 （v-bind）双向绑定指令（v-model）列表渲染指令（v-for）指令是 vue 开发中最基础、最常用、最简单的知识点。
从零开始快速构建Vue3项目
欧唯薇
11-13 694
是目前最推荐的方式来创建 Vue 3 项目，因为它速度快，配置简洁，并且是 Vue 3 的官方推荐工具。打开浏览器并访问 `http://localhost:5173`，你将看到一个基本的 Vue 3 应用程序运行。1、若需要使用不同版本node（兼容新旧项目环境），则需要使用nvm来进行node多版本管理，下载并安装。2、若出现某个依赖安装报错，可以npm install --ignore-scripts，最后再来单独安装报错的依赖。
Vue常用加密方式
m0_51431448的博客
11-13 95
消息摘要是从原始数据中通过特定算法计算出的一个固定长度的字符串，这个过程通常被称为哈希函数或散列函数。固定长度：无论输入的数据有多大，输出的消息摘要都有固定的长度。唯一性：理想情况下，不同的输入应该产生不同的消息摘要，虽然在现实中由于哈希碰撞的存在，这并不总是可能的。不可逆性：从消息摘要不能反推出原始数据。高效性：计算消息摘要的过程应该是快速且高效的。
Nuxt2和Nuxt3 对于SEO优化的区别
最新发布
书山有路_邓
11-14 332
nuxt
JavaScript笔试与面试题解析
这份笔试题涵盖了JavaScript的基础语法、对象操作、数组方法、DOM操作和窗口交互等重要知识点，是学习和复习JavaScript基础知识的好资料。在准备面试或自我提升时，理解和掌握这些内容对于成为一名合格的JavaScript...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值