一、 面试题：作用域和作用域链

作用域：

概念：变量能起到作用域的区域，全局/局部

在全局定义的变量叫全局变量；局部定义的变量叫局部变量 全局变量可以任意范围起到作用；局部变量只能在当前函数内起到作用

作用：局部可以访问全局变量，全局不能访问局部变量

作用域链：

概念：局部嵌套在全局中，局部被可以再次嵌套局部，这样由作用域嵌套形成的链式结构叫做作用域链

作用：

1.当将一个变量当做值使用的时候，先在当前作用域中找变量的定义，没找到就去上级作用域找，没有就再次去上级作用域找，。。。，直到全局也找不到就报错

2.当给一个变量赋值的时候，先在当前作用域中找变量的定义，没有找到就去上级作用域中找，没有就再次去上级作用域中找，。。。，直到全局也找不到，就在全局定义这个变量并赋值。

二、函数中的关键字arguments

作用：收集所有的实参

三、数组方法（前10个）

1、push方法： 给数组末尾添加一个或多个元素

数组.push(一个或多个元素) --- 返回新数组的长度

// 末尾添加多个元素
function push() {
    // 不用定义形参 - 只需要使用arguments接收所有实参
    // console.log(arguments);
    // 遍历argumments
    for (var a = 0; a < arguments.length; a++) {
        arr[arr.length] = arguments[a]
    }
    return arr.length
}

// var len = push('d', 'e')
var len = push('d')
console.log(arr);
console.log(len);

2、pop方法：将数组的最后一个元素删掉

数组.pop() --- 返回被删掉的元素

var arr = ['a', 'b', 'c', 'd']
var ele = arr.pop()
console.log(arr);
console.log(ele);

// 自己封装
function pop() {
    // 将最后一个元素用变量存起来
    var ele = arr[arr.length - 1]
    // 使用长度操作将长度 - 1；就会将最后一个元素删掉
    arr.length = arr.length - 1
    // 将删掉的元素返回
    return ele
}
var ele = pop()
console.log(arr);
console.log(ele);

3、shift方法：将数组第一个元素删掉

数组.shift() --- 返回被删掉的元素

var arr = ['a', 'b', 'c']
var ele = arr.shift()
console.log(ele);
console.log(arr);

// 自己封装
function shift() {
    var ele = arr[0]
    for (var a = 0; a < arr.length - 1; a++) {
        arr[a] = arr[a + 1]
    }
    arr.length = arr.length - 1
    return ele
}
var ele = shift()
console.log(ele);
console.log(arr);

4、unshift方法：给数组开头添加一个元素 ***

数组.unshift(1个或多个元素) --- 返回新数组的长度

var arr = ['a', 'b', 'c']
    var length = arr.unshift('d')
    var length = arr.unshift('d', 'e')
    console.log(arr);
    console.log(length);

    // 自己封装
    function unshift() {
        // 查看要添加的元素个数
        var length = arguments.length
        // 倒着遍历数组，将所有元素向后移动length位
        for (var a = arr.length - 1; a >= 0; a--) {
            arr[a + length] = arr[a]
        }
        // console.log(arr);
        // 遍历arguments，给前面空出来的空间中放上元素
        for (var a = 0; a < arguments.length; a++) {
            arr[a] = arguments[a]
        }
        // console.log(arr);
        // 返回新数组的长度
        return arr.length
    }

    // var len = unshift('d', 'e')
    var len = unshift('d')
    console.log(arr);
    console.log(len);

5、splice方法： 给数组在任意位置添加、删除、修改 1个或多个元素***

数组.splice(开始下标, 删除的元素个数, 1个或多个新元素) --- 返回被删掉的所有元素组成的数组

var arr = ['a', 'b', 'c', 'd', 'e', 'f']
删除
var brr = arr.splice(2, 3)
console.log(arr);
console.log(brr);

新增
var brr = arr.splice(3, 0, 1, 2, 3)
console.log(arr);
console.log(brr);

修改
var brr = arr.splice(2, 2, 1, 2)
console.log(arr);
console.log(brr);

6、concat方法：将1个或多个元素或数组合并成更大的数组

数组.concat(1个或多个元素或数组) --- 返回更大的数组

var arr = ['a', 'b', 'c']
// var brr = arr.concat('d')
// var brr = arr.concat('d', 'e')
// var brr = arr.concat(['d', 'e', 'f'])
// var brr = arr.concat(['d', 'e'], ['f', 'g'])
var brr = arr.concat('e', ['f', 'g'])
console.log(arr);
console.log(brr)

7、join方法：将数组中元素以指定的连接符连接成一个字符串

数组.join(连接符) --- 返回字符串

var arr = ['a', 'b', 'c']
// var str = arr.join('-')
// var str = arr.join('')
// var str = arr.join() // 如果省略连接符，默认使用逗号进行连接
var str = arr.join('哈哈')
console.log(str);

8、slice方法：截取数组的一部分

数组.slice(开始下标, 结束下标) --- 开始下标到结束下标之间的元素组成的新数组

var arr = [1,2,3,4,5,6,7,8,9]

// var brr = arr.slice(3, 6) // 结果默认包含开始下标对应的元素，不包含结束下标对应的元素
// var brr = arr.slice(3) // 省略掉结束下标，默认截取到末尾
var brr = arr.slice() // 省略两个参数，默认从头截取到末尾
console.log(brr);

9、reverse方法：翻转数组

数组.reverse() --- 返回翻转后的数组

var brr = arr.reverse()

console.log(arr);
console.log(brr);

10、sort方法：排序数组中的元素

数组.sort()

var arr = [21, 5, 13]
arr.sort(function(a, b) {
    // return a - b // 数字大小升序
    return b - a // 数字大小降序
})
console.log(arr);

11、indexOf方法：查找某个元素在数组中第一次出现的下标

数组.indexOf(元素) - 返回找到的下标，找不到就返回-1

数组.indexOf(元素, 开始下标) - 从指定的开始下标开始找元素在数组中第一次出现的下标

var arr = ['a', 'b', 'a', 'c', 'c', 'd']
var index = arr.indexOf('c')
console.log(index);
// 通常我们会利用这个方法，判断某个元素是否在数组中
if (arr.indexOf('e') >= 0) {
    console.log('在');
} else {
    console.log('不在');
}

12、lastIndexOf方法：查找元素在数组中最后一次出现的下标

数组.lastIndexOf(元素)

数组.lastIndexOf(元素, 下标) - 将指定下标的元素作为最后一个元素，找元素最后一次出现的下标

var arr = ['a', 'b', 'a', 'c', 'c', 'd']
// var index = arr.lastIndexOf('a')
// console.log(index);

var index = arr.lastIndexOf('a', 1)
console.log(index);

13、forEach方法：遍历数组

数组.forEach(function(value, index, array) {

value代表数组中的每个元素，类似于我们通过for循环遍历的 arr[a]

index代表每个元素对应的下标，相当于for循环遍历的a

array代表当前正在遍历的数组

})

// var arr = ['a', 'b', 'c']
// arr.forEach(function(value, index, array) {
//     console.log(value, index, array);
// })

在遍历的时候通常，我们只会用到具体的元素，不会用到下标和数组本身，所以forEach方法在使用的时候，可以只有value这一个参数，可以省略后面的两个参数

arr.forEach(function(value) {
    console.log(value);
})

14、map方法：将数组中每个元素都通过相同的处理方式得到新的元素，所有新元素组成一个新的数组 并返回

新的数组 = 数组.map(function(value, index, array) {

return 新的元素

})

var arr = [10, 20, 30]
var brr = arr.map(function(v) {
    var newV = v + v * 0.3
    return newV
})
console.log(brr); // [13, 26, 39]

15、filter方法：将数组中满足指定条件的所有元素组成新的数组并返回

新数组 = 数组.filter(function(value, index, array) {

return 条件

})

var brr = arr.filter(function(item) {
    // return item.completed === false
    return !item.completed
})
console.log(brr);

16、every方法：判断数组中是否所有元素都满足指定条件

布尔值 = 数组.every(function(value, index, array) {

return 条件

})

var arr = [78, 90, 560, 88]

var bool = arr.every(function(item) {
    return item > 60
})
console.log(bool);

17、some方法：判断数组中是否 有 满足条件的元素

布尔值 = 数组.some(function(value, index, array) {

return 条件

})

var arr = [78, 90, 56, 88]

var bool = arr.some(function(item) {
    return item < 60
})
console.log(bool);

18、find方法：查找数组中第一个满足指定条件的元素；

元素 = 数组.find(function(value, index, array) {

return 条件

})

找到了就返回元素，找不到就返回undefined

var ele = arr.find(function(item) {
    return item.age >= 18
})
console.log(ele);

19、findIndex方法：查找数组中第一个满足指定条件的元素的下标

下标 = 数组.findIndex(function(value, index, array) {

return 条件

})

找到了就返回下标，找不到就返回-1

var index = arr.findIndex(function(item) {
    return item.age >= 180
})
console.log(index);

20、reduce方法：数组求和

// arr.reduce(function(a, b) {

// console.log(a, b); // 3个元素执行2次，4个元素执行3次

// // 第一次，a代表第一个元素，b代表第二个元素

// // 第二次，a代表上次返回的值；b代表第三个元素

// // 第三次，a代表上次返回的值；b代表第四个元素

// return 666

// })、

var arr = [1, 2, 3, 4, 5]
var sum = arr.reduce(function(a, b) {
    return a + b
})
console.log(sum);

四、遍历数组：

var arr = ['a', 'b', 'c', 'd']
// console.log(0 + '---' + arr[0]);
// console.log(1 + '---' + arr[1]);
// console.log(2 + '---' + arr[2]);
// console.log(3 + '---' + arr[3]);

for (var a = 0; a < arr.length; a++) {
    console.log(a + '---' + arr[a]);
}

五、冒泡排序：

给数组中所有数字进行排序 ==> 每相邻的两个元素进行大小比较排列顺序

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

for (var b = 0; b < arr.length - 1; b++) {
    for (var a = 0; a < arr.length - 1 - b; a++) {
        if (arr[a] < arr[a + 1]) {
            var tmp = arr[a]
            arr[a] = arr[a + 1]
            arr[a + 1] = tmp
        }
    }
}

console.log(arr);

六、选择排序：

从大到小

从数组中找到最大值，排在第一位

从剩下的元素中找到最大值，排在第二位

从剩下的元素中找到最大值，排在第三位

...

for (var b = 0; b < arr.length - 1; b++) {
    for (var a = b + 1; a < arr.length; a++) {
        if (arr[b] < arr[a]) {
            var tmp = arr[b]
            arr[b] = arr[a]
            arr[a] = tmp
        }
    }
}
console.log(arr);