js数组方法总结

• splice() 数组任意地方删除或者添加元素
  返回被删除的元素组成的数组

  var arr = ['zs','ls','ww','zl','xmg'];
  // 影响原来的数组
  //- splice(start, deletedCount)   删除元素
  // 		- start 开始
  // 		- deletedCount 删除个数
  //- splice(start, deletedCount , item) 删除+添加,  第三个参数是在原来删除的位置上新加几个元素
  //- 特殊 : 
  //   splice(start, 0 , item)   就是在某个位置新加元素

• 数组的增删操作
  push() 从后面添加元素，返回新数组的length
  pop() 从数组的后面删除一个元素，返回删除的那个元素
  unshift() 从数组的前面的添加元素，返回新数组的长度
  shift() 从数组的最前面的一个删除元素，返回删除的那个元素

  var arr = ['zs','ls','ww']
  
  array.push(元素);
  array.pop();
  array.unshift(元素);
  array.shift();
  
  //总结:
  //1. shift 在前面 ,所以处理数组前面的
  //2. p+ 在后面,所以是处理后面的
  //3. unshift 比 shift 多个un,,所以就是加
  //4. 添加的都是返回长度
  //5. 删除的都是返回删除的元素
  //6. 添加要说明添加什元素,,删除直接删除
  
  //练习1
  var arr = ["刘备"];
  //添加数据后变成：["赵云","马超","刘备","关羽","张飞"]
  //删除数据后变成：["关羽","张飞"]
  
  //练习2
  var arr = ["赵云","马超","刘备","关羽","张飞"];
  //把数组的最后一个元素变成数组的第一个元素
  //把数组的第一个元素变成数组的最后一个元素

• concat() 数组的拼接
  数组合并，不会影响原来的数组，会返回一个新数组。

  var newArray = array.concat(array2);//可以传进多个参数，同时拼接多个数组

• sort() 数组的排序
  影响原来数组，返回一个原来数组的引用

  array.sort();//数组的排序，默认按照 字母/首字符 顺序排序 => 1 11 2 3
  var arr1 =  ['a','d','b','c'];
  var arr2 = [3, 6, 1, 5, 10, 2,11];
  
  //sort方法可以传递一个函数作为参数，这个参数用来控制数组如何进行排序
  arr.sort(function(a, b){
    //如果返回值>0,则交换位置
    return a - b;//升序
    //return b - a; //降序
  });
  
  记忆技巧 : b比a高

• reverse() 数组的反转
  影响原来数组，返回一个反转过的数组

  array.reverse();//翻转数组

• join() 数组和字符串的转换
  不影响原来数组，返回一个拼接过后的字符串

  //语法：array.join(分隔符)
  //作用：将数组的值拼接成字符串,并且返回字符串
  
  var arr = [1,2,3,4,5];
  arr.join();//不传参数，默认按【,】进行拼接
  //拼接结果为字符串"1,2,3,4,5"
  arr.join("");//按【""】进行拼接(空串)
  //拼接结果为字符串"12345"
  arr.join("-");//按【-】进行拼接
   //拼接结果为字符串"1-2-3-4-5" 
   
  //split:将字符串分割成数组（很常用）
  //功能和数组的join正好相反。
  var str = "张三,李四,王五";
  var arr = str.split(",");

• slice() 截取数组
  不影响原来数组，返回截取到的数组

//语法：
//数组.slice(开始下标,结束下标)
//截取的结果不包含结束下标对应的元素
var brr = arr.slice(0,4)

//第二个参数可以省略 - 默认截取到数组的末尾
var brr = arr.slice(2)

//两个个参数都省略 - 默认从开头截取到末尾
var brr = arr.slice()

• indexOf() 查找下标
  查找一个元素在数组中第一次出现的位置-找到了下标，找不到返回-1

// indexOf
var arr = [1,2,3,4,5,6,7,8,9,5];
/*
语法：
参数1：要找的元素
参数2：从指定的位置开始
*/
var index = arr.indexOf(5,5)
console.log(index);

• forEach() 遍历数组

/*
语法：
数组.forEach(function(v,i,a){
    v值
    i下标
    a数组本身
})
*/
var arr = ['a','b','c','d'];
arr.forEach(function(value,index,a){
   console.log(value + '----' + index + '---' + a);
})
// 参数都是可选项

var arr = [1,2,3,4,5];
var sum = 0
arr.forEach(function(v){
	sum += v
})
console.log(sum);

// var max = arr[0]
// arr.forEach(function(v){
//     if(max<v){
//         max = v
//     }
// })
// console.log(max);

• map() 将数组中每个元素遍历后交给一个函数去处理，处理后得到新的元素，每个新的元素组成一个新的数组返回

/*
语法：
数组.map(function(v,i,a){
    return 新的元素
})
*/
var arr = [10,20,30];
var brr = arr.map(function(v){
	return v + v * 0.3
})
console.log(brr);

• fliter() 过滤，将数组中满足指定条件的元素组成一个新的数组返回

/*
语法：
跟map一样
数组.filter(function(v,i,a){
    return 条件
})
*/
var arr = [100,90,50,60,80,30];
var brr = arr.filter(function(v){
	return v<60
})
console.log(brr);

• reduce() 数组求和

// reduce - 数组求和
var arr = [1,2,3,4]
var sum = arr.reduce(function(a,b){
	console.log(a + '----' +b);
	return a+b
})
console.log(sum);

• some() 方法先遍历数组，如果至少有一个元素满足条件，则返回true，否则返回false。

var arr = [2,4,6,10,15,21];
var f = arr.some(function(element,index,array){
	if(element > 20){
		return true;
	}else{
		return false;
	}
});

• every() 方法先遍历数组，判断所有元素是否满足条件，返回布尔值

var arr = [2,4,6,10,15,21];
var f = arr.some(function(element, index, array){
	return element > 10;
});

• find() 方法返回数组中满足条件的第一个值，找不到元素则返回false

     var arr = [2,4,6,10,15,21];
     var f = arr.find(function(element, index, array){
         return element > 10;
     });

• findIndex() 方法返回数组中满足条件的第一个值的下标，找不到元素则返回-1

  var arr = [2,4,6,10,15,21];
  var f = arr.findIndex(function(element, index, array){
      return element > 10;
  });