数组方法

push

• 在数组的尾部添加若干元素，返回新的数组长度
• 操作后原数组的引用关系不变

var arr=[1];// 可以在数组的尾部添加若干个元素，返回新数组的长度var len=arr.push(5,6,7,8);console.log(len);

    while(arr.push({})<10);//循环给尾部添加若干个元素arr[0].a=10;console.log(arr); 

• 重构方法

function push(arr){for(var i=1;i<arguments.length;i++){arr[arr.length]=arguments[i];}return arr.length;}var arr=[];var len=push(arr,1,2,3);console.log(len,arr);

pop

• 删除数组尾部的最后一个元素，并且将删除的元素返回

• 操作后原数组的引用关系不变

• 如果数组中存储的是对象，我们必须将所有的对象引用全部设为null

         var arr=[1,3,5,2,1];var element=arr.pop();console.log(element,arr);while(arr.pop()!==3);//删除到某元素为止console.log(arr);	

• 重构方法

function pop(arr){var elem=arr[arr.length-1];if(arr.length>0) arr.length--;return elem;}while(arr.length>0){arr[arr.length-1]=null;arr.pop();} for(var i=0;i<arr.length;i++){arr[i]=null;}arr.length=0;

concat

• 连接数组
• 数组连接若干个数组或者元素，返回一个新的连接完成的数组，与原数组无引用关系
• 重构方法

function concat(arr) {var arr1 = [];for (var i = 0; i < arr.length; i++) {arr1[i] = arr[i];}if (arguments.length === 1) return arr1;for (var j = 1; j < arguments.length; j++) {if (arguments[j] !== null && arguments[j].constructor === Array) {for (var k = 0; k < arguments[j].length; k++) {arr1[arr1.length] = arguments[j][k];}} else {arr1[arr1.length] = arguments[j];}}return arr1;}var arr = [3, 4, 5];var arr1 = concat(arr, "");console.log(arr1);

join

• 使用某个字符作为连接符，将所有数组的元素连接成为一个字符串并且返回这个字符串，如果连接符没有，默认以逗号连接

function join(arr,separator){if(separator===undefined) separator=",";separator=String(separator);var str="";for(var i=0;i<arr.length;i++){if(i!==arr.length-1) str+=arr[i]+separator;else str+=arr[i];}return str;} var arr=[1,2,3,4,5];var str=arr.join("*");console.log(str);

sort 排序

• 冒泡排序

  function sort(arr){var len=arr.length-1;while(len>0){for(var i=0;i<arr.length-1;i++){if(arr[i]>arr[i+1]){var temp=arr[i];arr[i]=arr[i+1];arr[i+1]=temp;}}len--;}     }var arr=[3,9,6,8];sort(arr);console.log(arr);

• 选择排序

  function selectorSort(arr){var len=arr.length;var minIndex,temp;for(var i=0;i<len-1;i++){minIndex=i;for(j=i+1;j<len;j++){if(arr[j]<arr[minIndex]){minIndex=j;}}temp=arr[i];arr[i]=arr[minIndex];arr[minIndex]=temp;}return arr;}var arr=[3,9,6,8,2,5,4];selectorSort(arr);console.log(arr);

• 快速排序

  var arr = [2, 5, 6, 4, 1, 7, 8];function quickSort(arr) {if (arr.length < 1) {return arr;}var pivotIndex = parseInt(arr.length / 2);var pivot = arr.splice(pivotIndex, 1)[0];var left = [];var right = [];for (var i = 0; i < arr.length; i++) {if (arr[i] < pivot) {left.push(arr[i]);} else {right.push(arr[i]);}}return quickSort(left).concat([pivot], quickSort(right));}var j = quickSort(arr);console.log(j);

reverse 逆序

• 当前数组按照倒装顺序将原数组颠倒，并且返回原数组

function reverse(arr) {var arr1 = [];for (var i = 0; i < arr.length; i++) {if (i in arr) {arr1[i] = arr[i];}}arr.length = 0;for (var j = arr1.length - 1; j >= 0; j--) {if (j in arr1) {arr[arr1.length - j - 1] = arr1[j];}}return arr;}var arr = [1, 5, 3, 6, 2, 9]var arr1 = reverse(arr);console.log(arr);

fill 填充

• 语法：fill(要填充的值,从什么位置开始,到什么位置之前结束);
• fill只能用于有长度的数组，如果不给与开始位置和结束位置，就会全部填充覆盖
• 这种方式如果填充对象，就会造成填充同一个引用地址的对象

indexOf

• 在数组中查找元素，并且返回该元素的下标，如果没有找到返回-1

function indexOf(arr, search, index) {if (index === undefined) index = 0;for (var i = 0; i < arr.length; i++) {if (arr[i] === search) return i;} return -1;}var arr=[1,3,3,6,8,2,3,5,6,3,7,9,8,3,6,7,3,8,9];var index=arr.indexOf(5)var index=indexOf(arr,5);console.log(index);

• 语法：indexOf(要搜索的元素,从第几个下标开始搜索)

lastIndexOf

• 从后向前查找元素
• 语法：lastIndexOf(要查找的元素,从什么位置开始查找);

shift

• 将数组的头部一个元素删除，并且返回一个元素
• 操作后原数组的引用关系不变

 function shift(arr){var elem=arr[0];for(var i=1;i<arr.length;i++){arr[i-1]=arr[i];}if(arr.length>0)arr.length--;return elem;}var arr=[1,3,5,7];var elem=shift(arr);var elem=shift(arr);console.log(elem,arr);

unshift

• 在数组的头部添加若干个元素，并且返回这个元素
• 操作后原数组的引用关系不变

1.    function unshift(arr){var len=arguments.length-1;for(var i=arr.length-1;i>=0;i--){arr[i+len]=arr[i];arr[i]=null;}for(var j=1;j<arguments.length;j++){arr[j-1]=arguments[j];}return arr.length;}var arr=[1,2,3];var len=unshift(arr,4,5,6);console.log(arr,len);
2.function unshift(arr){var arr1=[];for(var i=0;i<arr.length;i++){arr1[i]=arr[i];}arr.length=0;for(var j=1;j<arguments.length;j++){arr[j-1]=arguments[j];}var len=arr.length;for(var k=0;k<arr1.length;k++){//    arr[len+k]=arr1[k];arr[arr.length]=arr1[k];}return arr.length;}var arr=[1,2,3];var len=unshift(arr,4,5,6);console.log(arr,len);

some

遍历数组，判断元素是否有满足的条件的，如果有直接跳出返回true，否则返回false

function some(arr,fn){for(var i=0;i<arr.length;i++){if(i in arr && fn(arr[i],i,arr)) return true; }return false;}

every

• 遍历数组，并且判断每个元素是否满足条件，如果不满足直接跳出返回false，否则返回ture

function erery(arr,fn){
for(var i=0;i<arr.length;i++){
if(i in arr && !fn(arr[i],i,arr)) return false;
}
return true;
}

slice()复制数组

• 从第几项开始到第几项结束复制这些元素到新数组中，原数组不改变
• 复制原数组到新数组，没有引用关系

function slice(arr,start,end){if(start===undefined) start=0;if(end===undefined) end=arr.length;start=Number(start);end=Number(end);if(!isNaN(end) && isNaN(start)) start=0;if(isNaN(start)) return[];if(start<0) start=arr.length+start;if(end<0) end=arr.length+end;var arr1=[];for(var i=start;i<end;i++){arr1[i-start]=arr[i];}return arr1;}var arr=[2,3,4,5,6,7];console.log(arr.slice(1,"3"));var arr1=slice(arr,true,4);console.log(arr1);

var arr1=arr.slice(-2);//从后向前数第2个元素到尾部的所有元素复制var arr1=arr.slice(1,2); //从第一项复制到第二项，不包括结束这一项

splice（）删除元素

这个方法实现需要耗费大量时间

1、 将数组中从第几位开始删除多少个元素，并且返回被删除的元素组成的新数组

2、将数组中从第几个位开始删除多少个元素后，并且在该位置插入新的若干元素，返回删除元素组成的新数组

3、在数组的第几位开始插入若干个元素，并且返回空的新数组

 var arr1=arr.splice(1);//删除到尾部var arr1=arr.splice(-1);//如果第一个参数是负数，从后向前数开始删除var arr1=arr.splice(0);//将一个数组的所有元素转移到另一个数组var arr1=arr.splice();//没有删除返回空数组var arr1=arr.splice(-3,2);//从倒数第3个元素向后删除2个元素var arr1=arr.splice(1,2,-2,-3);//从第一位开始向后删除两个元素，并且在该位置插入-2和-3，替换，并且返回被删除两个元素组成的数组var arr1=arr.splice(1,arr.length,0,-1,-2);//从某个位置开始删除到数组的尾部，并且添加0,-1,-2var arr1=arr.splice(1,0,0);//在第一位插入一个元素0，不删除，返回空数组

数组的遍历

forEach

function forEach(arr,fn){for(var i=0;i<arr.length;i++){if(i in arr)fn(arr[i],i,arr);}}var arr=[2,3,4,7,5,8];forEach(arr,function(item,index,arr){console.log(item,index,arr);})

• 遍历数组，可以获取使用元素和下标，自动过滤空元素，空元素不遍历

• 比for in来说，不会遍历到数组的属性

• 比for 来说，不会遍历到空元素

• 有缺陷 函数中this指向将会被改变

map

• 遍历数组，并且使用return 返回元素，这些被返回的元素会被放在一个新数组中 新数组的长度和原数组相同

function map(arr, fn) {var arr1 = [];for (var i = 0; i < arr.length; i++) {if (i in arr) arr1[i] = fn(arr[i], i, arr);}return arr1;var arr = [1, 2, 5, , 3, 6, 8];var arr1 = map(arr, function (item) {return item + 10;});console.log(arr1);

delete

• 使用delete会变成松散型数组

XMind - Trial Version