-
什么是标准库？？
image.png 数据类型的简单复习
Object(1) //Number {1}
Object('ss') //String {"ss"}
Object() //{}
new Object() //{}
----------------------------
Number(2) //2
Number(true) //1
Number('ss') //NaN
new Number(2) //Number {2}
-------------------------------------
String(2) //"2"
new String(2) //String {"2"}
String(null) //"null"
String(false) //"false"
String(undefined) //"undefined"
---------------------------
Boolean(1) //true
Boolean(0) //false
new Boolean(0) //Boolean {false}
-------------------
5个falsey值：0 NaN null undefined “”
1. window.Array和window.Function
1.1 Array和Function 的创建
1.1.1 Array
JavaScript 的 Array 对象是用于构造数组的全局对象
创建数组：
let a1 = ['a','b'] //["a", "b"]
let a3 = new Array('a','b') //["a", "b"]
let a4 =Array('a','b') //["a", "b"]
var a = Array(3) 到底会生成什么？？？？
var a = Array(3)
a
(3) [empty × 3]
length: 3
__proto__: Array(0)
a[0] //undefined
a[1] //undefined
a[2] //undefined
'0' in a //false
a['length'] //3
画个内存图看看：
实际上
var a = Array(3) 没有存 任何 key；
那么 ，var a = Array(3，3) 会生成什么？？？？
var a1 = Array(3,3)
undefined
a1
(2) [3, 3]
0: 3
1: 3
length: 2
__proto__: Array(0)
所以：
小结：
1.1.2 Function
Function 构造函数 创建一个新的Function对象。 在 JavaScript 中, 每个函数实际上都是一个Function对象。
语法：
new Function ([arg1[, arg2[, ...argN]],] functionBody)
创建函数：
var f1 = function(a,b){
return a+b;
}
var f2 = new Function('a','b','return a+b')
f1(1,2) //3
f2(1,3) //4
var f3 = Function('a','b','return a+b')
f3(1,3) //4
1.2 到底什么是数组
1.2.1 什么是数组-------由 window.Array 所构造出来的对象即是 数组；
如上：数组 不同于 一般对象 是因为 __proto__引用的原型不同，数组有数组特定的 方法；
1.2.2 数组 与 对象 的遍历
var a1 = [1,2,3]
a1.xxx = 'xxx'
a1.yyy = 'yyy'
console.log(a1)
//[1, 2, 3, xxx: "xxx", yyy: "yyy"]
for(let i = 0; i<a1.length; i++){ // 数组的遍历方法
console.log(a1[i])
} //1,2,3
for(let key in a1){ // 一般对象的遍历方法
console.log(key)
} // 0,1,2,xxx,yyy
var obj = {'0':11, '1':12, '2':13, 'length':3}
console.log(obj)
// {0: 11, 1: 12, 2: 13, length: 3}
for(let i = 0; i<obj.length; i++){
console.log(obj[i])
} //11,12,13
for(let key in obj){
console.log(key)
} // 0,1,2,length
对比发现：遍历只是一种独立存在的方法，遍历的目标是数组还是一般对象并无多大区别（对象会多遍历一个‘length’）；
而对于 key 类似于 数组的对象，也可以当做数组来看，除了不能引用数组特有的方法（即，没有 链 到 Array.prototype 这个hash上）；这种对象也可叫 伪数组；
伪数组举例：
function f(){
console.dir(arguments)
}
f(1,2,3)
Arguments(3)
0:1
1:2
2:3
callee:ƒ f()
length:3
Symbol(Symbol.iterator):ƒ values()
__proto__:Object
传给函数的参数即为 伪数组；
1.3 Array.forEach()
返回值：
也可以说：无返回值；
举个例子：
function 接受一个函数为参数并执行(f){
if(typeof f !=='function'){
console.log('滚')
return false
}else{
console.log('我接受了一个函数作为实参')
f(666)
console.log('给这个实参传了参数，并且执行了这个作为实参的函数')
return true
}
}
接受一个函数为参数并执行(function(xxx){
console.log(xxx)
})
我接受了一个函数作为实参
666
给这个实参传了参数，并且执行了这个作为实参的函数
true
------------------
接受一个函数为参数并执行(123)
滚
false
上述例子中有个特点：作为参数的函数，其自身的参数由调用他的函数指定；
Array.forEach() ：接受一个函数作为参数，并给这个函数指定参数；
function forEach(array,x){
for(let i = 0; i < array.length; i++){
x(array[i],i)
}
}
forEach(['a','b',3],function(value,key){
console.log(value,key)
})
---
a 0
b 1
3 2
---------------------------
['a','b',3].forEach(function(value,key,a){
console.log(value,key)
console.log(a)
})
a 0
(3) ["a", "b", 3]
b 1
(3) ["a", "b", 3]
3 2
(3) ["a", "b", 3]
1.4 Array.sort()
sort() 方法是对数组的元素进行排序，并返回排序后的数组。
var fruit = ['cherries', 'apples', 'bananas'];
fruit.sort();
// ['apples', 'bananas', 'cherries']
var scores = [1, 10, 21, 2];
scores.sort();
scores // [1, 10, 2, 21]
// 注意10在2之前,
// 因为在 Unicode 指针顺序中"10"在"2"之前
var things = ['word', 'Word', '1 Word', '2 Words'];
things.sort();
// ['1 Word', '2 Words', 'Word', 'word']
// 在Unicode中, 数字在大写字母之前,
// 大写字母在小写字母之前.
语法
arr.sort()
arr.sort(compareFunction)
参数
compareFunction---
可选。用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。
返回值
返回排序后的数组。原数组已经被排序后的数组代替。
如果没有指明 compareFunction ，那么元素会按照转换为的字符串的诸个字符的Unicode位点进行排序。例如 "Banana" 会被排列到 "cherry" 之前。当数字按由小到大排序时，9 出现在 80 之前，但因为（没有指明 compareFunction），比较的数字会先被转换为字符串，所以在Unicode顺序上 "80" 要比 "9" 要靠前。
var numbers = [4, 2, 5, 10, 3];
numbers.sort(function(a, b) {
return b - a;
});
(5) [10, 5, 4, 3, 2]
-----------------------------------------
var numbers = [4, 2, 5, 10, 3];
numbers.sort(function(a, b) {
return a - b;
});
(5) [2, 3, 4, 5, 10]
- 如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；
- 如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。
- 如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变。备注： ECMAScript 标准并不保证这一行为
1.5 join&concat&map&filter&reduce
1.5.1 Array.join()
例：
var a = [1,2,3]
a.join("方")
"1方2方3"
a.join(",")
"1,2,3"
a.toString()
"1,2,3"
a + ''
"1,2,3"
a.join()
"1,2,3"
1.5.2 Array.concat()
举例：
var a = [1,2,3]
var b = [4,5,6]
a + b //"1,2,34,5,6"
var c = a.concat(b)
c //(6) [1, 2, 3, 4, 5, 6]
var d = a.concat([]) //或者 var d = a.concat()
d //(3) [1, 2, 3]
d === a //false
var e = a
e // [1, 2, 3]
e === a //true，e和a 是同一个数组
a.xx = 'xx'
e //[1, 2, 3, xx: "xx"]
d //[1, 2, 3] d 是一个拷贝a后生成的新的数组
1.5.3 Array.map()
Array.map() 和 Array.forEach() 相似，区别在于，Array.map() 有返回值；
Array 本身不变；
var a = [1,2,3]
a.map(function(value,key){})
(3) [undefined, undefined, undefined]
0: undefined
1: undefined
2: undefined
length: 3
__proto__: Array(0)
a.map(function(value,key){
return value * 2
})
(3) [2, 4, 6]
a.forEach(function(value,key){})
undefined
a.forEach(function(value,key){
return value * 2
})
undefined
a.map(value => value * 2)
(3) [2, 4, 6]
a.map(value => value * 10)
(3) [10, 20, 30]
a.map(function(value,key){
return 2
})
(3) [2, 2, 2]
a.map(function(value,key){
return ['a','b']
})
(3) [Array(2), Array(2), Array(2)]
0:(2) ["a", "b"]
1:(2) ["a", "b"]
2:(2) ["a", "b"]
length:3
__proto__:Array(0)
1.5.4 Array.prototype.filter()
filter() 方法创建一个新数组, 其包含通过所提供函数 筛选 的所有元素。
var words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
var result = words.filter(word => word.length > 6);
console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]
************
var a = [1,2,3,4,5,6,7,8,9]
a.filter(function(value,key){
return value >= 5
})
(5) [5, 6, 7, 8, 9]
Array.filter()-----过滤器
1.5.4 Array.prototype.reduce()
Array.reduce()的简化理解：
function reduce(f,initialValue){
for(let i = 0; i < this.length; i++){
n = this[i]
sum = f(sum,n)
}
return sum
}
-------------------------------
a = [1,2,3,4]
// reduce(f(sum,n),0,a)
a.reduce(function(sum,n){return sum+n;},0)
10
a1 = [1,2,3,4,5]
(5) [1, 2, 3, 4, 5]
a1.reduce(function(sum,n){return sum+n;},0)
15
// 或者
a.reduce((sum,n) => sum+n,0)
10
参数：
callback
执行数组中每个值的函数，包含四个参数：
accumulator
累加器累加回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue（如下所示）。currentValue
数组中正在处理的元素。即当前遍历到的 value。currentIndex（可选）
数组中正在处理的当前元素的索引。 如果提供了initialValue，则索引号为0，否则为索引为1。array（可选）
调用reduce的数组initialValue（可选）
用作第一个调用 callback的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错
