javascript 构建数组 javascript如何创建数组

数组

一.创建数组方式（3种）

1.创建字面量数组：var arr[];
2.创建数组对象

• new Array();
• new Array(size);
• new Array(element0,element1,…,elementn)

3.根据对象创建数组：var arr=new Oject([]); //不用

注意： 数组是一个引用列表；列 表：顺序，只有值，紧密，速度慢;
数组只有值得存储，只能遍历数组获取值是否存在;遍历内容较多，当添加删除元素时，因为数组紧密型，速度变慢，尤其前面插入和删除

var arr=[1,2,3,4,5];
arr[7]=10;   数组的紧密型，如果中间空余，就会自动补充空元素
console.log(arr);// [1, 2, 3, 4, 5, empty × 2, 10]

arr[-1]=10  插入到最后

二.数组属性

• length 设置或返回数组中元素的数目。
• length也是可以设置的，如果设置为0，表示清空数组，如果设置为3，表示保留到第三位
  例如：arr.length=0; //表示清空数组
  arr.length=-2;//错误数组长度不能为负值
  arr.length=“a”;//如果给的不是数值，会隐式转换为数值，如果值是NaN，就会报错（字符串中如果有字符存在，转换数据类型变为NaN）

三.数组的方法

• push()和pop()

push()方法：在数组尾部添加一个或多个新元素，并且返回数组的新长度

var arr=[1,2,3]; 
arr.push(5,6,7);
console.log(arr);//[1, 2, 3, 5, 6, 7]

pop()方法：删除数组的尾部元素，并且返回这个被删除的元素

var arr=[1,2,3];
var item=arr.pop();
console.log(item,arr);//3 >(2) [1, 2]

注意： 两个方法都修改并替换原始数组而非生成一个修改版的新数组。

• unshift()和shift()

unshift() 将一个或者多个新元素添加在数组的最前面，返回数组的新长度

var arr=[1,2,3];
a=arr.unshift(5,[6,7],8);
console.log(arr,a);//运行结果如下

shift(); 删除数组的第一个元素，并且返回该元素

var arr=[1,2,3,4];
item=arr.shift();
console.log(arr,item);//[2, 3] 1

• concat()和join()

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

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

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

var a=[1,2,3];
a.join(); //返回"1,2,3"
a.join(" "); //返回"1 2 3"
a.join(""); //返回"123"
a.join(); //返回"1,2,3"
var b=new Array(10);
b.join('-')//'---------':9个连字号组成的字符串

• splice()和slice()

splice()方法：第一个参数插入或删除的起始位置，第二个参数指定了应该从数组中删除的元素的个数。并返回一个由删除元素组成的数组，或者如果没有删除元素就返回一个空数组。
注意： 会改变原数组

var arr=[1,3,5,7,9,2,4,6,8,10];
var arr1=arr.splice(2,0,12,14);//插入元素13，14，插入在第二位
console.log(arr,arr1);//[1, 3, 12, 14, 5, 7, 9, 2, 4, 6, 8, 10] []
var arr1=arr.splice(2,2,12,14);//替换元素，删除两位并且插入12，14 [1, 3, 12, 14, 5, 7, 9, 2, 4, 6, 8, 10]  [12, 14]
console.log(arr,arr1)

slice(从什么位置开始，截取到什么位置之前);//返回一个新数组，原数组不改变

var a = [1,2,3,4,5];
a.slice(0,3); //返回[1,2,3]
a.slice(3); //[4,5]
a.slice(1,-1);//[2,3,4]
a.slice(-3,-2);//[3]

• indexOf()和lastIndexOf()

indexOf()方法：arr.indexOf(要查找的元素,从第几位开始查找被包含);查
找元素在数组中的下标,如果没有查找到返回-1

lastIndexOf()方法： 从后向前查找，
lastIndexOf(要查找的元素,从第几位开始查找被包含);

• forEach()

forEach()方法：从头到尾遍历数组，为每个元素调用指定的函数，传递的函数作为forEach()的第一个参数。然后forEach()使用三个参数调用该函数：数组元素、元素的索引和数组本身。

注意： forEach()无法在所有元素都传递给调用的函数之前终止遍历。forEach不能返回任何内容。forEach()不遍历空元素，也不遍历属性。

var arr=[2,4,6,8,10,,12,14,16,18,20];
 arr.a=10;
 // forEach不遍历空元素，也不遍历属性
 // forEach是匿名函数，无法阻止它在循环中断循环跳出
 arr.forEach(function(item,index,a){
     console.log(item,index,a);//打印结果如下图
 });

重构forEach方法
function forEach(arr,fn){
     for(var i=0;i<arr.length;i++){
         if(arr[i]===undefined) continue;
         fn(arr[i],i,arr);
     }
 }
 // 桥接模式
 forEach(arr,function(item,index,a){
     console.log(item,index,a);
 })

• map()

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

例如：a=[1,2,3];
b=a.map(function(x){return x*x;}); //b是[1,4,9]

注意： map()返回的是新数组，不修改调用的数组。如果是稀疏数组，返回的也是相同方式的稀疏数组，它具有相同的长度，相同的缺失元素。

• some()和every()

some()方法：遍历数组，查找是否有满足条件（返回的结果如果是true，）就直接跳出遍历，返回true。

var arr=[1,2,3,4,5,6];
var bool=arr.some(function(item,index,a){
	return item>4;
})
console.log(bool);//true

every()方法：判断每一个是否都满足条件，如果有一个返回的结果是false，直接返回false。

var arr=[1,2,3,4,5,6];
var bool=arr.every(function(item){
	return item>4;
});
console.log(bool);//返回false

• filter()

filter()方法：创建一个新数组，其中包含所提供函数实现的测试的所有元素。
注意： filter()会跳过稀疏数组中缺少的元素，他返回数组总是稠密的。

var arr=[1,2,3,4,5,6,7];
var arr1=arr.filter(function(item,index,a){
     return item>4;
 });
console.log(arr1);//[5, 6, 7]

• reduce()
  reduce()方法：归并 arr.reduce(function(上次归并值，本次遍历的元素，索引值，数组),初始化值)；
  如果没有设置初始化值，上次归并值初始值为数组的第0项，本次遍历将从下标1开始
  如果设置了初始化值，上次归并值初始值就是初始化值，本次遍历将从下标0开始

var arr=[1,2,3,4,5];
 var sum= arr.reduce(function(value,item,index,a){
     console.log(value,item);
     return value+item;
  },100);
  console.log(sum); //结果如下图

• sort()

sort()方法：用于对数组的元素进行排序，并返回数组。默认排序顺序是根据字符串UniCode码。因为排序是按照字符串UniCode码的顺序进行排序的，所以首先应该把数组元素都转化成字符串（如有必要），以便进行比较。

语法：arrayObject.sort(sortby);

例一：按照字母顺序排序

例二：还是按照字母进行排序

如果要得到自己想要的结果，不管是升序还是降序，就需要提供比较函数了。该函数比较两个值的大小，然后返回一个用于说明这两个值的相对顺序的数字。

比较函数应该具有两个参数 a 和 b，其返回值如下：

若 a 小于 b，即 a - b 小于零，则返回一个小于零的值，数组将按照升序排列。

若 a 等于 b，则返回 0。

若 a 大于 b, 即 a - b 大于零，则返回一个大于零的值，数组将按照降序排列。

例三：升序排列

例四：降序排序

• reverse()

reverse倒序，不排序，原数组改变，返回原数组;

var arr=[1,4,6,2,3,8,7,6,5,3,9];
 arr.reverse();
 console.log(arr);//9, 3, 5, 6, 7, 8, 3, 2, 6, 4, 1]