数组的所有方法

var Arr1 = new Array();//创建一个空数组
 var Arr2 = new Array(6);//规定了数组长度为6，然后再根据索引向里面添加值
   	Arr2[0] = 1;
 var Arr3 = new Array('a','b','c');//直接实例化创建一个包含三个字符串的数组

var Arr1 = [];//创建一个空数组
 var Arr2 = [6];//创建一个包含6项的数组
 var Arr3 = ['a','b','c'];//创建一个包含三个字符串的数组

var array = ['1','2'];
array.push('3','4');
console.log(array);//['1','2','3','4'] 改变了数组

var array = ['1','2'];
array.pop();
console.log(array); //['1'] 改变了原数组

var array = ['1','2'];
array.unshift('0','6');
console.log(array); //['0','6','1','2'] 改变了原数组

var array = ['1','2'];
array.shift();
console.log(array); //['2'] 改变了原数组

//1.第一种情况不传参数默认为升序
	var array = ['2','1','4'];
   array.sort();
   console.log(array);//['1','2','4'] 改变了原数组
   //2.数字排序（数字和升序)
   var array = ['2','1','4'];
   array.sort(function(a,b){
     return a - b
   });
   console.log(array);//['1','2','4']
   //3.数字排序（数字和降序)
   var array = ['2','1','4'];
   array.sort(function(a,b){
     return b - a
   });
   console.log(array);//['4','2','1']

var array = ['2','1','4'];
   array.reverse()
   console.log(array);//['4','1','2'] 改变了原数组

//1.只有一个参数的时候
var array = ['2','1','4','5'];
   array.splice(2);//删除从左到右两项
   console.log(array);// ['2','1'] 改变了原数组 返回的是删除的元素
   
   //2.只有两个参数的时候
   var array = ['2','1','4','5'];
   array.splice(0,3);//如果第一个参数是0则删除不会包括第二个参数的索引
   console.log(array);// ['5'] 改变了原数组
   array.splice(1,2);//如果第二个参数不是0则删除会包括第二个参数的索引['2','5'] 显然它删掉了索引为2的元素‘4’

//3.当有>=3个参数的时候
//当第二个参数为0的时候,第一个参数就是起始位置，从索引1开始添加第三个参数到array数组
var array = ['1','2','3','4'];
array.splice(1,0,'xiaoming');
console.log(array);//['1', 'xiaoming', '2', '3', '4']

//当第二个参数不为0的时候,从第一个参数索引1起始位置开始删除一个元素并把第三个参数加上
var array = ['1','2','3','4'];
array.splice(1,1,'xiaoming');
console.log(array);//['1', 'xiaoming',  '3', '4']

var array = ['1','2','3','4'];
array.splice(1,2,'xiaoming');
console.log(array);//['1', 'xiaoming','4']

//一个参数的时候
var array = ['1','2','3','4'];
array.copyWithin(2);
console.log(array);//['1','2','1','2'];

//二个参数的时候
var array = ['1','2','3','4'];
array.copyWithin(2,1);
console.log(array);//['1','2','2','3'];

//三个参数的时候
var array = ['1','2','3','4','5'];
array.copyWithin(2,1,3);//从索引2开始,复制的元素索引从1开始,复制到索引为3(包括3)停止
console.log(array);//['1','2','2','3','5'];

var array1 = ['1','2'];
var array2 = ['3','4'];
var array3 = ['5','6'];
var arrayBox = array1.concat(array2,array3)
console.log(arrayBox) //['1', '2', '3', '4', '5', '6'];

var array = ['xiaoming','lisi','zhangsan'];
var x = array.entries();
console.log(x.next().value); //[0, 'xiaoming'];
console.log(x.next().value); //[1, 'lisi'];
console.log(x.next().value); //[2, 'zhangsan'];

var array = ['1','2','3','4','5','6'];
var ArrBox = array.every(function(currentValue,index,arr){
	return currentValue > 5
})
console.log(ArrBox);//false

//只有一个参数的时候
var array = ['1','2','3','4'];
array.fill('6');
console.log(array);//['6', '6', '6', '6'] 所有的都会被替换掉

//不止一个参数的时候
var array = ['1','2','3','4'];
array.fill('6',1,3);
console.log(array);//['1', '6', '6', '4'] 索引1到索引3 不包括索引3都会被替换掉

var array = ['1','2','3','4'];
var ArrBox = array.filter(function(currentValue){
	return currentValue > 2
})
console.log(ArrBox);// ['3', '4']

var array = ['6','9','18','20'];
var ArrBox = array.find(function(currentValue){
	return currentValue >= 18
})
console.log(ArrBox);//18 第三个元素满足条件,返回第三个元素就不接着往下面走啦

var array = ['1','2','3'];
var ArrBox = array.findIndex(function(currentValue){
	return currentValue > 2
})
console.log(ArrBox);//2 这个2就是索引2 它满足条件，如果array中都没有大于2的这时就会返回-1

var array = ['1','2','3','4'];
array.forEach(function(currentValue, index, arr){
	console.log(currentValue, index, arr);
})
//1 0 (4) ['1', '2', '3', '4']
	//2 1 (4) ['1', '2', '3', '4']
   //3 2 (4) ['1', '2', '3', '4']
   //4 3 (4) ['1', '2', '3', '4']

//只有一个参数的情况
var array = Array.from('xiaoming');
console.log(array);//(8) ['x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']

//不止一个参数的情况
var array = Array.from([1,2,3],function(x){
	return x * 10
})
console.log(array);//[10, 20, 30]

//从类数组对象（arguments）生成数组
function f() {
   console.log(arguments);
   console.log(Array.from(arguments)); // [ 1, 2, 3 ]
}
f(1, 2, 3);

//传一个参数的时候
var array = ['1','2','3','4'];
var ArrBox = array.includes('2');
console.log(array);//true

//传两个参数的时候
var array = ['1','2','3','4'];
var ArrBox = array.includes('2',2);
console.log(array);//false 虽然这时array数组里面有2但是它是从索引为2开始查找的,所以返回false

//一个参数的时候
var array = ['1','2','3','4'];
var ArrBox = array.indexOf('1');
console.log(ArrBox);//0 返回的就是‘1’的索引位置
//二个参数的时候
var array = ['1','2','3','4'];
var ArrBox = array.indexOf('1',1);
console.log(ArrBox);//false 这是第二个参数的是为1,从索引1开始查找找不到‘1’，所以返回-1

var array1 = ['1','2','3'];
var array2 = {name:'xiaoming',age:18};
console.log(Array.isArray(array1));//true
console.log(Array.isArray(array2));//false

var array = ['1','2','3','4'];
var ArrBox = array.join('--');
console.log(ArrBox);//1--2--3--4

var array = ['a','b','c','d'];
var ArrBox = array.keys();
console.log(ArrBox);//Array Iterator {}
for(key of ArrBox){
   console.log(key);//0 1 2 3
 	};

//当只有一个参数的时候
var array = ['1','2','3','2'];
var ArrBox = array.lastIndexOf('2');
console.log(ArrBox);//3 从后往前开始检索
//当有两个参数的时候
var array = ['1','2','3','2'];
var ArrBox = array.lastIndexOf('2',array.length - 2);
console.log(ArrBox);//1 从后往前开始检索,开始检索的位置是从倒数第二个开始

var array = ['1','2','3','4'];
var ArrBox = array.map(function(currentValue){
	return currentValue * 10
});
console.log(ArrBox);//[10, 20, 30, 40]

var array = [1,2,3,4];
var ArrBox = array.reduce(function(total,currentValue){
	console.log(total,currentValue);
	// 0 1 
	// 1 2
	// 3 3
	// 6 4
	return total + currentValue
},0);
console.log(ArrBox);// 10

var array = [1,2,3,4];
var ArrBox = array.reduceRight(function(total,currentValue){
	console.log(total,currentValue);
	// 4 3
	// 1 2
	// -1 1
	// -2
	return total - currentValue
});
console.log(ArrBox);//-2

var array = [1,2,3,4];
console.log(array.slice(1));//[2, 3, 4] 从索引1截取到最后
console.log(array.slice(-2));//[3, 4] 从原数组中的倒数第几个元素开始提取
console.log(array.slice(1,2));//[2] 选取索引1到索引2的元素（不包含索引2）
console.log(array.slice(-2,-1));//[2] 选取倒数第二个到倒数第一个（不包含倒数第一个）

var array = [1,2,3,4];
var ArrBox = array.some(function(currentValue){
	return currentValue > 2
});
console.log(ArrBox);//true

var array = ['1','2','3','4'];
var ArrBox = array.toString();
console.log(ArrBox);//1,2,3,4

//返回数组本身
var array = ['xiaoming','1','2'];
console.log(array.valueOf() == array);//true

//返回布尔值
var boolean = true
console.log(boolean.valueOf() == boolean);//true
// new一个Boolean对象
var newBool = new Boolean(true); // Boolean {true}
newBool.valueOf() // true
// valueOf()返回的是true，两者的值相等
console.log(newBool.valueOf() == newBool);   // true
// 但是不全等，两者类型不相等，前者是boolean类型，后者是object类型
console.log(newBool.valueOf() === newBool);   // false

//返回时间戳
var date = new Date(2021, 11, 2, 13, 04, 59, 230);
console.log(date.valueOf());//1638421499230 返回时间戳

//返回函数本身
var function = function foo(){};
console.log(function.valueOf() == function);//true

//返回数字值
var number = 5;
 	console.log(number.valueOf() == number );//true

//返回对象本身
var object = {name: "张三", age: 18};
console.log(object.valueOf() == object);//true

//返回字符串本身
var string = 'xiaoming';
console.log(string.valueOf() == string);//true

let arr = [1,2,3,4,1,2];
let set1 = new Set(arr);
console.log(set1);//Set(3) {1, 2, 3} 此时时类数组，不是真正的数组

let newArr1 = Array.from(set1); //第一种方法可以使用Array.from()将类数组转换成真正的数组
console.log(newArr1);//[1, 2, 3, 4]

let newArr2 = [...set1];//第二种方法直接结构赋值，也可以得到一个真正的数组
console.log(newArr2);//[1, 2, 3, 4]

var arr = [1,2,3,4,1,2];
   for(var i = 0;i<arr.length;i++){
     for(var j = i+1;j<arr.length;j++){
       console.log(arr[i],arr[j]);
       if(arr[i] == arr[j]) {
         //如果数据相同则通过splice删除一条相同的数据
         arr.splice(i,1);
          //i是第一层遍历的下标，因为上一步删除了一条数据，所以下标也需要减一，否则实际下标，要比数组中的数据更多
         i--;
         //j 也同样需要和i一样减一，保持遍历依旧同步判断
         j--;
       }

     }
   }
   console.log(arr);// [3, 4, 1, 2]

let arr = [4,5,6,2,3,2,4,5];
   let newArr = []
   for(var i=0;i<arr.length;i++) { //循环arr数组
     if(newArr.indexOf(arr[i]) == -1) {
       newArr.push(arr[i]);
     }
   }
   console.log(newArr);//[4, 5, 6, 2, 3]

let arr = [4,5,6,2,3,2,4,5];
let newArr = []
for(var i=0;i<arr.length;i++) {
  if(!newArr.includes(arr[i])){ 
    newArr.push(arr[i])
  }
}
console.log(newArr);//[4, 5, 6, 2, 3]

let arr = [4,5,6,2,3,2,4,5];
   let newArr = arr.filter(function(item,index){
   console.log(arr.indexOf(item,0),index);
   //arr.indexOf(item,0)循环返回元素所在的位置,有两个相同的元素只会返回第一个元素的索引
   //0 0
  //1 1
  //2 2
  //3 3 
  //4 4
  //3 5
  //0 6
  //1 7
     return arr.indexOf(item,0) === index
   })
   console.log(newArr);/[4, 5, 6, 2, 3]