javascript——马步之Array篇

数组 Array

== 1、建立数组==
* 通过变量赋值为[]来建立数组

var arr = []; // arr 是一个数组

* 需要注意数组的下标是从0开始中的

==2、获取数组长度==

* 通过length 属性来获得长度

var arr = [1,2];
console.log(arr.length);// =>2

==3、合并数组==

* 调用 concat 函数产生一个新的合并后的函数 :

var arr = [1,4,3,2];
var r = [5,6]
console.log(arr.concat(r)); //=>[1, 4, 3, 2, 5, 6]
console.log(arr.concat(8,9)); //=>[1, 4, 3, 2, 8, 9]

==4、转化为字符串==

var arr = [1,2];
console.log(arr.join('-'));//=>1-2

==5、取最后一个元素==

* 调用 pop， 移除数组中最后一个元素，并返回该元素

var arr = [1,2,3];
console.log(arr.pop());// => 3
console.log(arr)// =>[1,2]

==6、添加元素到数组尾部==

* 调用push, 将新元素添加到数组尾部，并返回数组新长度

var arr = [1,2,3]
console.log(arr.push(4));
console.log(arr);// => [1,2,3,4]

==7、倒转数组元素顺序==

*调用reverse, 将元素位置颠倒

var arr = [1,2,3];
arr.reverse();
console.log(arr);//=>[3,2,1]

==8、取数组第一个元素==

* 调用shift， 移除数组中第一个元素，并返回该元素

var arr = [1,2,3];
console.log(arr.shift); // => 1
console.log(arr);// => [2,3]

==9、添加元素到数组头部==

* 调用unshift, 将新元素添加到数组头部，并返回数组新长度

var arr = [1,2,3];
console.log(arr.unshift(4));
console.log(arr);// => [4,1,2,3]

==10、获取子数组==

* 调用slice , 获取数组指定范围了子数组

* 返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素

* 请注意，该方法并不会修改数组，而是返回一个子数组。如果想删除数组中的一段元素，应该使用方法 Array.splice()。

var arr = [1,2,3,4,5,6,7];
console.log(arr.slice(2,4));// => [3,4]
console.log(arr);//=>[1,2,3,4,5,6,7]

==11、替换，删除，插入数组元素==

*  替换： 将数组的连续元素替换为另外一批元素（把任意多个连续的值替换成另一个或多个值）

*  删除：从指定位置删除任意长度的值

*  插入：从指定位置的前面插入任意多个新的值

var arr = [1,2,3,4,5,6,7];
console.log(arr.splice(1,2)); // =>[2,3] 删除
console.log(arr.splice(1,2,5,6));// => [2,3] 替换  从第1个下标开始的两个数为 5,6，并返回被替换的数组成的数组
console.log(arr);// =>[1,5,6,4,5,6,7]
console.log(arr.splice(1,0,9,0));// => []  插入 不删除项目返回的值为空，从第一个位置的前面添加了新的值，删除的长度为0
console.log(arr);// =>[1, 9, 0, 2, 3, 4, 5, 6, 7]

==12、排序==

* 调用 sort 对数组进行排序，默认为从小到大，也可以自定义排序规则

var arr = [1,4,3,2,5,6,7];
console.log(arr.sort(function(a,b){return a-b;}));// => [1,2,3,4,5,6,7]
console.log(arr.sort(function(a,b){return b-a;}));// => [7,6,5,4,3,2,1]

==13、循环==

* 调用 forEach 对数组进行循环

var arr = [1,4,3,2];
arr.forEach(function(i){
    console.log(i); // => 1,4,3,2
})

==14、索引==

* 调用 indexOf 正向查找某个值在数组中的索引位置

var arr = [1,4,3,2];
var index = arr.indexOf(3);
console.log(index);//=>2

==15、索引==

* 调用 lastIndexOf 反向查找某个值在数组中的索引位置, 与indexOf的方法不同在于开始查找的位置。

var arr = [1,4,3,2];
var index = arr.lastIndexOf(3);
console.log(index);//=>2

==16、循环==

*  调用 map对数组进行循环处理. 类似于forEach，不同的是提供了index 索引的值

var arr = [1,4,3,2];
arr.map(function(item,index){
    console.log(item);// =>1,4,3,2
    console.log(index);// =>0,1,2,3
})

==17、对数组中每一个元素执行回调函数==

* 对数组中的每个元素都执行一次指定的函数（callback），直到此函数返回 false，如果发现这个元素，every 将返回 false，如果回调函数对每个元素执行后都返回 true ，every 将返回 true。它只对数组中的非空元素执行指定的函数，没有赋值或者已经删除的元素将被忽略。

回调函数可以有三个参数：当前元素，当前元素的索引和当前的数组对象。console.log(arguments)

var arr = [1,4,3,2];
var flag = arr.every(function(a){
    return a > 4;
})
console.log(flag);// =>false
var flag2 = arr.every(function(a){
    return a > 0;
})
console.log(flag2);// => true
console.log(arr); // =>[1,4,3,2]

==18、对数组中每一个元素执行回调函数==

* 对数组中的每个元素都执行一次指定的函数（callback），直到此函数返回true，如果发现这个元素，some 将返回true，如果回调函数对每个元素执行后都返回 false ，some 将返回false。它只对数组中的非空元素执行指定的函数，没有赋值或者已经删除的元素将被忽略。

回调函数可以有三个参数：当前元素，当前元素的索引和当前的数组对象。console.log(arguments)

var arr = [1,4,3,2];
var flag = arr.some(function(a){
    return a > 3;
})
console.log(flag);// => true
var flag2 = arr.some(function(a){
    return a < 0;
})
console.log(flag2);// => false
console.log(arr); // =>[1,4,3,2]

==19、过滤数组==

* filter 不会改变原有数组，记住：只有在回调函数执行前传入的数组元素才有效，在回调函数开始执行后才添加的元素将被忽略，而在回调函数开始执行到最后一个元素这一期间，数组元素被删除或者被更改的，将以回调函数访问到该元素的时间为准，被删除的元素将被忽略。

var arr = [1,4,3,2];
var newarr = arr.filter(function(a){
    return a > 3;
})
console.log(arr); // =>[1,4,3,2]
console.log(newarr); //=> [4]

=====数组一些方法=====

==取出最小值，并alert出他的位置==

// 最小值， 最大值
var arr = [6,4,1,2];
//var a=[10,2,3,[5,6],[1,4,8]];
//var arr = a.join(',').split(',');
var min = Math.min.apply(null,arr);
console.log(min);//=>1
var max = Math.max.apply(null,arr);
console.log(max); //=>6   /10

// 取索引
var arr = [6,4,1,2];
var min = Math.min.apply(null,arr);
var index = arr.indexOf(min);
console.log(index);// =>2

var arr = [4,6,4,1,2];
var max = Math.max.apply(null,arr);
var index = arr.indexOf(max);
console.log(index);//=>1

// split 后的数组
var a=[2,3,[5,10,6],[1,4,8]];
var arr = a.join(',').split(',');
var max = Math.max.apply(null,arr);
var index = arr.indexOf(''+max); // split 之后数组变成字符串形式 需要以字符串形式查找
console.log(index); // => 3  

// jq 位置
var arr = [6,4,1,2];
var min = Math.min.apply(null,arr);
var index = $.inArray(min,arr)
console.log(index) 

// 取出 最小值， 并获取他的位置
var arr = [6,4,1,2];
var minArr = arr[0];
var n = 0;
for(var i=1,len=arr.length;i<len;i++){
        if(minArr>arr[i]){
            minArr = arr[i];
         n = i;
     }
 }
 console.log(minArr,n); // => 1, 2

// 取出最大值 ，并获取他的位置
var arr = [6,4,1,2];
var maxArr = arr[0];
var n = 0;
for(var i=1,len=arr.length;i<len;i++){
    if(maxArr<arr[i]){
        maxArr = arr[i];
        n = i;
    }
}
console.log(maxArr,n);// 6 , 0

==数组排序==

var arr = [6,4,1,2];
console.log(arr.sort(function(num1,num2){return num1-num2;})); //=>[1,2,4,6]
console.log(arr.sort(function(num1,num2){return num2-num1;})); //=>[6,4,2,1]

// 冒泡排序
var arr = [6,4,1,2];
for(var i=0,len=arr.length;i<len;i++){
    for(var j=0,l=arr.length;j<l-i;j++){
        toSort(j,j+1);
    }
}
function toSort(prev,next){
    var tmp = 0;
    if(arr[prev]>arr[next]){ // > 从小到大， < 从大到小
        tmp = arr[prev];
        arr[prev] = arr[next];
        arr[next] = tmp;
    }
}
console.log(arr);//=>[1,2,4,6]   [6,4,2,1]

==数组去重==

var arr = [6,4,1,2,4,2,6];
Array.prototype.fn = function(){
    var newArr = [];
    var json = {};
    for(var i=0,len=this.length;i<len;i++){
        if(!json[this[i]]){
            newArr.push(this[i]);
            json[this[i]] = true;
        }
    }
        return newArr;
}
var nArr = arr.fn();
console.log(nArr);

var arr = [6,4,1,2,4,2,6];
var newArr = [];
var json = {};
for(var i=0,len=arr.length;i<len;i++){
    if(!json[arr[i]]){
        newArr.push(arr[i]);
        json[arr[i]] = 1;
    }
}
console.log(newArr);

var arr = [6,4,1,2,4,2,6];
Array.prototype.fn = function(){
    var newArr = [];
    for(var i=0,len=this.length;i<len;i++){
        if(newArr.indexOf(this[i])==-1){
            newArr.push(this[i]);
        }
    }
    return newArr;
}
var nArr = arr.fn();
console.log(nArr);

var arr = [6,4,1,2,4,2,6];
            Array.prototype.fn = function(){
                var _this = this;
                var tmpArr = [];
                for(var i=0,len=this.length;i<len;i++){
                    _this.toCom(this[i],tmpArr);
                }
                return tmpArr;
            }
            Array.prototype.toCom = function(arr,tmpArr) {
                var isT = true;
                for(var i=0,len=tmpArr.length;i<len;i++){
                    if(arr == tmpArr[i]){
                        isT = false;
                        break;
                    }
                }
                if(isT){
                    tmpArr.push(arr);
                }
            };
            var nArr = arr.fn();
            console.log(nArr);

function fn(){
                var arr = [6,4,1,2,4,2,6];
                var tmpArr = [];
                for(var i=0,len=arr.length;i<len;i++){
                    toCom(arr[i],tmpArr);
                }
                return tmpArr;
            }
            function toCom(arr,tmpArr) {
                var isT = true;
                for(var i=0,len=tmpArr.length;i<len;i++){
                    if(arr == tmpArr[i]){
                        isT = false;
                        break;
                    }
                }
                if(isT){
                    tmpArr.push(arr);
                }
            };
            console.log(fn());