Cacher is the code snippet organizer for pro developers

slice splice push pop unshift shift sort reverse concat join

三大属性

length

和其他大多数语言不同的是，JavaScript数组的length属性是可变的

var arr=[0, 1, 2, 3, 4, 5, 6, 7, 8];
arr.length; //9

arr.length=12; //增大数组的长度

arr.length; //12 整个数组的状态事实上不会发生变化，仅仅是length属性变大

arr.length=5; //将数组的长度减少到5，索引大于或等于5的元素被丢弃

arr[6]; //"undefined"

arr.length=9; //将数组长度恢复为9
arr[6]; //虽然长度被恢复，但元素无法恢复，显示"undefined"

arr[10]=10;  //增加元素

arr.length; //11，对其中未定义元素的操使数组的长度发生变化

arr[9]; //"undefined"

constructor

let arr5 = [1,3,5,7]; console.log(arr5.constructor);//ƒ Array() { [native code] }

表示创建对象的函数。

object.constructor //object是对象或函数的名称。

说明：constructor 属性是所有具有 prototype 的对象的成员。它们包括除 Global 和 Math 对象以外的所有 JScript 固有对象。constructor 属性保存了对构造特定对象实例的函数的引用。

例如：

x = new String("Hi");

if (x.constructor == String) // 进行处理（条件为真）。

或

function MyFunc {

// 函数体。

}

y = new MyFunc;

if (y.constructor == MyFunc) // 进行处理（条件为真）。

对于数组来说：

y = new Array();

prototype

prototype原型对象是javascript基于原型链表实现的一个重要属性。 Javascript角度：1. 实例对象没有prototype属性，只有构造函数才有prototype属性，也就是说构造函数本身保存了对prototype属性的引用。。2. prototype属性对象有一个constructor属性，保存了引用他自己的构造函数的引用（看起来像是个循环：A指向B，B指向A...） 3.prototype对象（不要被我这里的属性对象，对象，对象属性搞晕乎了，说是属性对象，就是说当前这个东西他首先是某个对象的属性，同时自己也是个对象。对象属性就是说它是某个对象的属性。）的属性变量和属性对象将会被该prototype对象引用的构造函数所创建的对象继承(function A(){} A.prototype.pa = function(){} var oA = new A(); 那么oA将会继承属性函数pa)。**

let arr6 = [1,2,4,5,6]; console.log(arr6.prototype)//undefined 一般我们用到的时候是这样用的

let arr7 = [1,3,5,6,7,8]; Array.prototype.alert = function(){console.log('arr7')}//这里封装的是数组的公有方法。 console.log(arr7.alert())//arr7

function array_max( ) { var i, max = this[0]; for (i = 1; i < this.length; i++) { if (max < this[i]) max = this[i]; }

return max; }

Array.prototype.max = array_max;

var x = new Array(1, 2, 3, 4, 5, 6); var y = x.max();

对于想要深入的了解请百度原型链模式，这样您可以详细的研究它的一些公有方法。

插入、删除或替换数组的元素

添加元素

//splice() --指定位置
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,0,"Lemon","Kiwi");
fruits

//push() --结尾
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Lemon","Kiwi");
fruits

//unshift() --头部
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon","Kiwi");
fruits

删除元素

//splice() --指定位置
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,1);
fruits

//pop() --结尾
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop();
fruits

//shift() --头部
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift();
fruits

替换

//splice()
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(1,2,"Lemon","Kiwi");
fruits

5、数组的截取和合并 arrayObj.slice(start, [end]); //以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制 start 之后的所有元素

arrayObj.concat([item1[, item2[, . . . [,itemN]]]]); //将多个数组（也可以是字符串，或者是数组和字符串的混合）连接为一个数组，返回连接好的新的数组

6、数组的拷贝 arrayObj.slice(0); //返回数组的拷贝数组，注意是一个新的数组，不是指向

arrayObj.concat(); //返回数组的拷贝数组，注意是一个新的数组，不是指向

7、数组元素的排序 arrayObj.reverse(); //反转元素（最前的排到最后、最后的排到最前），返回数组地址

arrayObj.sort(); //对数组元素排序，返回数组地址

8、数组元素的字符串化 arrayObj.join(separator); //返回字符串，这个字符串将数组的每一个元素值连接在一起，中间用 separator 隔开。

toLocaleString 、toString 、valueOf：可以看作是join的特殊用法，不常用

array.splice(index,howmany,item1,.....,itemX)

参数	描述
index	必需。规定从何处添加/删除元素。该参数是开始插入和（或）删除的数组元素的下标，必须是数字。
howmany	必需。规定应该删除多少元素。必须是数字，但可以是 "0"。如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。
item1, ..., itemX	可选。要添加到数组的新元素

可以配合sort()和reverse()方法使用

以上方法不创建新数组，而是直接修改原有的 arrayObject

---

数组中的常用方法

按照四个维度记忆

• 方法的作用
• 方法的参数
• 方法的返回值
• 原有数组是否改变

push

• 作用: 向数组末尾追加新的内容
• 参数: 追加的内容(一或多)
• 返回值: 新数组的长度
• 原数组被改变

pop

• 作用: 删除数组最后一项
• 参数: 无
• 返回值: 被删除的那一项的内容
• 原数组被改变

shift

• 作用: 删除数组第一项
• 参数: 无
• 返回值: 被删除的那一项内容
• 原数组被改变

unshift

• 作用: 向数组开头追加新的内容
• 参数: 追加的内容(一或多)
• 返回值: 新数组的长度
• 原数组被改变

splice

• 作用: 对数组指定位置的元素进行增删改

//删除
Array.splice(n, m)
//删除数组从索引n开始的m项内容, 如果不指定m或者m大于从索引n开始的数组长度, 则删除到数组末尾
//把被删除的内容以一个新数组返回

//新增
Array.splice(n, 0, x, ...)
//从索引n开始删除0项, 把x或更多内容插入到数组中索引n的"前面"
//返回空数组(删除0项)

//修改
Array.splice(n, m, x, ...)
//结合删除和新增, 删除旧内容, 增加新内容

//删除最后一项
var arr = [1, 2, 3];
arr.pop(); //3
arr.splice(arr.length - 1); //[3]
arr.length--;
delete arr[arr.length-1]; //[1, 2, empty], 不建议

//向数组末尾追加新内容
arr.push(100);
arr.splice(arr.length, 0, 100);
arr[arr.length] = 100;

slice

• 作用: 在一个数组中, 按照条件查找出其中的部分内容
• 参数: 两个参数(n/m), n和m可以是负数
• 返回: 以一个新数组存储查找的内容
• 原数组不改变

//数组克隆
arr.slice(0); //独立于原数组, 堆内存空间不相同

concat

• 作用: 实现多个数组(或值)的拼接
• 参数: 数组或值
• 返回: 拼接后的新数组
• 原数组不变

[].concat(arr1, "concat", arr2);
arr1.concat(arr2, "concat");

toString()

• [1, 2, 3].toString(); //"1, 2, 3"
• 原数组不变

join

• [1, 2, 3].join('+'); //"1+2+3"
• 原数组不变

reverse

• 作用: 把数组倒过来排列
• 参数: 无
• 返回: 排列后的新数组
• 原数组改变

sort

• 作用: 给数组排序
• 参数: 无 / 函数
• 返回: 排序后的新数组
• 原数组改变

// sort 在不传递参数的情况下, 只能处理10以内的数字的排序
var arr = [1, 3, 2];
arr.sort(); // [1, 2, 3]

var arr = [12, 1, 3];
arr.sort(); // [1, 12, 3]

// 真实项目中基于 sort 排序, 都需要传递参数
arr.sort(function (a, b){
  return a - b; // 升序 return b - a; 降序
});

indexOf / lastIndexOf

if(arr.indexOf(100) > -1){
  // arr 中包含 100
}

• every
• filter
• find
• forEach
• includes
• keys
• map
• reduce / reduceRight
• some
• ...