js 数组的基础用法以及进阶详解，Array构造函数详解

向右看齐 2022-09-07 12:28 211阅读 0赞

### Array的基础用法 ###

*   *   *  1.两种创建方式
         *  2.常用内置方法
         *   *  push 末尾添加
             *  unshift 开头添加
             *  splice 删除，替换，原地添加操作
             *  shift 删除第一个元素
             *  pop 删除最后一个元素
             *  concat 合并数组
             *  includes 检查数组中是否包含XXX
             *  indexOf 根据元素获取下标
             *  Array.isArray 检查数组
             *  join 连接数组元素返回字符串
         *  3.懒得写了，后面再更新吧

--------------------

### 1.两种创建方式 ###

实例创建数组的参数比较特殊，下方有讲解

//隐式创建数组
    	let arr = [1,2,3,4,5]
    	//实例化
    	let arr1 = new Array()
    	//两种实例参数
    	let exm = new Array(5)	//生成长度为5但值为空的数组
    	let exm1 = new Array(1,2,3,4,5)//长度为5，值对应参数

--------------------

### 2.常用内置方法 ###

#### push 末尾添加 ####

方法将`一个`或`多个`元素添加到数组的末尾，并返回该数组的新长度。

let a = []
    	a.push('a')	//添加一个
    	a.push('a','b','c','d')	//添加多个
    	
    	//还可使用解构符进行快捷添加多个
    	//添加多个应使用concat合并
    	let b = ['a','b','c']
    	let c= [1,2,3,4,5]
    	b.push(...c)	//结果：["a","b","c",1,2,3,4,5]

#### unshift 开头添加 ####

unshift() 方法将`一个`或`多个`元素添加到数组的开头，并返回该数组的新长度，用法与push几乎相同。

let a = [1,2]
    	a.unshift('a')	//添加一个 ['a',1,2]
    	a.unshift('a','b','c','d')	//添加多个 ['a','b','c','d',1,2]

#### splice 删除，替换，原地添加操作 ####

方法通过`删除`或`替换`现有元素或者`原地添加`新的元素来修改数组,并以数组形式返回被修改的内容。  
Array.splice(\_a,\_b,\_c)  
splice方法有三个参数，\_a,\_b表示下标，\_c表示插入或替换的内容

//替换 - 从下标1开始计算两个单位所有的元素替换为'a'
    	let s = [1,2,3,4,5,6]
    	s.splice(1,2,'a')
    	//删除 - 删除从下标2开始计算一个单位进行删除
    	let s1 = [1,2,3,4,5,6]
    	s1.splice(2,1)
    	//添加 - 从下标3开始计算，但不包括下标3的位置进行添加
    	let s2 = [1,2,3,4,5,6]
    	s1.splice(3,0,3.5)

#### shift 删除第一个元素 ####

shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。

let a = [1,2,3]
    	console.log(a.shift())	//1
    	console.log(a)	// [2,3]

#### pop 删除最后一个元素 ####

pop()方法从数组中删除最后一个元素，并返回该元素的值。

let a = [1,2,3]
    	console.log(a.pop())	//3
    	console.log(a)	// [1,2]

#### concat 合并数组 ####

concat方法用于合并`两个`或`多个`数组。此方法不会更改现有数组，而是返回一个新数组。  
此方法一般在处理多列表数据合并的时候使用，多数据应使用concat而不是push

//两个合并
    	let a = [1,2,3]
    	let b = ['a','b','c']
    	let c = a.concat(b)	//结果:[1,2,3,'a','b','c']
    	//多个合并
    	let a1 = [1,2]
    	let a2 = [3,4]
    	let a3 = ['a','b']
    	console.log(a1.concat(a2,a3))	//[1,2,3,4,'a','b']

#### includes 检查数组中是否包含XXX ####

includes(\_valueToFind,\_index) 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。  
`includes的第二个参数为下标值`  
从\_index 索引处开始查找\_valueToFind。如果为负值，则按升序从 array.length + index的索引开始搜 （即使从末尾开始往前跳 index的绝对值个索引，然后往后搜寻）。默认为 0。

//实例
    		let fun = ()=>{ 
                console.log('123')
            }
            let obj = { a:2}
            let b1 = [1,'a',{ a:1},obj,[1,2],bfun,()=>{ return 1}]
    		b1.includes(1)	//true
            b1.includes('a')	//true
            b1.includes({ a:1})	//false
            b1.includes(obj)	//true
            b1.includes([1,2])	//false
            b1.includes(fun)	//true
            b1.includes(()=>{ return 1})	//false

#### indexOf 根据元素获取下标 ####

indexOf()方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。

console.log([1,2,3,4].indexOf(3))	//结果：2
       	console.log([1,2,3,4].indexOf(-2))	//结果：-1

#### Array.isArray 检查数组 ####

> 这是构造函数下的方法，所以为Array.isArray形式使用

Array.isArray() 用于检查参数是否是一个 Array

Array.isArray([1, 2, 3]);	// true
    	Array.isArray({ foo: 123});	// false
    	Array.isArray("foobar");	// false
    	Array.isArray(undefined);	// false

#### join 连接数组元素返回字符串 ####

join() 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。  
如果一个元素为 undefined 或 null，它会被转换为空字符串。

//实例
    const elements = ['Fire', 'Air', 'Water'];
    console.log(elements.join());	//"Fire,Air,Water"
    console.log(elements.join(''));	//"FireAirWater"
    console.log(elements.join('-'));	//"Fire-Air-Water"
    
    //连接类数组对象
    function f(a, b, c) { 
     var s = Array.prototype.join.call(arguments);
        console.log(s); // '1,a,true'
    }
    f(1, 'a', true);

--------------------

### 3.懒得写了，后面再更新吧 ###