【javascript数据结构】----数组

Love The Way You Lie 2022-08-04 16:45 131阅读 0赞

### **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);

**结果**：  
![这里写图片描述][20150523090647195]

**判断是否是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 \]

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

**一个扩展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数组中查找元素** ####

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

**结果**：

> \[ 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)***

其它方法js数组去重，使用hash表的原理：

/** * js对象也可以认为是一个hash表 */
    var testArray = [1, 2, 3, 3, 4, 4, 6, 7, 8];
    function unique3(arr) {
        var tmpArr = [],
            hash = {}; //hash为hash表
        for (var i = 0; i < arr.length; i++) {
            if (!hash[arr[i]]) { //如果hash表中没有当前项
                hash[arr[i]] = true; //存入hash表
                tmpArr.push(arr[i]); //存入临时数组
            }
        }
        console.log(hash);
        return tmpArr;
    }
    console.log(unique3(testArray));

> 结果如下：  
> \{ ‘1’: true,  
> ‘2’: true,  
> ‘3’: true,  
> ‘4’: true,  
> ‘6’: true,  
> ‘7’: true,  
> ‘8’: true \}  
> \[ 1, 2, 3, 4, 6, 7, 8 \]

#### **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.

**代码如下:**

**结果:**

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

##### 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 \]

[20150523090647195]: /images/20220805/8aac30fd05eb4842887545847c2f4082.png
[Link 1]: http://blog.csdn.net/yisuowushinian/article/details/45544343