vue面试题

面试录音

js为什么会产生变量提升

JavaScript 产生变量提升的原因可以追溯到它的早期设计和语言规范。在JavaScript中，代码执行分为两个阶段：预解析（Preparation） 和 执行（Execution）。

在预解析阶段，JavaScript引擎会做以下两件事：

创建作用域 ：确定变量和函数的作用域，这包括在当前作用域内查找并声明所有的变量和函数。JavaScript 只有两种作用域：全局作用域和函数作用域（ES6引入的块级作用域除外，例如 let 和 const 声明的变量不遵循这个规则）。
变量和函数声明的提升 ：在这个阶段，引擎会将所有的变量声明（var、let、const）和函数声明（function）提升到它们所在的作用域的顶部。这就是所谓的"提升"。

之所以这样做，是因为JavaScript的设计者希望在代码的任何位置都能够安全地使用变量和函数的声明，即使这些声明位于它们实际被定义的位置之前。这种设计允许开发者在函数体的任何地方声明函数，而该函数在整个函数体内都是可用的。

然而，这种行为对于变量特别是使用 var 声明的变量可能会导致一些混淆，因为它们的赋值操作并不会被提升。这就意味着虽然变量的声明被提升到了作用域顶部，但赋值仍然保持在原地，这可能导致意外的结果。

例如：

javascriptconsole.log(x); // 输出 undefined，而不是报错
var x = 5;

在这个例子中，var x 被提升了，所以变量 x 在作用域中是已声明的，但它的赋值 5 仍然留在原处，因此在 console.log 时，x 的值是 undefined。

随着ES6的引入，let 和 const 的出现提供了块级作用域，并且它们不会被提升，而是遵循暂时性死区（Temporal Dead Zone, TDZ）的概念，这有助于减少因变量提升导致的错误和混淆。

箭头函数和普通函数有什么区别

箭头函数和普通函数（也称为函数表达式或function关键字定义的函数）在JavaScript中有几个关键区别，主要包括以下几个方面：

this 关键字 ：
- 普通函数 ：this 在普通函数中是动态绑定的，取决于函数是如何被调用的。通常，在非严格模式下，如果函数作为对象的方法被调用，this 指向那个对象；在全局环境中，this 指向全局对象（在浏览器中通常是 window 或 global）；在严格模式下，this 不会默认指向全局对象。
- 箭头函数 ：箭头函数没有自己的 this，它会捕获其所在（即定义时）的作用域的 this 值。这意味着箭头函数不能用作对象的方法，因为它们不会像普通函数那样在调用时改变 this。
函数体 ：
- 普通函数 ：函数体通常使用 function 关键字开始，然后是函数名（可选），参数列表，然后是一个花括号 {} 包裹的代码块。
- 箭头函数 ：函数体可以非常简洁。如果只有一个参数，圆括号可以省略；如果函数体只有一条语句，花括号也可以省略。例如，param => expression 或 (params) => { statements }。
返回值 ：
- 普通函数 ：需要使用 return 关键字来返回一个值。
- 箭头函数 ：如果函数体只有一条返回语句，可以省略 return 关键字，直接返回表达式的值。
构造函数 ：
- 普通函数 ：可以用 new 关键字来实例化对象。
- 箭头函数 ：不能用 new 关键字来实例化，因为它们没有自己的 prototype。
arguments 对象 ：
- 普通函数 ：拥有一个内置的 arguments 对象，可以访问所有传入的参数。
- 箭头函数 ：没有自己的 arguments 对象，但可以通过剩余参数语法 ...args 来获取传入的参数。

这些差异使得箭头函数在某些情况下更简洁，但在处理涉及 this 绑定的场景时需要特别注意，因为它们的行为与普通函数不同。在选择使用哪种类型的函数时，开发者应根据具体的需求来决定。

改变this指向的方式有哪些

在JavaScript中，改变函数内部的 this 指向有几种常见的方法，每种方法适用于不同的场景：

.call() 和 .apply() 方法 :
- 这两个方法允许你指定函数的 this 值，并立即调用函数。
- .call(thisArg, arg1, arg2, ...) 直接传递参数。
- .apply(thisArg, [argsArray]) 第二个参数是一个数组或类数组对象，表示传递给函数的参数列表。
.bind() 方法 :
- bind(thisArg[, arg1[, arg2[, ...]]]) 创建一个新的函数，当这个新函数被调用时，其 this 值被固定为传给 bind 的第一个参数，后面的参数则作为新函数的初始参数。
- 这对于需要传递特定上下文给事件处理器或其他回调函数非常有用。
箭头函数 :
- 箭头函数不会创建自己的 this 上下文，它会从外层作用域继承 this 的值。这是改变 this 指向的一种间接方式，因为它避免了传统函数中 this 的复杂行为。
使用闭包 :
- 通过闭包可以在内部函数中访问外部函数的 this，从而间接控制 this 的指向。
构造函数中的 new 关键字 :
- 当使用 new 调用函数时，会自动创建一个新的对象，并将其绑定为该函数内部的 this。
对象的方法 :
- 在对象字面量或原型链上的方法，默认的 this 指向该对象，除非被上述方法改变。
事件监听器 :
- 在某些情况下，如为DOM元素添加事件监听器时，可以使用 addEventListener 的第三个参数 useCapture（不是直接改变 this，但可以通过这个特性确保在事件处理函数中 this 是预期的对象）。

了解并熟练掌握这些方法对于编写复杂的JavaScript代码非常重要，尤其是在处理对象方法、事件处理和异步编程时。

常用的js数组方法有哪些呢

改变自身的方法
	pop
	push
	reverse
	shift
	sort
	splice
	unshift
	es6
		copyWithin
		fill
不改变自身的方法
	concat
	join
	slice
	toString
	toLocaleString
	indexOf
	lastIndexOf
	includes

数组遍历的方法
	不会改变自身的遍历方法
		forEach
			不会返回处理之后的数组
		every
		some
		filter
			会返回处理之后的数组
		map
		reduce
		reduceRight
		ES6
			entries
			find
			findIndex
			keys
			values

js数组长度为10，删除比如第五个怎么办

在JavaScript中，如果你有一个数组，长度为10，想要删除某个特定位置的元素（比如第五个元素），有几种方法可以实现。这里以删除第五个元素为例：

使用 splice() 方法：

javascript let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
arr.splice(4, 1); // 删除索引为4的元素，即第五个元素
console.log(arr); // 输出: [1, 2, 3, 4, 6, 7, 8, 9, 10]

splice() 方法接受两个参数，第一个是开始删除的位置，第二个是要删除的元素个数。

使用 filter() 方法：

javascript let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
arr = arr.filter((value, index) => index !== 4); // 删除索引为4的元素
console.log(arr); // 输出: [1, 2, 3, 4, 6, 7, 8, 9, 10]

filter() 方法创建一个新的数组，包含所有使回调函数返回 true 的元素。

使用 slice() 和 concat() 方法：

javascript let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
arr = arr.slice(0, 4).concat(arr.slice(5, arr.length));
console.log(arr); // 输出: [1, 2, 3, 4, 6, 7, 8, 9, 10]

这里先用 slice() 获取删除点之前的元素，再获取删除点之后的元素，然后使用 concat() 合并这两个部分。

使用 delete 关键字：

javascript let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
delete arr[4]; // 删除索引为4的元素
arr = Array.from(arr); // 转换为新的数组，因为delete不会改变数组长度
console.log(arr); // 输出: [1, 2, 3, 4, undefined × 1, 6, 7, 8, 9, 10]

使用 delete 关键字会删除元素，但不会调整数组长度，因此需要额外的转换来清理数组。

请注意，删除元素后，原数组的长度不会自动更新，需要手动处理或者使用新的数组。在JavaScript中，数组的长度是基于数组中存在的非undefined值来计算的，所以在使用 delete 后，数组的长度不会变，但会有空位。

字符串转换为数组

在JavaScript中，将字符串转换为数组有几种方法。以下是常用的方法：

使用 split() 方法：

javascript let str = "exampleString";
let arr = str.split(""); // 分割字符串，每个字符作为一个元素
console.log(arr); // 输出: ["e", "x", "a", "m", "p", "l", "e", "S", "t", "r", "i", "n", "g"]

split() 方法将字符串分割成子字符串，并将结果放在一个数组中。如果不提供参数，它默认使用空字符串 "" 作为分隔符，这样每个字符就会成为一个单独的元素。

使用扩展运算符 ...：

javascript let str = "exampleString";
let arr = [...str];
console.log(arr); // 输出: ["e", "x", "a", "m", "p", "l", "e", "S", "t", "r", "i", "n", "g"]

扩展运算符可以从可迭代对象（如字符串）创建一个数组。

使用 Array.from() 方法：

javascript let str = "exampleString";
let arr = Array.from(str);
console.log(arr); // 输出: ["e", "x", "a", "m", "p", "l", "e", "S", "t", "r", "i", "n", "g"]

Array.from() 方法从可迭代对象或类数组对象创建一个新的数组实例。

使用 Object.assign() 方法：

javascript let str = "exampleString";
let arr = Object.assign([], str);
console.log(arr); // 输出: ["e", "x", "a", "m", "p", "l", "e", "S", "t", "r", "i", "n", "g"]

Object.assign() 方法用于将一个或多个源对象的属性复制到目标对象。在这种情况下，字符串被视为类数组对象，因此可以复制到数组中。

这些方法都可以将字符串转换为数组，根据具体情况和需求选择合适的方法。

数组转字符串

在JavaScript中，将数组转换为字符串可以使用以下几种方法：

使用 toString() 方法：

javascript let arr = [1, 2, 3];
let str = arr.toString(); // 默认使用逗号分隔每个元素
console.log(str); // 输出: "1,2,3"
使用 join() 方法：

js 复制代码

javascript   let arr = [1, 2, 3];
   let str = arr.join(", "); // 可以指定分隔符
   console.log(str); // 输出: "1, 2, 3"

join() 方法允许你指定一个字符串作为数组元素之间的分隔符。如果不提供参数，它默认使用逗号作为分隔符。

使用 JSON.stringify() 方法：

javascript let arr = [1, 2, 3];
let str = JSON.stringify(arr); // 将数组转换为JSON格式的字符串
console.log(str); // 输出: "[1,2,3]"

这个方法将数组转换为JSON字符串，常用于数据序列化，它会在元素间添加双引号，并且整个数组包裹在方括号中。

循环遍历数组手动拼接：

javascript let arr = [1, 2, 3];
let str = "";
for(let i = 0; i < arr.length; i++) {
str += arr[i] + (i < arr.length - 1 ? ", " : "");
}
console.log(str); // 输出: "1, 2, 3"

这种方法更加灵活，可以根据需要自定义分隔符和格式。

根据你的具体需求，可以选择最适合的方法来将数组转换为字符串。

什么是类数组

arguments
HTMLCollection
NodeList

怎么转化为数组

类数组借用数组方法转数组
ES6 的方法对象转数组
	Array.from
	展开运算符

ES6的promise是用来做什么的

promise是怎么解决回调地狱问题的

promise系统学习

promise的链式调用是怎么实现的

promise的错误捕获有几种方式

Promise 的错误捕获通常有以下几种方式：

.catch() 方法

：
- 当Promise链中的Promise被拒绝时，.catch() 方法会被调用，用于处理错误。它是链式调用的一部分，可以捕获前面所有Promise中抛出的错误。
javascript promise
.then(result => {
// 处理成功情况
})
.catch(error => {
// 处理错误情况
});
.then() 的第二个参数

：
- 除了.catch()，你也可以在.then()方法中提供第二个参数来捕获错误。
javascript promise
.then(result => {
// 成功处理
}, error => {
// 错误处理
});
全局未捕获错误监听

：
- 可以监听全局的 unhandledrejection 事件来捕获那些未被任何.catch()处理的Promise拒绝错误。
javascript // Node.js
process.on('unhandledRejection', (reason, promise) => {
// 处理未捕获的Promise拒绝
});
```
// 浏览器
window.addEventListener('unhandledrejection', function(event) {
  // 阻止默认行为以防止页面崩溃
  event.preventDefault();
  // 处理错误
  console.error('Promise rejection:', event.reason);
});
```
async/await 结合try-catch

：
- 当使用async函数时，可以使用传统的try-catch语句来捕获Promise中的错误。
javascript async function myAsyncFunction() {
try {
await somePromise();
} catch (error) {
console.error('Error:', error);
}
}
Promise.allSettled()

：
- Promise.allSettled() 返回一个Promise，当所有输入的Promise都已解决（resolve或reject）时，无论结果如何，都会解决。这使得可以在同一处处理所有的结果，包括错误。
javascript Promise.allSettled(promises)
.then(results => {
results.forEach(result => {
if (result.status === 'fulfilled') {
// 处理成功情况
} else if (result.status === 'rejected') {
// 处理错误情况
}
});
});

通过这些方法，开发者可以确保Promise的错误得到适当的处理，避免未捕获的错误导致程序中断。

promise的all和promise的race有什么区别

vue的watch和computed有什么区别

Vue中的watch和computed都是用来响应式地处理数据变化的工具，但它们之间存在一些核心差异：

目的与使用场景 ：
- computed：主要用于计算属性，即基于其他数据（通常是响应式依赖，如data中的属性或props）计算出一个新值。这个新值会被缓存起来，只有当依赖的数据变化时，才会重新计算。它适用于任何不需要异步操作且结果能被缓存的计算场景。
- watch：主要用于执行副作用或处理数据变化后的逻辑，特别是当数据变化需要执行异步操作或较为复杂的操作时。它不提供缓存机制，每次依赖的数据变化时，都会触发相应的函数执行。
缓存与性能 ：
- computed：具有缓存功能，只在依赖发生变化时计算，提高性能。
- watch：不带缓存，每次依赖变化时都会执行，可能导致性能开销较大，尤其是处理高频变化的数据时。
执行时机 ：
- computed：在初始化时以及依赖数据变化时计算。
- watch ：默认在数据变化后的下一个Vue事件循环中执行，可以通过设置immediate: true使其在初始渲染时立即执行。
异步支持 ：
- computed：不适合处理异步操作，因为它依赖于同步的getter/setter逻辑。
- watch：非常适合处理异步操作，可以在回调函数中执行异步逻辑。
写法：
- computed：定义为对象的属性形式，包含get和可选的set方法。
- watch：定义为对象，键为要观察的属性名，值为处理函数。

总结来说，如果你需要一个依赖其他数据并能自动更新的值（且该值可以被缓存），应使用computed。如果你需要在数据变化时执行某些操作，特别是这些操作涉及异步逻辑或复杂的业务逻辑时，应使用watch。

computed的缓存是怎么实现的

Vue.js的computed属性的缓存机制是基于依赖跟踪和观察者模式实现的。具体实现细节如下：

依赖收集：Vue在初始化组件时，会遍历所有的computed属性。当计算属性的getter被访问时，Vue会追踪依赖，记录下该计算属性依赖的所有响应式数据（通常是data中的属性）。这是通过代理和getter/setter机制实现的，Vue为data中的每个属性都设置了访问器属性，从而能够监视属性的访问和修改。
缓存机制：对于每个computed属性，Vue内部维护了一个缓存对象，用于存储计算结果。当计算属性首次被访问时，其getter函数会被执行，并且计算结果会被存储在缓存中。
依赖变化检测：Vue会为每个响应式数据设置变更监听器（Watcher）。一旦这些依赖的数据发生变化，Vue会知道哪些计算属性的依赖被改变了。此时，Vue会标记这些计算属性为"脏"状态。
重计算：在下一个事件循环中，Vue会检查标记为"脏"的计算属性，并重新执行其getter函数以更新缓存，但只有当依赖的数据确实发生变化时才会这样做。
避免重复计算：如果依赖的数据没有变化，即使再次访问同一个computed属性，Vue也会直接从缓存中返回之前计算的结果，而不会再次执行getter函数，这就是computed属性的缓存效果。
依赖丢失：当一个依赖被删除或不再被使用时，Vue的响应系统也会相应地清理这些不再使用的依赖，以避免内存泄漏。

这种机制使得computed属性非常适合用于计算衍生数据，因为它保证了只要依赖的数据没有变化，计算属性的值就不会变，从而减少了不必要的计算，提升了应用的性能。

watch为什么会支持异步呢

Vue的watch支持异步是因为它的设计允许在数据变化时执行更复杂的逻辑，包括但不限于异步操作。在实际应用中，我们经常需要在数据变化后进行一些后台请求、延迟操作、状态更新等，这些操作很多时候是异步的。例如，你可能希望在用户输入改变后延迟发送搜索请求，或者在某个数据更新后执行一系列网络调用。

Vue的watch允许你定义一个处理函数，这个函数可以是异步的，比如使用async/await或者返回一个Promise。这样做的好处是，Vue会在数据变化时调用这个处理函数，即使这个函数需要一段时间来完成（比如等待网络响应），Vue的响应式系统会等待这个异步操作完成。这意味着你可以编写更加灵活和复杂的逻辑来响应数据的变化，而不必担心立即返回结果的压力。

例如，下面是一个简单的异步watch使用示例：

javascriptwatch: {
  someData(newVal, oldVal) {
    async function fetchData() {
      // 假设这里有一个异步操作，比如API请求
      const response = await axios.get('/some-api');
      // 根据响应做一些处理
      console.log(response.data);
    }
    fetchData();
  },
}

在Vue中，异步watcher的执行是通过事件循环机制安排在下一个tick中进行的，确保DOM已经在数据变化后进行了更新，然后再执行异步回调，这样可以保证UI的一致性和正确的执行顺序。

vue组件通信方式

Vue.js 提供了多种组件间通信的方式，以适应不同的应用场景。以下是Vue中常见的组件通信方式：

Props（父组件向子组件传递数据）: 最基本的通信方式，父组件通过属性向子组件传递数据。子组件通过props选项声明它预期接收的数据。
**KaTeX parse error: Expected 'EOF', got '&' at position 6: emit &̲ 自定义事件**（子组件向父组...emit`触发一个自定义事件，并传递数据，父组件通过监听这个事件来接收数据或执行相应操作。
Provide / Inject: 主要用于祖先组件向子孙组件注入数据，适用于不确定层级关系的组件间通信。这种方式应该谨慎使用，因为它打破了组件的封装性。
Vuex: Vue的官方状态管理库，适用于大型应用中多组件共享状态的情况。通过创建一个全局唯一的store来集中管理应用的所有状态。
Event Bus（事件总线）: 创建一个中央事件总线实例，组件之间可以通过它来发送和监听事件，实现非父子关系组件间的通信。但在Vue 3中，随着Composition API的引入，更倾向于使用其它更现代的通信方式。
Refs: 直接访问子组件的方法或属性，通常用于获取子组件的状态或调用子组件的方法。适用于父组件需要直接操作子组件的情况。
Global Event Handlers（全局事件处理器）: 在Vue实例或原型上定义全局事件监听器，可以跨组件边界监听事件。
Attributes & Listeners (v-bind="$attrs" 和 v-on="$listeners"): 在组件间传递所有属性和事件监听器，常用于封装可复用组件，使组件能透明地传递外部属性和事件。

选择哪种通信方式取决于你的具体需求和组件之间的关系。在Vue 3中，还引入了Composition API，它提供了新的函数式编程风格来组织和复用逻辑，进一步丰富了组件通信的手段。

浏览器标签通信

浏览器标签页之间的通信可以通过以下几种方式进行：

LocalStorage 和 SessionStorage : 这两种Web Storage API允许在同源的页面之间共享数据。LocalStorage的数据在关闭浏览器后仍然存在，而SessionStorage的数据仅在当前会话中有效。当一个页面修改了存储的数据，其他页面可以通过监听storage事件来感知变化。
BroadcastChannel API: 这个API允许在同源的不同浏览上下文（如不同标签页、iframe或Service Worker）之间创建通道并发送消息。每个通道独立，不同通道之间不会互相干扰。
Window.postMessage : 如果一个页面有另一个页面的引用，可以通过postMessage方法向那个页面发送消息，然后在接收端使用message事件监听器接收消息。
SharedWorker: SharedWorker 是一个JavaScript工作线程，可以在多个同源页面之间共享。通过SharedWorker，页面可以异步通信，而不必直接持有对方的引用。
Cookie + setInterval: 尽管不太推荐，但可以通过设置共享的cookie并定期检查变化来实现通信，尤其是在没有其他API可用的旧版本浏览器中。
WebSocket: WebSocket可以建立持久的双向连接，如果服务端支持，可以在多个标签页之间通过同一个WebSocket连接实现通信。
IndexedDB: 虽然IndexedDB主要用于存储大量数据，但它也支持监听数据库的变化，可以作为通信的一种方式，但通常不如其他API直接。

选择哪种通信方式取决于具体的需求，如数据量、实时性要求、兼容性以及隐私和安全考虑。通常，BroadcastChannel和LocalStorage是最简单和最常用的解决方案，而SharedWorker和WebSocket则适用于需要低延迟、高吞吐量的场景。

vue导航守卫

Vue Router 提供了导航守卫（Navigation Guards）来控制路由的导航流程，允许你在路由切换之前、之后或在解析过程中执行逻辑，如身份验证、权限检查、数据预加载等。导航守卫分为全局守卫、路由独享守卫和组件内守卫。以下是详细的分类和用法：

全局前置守卫 (Global Before Guards) :
- router.beforeEach(to, from, next)
- 在每个路由切换之前执行，可以用于全局的身份验证、权限检查等。
- to 参数代表即将进入的路由对象，from 是即将离开的路由对象，next 是必须调用的函数，决定导航的下一步动作。
全局解析守卫 (Global Resolve Guards) :
- router.beforeResolve(to, from, next)
- 在所有组件实例都创建完毕并且在DOM更新之前执行，通常用于数据获取，确保数据获取完成后再进行导航。
全局后置守卫 (Global After Hooks) :
- router.afterEach(to, from)
- 在每个路由切换完成后执行，不涉及导航的取消或重定向，通常用于日志记录或页面过渡动画。
路由独享守卫 (Route-Local Guards) :
- 可以在每个路由的beforeEnter、beforeRouteUpdate和beforeRouteLeave钩子中定义。
- beforeEnter仅在路由进入时执行。
- beforeRouteUpdate在当前路由的组件实例被复用时（例如，导航从/:id到/:id?，id改变但组件被复用）执行。
- beforeRouteLeave在离开当前路由时执行，通常用于确认对话框或阻止离开。
组件内的守卫 (Component-Local Guards) :
- 可以在组件的beforeRouteEnter、beforeRouteUpdate和beforeRouteLeave钩子中定义，与路由独享守卫类似，但这些钩子是在组件实例内部。

导航守卫的调用顺序是这样的：

全局前置守卫
路由独享的beforeEnter
组件内的beforeRouteEnter
全局解析守卫
组件内的beforeRouteUpdate（仅在当前路由组件被复用时）
全局后置守卫
组件内的beforeRouteLeave

注意，每个守卫函数的next函数的调用至关重要，确保在每个守卫中调用它以继续导航流程。如果不调用next，导航就会被取消。如果next(false)，则会阻止导航；如果next('/')或next({ path: '/' })，则会重定向到指定路径。

导航守卫使用场景

Vue Router 的导航守卫（Navigation Guards）在许多场景下都非常有用，以下是一些常见的使用场景：

身份验证：在用户试图访问受保护的路由之前，检查用户是否已经登录。如果没有，可以重定向到登录页面，或者显示一个提示让用户登录。
权限控制：根据用户的角色或权限来决定他们可以访问哪些路由。例如，管理员可以看到和编辑所有内容，而普通用户只能查看自己的内容。
数据预加载：在进入某个页面之前，可以预先加载必要的数据，以提高用户体验，避免用户看到空白页面或等待数据加载。
路由懒加载：在某些情况下，你可能希望在用户首次访问特定路由时才加载对应的组件，以减少初始加载时间。
路由拦截：阻止用户离开当前页面，例如在用户尝试离开未保存的表单时显示确认对话框。
路由重定向：根据某些条件自动重定向用户，比如根据URL参数或用户行为。
错误处理：在导航过程中捕获并处理错误，例如网络请求失败或解析错误。
路由元信息验证：检查路由的元信息，如自定义的元字段，以决定是否允许导航。
路由缓存控制：控制路由是否被缓存，以及何时清除缓存。
页面过渡动画：在路由切换前或后执行动画，提供更好的视觉反馈。

导航守卫允许你精确控制路由的导航流程，确保应用的逻辑和用户体验得以优化。正确使用导航守卫可以极大地提升应用的安全性和功能性。

登录是纯前端判断还是和后端进行交互

登录验证通常涉及前后端的交互，而不是仅靠前端完成。这是因为安全性原因，前端验证不足以保护敏感信息，如用户名和密码。以下是典型的登录过程：

前端：
- 用户在前端界面输入用户名和密码。
- 点击登录按钮后，前端会通过AJAX（异步JavaScript和XML）或Fetch API等技术，将用户名和密码加密后发送到后端服务器。
后端：
- 后端服务器接收到请求，解密数据，然后验证用户名和密码的正确性。
- 通常会与数据库中的用户账户信息进行比较，检查密码是否匹配。
- 如果验证成功，后端会生成一个会话标识（如JWT或session ID），并将其发送回前端。
前端：
- 前端收到会话标识后，将其存储在浏览器的Cookie或LocalStorage中。
- 之后的每次请求，前端都会将该标识发送给后端，以证明用户已登录。
后端：
- 后端收到会话标识后，会检查其有效性，如果有效则允许请求通过，否则拒绝。
登录超时：为了防止长时间未活动的用户仍然保持登录状态，后端通常会设置一个会话超时时间。当超时后，后端会拒绝携带过期标识的请求，并提示用户重新登录。

因此，登录验证是一个涉及前后端协作的过程，前端负责收集用户输入并发送请求，而后端负责验证并管理用户的登录状态。这样可以确保用户认证的安全性，并防止中间人攻击等安全问题。

vue的组件缓存

Vue中的组件缓存主要是通过<keep-alive>组件来实现的。<keep-alive>是一个特殊的组件，它可以包裹动态组件，并缓存不活动的组件实例，而不是销毁它们，从而保留组件的状态和避免不必要的重新渲染。这在需要保持组件状态或者避免重复渲染的情况下非常有用，比如在导航菜单中，当用户在不同的子页面之间切换时。

<keep-alive>的基本用法如下：

html<keep-alive>
  <component :is="currentComponent"></component>
</keep-alive>

在这个例子中，currentComponent是一个动态绑定的属性，它决定了哪个组件应该被渲染。当用户切换currentComponent的值时，<keep-alive>会缓存之前渲染过的组件，而不是每次都重新创建。

<keep-alive>还有一些可选的属性来控制缓存行为：

include: 一个正则表达式或数组，只缓存匹配到的组件。
exclude: 一个正则表达式或数组，排除匹配到的组件，即使它们在include中也会被排除。

注意，<keep-alive>的缓存不是持久化的，它只在当前应用的运行时有效。如果页面刷新，组件的状态将会丢失，因为浏览器会重新加载整个页面。

另外，<keep-alive>不会出现在组件的父组件链中，它自身也不会渲染DOM元素，而是控制组件实例的缓存和销毁。

如果你需要在页面刷新后也能恢复组件状态，可以结合localStorage或sessionStorage来持久化部分数据，或者使用Vuex来管理全局状态，这样即使页面刷新，状态也可以恢复。

keep-alive生命周期(缓存还是不缓存的操作)

<keep-alive>组件在Vue中引入了一种特殊的生命周期，专门用于处理组件的缓存逻辑。当一个组件被<keep-alive>包裹时，它会有两个特有的生命周期钩子，这些钩子在组件被激活和停用时触发，而不是在组件的常规生命周期中：

activated: 当组件被激活时触发。这意味着组件从缓存状态变为活动状态，即用户可以看到并交互的阶段。这个钩子在组件首次渲染时也会被调用，以及每次从缓存中恢复活动状态时。
deactivated: 当组件被停用时触发，即组件从活动状态变为被缓存状态。这发生在用户导航到其他路由或组件被替换时，但组件实例并没有被销毁，只是暂时不显示。

除了这两个特有的钩子，组件的其他生命周期钩子（如created, mounted, updated, beforeDestroy等）在组件被<keep-alive>包裹时的行为会有所不同。特别是，像mounted这样的钩子只在组件初次被创建并挂载到DOM时调用，而不会在组件从缓存中重新激活时再次调用。

总结来说，通过activated和deactivated这两个生命周期钩子，开发者可以控制和响应组件的缓存和激活状态，进行如数据重新获取、状态重置等操作，而无需担心组件被频繁创建和销毁带来的性能开销。

vue路由跳转

Vue Router 提供了多种方式来实现路由的跳转，以下是一些常见的方式：

router-link组件 : 使用<router-link>组件来创建一个链接，当用户点击时，Vue Router 会处理导航。例如：

html
```
<router-link to="/about">About</router-link>
```
this.$router.push() : 在组件内部，可以使用this.$router.push()方法来导航到新的路径。例如：

javascript
```
this.$router.push('/dashboard')
```
this.$router.replace() : 类似于push，但不会在历史记录中添加新的条目，而是替换当前记录。点击返回按钮不会返回到之前的页面。

javascript
```
this.$router.replace('/settings')
```
this.$router.go(n) : 前进或后退到历史记录中的特定位置。n是一个整数，正数表示前进，负数表示后退。

javascript this. $router.go(-1) // 后退一页 this.$ router.go(1) // 前进一页
this.$route.push() 和 this.$route.replace() : 在使用Vue 3和最新版本的Vue Router时，this.$route对象也提供了push和replace方法，与this.$router相同，但它们需要在setup函数中使用，因为它们是响应式的。
beforeRouteLeave导航守卫 : 在组件中定义beforeRouteLeave导航守卫，可以在离开当前路由前进行一些操作，比如确认对话框，然后决定是否跳转。
beforeRouteUpdate导航守卫: 当路由参数改变但组件被复用时，可以使用这个守卫来更新组件状态。
beforeRouteEnter导航守卫: 在组件实例创建之前调用，不能访问组件实例，通常用于预加载数据。
router.addRoute() 和 router.removeRoute(): 动态添加或移除路由，可以在运行时修改路由配置。
router.resolve() : 解析一个路由路径，返回一个包含location、route和href的对象，不实际触发导航。

选择哪种方式取决于你的具体需求，如是否需要保留历史记录、是否需要在导航前后执行特定操作等。

路由传参和区别

Vue Router 提供了几种路由传参的方式，每种方式有其特定的使用场景和特点：

1. 查询参数（Query Parameters）

方式：通过URL的查询字符串传递参数，例如/user?id=123。
设置：直接在router-link的to属性中或使用this.$router.push({ path: '/user', query: { id: 123 }})。
获取：在目标组件中通过this.$route.query.id获取。
特点：参数会显示在URL中，页面刷新或分享URL时参数不会丢失。

2. 路径参数（Path Parameters）

方式：在路由路径中使用冒号（:）定义参数，例如/user/:id。
设置：在router-link或this.$router.push中直接使用命名的路径，如/user/123。
获取：在目标组件中通过this.$route.params.id获取。
特点：参数隐藏在URL路径中，但页面刷新时参数同样不会丢失。

3. Props 传参

方式：在路由配置中使用props: true或自定义一个函数来传递参数给组件。
设置：在路由配置中定义，例如{ path: '/user/:id', component: User, props: true } 或者使用自定义函数映射参数。
获取：在目标组件中直接作为props接收，无需通过this.$route。
特点：使得组件更加解耦，易于测试和重用，因为组件就像接收普通props一样接收路由参数。

区别与选择

可见性：查询参数对用户可见，路径参数相对隐蔽，但两者都可通过URL访问；props传参对用户不可见。
编码便利性：props传参让组件更加专注于自身逻辑，而不需要关心如何从路由中提取参数。
刷新影响：所有方式在页面刷新时都不会丢失参数，因为它们都是通过URL传递的。
适用场景：对于需要直接在URL中展示或需要分享的参数，使用查询参数或路径参数更合适；对于组件间传递复杂数据或需要组件化处理的参数，使用props传参更为优雅。

选择哪种方式取决于你的具体需求，比如参数是否需要保密、是否需要分享URL、组件设计的简洁性等。

http缓存

HTTP缓存是一种机制，它允许浏览器存储从服务器获取的资源（如HTML文件、CSS、JavaScript、图片等），以便在后续请求相同资源时能够快速从本地缓存中提供，而不是重新从服务器下载。HTTP缓存减少了网络延迟，提高了网页加载速度，同时也减轻了服务器负载。

HTTP缓存主要通过以下两种方式实现：

强缓存（Freshness Checking） ：
- Cache-Control ：这是HTTP 1.1中引入的头，它提供了更多的控制权，比如 max-age 指令指定了资源的有效期。
- Expires：HTTP 1.0中的头，指定一个绝对的过期时间，浏览器会在该时间之前直接使用缓存。
协商缓存（Validation） ：
- ETag：服务器为每个资源分配一个唯一的标识，浏览器在后续请求时会带上这个标识，服务器根据标识判断资源是否改变。
- Last-Modified：服务器提供资源的最后修改时间，浏览器在请求时带上这个时间，服务器根据时间判断资源是否更新。

当浏览器需要一个资源时，它首先检查是否在强缓存中，如果资源仍然新鲜（未过期），则直接使用缓存副本。如果资源过期，浏览器会进行协商缓存检查，发送请求到服务器验证资源是否改变，如果资源未变，服务器返回304 Not Modified，浏览器继续使用缓存；如果资源有更新，服务器会返回新的资源和更新后的缓存控制头。

开发者可以通过设置HTTP响应头来控制缓存行为，例如：

httpCache-Control: max-age=3600, must-revalidate
Expires: Sat, 01 Jan 2023 00:00:00 GMT
ETag: "123456"
Last-Modified: Thu, 01 Jan 2022 00:00:00 GMT

在开发环境中，通常会禁用或限制缓存，以确保每次都能获取最新的资源。在生产环境中，根据需要调整缓存策略以平衡性能和更新需求。

浏览器缓存

网络协议的七层都有哪些，tcp在哪一层，加密在哪一层加密

跨域有了解吗?跨域是http的限制还是浏览器的限制，为什么有这个限制

服务端会产生跨域吗

解决跨域的方式有哪几种

cors具体怎么解决跨域的

常用的响应头有哪些

常用抓包工具

http报文

小程序的分包是怎么做的?

小程序的登录流程

openid代表什么含义

appid代表什么

uid是什么

小程序内嵌-个h5页面

对于webview打开的限制有了解过吗?

3:49项目.上线了吗?有没有遇到什么问题呀?

13:35做项目遇到最大的困难是什么?

http报文

HTTP（Hypertext Transfer Protocol）是互联网上应用最为广泛的一种网络协议，用于从万维网服务器传输超文本到本地浏览器的传输协议。HTTP报文是HTTP通信的基本单位，分为请求报文和响应报文。

HTTP请求报文：
- 请求行：包括请求方法、URL、HTTP版本等信息，例如：GET /index.html HTTP/1.1
- 请求头部（可选）：包含多个键值对，例如：User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3
- 空行：分隔头部和主体
- 请求主体（可选）：通常在POST请求中使用，包含要发送的数据
HTTP响应报文：
- 状态行：包括HTTP版本、状态码、状态消息，例如：HTTP/1.1 200 OK
- 响应头部（可选）：同样包含多个键值对，例如：Content-Type: text/html
- 空行：分隔头部和主体
- 响应主体：通常包含服务器返回的HTML页面、数据或其他资源

HTTP报文通常是文本格式，易于阅读和调试，但在实际网络传输中，可能会被压缩或加密。

小程序的分包是怎么做的?

微信小程序的分包功能是为了应对小程序代码包大小的限制，以及优化用户体验，特别是当小程序变得较大时。以下是创建微信小程序分包的基本步骤：

理解分包规则：
- 主包（基础包）大小不能超过2MB。
- 所有分包和主包的总大小不超过20MB（小游戏若开通虚拟支付可达到30MB）。
配置app.json：
- 打开你的项目根目录下的app.json文件，这是小程序的主要配置文件。
- 在app.json中找到或添加subpackages字段。subpackages是一个数组，每个元素代表一个分包，包含分包的名称和路径。
例如：

json {
"subpackages": [
{
"root": "packageA", // 分包名，用户访问时的路径前缀
"pages": [ // 分包包含的页面路径
"pages/pageA/index",
"pages/pageB/index"
]
},
{
"root": "packageB",
"pages": [
"pages/pageC/index",
"pages/pageD/index"
]
}
],
"pages": [ // 主包包含的页面路径
"pages/index/index",
"pages/logs/logs"
]
}

pages字段定义的是主包内的页面，而subpackages定义的是分包及其包含的页面。

组织代码 ：
- 将需要分包的页面移动到对应的分包目录下。例如，pages/pageA/index和pages/pageB/index应该移动到src/packageA目录下。
构建与测试 ：
- 保存配置并运行构建命令，这通常会根据app.json的配置来打包你的小程序。
- 使用微信开发者工具进行预览和测试，确保分包加载正确，没有错误。
提交审核与发布 ：
- 构建完成后，将生成的代码包上传到微信开发者平台进行版本提交和审核。

通过这样的方式，小程序可以将不常用或者大体积的页面放在分包中，用户在首次打开时只会下载主包，当访问到分包中的页面时才会按需下载，从而减少首屏加载时间，提高用户体验。

小程序 openid代表什么含义

在微信小程序的上下文中，openid 是一个特定用户的唯一标识符。

阿里夸克面试准备

夸克，作为阿里巴巴集团的一部分，可能会在面试前端工程师时提出一系列技术性和实践性的问题来评估候选人的技能和经验。以下是一些可能的前端面试题，这些题目可能与ES5、ES6的区别、浏览器内核、项目经验和实际问题解决能力有关：

基础知识：
- 请解释一下JavaScript中的闭包是什么，以及它在实际编程中有哪些用途？
- ES5和ES6的主要区别是什么？举几个关键特性变化的例子。
- 介绍一下不同浏览器的内核，比如Trident、Blink、Gecko和WebKit。
- 什么是模块化，JavaScript中有哪些模块化解决方案（如CommonJS, ES modules）？
- 如何处理JavaScript异步编程，例如Promise、async/await？
技术细节：
- ES6中新增的类和ES5中的构造函数有何不同？
- 解释箭头函数与普通函数的区别。
- 什么是RESTful API，它遵循哪些原则？
- 如何使用CSS实现响应式设计？
- 如何优化前端性能，包括加载速度和用户体验？
项目经验与问题解决：
- 可以详细描述一个你参与过的前端项目，你在其中扮演的角色，以及你如何解决遇到的挑战吗？
- 在实际工作中，你是如何处理跨浏览器兼容性问题的？
- 你有使用过前端构建工具（如Webpack或Gulp）的经验吗？请分享一次优化构建过程的经历。
- 你对前端状态管理（如Redux, MobX）的理解，以及在项目中如何应用的？
- 请解释一下你是如何进行代码审查和保证代码质量的。
算法与数据结构：
- 讲解一下常见的排序算法（如冒泡、快速、归并排序）及其复杂度。
- 你会如何实现一个简单的缓存机制，比如LRU（Least Recently Used）？

记住，面试题可能会根据面试官和职位的具体要求而有所不同，而且通常会包含现场编码测试或白板编程环节。准备面试时，熟悉这些概念并能够清晰地表达自己的思考过程非常重要。

基础知识：

请解释一下JavaScript中的闭包是什么，以及它在实际编程中有哪些用途？

JavaScript 中的闭包是一种特殊的现象，它发生在函数内部的一个函数能够访问并操作其外部函数的变量，即使在其外部函数已经执行完毕并返回之后。闭包的核心在于它可以"记住"其创建时的作用域，即使这个作用域在逻辑上已经不再存在。

闭包的主要用途包括：

变量封装和隐私 ：
- 由于闭包可以访问外部函数的变量，但外部无法直接访问闭包内部的变量，因此可以用来创建私有变量和方法，防止全局作用域的污染。
数据持久化 ：
- 闭包可以让变量的值在函数执行后仍然保留，这在需要缓存结果或状态的情况下非常有用。例如，一个计数器函数，每次调用都能记住之前的计数值。
模块化 ：
- 在模块化编程中，闭包可以用来创建独立的作用域，每个模块都有自己的私有变量和方法，同时提供公共接口与外部交互。
记忆化 ：
- 对于计算密集型的函数，闭包可以用来存储之前计算过的结果，避免重复计算，提高性能。
异步操作 ：
- 在处理异步回调函数（如定时器或事件处理器）时，闭包可以保持对上下文的引用，解决回调地狱中的作用域问题。
函数工厂 ：
- 利用闭包，可以创建产生具有不同行为的函数，因为每个函数可以记住它创建时的环境。
事件处理 ：
- 当添加事件监听器时，闭包可以确保每个事件处理函数都有自己的一份变量副本，而不是共享同一个变量。
封装副作用 ：
- 闭包可以用来隐藏可能产生副作用的操作，使得代码更易于理解和测试。
匿名自执行函数 ：
- 闭包可以用来创建立即执行的匿名函数，这样可以在不污染全局作用域的情况下执行代码。

需要注意的是，不当使用闭包可能导致内存泄漏，因为闭包会保持对外部变量的引用，阻止它们被垃圾回收。因此，在编写闭包时，需要谨慎管理内存，尤其是在处理大量数据或长时间运行的闭包时。

JavaScript中的闭包在实际编程中有多种用途，以下是一些常见的应用场景和具体例子：

私有变量和方法：在JavaScript中，没有真正的私有变量，但可以通过闭包来模拟实现。闭包可以访问并修改其父函数的作用域内的变量，但外部无法直接访问这些变量。

js 复制代码

javascript   function counter() {
     let count = 0;
     return {
       increment: function() {
         count++;
         console.log(count);
       },
       decrement: function() {
         count--;
         console.log(count);
       }
     };
   }
   let myCounter = counter();
   myCounter.increment(); // 1
   myCounter.increment(); // 2

缓存机制（记忆化）：闭包可以用来缓存函数的结果，提高性能，尤其是对于计算量大但结果可复用的情况。

js 复制代码

function memoize(fn) {
     const cache = new Map();
     return function(...args) {
       if (cache.has(args[0])) {
         return cache.get(args[0]);
       } else {
         const result = fn.apply(this, args);
         cache.set(args[0], result);
         return result;
       }
     };
   }

   function slowExpensiveCalculation(n) {
     // 模拟耗时计算
     console.log('Calculating...');
     return n * n;
   }

   const fastCalculation = memoize(slowExpensiveCalculation);
   console.log(fastCalculation(5)); // 计算
   console.log(fastCalculation(5)); // 从缓存获取，不计算

模块封装：闭包可以用来封装代码，防止全局变量污染，创建模块化的功能。

js 复制代码

     const myModule = (function() {
     let privateVar = 0;

     function privateMethod() {
       privateVar++;
     }

     return {
       publicMethod: function() {
         privateMethod();
         console.log(privateVar);
       }
     };
   })();

   myModule.publicMethod(); // 输出: 1
   myModule.publicMethod(); // 输出: 2

事件处理：在事件处理中，闭包可以保持对特定状态的引用，即使事件处理函数在外部被调用。

js 复制代码

for (let i = 1; i <= 5; i++) {
     document.getElementById(`button${i}`).addEventListener('click', function() {
       console.log(i); // 此处的i是闭包引用，点击任何按钮都会输出最后一个值，即5
     });
   }

   // 使用闭包修复问题
   for (let i = 1; i <= 5; i++) {
     (function(index) {
       document.getElementById(`button${index}`).addEventListener('click', function() {
         console.log(index); // 输出点击的按钮对应的索引
       });
     })(i);
   }

异步操作：在回调函数或Promise链中，闭包可以捕获当前的作用域，这对于管理异步操作中的状态非常有用。

javascript function doAsyncTask(callback) {
setTimeout(function() {
callback(); // 闭包捕获了外层函数的callback
}, 1000);
}
```
let counter = 0;
doAsyncTask(() => {
  console.log(counter); // 输出: 0
  counter++;
});

counter++; // 在异步任务执行前增加counter
```

这些只是闭包在JavaScript中使用的一部分示例，实际上，闭包在函数式编程、状态管理、异步控制流等多个方面都有广泛的应用。

ES5和ES6的主要区别是什么？举几个关键特性变化的例子。

ES5和ES6（也称为ES2015）是JavaScript语言的两个重要版本，它们之间有很多关键的区别和新特性。以下是一些主要的区别和新特性的例子：

块级作用域 ：
- ES5 只有全局作用域和函数作用域，而没有块级作用域。例如，if语句或for循环内的var声明的变量会在整个函数内可见。
- ES6 引入了let和const关键字，它们提供了块级作用域，这意味着在块内声明的变量只在该块内有效。
箭头函数 ：
- ES5 使用传统的函数表达式或函数声明来创建函数。
- ES6 引入了箭头函数，语法更简洁，且箭头函数没有自己的this值，它会捕获其所在（最近）上下文的this值。
模板字符串 ：
- ES5 使用+操作符或者String()函数来拼接字符串。
- ES6 引入了模板字面量（模板字符串），用反引号（）包围，支持嵌入表达式 ${expression}`。
类（Class）和继承 ：
- ES5 使用原型链来实现面向对象编程，通过Object.create()和原型属性实现继承。
- ES6 引入了class关键字，提供了一种更接近传统类的语法糖，但底层仍然是基于原型的继承。
默认参数 ：
- ES5 中函数参数如果没有值，内部会是undefined。
- ES6 允许在函数参数定义时直接设置默认值，如function foo(a = 'default') {}。
解构赋值 ：
- ES5 需要手动赋值来从数组或对象中提取值。
- ES6 提供了解构赋值，可以从数组或对象中方便地提取值，如let [a, b] = [1, 2];。
扩展运算符 ：
- ES5 没有简便的方法来合并数组或复制数组。
- ES6 引入了扩展运算符（...），可以用来合并数组，如let arr1 = [1, 2]; let arr2 = [3, 4]; let arr3 = [...arr1, ...arr2];。
Promise 对象 ：
- ES5 处理异步操作通常使用回调函数，容易导致回调地狱。
- ES6 引入了Promise对象，提供了一种更优雅的方式来处理异步操作。

这些只是ES6相对于ES5的一些关键变化，实际上还有许多其他改进和新特性，如模块系统（import/export）、生成器（generators）、Set和Map数据结构等。

介绍一下不同浏览器的内核，比如Trident、Blink、Gecko和WebKit。

什么是模块化，JavaScript中有哪些模块化解决方案（如CommonJS, ES modules）？

文件增加，造成全局污染，立即执行函数不能暴漏出变量

模块化是一种软件设计方法，它将复杂的应用程序分解为一系列可重用的组件或模块，每个模块都有自己的功能，并且可以独立开发、测试和维护。模块化有助于提高代码的可读性、可维护性和复用性，减少命名冲突，以及管理复杂的依赖关系。

在JavaScript中，有几种常见的模块化解决方案：

文件增加，造成全局污染，立即执行函数不能暴漏出变量

ES Modules

CommonJS

AMD

CMD

UMD

如何处理JavaScript异步编程，例如Promise、async/await？

技术细节：

ES6中新增的类和ES5中的构造函数有何不同？

在ES6中引入的class关键字是用来创建对象的模板，它提供了一种更简洁、更面向对象的语法，使得代码更加易读和易写。相比于ES5中的构造函数，class有以下几个主要的不同点：

语法糖 ：
- ES5中的构造函数是通过function关键字定义的，并且原型方法需要手动添加到prototype对象上。
- ES6的class关键字是一个语法糖，它实际上还是基于原型的，但是语法更加紧凑，方法直接在类的体内定义。
方法定义 ：
- 在ES5中，你需要为每个方法创建一个函数并将其添加到prototype，如MyFunction.prototype.myMethod = function() {}。
- ES6的类允许你直接在类的方法块中定义方法，如class MyClass { myMethod() {} }。
this的绑定 ：
- 在ES5中，构造函数内的this可能会因为闭包或其他作用域问题而产生混淆，特别是在使用箭头函数时。
- ES6的类方法自动绑定this到类的实例，避免了this的混乱。
静态方法 ：
- ES5中，静态方法通常通过在构造函数上定义来实现。
- ES6允许你使用static关键字在类上直接定义静态方法，如class MyClass { static myStaticMethod() {} }。
继承：
- ES5中，继承通常是通过Object.create()或prototype链来实现的，语法较为复杂。
- ES6的class支持更直观的继承，通过extends关键字来实现，如class ChildClass extends ParentClass {}。
默认构造函数 ：
- ES6的类如果没有定义构造函数，会自动提供一个默认的构造函数。
- 在ES5中，你需要显式地定义构造函数，否则实例化时不会有任何初始化行为。
严格模式 ：
- class语法始终在严格模式下运行，这有助于避免一些常见的JavaScript陷阱。

总的来说，ES6的class提供了更现代和面向对象的语法，但它在底层仍然是基于原型的，只是提供了更好的抽象。

面试录音

js为什么会产生变量提升

箭头函数和普通函数有什么区别

改变this指向的方式有哪些

常用的js数组方法有哪些呢

js数组长度为10，删除比如第五个怎么办

字符串转换为数组

数组转字符串

什么是类数组

怎么转化为数组

ES6的promise是用来做什么的

promise是怎么解决回调地狱问题的

promise的链式调用是怎么实现的

promise的错误捕获有几种方式

promise的all和promise的race有什么区别

vue的watch和computed有什么区别

computed的缓存是怎么实现的

watch为什么会支持异步呢

vue组件通信方式

浏览器标签通信

vue导航守卫

导航守卫使用场景

登录是纯前端判断还是和后端进行交互

vue的组件缓存

keep-alive生命周期(缓存还是不缓存的操作)

vue路由跳转

路由传参和区别

1. 查询参数（Query Parameters）

2. 路径参数（Path Parameters）

3. Props 传参

区别与选择

http缓存

浏览器缓存

网络协议的七层都有哪些，tcp在哪一层，加密在哪一层加密

跨域有了解吗?跨域是http的限制还是浏览器的限制，为什么有这个限制

服务端会产生跨域吗

解决跨域的方式有哪几种

cors具体怎么解决跨域的

常用的响应头有哪些

http报文

小程序的分包是怎么做的?

小程序 openid代表什么含义

阿里夸克面试准备

基础知识：

请解释一下JavaScript中的闭包是什么，以及它在实际编程中有哪些用途？

ES5和ES6的主要区别是什么？举几个关键特性变化的例子。

介绍一下不同浏览器的内核，比如Trident、Blink、Gecko和WebKit。

什么是模块化，JavaScript中有哪些模块化解决方案（如CommonJS, ES modules）？

如何处理JavaScript异步编程，例如Promise、async/await？

技术细节：

ES6中新增的类和ES5中的构造函数有何不同？

解释箭头函数与普通函数的区别。

什么是RESTful API，它遵循哪些原则？

如何使用CSS实现响应式设计？

如何优化前端性能，包括加载速度和用户体验？