function cache(fn){
const cache = {}
return function(...args){
const key = JSON.stringify(args)
if(cache[key]){
return cache[key]
}
const result = fn(...args)
cache[key] = result
return result
}
}
①第一步需要返回一个promise实例,
这样呢就可以通过then方法获取兑现和拒绝的原因
②接着在内部需要做两个判断
async/await其实是Generator 的语法糖，它能实现的效果都能用then链来实现，它是为优化then链而开发出来的。从字面上来看，async是“异步”的简写，await则为等待，所以很好理解async 用于申明一个 function 是异步的，而 await 用于等待一个异步方法执行完成。当然语法上强制规定await只能出现在asnyc函数中，先来看看async函数返回了什么：
async function testAsy(){
return 'hello world';
}
let result = testAsy();
console.log(result)
总结简单实现版
//手写call()利用symbol优化
// 定义myCall方法
//...args 剩余参数
//context 上下文
Function.prototype.myCall = function (context, ...args) {
if (typeof this !== 'function') {
throw new TypeError('Error')
}
context = context || window
// ----------------
// symbol防止属性名冲突
const fnSymbol = Symbol()
// 设置this并调用原函数
context[fnSymbol] = this
const res = context[fnSymbol](...args)
delete context[fnSymbol]
return res
}
//手写apply()利用symbol优化
Function.prototype.myApply = function (context, args) {
if (typeof this !== 'function') {
throw new TypeError('Error')
}
context = context || window
//---------------------------
// symbol防止属性名冲突
const fnSymbol = Symbol()
// 设置this并调用原函数
context[fnSymbol] = this
const res = context[fnSymbol](...args)
delete context[fnSymbol]
return res
}
//手写bind()
Function.prototype.myBind = function (context, ...args) {
if (typeof this !== 'function') {
throw new TypeError('Error')
}
//---------------------------
const self = this
return (...newArgs) => {
return self.call(context, ...args, ...newArgs)
}
}
//手写bind()
Function.prototype.myBind = function (context, ...args) {
if (typeof this !== 'function') {
throw new TypeError('Error')
}
const self = this
return function (...newArgs) {
return self.apply(context, args.concat(newArgs))
}
}function quickSort(arr) {
if (arr.length <= 1) {
return arr; // 基本结束条件
}
const pivot = arr[0]; // 选择一个基准点，这里选择第一个元素
const left = []; // 定义左数组
const right = []; // 定义右数组
// 遍历数组，根据与基准点的比较将元素分配到左右数组
for (let i = 1; i < arr.length; i++) {
if (arr[i] < pivot) {
left.push(arr[i]); // 小于基准点的放在左边
} else {
right.push(arr[i]); // 大于等于基准点的放在右边
}
}
// 递归调用快速排序，并对左右数组进行排序
return [...quickSort(left), pivot, ...quickSort(right)];
}
// 示例
const array = [7, 2, 1, 6, 8, 5, 3, 4];
console.log(quickSort(array)); // 输出: [1, 2, 3, 4, 5, 6, 7, 8]在参数中 ...args 是剩余参数
（1）对象扩展运算符
对象的扩展运算符(...)用于取出参数对象中的所有可遍历属性，拷贝到当前对象之中。
let bar = { a: 1, b: 2 };
let baz = { ...bar }; // { a: 1, b: 2 }更简洁的语法，例如
箭头函数没有自己的 this，arguments，super
箭头函数 this 只会从自己的作用域链的上一层继承 this。
解构是 ES6 提供的一种新的提取数据的模式，这种模式能够从对象或数组里有针对性地拿到想要的数值。
1）数组的解构
在解构数组时，以元素的位置为匹配条件来提取想要的数据的：
const [a, b, c] = [1, 2, 3]