JavaScript权威指南（第六版） （JavaScript 数组一些概念）笔记

1.Javascript是区分大小写的语言。也就是说，关键字，变量，函数名和所有的标识符（identifier）都必须采用一致的大小写形式。

2.直接量：所谓直接量（Literal）就是程序中直接使用的数据值。例如：
 12//数字
 1.2
  “helll”
  true
  false
  /javascript/gi  //正则表达式直接量（用做模式匹配）
 
3.javascript数组一些基本概念：
1）javascript数组是值的有序集合。每个值叫做一个元素，而每一个元素在数组中有一个位置，以数字表示，称为索引。
2）javascript数组是无类型的：每个数组元素可以是任意类型，并且同一个数组中的不同元素也有可能有不同的类型。数组的元素也有可能是对象或者是其他数组，这允许创建复杂的数据结构，如对象的数组和数组的数组。
3）javascript数组的索引是基于零的32位数值：第一个元素的索引为0，最大可能的索引为4294967294，数组最大能容纳4294967295个元素。
4）javascript数组是动态的：根据需要它们会增长或缩减，并且创建数组时无须声明一个固定的大小或者在数组大小变化时无需重新分配空间。
5）javascript数组可能是稀疏的：数组元素的索引不一定要连续的，它们之间可以有空缺。
6）每个javascript数组都一个length属性。针对非稀疏数组，该属性就是数组元素的个数。针对稀疏数组，length比所有元素的索引要大。

4.数组方法
1）join（）:
Array.join()方法将数组中所有元素都转化为字符串并连接在一起，返回最后生成的字符串。可以指定一个可选的字符串在生成的字符串中来分割数组的各个元素。如果不知道分割符，默认使用逗号。
例如：
 var a = [1, 2, 3];  //创建一个包含三个元素的数组
 a.join();  // =>"1,2,3"
 a.join(" ")； // => "1 2 3"
 a.join("");  // =>"123"
 var b = new Array(10);  //长度为10的空数组
 b.join('-'); //=>’----------‘:9个连字号组成的字符串
 
Array.join()方法是String.split()方法的逆向操作，后者是将字符串分割成若干块创建一个数组。

2）reverse（）
Array.reverse()方法将数组中的元素颠倒顺序，返回逆序的数组。
它采取了替换：它不通过重新排列的元素创建新的数组，而是在原先的数组中重新排列它们。
例如：
   var a =[1,2,3];
   a.reverse().join()  // =>"3,2,1",并且现在的a是[3,2,1]

3）sort()
Array.sort()方法将数组中的元素排序并返回排序后的数组。当不带参数调用sort()时，数组元素以字母表顺序排序（如有必要将临时转化为字符串进行比较）：
   var a = new Array("banana", "cherry", "apple");
   a.sort();
   var s = a.join(", "); //s== "apple, banana, cherry"
如果数组包含undefined元素，它们会被排到数组的尾部。

为了按照其他方式而非字母表顺序进行数组排序，必须给sort()方法传递一个比较函数。该函数决定了它的两个参数在排好序的数组中的先后顺序。加上第一个参数应该在前，比较函数应该返回一个小于0的数值。反之，假设第一个参数应该在后，函数应该返回一个大于0的数值。并且假设两个值相等函数应该返回0。因此用数值大小而非字母表顺序进行数组排序，代码如下：
   var a = [33, 4, 1111, 222];
   a.sort();           //字母表顺序：1111， 222，33，4
   a.sort(function(a, b) { //数值顺序： 4，33，222，1111
   return a-b; //根据顺序,返回负数， 0，正数
  });
   a.sort(function(a ,b){return b-a}); //数值大小相反的顺序
  
另外一个数组元素排序的例子，需要对一个字符串数组执行不区分大小写的字母表排序，比较函数首先将参数都转化为小写字符串（使用toLowerCase()方法），再开始比较：
    a = ['ant', 'Bug', 'cat', 'Dog']
    a.sort();                //区分大小写的排序：['Bug', 'Dog', 'ant', 'cat']
 a.sort(function(s,t){    //不区分大小写的排序
   var a = s.toLowerCase();
   var b = t.toLowerCase();
   if(a     return -1;
   }
   if(a>b) {
    return 1;
   }
   
   return 0;   
  })        // =>['ant', 'Bug', 'cat', 'Dog']

4)concat()
Array.concat()方法创建并返回一个新数组，它的元素包括调用concat()的原始数组的元素和concat()每个参数。
如果这些参数中的任务一个自身是数组，则连接的是数组的元素，而非数组本身。
但要注意，concat()不会递归扁平化数组的数组。concat()也不会修改调用的数组。

var arr = [1,2,3];
console.log(arr.concat(4,5)); // 返回[1, 2, 3, 4, 5]
console.log(arr);  // 返回[1, 2, 3]
console.log(arr.concat([4,5])); // 返回[1, 2, 3, 4, 5]
console.log(arr.concat([4,5],[6,7])); // 返回[1, 2, 3, 4, 5,6,7]
console.log(arr.concat([4,[5,[6,7]]])); // 返回[1, 2, 3, 4, [5, [6, 7]]]
console.log(arr.concat(4,[5,[6,7]])); //返回 [1, 2, 3, 4, 5,[6,7]]

5）slice()
Array.slice()方法返回指定数组的一个片段或子数组。它的两个参数分别指定了片段开始和结束的位置（a,b）。返回的是从a开始到b的不包括b的数组元素。
如果只有一个参数(a).则代表从a到数组结尾的元素。
如果参数中出现负数（-a). 则表示相对于数组中最后一个元素相距a的位置。比如（-3）代表倒数第三个元素到末尾。出现负数就先换算出来，然后按照范围规则找出来
它也是返回新的数组，不会修改原始数组

var arr = [1,2,3,4,5];
console.log(arr.slice(0,3)); // [1, 2, 3]
console.log(arr); // [1, 2, 3, 4, 5]
console.log(arr.slice(3));//[4, 5]
console.log(arr.slice(-3));// [3, 4, 5]
console.log(arr.slice(-3,-1));// [3, 4]
console.log(arr.slice(2,-1));// [3, 4]

6）splice()
Array.splice()方法是在数组中插入或者删除元素的通用方法。它会修改原始数组的值，并返回一个新的数组序列
splice()的第一个参数指定了插入或删除的起始位置，第二个参数指定了应该从数组中删除的元素的个数。第二个参数省略则默认删到末尾。
 
var arr = [1,2,3,4,5,6,7,8];
console.log(arr.splice(4)); //[5, 6, 7, 8]
console.log(arr); // [1, 2, 3, 4]
console.log(arr.splice(1,2));// [2, 3]
console.log(arr); // [1, 4]
splice()的前两个参数指定了需要删除的数组元素。紧随其后的任意个数的参数指定了需要插入到数组中的元素，并从第一个参数代表的位置开始插入。
不同于上边的concat()，splice()是直接把数组插进去，比如下面的[1,2]
 
 
var arr = [1,2,3,4,5];
console.log(arr.splice(2,0,'a','b')); // []
console.log(arr); // [1, 2, "a", "b", 3, 4, 5]
console.log(arr.splice(2,1,[1,2],3));// ["a"]
console.log(arr); // [1, 2, [1, 2], 3, "b", 3, 4, 5]

7）push() pop() unshift() shift()
把这些方法看成栈操作就行：前两者正常的栈操作，后两者是反向的栈操作
push()和unshift()往数组中从后面、前面添加元素，并返回新数组的长度
pop()和shift()删除数组中最后、最前的元素，并返回删除的元素
 
var arr = [];
console.log(arr.push(1,2,3));//3
console.log(arr);//[1, 2, 3]
 
console.log(arr.pop());// 3
console.log(arr);//[1,2]
 
console.log(arr.push([4,5]));//3
console.log(arr);// [1, 2, [4, 5]]
 
var arr = [];
 
console.log(arr.unshift(1,2,3));//3
console.log(arr);//[1, 2, 3]
console.log(arr.shift());// 1
console.log(arr);// [2, 3]
console.log(arr.unshift([4,5]));//3
console.log(arr);//[[4, 5], 2, 3]

5.ECMAScript5中的数组方法
这一类数组方法大多数有统一大致的规则。它们都不会修改原始数组。
大多数方法的第一个参数接收一个函数，并且对数组的每个元素（或一些元素）调用一次该函数。
　　　　如果是稀疏数组，对不存在的元素不调用传递的函数；
　　　　在大多数情况下，调用的这个函数一般使用三个参数：数组元素、元素的索引、数组本身。通常后两个参数也不需要填写进去。
除了这里第一个参数（函数）之外，还有第二个参数（它是可选的），如果第二个参数存在，则调用的函数将被看做是第二个参数的方法。
　　　　也就是说，在调用函数时传递进去的第二个参数作为它的this关键字的值来使用。
1）forEach()
这个方法从头至尾遍历数组，为每个数组调用指定的函数。
 
var data = [1,2,3,4,5];  //要求和的数组
var sum = 0;
data.forEach(function(value){ //只使用了第一个参数（函数），调用的函数也只使用了第一个参数数组元素
 sum += value;
});
 
console.log(sum);//15
console.log(data);// [1, 2, 3, 4, 5]
注意：forEach()无法在所有元素都传递给调用的函数之前终止遍历。也就是说，没有像for循环中使用的相应break语句。
如果要提前终止，必须把forEach()方法放在一个try块中,并能抛出一个异常.如果forEach()调用的函数抛出foreach.break异常,循环会提前终止:
 function foreach(a, f, t) {
  try {
   a.forEach(f,t);
  } catch(Excepiton e) {
   if( e=== foreach.break) {
    return;
   } else {
    throw e;
   }
  }
 }
 foreach.break = new Error("StopIteration");

2)map()
map()方法将调用的数组的每个元素都传递给指定的函数，并返回一个数组，它包含该函数的返回值。 

 var data = [1,2,3,4,5];
 var data1 = data.map(function(value){
  return ++ value;
 });
 
 console.log(data); // [1, 2, 3, 4, 5]
 console.log(data1);// [2, 3, 4, 5, 6]

3）filter()
这个方法返回的数组元素是调用的数组的一个子集。传递的函数是用来逻辑判定的，该函数返回true或false。
如果返回值是true或者能转化为true的值，那么传递给判定函数的元素就是这个子集的成员，它将被添加到一个作为返回值的数组中。
 
 var data = [1,2,3,4,5];
 var data1 = data.filter(function(value){
  return value <= 3;
 });
 
 var data2 = data.filter(function(value){
  return value > 3;
 });
 
 console.log(data); // [1, 2, 3, 4, 5]
 console.log(data1);// [1,2,3]
 console.log(data2);// [4,5]

注意：filter（）会跳过稀疏数组中缺少的元素，它的返回数组总是稠密的。为了压缩稀疏数组的空缺，代码如下：
    var dense = sparse.filter(function() {
   return true;
  });
   甚至，压缩空缺并删除undefined和null元素，可以这样使用filter();
   a = a.filter(function(x) { return x != undefined && x != null; });
  
4）.every()和some()
顾名思义，every()就是数组中所以元素都满足函数指定的条件时 返回true; some()就是某一项满足时就返回 true
 
 var data = [1,2,3,4,5];
 var data1 = data.every(function(value){
  return value < 4;
 });
 
 var data2 = data.some(function(value){
  return value >4;
 });
 
 console.log(data); // [1, 2, 3, 4, 5]
 console.log(data1);// false
 console.log(data2);// true  

注意：一旦every()和some()确认该返回什么值它们就会停止遍历数组元素。
some（）在判定函数第一次返回true后就返回true，但如果判定函数一致返回false，它将会遍历整个数组。
every（）恰好相反：它在判定函数第一次返回false后就返回false，但如果判定函数一指返回true，它将会遍历整个数组。
注意：根据数学上的惯例，在空数组上调用时，every()返回true，some（）返回false。

5）reduce()和reduceRight()
这两个方法使用指定的函数将数组元素进行组合，生成单个值。
reduce()有两个参数。第一个是执行化简操作的函数，就是说用某种方法把两个值化简为一个值，并返回化简后的值。
　　　　　　　　　　第二个参数可选，用来传递给第一个参数函数作为初始值。如果第二个参数没有，则初始值就使用数组的第一个元素值。

 var data = [1,2,3,4,5];
 var sum = data.reduce(function(a,b){
  return a+b;
 });
 
 var sum1 = data.reduce(function(a,b){
  return a+b;
 },5);
 
 var min = data.reduce(function(a,b){
  return (a  });
 
 console.log(data); // [1, 2, 3, 4, 5]
 console.log(sum);// 15
 console.log(sum1);// 20
 console.log(min);// 1

sum中没有第二个参数，所以初始值为第一个数组元素，第一步1+2=3，第二步3+3=6... 最后得15
sum1中有第二个参数，所以初始值为5，第一步5+1=6，第二步6+2=8... 最后得20
reduceRight()和reduce()差不多，不同的是它按照数组索引从高到低（从右到左）处理数组，而不是正常的从低到高。
 
 var data = ['a','b','c'];
 var str = data.reduce(function(x,y){ //顺序
  return x+y;
 });
 
 var str1 = data.reduceRight(function(x,y){ //逆序
  return x+y;
 });
 
 console.log(data);// [1, 2, 3]
 console.log(str);//"abc"
 console.log(str1);//"cba"

6）indexOf()和lastIndexOf()
这个方法搜索整个数组中具有给定值的元素，返回找到的元素的索引（找到了一个就退出了），没有找到则返回-1.
一个从头至尾，一个从尾至头
 
 var data = ['a','b','a','c','a'];
 
 console.log(data.indexOf('a')); //0
 console.log(data.indexOf('d')); //-1
 console.log(data.lastIndexOf('a'));//4
 
 console.log(data.lastIndexOf('a',-2));//2 从倒数第二个开始
 console.log(data.lastIndexOf('a',1));//0? 从顺序第二个往前
 
7）数组类型 isArray()
判断一个对象是不是数组
 
console.log(Array.isArray([]));//true
console.log(Array.isArray({}));//false
 
//模拟上边的
var isArray1 = Function.isArray||function(o){
  return typeof o === "object" && Object.prototype.toString.call(o) === "[object Array]";
};
 
console.log(isArray1([]));//true
console.log(isArray1({}));//false