创建数组
第一种：

var color=new Array() //第一种使用Array构造函数
 var color=new Array(10) //设置length为10的数组
 var colors=new Array(“red”, “blue”,“green”) //包含3个字符串值的数组。即3项的数组。
 var colors=Array(3) //创建一个包含3项的数组，长度为3，值为undefined
 var name=Arry(“greg”) //创建包含1项的数组


第二种：数组字面量表示法

var color=[] //创建一个空数组
 var color=[‘red’,‘blue’,‘green’]// 创建包含3个字符串的数组
 var value=[1,2,] //不推荐，不要这样，这样会创建一个包含2项或者3项的数组
 var options=[,] //不要这样，这样会创建一个包含5项或者6项的数组。

获取或设置数组的值
读取或者设置数组值时候，要使用方括号并提供相应值的基于0的数字索引：

var color=[‘red’,‘blue’,‘green’]
 console.log(color[0]) //red
 console.log(color[1]) //blue
 color[2]=‘black’; //修改第三项，把green的改成black
 color[3]=‘brown’ //新增第四项


获取数组长度的方法： color.length //3
修改数组长度，可以从数组末尾移除项或向数组添加新项。
例如：color.length=2; console.log(color[2]) //undefined
例如：color.length=4; console.log(color[3]) //undefined
也可以利用length属性给数组添加新项：
例如：color[color.length]=‘yellow’;

一般的清空数组元素

1、var ary = [1,2,3,4]; （执行速度第二2）
ary.splice(0,ary.length);//清空数组 
2、这种方式数组长度不变,此时arr[1]变为undefined了,但是也有好处原来数组的索引也保持不变,此时要遍历数组元素可以才用。（删除一个元素）
delete arr[1]

3、给数组的length赋值为0 (执行速度最快1)
   var arr = [1,2,3,4];  
   arr.length = 0;

4、直接赋予新数组 []   （大量数据清空下，执行熟读最慢3）
  var arr = [1,2,3,4];  
   arr = [];

检测数组

第一种方法
if( value instanceof Array){  返回值是true或者false
    //对数组进行操作
}
第二种方法(推荐)
if(Array.isArray(value)){ //返回true或者false
 //对数组进行操作
}

转换方法–数组转成字符串

var colors=[‘red’,‘blue’,‘green’]
console.log(colors.toString()) //变成逗号分隔的字符串"red,blue,green"
colors.valueof() //返回的还是原始值数组[‘red’,‘blue’,‘green’]
colors.join(",") //变成逗号分隔的字符串"red,blue,green",其中这个方法只接收一个 参数，用作分隔符的字符串然后返回包含所有数组项的字符串。参数可以是逗号，|| 等作为分隔符。如果不传递任何参数，或则传入undefined,则使用逗号分隔符。
colors.join("||") //字符串"red||blue||green"

转换方法–字符串转成数组

split() 将字符串以指定的分隔符分割成数组。
const a = '7,2,0,5';
a.split(',')  //[7,2,0,5]

数组增删方法

push()–接收任意数量的参数，把他们逐个添加到数组的末尾，并返回修改后的数组的长度。原数组发生改变。

例如：

var colors=[‘red’,‘blue’,‘green’]
 var count=colors.push(‘yellow’); //count的值是4
 var count2=colors.push(‘yellow’,‘black’); //count的值是6

pop()–从数组末尾删除最后一项，减少数组的length值。然后返回移除项。原数组发生 改变。

var colors=[‘red’,‘blue’,‘green’]；
 var item=colors.pop() //item的值为green。
 alert(colors.length) //2

俩个数组合并

const a=[1,2,3];  const b=[4,5,6];
const c=a.concat(b)  //[1,2,3,4,5,6]

a.push.apply(a,b) ; 
console.log(a) //[1,2,3,4,5,6]

a.push(8,[7,10]); console.log(a)  //[1,2,3,8,[7,10]]

shift()–从数组中移除第一项，并且返回该项的值。同时原数组长度也减少1。

var colors=[‘red’,‘blue’,‘green’]；
 var item=colors.shift() //item的值是red, colors的数组改变变成blue,green
 colors.length //2

unshift()–从数组的最前端添加任意个项并且返回新数组的长度。原数组发生改变

var colors=[‘red’,‘blue’,‘green’]；
 var count=colors.unshift(‘yellow’,‘black’) // 5
 colors //数组值变成[‘yellow’,‘black’,‘red’,‘blue’,‘green’]


`

数组重排序
sort()默认按照升序排序 ，最小值在前面，最大值在后面。注意：sort()方法会调用每个数组项的toString()转型方法。然后再比较得到的字符串。来确定如何排序，所以即使数组中的每一项都是数值，但是比较的也是字符串。例如字符串‘5’ > ‘10’ .

reverse()数组值倒转或者反转数组原来的位置.

var arry=[1,2,3,4,5];  
arry.reverse()  //5,4,3,2,1

var value=[0,1,5,10,15]
console.log(value.sort()) //结果 0,1,10,15,5

下面是比较全面的方法

function compare(a,b){
    if(a<b){
           return -1
    }else if(a>b){
           return 1
    }else{
           return 0
    }
}

function compare2(a,b){
    if(a<b){
           return 1
    }else if(a>b){
           return -1
    }else{
           return 0
    }
}

排序从小到大，升序排序
var values=[0,1,5,10,15]
values.sort(compare)  //0,1,5,10,15

排序从大到小，降序排序
var values=[0,1,5,10,15]
values.sort(compare2)  //15,10,5,1,0

如果是数值类型或者是valueof的方法返回的数值类型的就可以用比较简单的幻术。用第二个值减去第一个值即可。
function compare3(a,b){
   return a-b
}

数组操作方法

concat()-先创建当前数组一个副本，然后将参数添加到副本的末尾，最后返回新构成的数组。原数组不发生改变。(连接俩个数组合并，但是不能去重)

var colors=['red'];
var colors2= colors.concat(‘blue’)  //colors2的是['red','blue']
var colors3= colors.concat(['red','black'])  //colors3的是['red','red','black']
var colors4= colors.concat('yellow',['red','black'])  //colors4的是['red','yellow','red','black'],colors的数组值原数组不变

slice()-从已有的数组中返回选定的元素组成新的数组
语法格式：slice(start,end) ，slice() 并不会修改数组

let arr=[1,2,3,4,5,6,7,8,9,10]; 
			     
let newArry=arr.slice(0,1); //slice(start,end)裁剪数组元素  返回一个新的数组
console.log(newArry) //[1]
			
let newArry3=arr.slice(0);  //代表从第一个开始到最后一个元素裁剪
console.log(newArry3) //[1,2,3,4,5,6,7,8,9,10]
			
let newArry2=arr.slice(0,2);  
console.log(newArry2) //[1,2]
			
let newArry4=arr.slice(-3,2);  
console.log(newArry4) //[]
			
let newArry6=arr.slice(-1,-5);  
console.log(newArry6) //[]
			
let newArry5=arr.slice(1,-2);  //(1,8) 
console.log(newArry5) // [2,3,4,5,6,7,8]

let newArry7=arr.slice(-2,-1);  //(8,9)
console.log(newArry7) //[9]

Array.splice()：用于添加或删除数组中的元素。 原数组发生改变

他slice更加强大。主要目的是在数组中间插入元素。

1、删除：需要传递2个参数，要删除的第一个元素的位置和要删除的元素数量。可以从数组中删除任意多个元素。例如：splice(0,2)会删除前俩个元素。

2、插入：需要传3个参数，开始位置、0（需要删除元素数量）和要插入元素，可以在数组中指定的位置插入元素。第三个参数之后还可以传递第四个、第五个参数，甚至任意多个要插入的元素。比如：splice(2,0,“red”,“green”)会从数组位置2开始插入字符串‘’red’'和“green”。

3、替换：splice（）在删除元素的同事可以在指定位置插入新元素，同样要传入3个参数：开始位置、要删除元素的数量和要插入任务一多个元素。要插入元素的数量不一定要跟删除元素数量一致。比如：splice（2,1，“red”,“green”）会在位置2删除一个元素，然后从该位置开始向数组插入“red”和‘green’ 。

let arr = ["George","John","Thomas","James","Adrew","Martin"]; 
	document.write(arr.splice(2,3) + "<br />")  // Thomas,James,Adrew
	document.write(arr)  // George,John,Martin

//splice每次返回删除的元素数组，如果没有删除的元素就返回空数组。
var arrSplice=[1,2,3,4];
var newArrySplice=arrSplice.splice(0,1);  //从数组下标0开始，删除一个元素。返回删除元素的数组.元素组发生改变
console.log("原数组："+arrSplice+"----"+"删除的数组："+newArrySplice) //[2,3,4]----[1]
			
var arrSplice2=[1,2,3,4];
var newArrySplice2=arrSplice2.splice(1,0,5,6);  //从数组下标1开始，删除0个元素。后面添加5，6
console.log("原数组："+arrSplice2+"----"+"删除的数组："+newArrySplice2) //[1,2,3,4,5,6]----[](由于没有删除元素所以空)
			    
var arrSplice3=[1,2,3,4];
var newArrySplice3=arrSplice3.splice(1,1,5,6);  //从数组下标1开始，删除1个元素。后面添加5，6
console.log("原数组："+arrSplice3+"----"+"删除的数组："+newArrySplice3) //[1,5,6,3,4]----[2](删除了一个元素2)`

数组新增es6中Array.from 与Array.of

Array.from ：将传入对象转为数组
// 字符串会被拆分为单字符数组
console.log(Array.from("『全面资源集』")); // ["『", "全", "面", "资", "源", "集", "』"]

// 可以使用from()将集合和映射转换为一个新数组
const m = new Map().set(1, 2)
					.set(3, 4);
const s = new Set().add(1)
					.add(2)
					.add(3)
					.add(4);
console.log(Array.from(m)); // [[1, 2], [3, 4]]
console.log(Array.from(s)); // [1, 2, 3, 4]

// Array.from()对现有数组执行浅复制
const a1 = [1, 2, 3, 4];
const a2 = Array.from(a1);
console.log(a1);          // [1, 2, 3, 4]
alert(a1 === a2); // false

// 可以使用任何可迭代对象
const iter = {
  ＊[Symbol.iterator]() {
	yield 1;
	yield 2;
	yield 3;
	yield 4;
  }
};
console.log(Array.from(iter)); // [1, 2, 3, 4]

// arguments对象可以被轻松地转换为数组
function getArgsArray() {
  return Array.from(arguments);
}
console.log(getArgsArray(1, 2, 3, 4)); // [1, 2, 3, 4]

// from()也能转换带有必要属性的自定义对象
const arrayLikeObject = {
  0: 1,
  1: 2,
  2: 3,
  3: 4,
  length: 4
};
console.log(Array.from(arrayLikeObject)); // [1, 2, 3, 4]