逆袭班学习之 数组—1

数组
数组的概念 
所谓数组，是有序的元素序列。（一组有序 数据）
JavaScript的Array可以包含任意数据类型。注：一般来说数组中元素的类型相同
数组里边可以嵌套对象
但对象里边无法嵌套数组
当你在对象里边嵌套数组的时候会报错： Uncaught SyntaxError: Unexpected token
数组的创建方式  
1-字面量 （利用数组字面量创建数组）
数组的字面量是方括号 [ ] 
声明数组并赋值称为数组的初始化
这种字面量方式也是我们以后最多使用的方式
var arr = [1, 2];//数组中有两个元素
arr.length ;//获取数组的长度   （将数组的长度改为0可强制清除数组内容）
数组可以通过索引来访问、设置、修改对应的数组元素，我们可以通过“数组名[索引]”的形式来获取数组中的元素。
这里的访问就是获取得到的意思。
arr[i]获取数组中的第i个元素，i称为数组的下标或者索引，下标从0开始
arr[0]//获取数组中的第一个元素    
arr[0] = 100;//修改数组中第一个元素的值为100 
2- 构造函数方式创建数组 （利用  new 创建数组）
这种方式暂且了解，等学完对象再看
注意 Array () ，A 要大写
Array是一个构造函数（原生自带），可以用它生成新的数组
var arr = new Array(2);// 生成一个两个成员的数组
arr.length // 2-------
arr[0]//undefined
上面代码中，Array构造函数的参数2，表示生成一个两个成员的数组。 
数组中可以存放任意类型的数据，例如字符串，数字，布尔值等；
Array构造函数有一个很大的缺陷，就是不同的参数，会导致它的行为不一致。
// 单个非数值（比如字符串、布尔值、对象等）作为参数，
// 则该参数是返回的新数组的成员
new Array('abc') // ['abc']
// 多参数时，所有参数都是返回的新数组的成员
new Array(1, 2) // [1, 2]
new Array('a', 'b', 'c') // ['a', 'b', 'c']
可以看到，Array作为构造函数，行为很不一致。因此，不建议使用它生成新数组，直接使用数组字面量是更好的做法。
数组的操作
.push() 添加/pop() 删除
作用于数组的末端；
!!!   push方法用于在数组的末端添加一个或多个元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组
var arr = [];
arr.push(1) // 1
arr.push('a') // 2
arr.push(true, {}) // 4
arr // [1, 'a', true, {}]
!!!   pop方法用于删除数组的最后一个元素，并返回该元素。注意，该方法会改变原数组。
var arr = ['a', 'b', 'c'];
arr.pop() // 'c'
arr // ['a', 'b']
对空数组使用pop方法，不会报错，而是返回undefined。
补充计算机基础
push和pop结合使用，就构成了“后进先出”（先加的先删）的栈结构（stack）。
var arr = [];
arr.push(1, 2);
arr.push(3);//1,2,3
arr.pop();
arr // [1, 2]
上面代码中，3是最后进入数组的，但是最早离开数组。
.concat()  合并数组
不改变原数组，返回合并后的数组

.unshift() 添加/.shift() 删除
作用于数组的头部；
!!!   shift方法用于删除数组的第一个元素，并返回该元素。注意，该方法会改变原数组。
var a = ['a', 'b', 'c'];
a.shift() // 'a'
a // ['b', 'c']
push和shift结合使用，就构成了“先进先出”的队列结构（queue）。
!!!   unshift方法用于在数组的第一个位置添加元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组。
var a = ['a', 'b', 'c'];
a.unshift('x'); // 4
a // ['x', 'a', 'b', 'c']
.slice（起始,终止）复制
!!!   slice方法用于复制目标数组的一部分，返回一个新数组，原数组不变。
arr.slice(start, end);
它的第一个参数为起始位置（从0开始），第二个参数为终止位置（但该位置的元素本身不包括在内）。如果省略第二个参数，则一直返回到原数组的最后一个成员。
var a = ['a', 'b', 'c'];
a.slice(0) // ["a", "b", "c"]
a.slice(1) // ["b", "c"]
a.slice(1, 2) // ["b"]
a.slice(2, 6) // ["c"]
a.slice() // ["a", "b", "c"]
上面代码中，最后一个例子slice没有参数，实际上等于返回一个原数组的拷贝。
如果slice方法的参数是负数，则表示倒数计算的位置。
var a = ['a', 'b', 'c'];
a.slice(-2) // ["b", "c"]
a.slice(-2, -1) // ["b"]
上面代码中，-2表示倒数计算的第二个位置，-1表示倒数计算的第一个位置。
如果第一个参数大于等于数组长度，或者第二个参数小于第一个参数，则返回空数组。
var a = ['a', 'b', 'c'];
a.slice(4) // []
a.slice(2, 1) // []
.splice（起始,几个,添加,添加）删除部分再补上
!!!   splice方法用于删除原数组的一部分成员，并可以在删除的位置添加新的数组成员，返回值是被删除的元素。注意，该方法会改变原数组。
arr.splice(start, count, addElement1, addElement2, ...);
splice的第一个参数是删除的起始位置（从0开始），第二个参数是被删除的元素个数。如果后面还有更多的参数，则表示这些就是要被插入数组的新元素。
var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(4, 2) // ["e", "f"]
a // ["a", "b", "c", "d"]
上面代码从原数组4号位置，删除了两个数组成员。
var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(4, 2, 1, 2) // ["e", "f"]
a // ["a", "b", "c", "d", 1, 2]
上面代码除了删除成员，还插入了两个新成员。
起始位置如果是负数，就表示从倒数位置开始删除（还是往后删除）。
var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(-4, 2) // ["c", "d"]
上面代码表示，从倒数第四个位置c开始删除两个成员。
如果只是单纯地插入元素，splice方法的第二个参数可以设为0。
var a = [1, 1, 1];
a.splice(1, 0, 2) // []  在 删除位置的前面添加了
a // [1, 2, 1, 1]
如果只提供第一个参数，等同于将原数组在指定位置拆分成两个数组。
var a = [1, 2, 3, 4];
a.splice(2) // [3, 4]
a // [1, 2]
.reverse()颠倒
reverse方法用于颠倒排列数组元素，返回改变后的数组(还是原数组)。注意，该方法将改变原数组。
var a = ['a', 'b', 'c'];
a.reverse() // ["c", "b", "a"]
a // ["c", "b", "a"]
.sort()排序
sort方法对数组成员进行排序，默认是按照字典顺序排序。排序后，原数组将被改变。返回改变后的数组(还是原数组) 
['d', 'c', 'b', 'a'].sort()
// ['a', 'b', 'c', 'd']
[4, 3, 2, 1].sort()
// [1, 2, 3, 4]
[11, 101].sort()
// [101, 11]
[10111, 1101, 111].sort()
// [10111, 1101, 111]
上面代码的最后两个例子，需要特殊注意。sort方法不是按照大小排序，而是按照字典顺序。也就是说，数值会被先转成字符串，再按照字典顺序进行比较，所以101排在11的前面。
如果想让sort方法按照自定义方式排序，可以传入一个函数作为参数。
[10111, 1101, 111].sort(function (a, b) {
  return a - b;//升序  （return b – a;降序）                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
})
// [111, 1101, 10111]
上面代码中，sort的参数函数本身接受两个参数，表示进行比较的两个数组成员。如果该函数的返回值大于0，表示第一个成员排在第二个成员后面；其他情况下，都是第一个元素排在第二个元素前面
sort()内部是利用递归进行冒泡排序的；
例如：
var arr = [1, 5, 4, 2];
sort()方法的比较逻辑为：
第一轮：1和5比，1和4比，1和2比
第二轮：5和4比，5和2比
第三轮：4和2比
其次，sort()方法会接受一个比较函数compare(a, b)，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。
最后，永远要记住一句话，凡是返回1或者大于0的正数的时候就要交换位置。（内部实现）
.Join(分隔符) 用于数组转字符串
join方法以指定参数作为分隔符，将所有数组成员连接为一个字符串返回一个新字符串，不改变原数组。如果不提供参数，默认用逗号分隔。
var a = [1, 2, 3, 4];
a.join(' ') // '1 2 3 4'
a.join(' | ') // "1 | 2 | 3 | 4"
a.join() // "1,2,3,4"
如果数组成员是undefined或null或空位，会被转成空字符串。
[undefined, null].join('#')
// '#'
['a',, 'b'].join('-')
// 'a--b'``