【从0到1学javascript】javascript数据结构----数组

javascript中对数组的定义

数组是一种特殊的对象，用来表示偏移量的索引是该对象的属性，索引可以是整数。这些数字索引在内部被转换成字符串类型。这是因为javascript对象中的属性名必须是字符串。数组在javascript中只是一种特殊的对象，效率上没有其它语言数组的效率高。

1.1创建数组的方式

//初始化数组以下的两种声明方式相同
console.log('-----数组的声明方式-----');
var array1 = [];
var array2 = new Array();

//创建数组时指明数组长度
console.log('-----创建数组时可以指明数组长度-----');
var array3 = new Array(3);
console.log(array3.length);
array3[4] = 5;
console.log(array3);

//声明有默认值的数组,且数组中的元素不必是同一种类型（与强类型语言有区别）
console.log('-----默认值的数组-----');
var array4 = [1,'22',3];
var array5 = new Array(1,'22',3);
console.log(array4);
console.log(array5);

//怎么初始化一个数组，通过设置Array对象的length为0
console.log('------初始化一个数组----');
console.log(array5);
array5.length =0;
console.log(array5);

结果：

判断是否是javascript数组的方法：

//判断是否是数组的方法
var array5 =[];
console.log(typeof array5 ==Array);    //false
console.log(typeof array5 ===Array);    //false
console.log(typeof array5); //object
console.log(Array.isArray(array5));     //true
console.log(array5 instanceof Array);   //true

由上可以知道当我们要判断是否是js数组的时候typeof操作符是不好用的，可以使用instanceof操作符或者是使用Array对象的内置函数isArray()。

1.2对数组的操作

var array1 =[1,2,3,4];
var array2 = array1;
array2[2] =5;
console.log(array1);
console.log(array2);

结果：

[ 1, 2, 5, 4 ]
[ 1, 2, 5, 4 ]

由结果知道简单的赋值操作只是所谓的浅复制（引用复制）。深复制和浅复制区别点击这里

一个扩展Array对象自身方法的深复制：

Array.prototype.deepCopy = function(array){
    var tempArray = [];
    //判断array参数不是null ,undefined,0,'',nan,false
    if (array){
        for (var i =0,len = array.length;i<len;i++){
            tempArray[i] = array[i];
        }
        return tempArray;
    }
    return null;
}
var array1 =[1,2,3,4];
var array2 = array1;
var array3 = [];
array2[2] =5;
console.log(array1);
console.log(array2);

array3 = array3.deepCopy(array1);
console.log(array3);
array3[0] = 78;
console.log(array1);
console.log(array3);

结果：

[ 1, 2, 5, 4 ]
[ 1, 2, 5, 4 ]
[ 1, 2, 5, 4 ]
[ 1, 2, 5, 4 ]
[ 78, 2,5, 4 ]

2.1数组中查找元素

先抛一块“石头“，最常见的数组去重问题：
代码：

var array1 = [1, 2, 3, 4, 5, 5, 4, 2, 7, 8];
Array.prototype.UnRepeat = function(array) {
    var temp = [];
    for (var i = 0, len = array.length; i < len; i++) {
        if (temp.length != 0) {
            for (var m = 0; m < temp.length; m++) {
                var isExist = false;
                if (array[i] == temp[m]) {
                    isExist = true;
                    break;
                }
            }
            if (isExist == false) {
                temp.push(array[i]);
            }
        } else {
            temp.push(array[i]);
        }
    }
    return temp;
}

结果：

[ 1, 2, 3, 4, 5 ]

以上代码可以满足对数组进行去重的操作。但是时间复杂度较高为T(n) = O(n^2) 。其实在原生得javascript中提供了方法支持查找元素的操作。分别是indexOf()和lastIndexOf()
优化后的代码

Array.prototype.UnRepeat1 = function(array) {
    var temp = [],
        indexResult;
    for (var i = 0, len = array.length; i < len; i++) {
        indexResult = temp.indexOf(array[i])
        if (indexResult == -1 && indexResult != null) {
            temp.push(array[i]);
        }
    }
    return temp;
}

结果:

[ 1, 2, 3, 4, 5, 7, 8 ]

此时的时间复杂度为T(n) = O(n)

2.2数组的排序

看一段代码：

var nums = [1,5,9,2,3];
//将数组中的元素反转
nums.reverse();
console.log(nums);

//当数组元素是字符串时可以使用sort()
var strArray = ['qwe','erere','sdsf','hghgj'];
strArray.sort();
console.log(strArray);

//对数字进行sort()方法
var numArray = [1,45,67,23,09,100];
numArray.sort();
console.log(numArray);

结果如下：

[ 3, 2, 9, 5, 1 ]
[ ‘erere’, ‘hghgj’, ‘qwe’, ‘sdsf’ ]
[ 1, 100, 23, 45, 67, 9 ]

可以很清楚的指导当数组的元素都是数字的时候，使用sort()方法对数组排序是没有效果的。这是为什么呢？

sort()方法是按照字典顺序进行排序的。因此当使用sort()方法时，如果被排序元素非数字就会直接按照字典顺序进行排序。如果是数字在内部就会先进行转化，将数字转化为字符串。
为了能够让sort()方法也能够排序数字元素，可以在sort()方法中传入一个比较大小的函数。sort()将会根据函数根据函数确定元素的大小，并且确定数组的顺序。

看下面的一段代码：

//对数字进行sort()方法
var numArray = [1,45,67,23,09,100];
numArray.sort();
console.log(numArray);

function sortNum(num1,num2){
    //减号操作符会将两边的字符串强制转换为数字
    return num1 - num2;
}
numArray.sort(sortNum);
console.log(numArray);

结果为：

[ 1, 9, 23, 45, 67, 100 ]

3.1数组的迭代器方法

3.1.1不生成新数组的迭代器方法

forEach()该方法接受一个函数参数,对数组的所有元素运用该函数

var numArray = [1,45,67,23,09,100];
function eachFunc(num){
    console.log( num + '字符串');
}

numArray.forEach(eachFunc);
console.log(numArray);

结果:

1字符串
9字符串
23字符串
45字符串
67字符串
100字符串
[ 1, 9, 23, 45, 67, 100 ]

定义:

every()和some()方法接受一个返回值为布尔类型的函数,对数组中的元素使用该函数.如果对于所有的元素.该函数的返回值都是true,则该方法返回true.

代码如下:

var numArray = [1, 45, 67, 23, 09, 100];
var numArray1 = [-1, 45, 67, 23, 09, 100];
function eveFunc(num) {
    return num > 0;
}
function resultFunct(result) {
    if (result) {
        console.log('全部为正数.');
    } else {
        console.log('有负数存在.');
    }
}
var result = numArray.every(eveFunc);
resultFunct(result);

var result1 = numArray1.every(eveFunc);
resultFunct(result1);

结果:

全部为正数.
有负数存在.

3.1.2生成新数组的迭代器方法

map()和filter()对数组的每个元素应用该函数.但是map()会返回一个新数组.
filter()函数与every()函数类似,every()函数当所有元素满足条件时返回true,而filter()函数返回一个新数组.

function mapFunc(num){
    return num *2;
}
var numArray1 = [-1, 45, 67, 23, 09, 100];
var resultMap = numArray1.map(mapFunc);
console.log(resultMap);

结果:

[ -2, 90, 134, 46, 18, 200 ]