我对Javascript数组的理解

一：数组概念的理解
1.数组是值的有序集合。每个值叫一个元素，每个元素在数组中都有一个位置，以数字表示，称为索引。索引最小为0，最大为2的32次方减2，即0-4294967295。
2.数组是无类型的，数组元素可以是字符串，布尔型，Number,甚至数组和对象，同一数组中各个元素的类型也可以不尽相同。
3.数组长度是动态的，可根据需要增长或缩减。
4.数组元素的索引不一定要连续的，它们之间可以有空缺。每个javaScript数组都有一个length属性。针对非稀疏数组，该属性就是数组元素的个数；针对稀疏数组，length比所有元素的个数要大。

二：数组的创建
1.数组直接量

var empty = [ ];
var arr1 = [1,2,3,4];
var arr2 = [1.1,true,"a",] //数组直接量的语法允许有可选的结尾逗号，so [, ,]只有两个元素而非三个。
var arr3 = [[1,{x:2,y:3}],[1,2,3,4]] //可包含对象直接了和其他数组直接量
var arr4 = [1, ,3,] //省略某个元素的值，这个元素会被赋予undefined

2.调用构造函数
(1)调用无参构造函数
var a = new Array();
(2)有一个数值参数
var b = new Array(10) //指定数组b长度为10，可以用来预分配一个数组空间
（3）显示的指定另个或多个数组元素，或者一个非数值元素。这个参数会成为这个数组的元素
var c = new Array(1,2,3,4,5,”testing testing”)

三：数组元素的读和写
数组使用[ ]操作符来访问数组中的一个元素。c[0]=1
因为数组是对象的特殊形式，使用[ ] 访问数组和使用[ ]访问对象的属性是一样的。js将数组索引的值转换成字符串，然后作为属性名来访问(只有在0-4294967295之间的数组索引才可以当成属性名和自动维护他的length属性)。如 c[0]->c[“0”]

四：数组的长度
数组区分于常规js对象，是因为每个JS数组都有一个length属性。
针对稠密数组（非稀疏数组）,length代表数组中元素的个数，length的值比最大的索引大1.
针对所有数组。length的值大于任意一个索引值。

设置数组length属性的值，可以改变数组的长度。

var  arr=[1,2,3,4,5]
arr.length =>5
arr.length=3  =>arr=[1,2,3]
arr.length=5  =>arr=[1,2,3,undefined,undefined]

es5中，可用Object.defineProperty()，让数组的length变成只读
Object.defineProperty(arr,’length’,{writable:false})
再次设置arr.length=0 不会改变arr的长度。

五：数组遍历
（1）for循环：遍历数组 最常用 的方法。
for(var i = 0；i < arr.length ; i++){….} //假设数组是稠密数组，否则该检测它们

        for(var i = 0；i < arr.length ; i++){
            if（！arr[i]） continue;
        }        //跳过null,undefined，不存在的元素

        for(var i = 0；i < arr.length ; i++){
            if(a[i]===undefined) continue;
        }     //跳过undefined和不存在的元素

    for(var i = 0；i < arr.length ; i++){
            if(!(i in a))  continue;
    }          //跳过不存在的元素

（2）for/in循环
使用for/in循环处理稀疏数组。循环每次将一个可枚举的属性名赋给循环变量，不存在的变量将不会遍历到：

for(var i in arr){
    var value = arr[i]
}

因为for/in循环能够美剧集成的属性名，所以在数组中要过滤掉这些继承属性

for( i in arr){
    if(!arr.hasOwnProperty(i)) continue;
}

（3）forEach()方法
es5中定义的遍历数组的新方法，按照索引的顺序挨个传递给定义的一个函数

var arr = [1,2,3,4];
var sunOfSquares = 0;
arr.forEach(function(x){
    sumOfSquares += x*x;
})

sumOfSquares        =>55

六：多维数组
JS并不支持真正的多维数组，但可以用数组的数组来近似。
访问数组的数组中的元素只需要使用两次[ ]操作符即可。
，使用二维数组创建一个九九乘法表

var table = new Array(10);
for(var i = 0; i < table.length; i++){
    table[i] = new Array(10);
}   
for(var row = 0; row < table.length; row++){
     for(var col = 0; col < table[row].length; col ++){
             table[row][col]= row * col;
        }
    }

table[5][6]   =>30

八：数组元素的添加和删除
1.添加：
（1）push（）方法在数组末尾增加一个或多个元素

a=[];   
a.push("a");  也可用a[a.length]="a"
a.push("b","c");

（2）使用unshift（）方法在数组首部插入一个元素，会改变其他元素的索引。

2.删除：
（1）delete运算符

a = [1,2,3];
delete a[1];
1 in a   =>false;     //删除成功
a.length  =>3          //delete操作不会影响数组长度

( 2 )pop()方法（与push()一起使用）,删除数组尾部的一个元素并返回删除的元素值，不带参数。
（3）shift()方法（与unshift()方法一起使用），删除头部的元素。

3.splice()是一个通用的方法用来插入，删除或替换数组元素。

splice(start,num,item1,item2)  item为增加的元素。

九：数组方法
1.join()
Array.join()方法将数组中所有元素都转化为字符串并连接在一起，返回最后生成的字符串。可以自己指定分隔的符号，如果不指定，默认使用逗号

var arr = [1,2,3];
console.log(arr.join());//"1,2,3"
console.log(arr.join("-"));//"1-2-3"

var a = new Array(10); //长度为10的空数组 组成下边字符串
console.log(a.join("-"));//"---------"

2.reverse()
Array.reverse()方法将数组中的元素颠倒顺序，返回逆序的数组（返回的数组是其本身，原始数组已经改变了）

var arr = [1,2,3];
arr.reverse();
console.log(arr.join());//"3,2,1"

所以，如果想把一个字符串逆序的话，可以这样

var str = "abcdefg";

console.log(str.split("").reverse().join(""));//"gfedcba" 返回的是新的值
console.log(str); //"abcdefg" 当然了，原始的是不会变的.

3.sort()
Array.sort()方法将数组中的元素排序并返回排序后的数组。
当不带参数时，默认按照顺序排序，也就是从小到大。当然，也可以直接给sort加一个比较函数比较

var arr = [1,4,7];
arr.sort();
console.log(arr); //[1,4,7]

arr.sort(function(a,b){
 return a-b; //从小到大
});
console.log(arr); //[1,4,7]

arr.sort(function(a,b){
 return b-a; //从大到小
});
console.log(arr); //[7,4,1]

var num = new Array('one','three','Six','Five');
num.sort(); //区分大小写排序
console.log(num); // ["Five", "Six", "one", "three"]

num.sort(function(s,t){
 var a = s.toLowerCase();
 var b = t.toLowerCase();
 if(a<b) return -1;
 if(a>b) return 1;
 return 0;
});
console.log(num); // ["Five", "one", "Six", "three"]

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]

1. 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]

（2）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]

var data = [1,2,3,4,5];
var sum = 0;
data.forEach(function(value,item,data){ //调用的函数具有了三个参数
  data[item] = value*value; //取平方
});

console.log(data);// [1, 4, 9, 16, 25]

2.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]

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

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<b)?a:b;
});

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

最后

以上就是超级羽毛为你收集整理的我对Javascript数组的理解的全部内容，希望文章能够帮你解决我对Javascript数组的理解所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。