前端重要知识总结

let o = {
            name: '优秀的'
        }        
function fn(frist, last) { 
           console.log(this);
            console.log(`${frist}${this.name}${last}`);
        };        
fn.call(o, '我是', "前端"); //输出：我是优秀的前端

let o = {
            name: 'andy'
        };        
function fn(arr) {
            console.log(this);
            console.log(arr); // 'pink'
        };        
fn.apply(o, ['pink']);

7.数组排序

// 1.选择排序
// (1)选择排序-递归
let min = (numbers) => {
    if (numbers.length > 2) {
        return min([numbers[0], min(numbers.slice(1))])
    } else {
        return Math.min.apply(null, numbers)
    }
}
let minIndex = (numbers) => {
    let index = 0
    for (let i = 0; i < numbers.length; i++) {
        if (numbers[i] < numbers[index]) {
            index = i
        }
    }
    return index
}

let sort = (numbers) => {
    if (numbers.length > 2) {
        let index = minIndex(numbers)
        let minNum = numbers[index]
        numbers.splice(index, 1) //返回一个被切去最小数的数组
        return [minNum].concat(sort(numbers))
    } else {
        return numbers[0] > numbers[1] ? numbers.reverse() : numbers
    }
};
// (2)选择排序-for循环
//实现求最小值的下标
let minIndex = (numbers) => {
    let indexInt = 0
    for (let i = 1; i < numbers.length; i++) {
        if (numbers[i] < numbers[indexInt]) {
            indexInt = i
        }
    }
    return indexInt
};
//实现交换swap， 交换一个数组中的两个值
let swap = (numbers, i, j) => {
    let temp = numbers[i]
    numbers[i] = numbers[j]
    numbers[j] = temp
}

let sort = (numbers) => {
    for (let i = 0; i < numbers.length - 1; i++) {
        let index = minIndex(numbers.slice(i)) + i
            //minIndex里面的numbers和下面的numbers没关系，他是在minIndex函数里面运行的，即使切了也不影响下面的numbers，i最开始为零，所以numbers.slice（0）切零个，就是原数组，因为切掉了i个，所以他的下标就和原来的数组不相等了，切掉了i个，后面加上i
        if (index !== i) { swap(numbers, index, i) }
    }
    return numbers
};
// 2.快速排序

let quickSort = (numbers) => {
    if (numbers <= 1) { return numbers }
    let pivotIndex = Math.floor(numbers.length / 2)
    let pivot = numbers.splice(pivotIndex, 1)[0]
    let left = []
    let right = []
    for (let i = 0; i < numbers.length; i++) {
        if (numbers[i] < pivot) {
            left.push(numbers[i])
        } else {
            right.push(numbers[i])
        }
        return quickSort(left).concat(pivot, quickSort(right))
    }
};

// 3.归并排序
let merge = (a, b) => {
    if (a.length === 0) { return b }
    if (b.length === 0) { return a }
    return a[0] > b[0] ? [b[0]].concat(merge(a, b.slice(1))) : [a[0]].concat(merge(b, a.slice(1)))
}
let mergeSort = (numbers) => {
    if (numbers.length === 1) { return numbers }
    let left = numbers.slice(0, Math.floor(numbers.length / 2))
    let right = numbers.slice(Math.floor(numbers.length / 2))
    return merge(mergeSort(left), mergeSort(right))
};

// 4.计数排序

let countSort = arr => {
    let hashTable = {},
        max = 0,
        result = []
    for (let i = 0; i < arr.length; i++) {
        if (!(arr[i] in hashTable)) {
            hashTable[arr[i]] = 1
        } else {
            hashTable[arr[i]] += 1
        }
        if (arr[i] > max) { max = arr[i] }
    }
    for (let j = 0; j <= max; j++) {
        if (j in hashTable) {
            for (let i = 0; i < hashTable[j]; i++) {
                result.push(j)
            }
        }
    }
    return result
}作者：xiaoyuAnd链接：https://juejin.cn/post/6873394120639905800来源：掘金著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

8.你对 Promise 的了解？

Promise 的用途

如何创建一个 new Promise

//new Promise((resolve,relsct)=>{.....})
function fn(){
    return new Promise((resolve, reject)=>{
        成功时调用 resolve(data)
        失败时调用 reject(reason)
    })
}

如何使用 Promise.prototype.then

let promise1 = new Promise((resolve,reject) => {   resolve('seccess')})promise1.then((value)=>{   console.log(value)   //seccess}

如何使用 Promise.all

Promise.all([promise1, promise2]) 并行，等待所有 promise 成功。
如果都成功了，则 all 对应的 promise 也成功；如果有一个失败了，则 all 对应的 promise 失败。

const promise1 = Promise.resolve(3);const promise2 = 42;const promise3 = new Promise((resolve, reject) => {    setTimeout(resolve, 100, 'foo');});Promise.all([promise1, promise2, promise3]).then((values) => {    console.log(values);//Array [3, 42, "foo"]});

如何使用 Promise.race

Promise.race([promise1, promise2])，返回一个 promise，一旦数组中的某个promise解决或拒绝，返回的 promise就会解决或拒绝。

9.说说跨域

什么是同源：

同源策略/SOP（Same origin policy）是一种约定，所谓同源是指"协议+域名+端口"三者相同，即便两个不同的域名指向同一个ip地址，也非同源。

什么是跨域

在浏览器同源策略限制下，向不同源（不同协议、不同域名或者不同端口）发送XHR请求，浏览器认为该请求不受信任，禁止请求，具体表现为请求后不正常响应

JSONP 跨域

CORS 跨域

简单请求：在响应头加Access-Control-Allow-Origin：允许跨域请求的源
非简单请求：在响应头加Access-Control-Allow-Origin:
Access-Control-Allow-Methods:
Access-Control-Allow-Headers: