c++ 数组截取_温习笔记 数组

~定义方式

let arr=[1,2] //字面量创建
let arr2=new Arrery() //构造函数创建

~间隔推入数组

let arr=[1,2,3]
arr[10]=10
arr

68255ee3c86dcf2f91ebd4b42ebdb6b0.png
数组元素还是有四个，数组长度是11，剩下是空的
	let arr=[1,2,3]
	arr[10]=11
	for(let i of arr){
		console.log(i)
	}

8539af1462ed97f48255c5cd43cd0d50.png
推入下标大于数组长度，数组会补齐，但是会是undefined

~数组的本质

本质上数组是一种特殊的对象，typeof查看其基本类型返回 object

typeof [] //object

数组的特殊性在于，他的键名是按次数排列的整数。

let arr=[1,2,3]
Object.keys(arr)
//['0','1'，'2']

上面的代码我们可以看到，object的键名方法arr是可以使用的，返回的也是整数

let arr=[1,2,3]
arr[0] //1
arr['0'] //1

按照对象的写法 obj['key'] 括号里必须是字符串，而数组却不需要。之所以可以是非字符串键名转化为字符串

~length属性

通过length控制数字的数据

let arr=[1,2,3]
arr.length=2
arr //[1,2]

如果人为设置的length大于数组实际的长度，数组成员的数量会增加到这个值，新增的位置都是空位

let arr=[1,2,3]
arr.length=10
arr[7] //undefined

~为数组添加属性

数组本质是对象，所以可以为数组添加属性，但这不影响length属性

	let arr=[
		1,2,3,4
	]
	arr['a']='ss'
	arr['b']='ss'

ac1369e2be89759853377807e18184f9.png
影响length属性

~ in运算符

检测某个键名是否存在，适用于对象，也适用于数组

let arr=['v'，2，4，‘a’]
0 in arr //true
'1' in arr //true
4 in arr //false

数值也会转为字符串，如果数组某个位置为空，in将返回false

let arr=[]
arr[100]=1
100 in arr //true
1 in arr //false

~for in 循环遍历数组

以为数组也是特殊的对象，所以可以可以用for in 遍历数组

let arr=[1,2,3]
for(const i in arr){
   i // key
   arr[i] //value
}

但是需要注意的是for in 会将数组中的属性也会遍历出来

0f9b8bd861bc8e496ad4e1e1eb495d5c.png

287fbf178b105215efb9c1266b7c6d00.png
如果不想出现这种情况还是用for length循环或是foreach

f4ea0026306d80083a21146deaab25f2.png

aac991fa9c244d2bc73c40279e1a09d0.png

~数组的空位

当数组中两个逗号之间没有值，即为数组中的空位

let arr=[1,,2]
arr.length //3

空位是可以读取的

let arr=[,,,]
arr.length //3
arr[0] //undefined

使用delete命令删除一个数组元素，会形成空位影响length属性

let arr=[1,2,3]
delete(arr[0]) //true
arr[0] //undefined
arr.length //3

数组某个位置是空位与其是undefined是不一样的，如果是空位for in Object.keys方法遍历是会跳过的

var a = [, , ,];

a.forEach(function (x, i) {
  console.log(i + '. ' + x);
})
// 不产生任何输出

for (var i in a) {
  console.log(i);
}
// 不产生任何输出

Object.keys(a)
// []

如果某个位置是undefined，遍历的时候就不会被跳过。

var a = [undefined, undefined, undefined];

a.forEach(function (x, i) {
  console.log(i + '. ' + x);
});
// 0. undefined
// 1. undefined
// 2. undefined

for (var i in a) {
  console.log(i);
}
// 0
// 1
// 2

Object.keys(a)
// ['0', '1', '2']

~ Array.isArray()

isArray()方法返回一个布尔值，用来判断参数是否是数组。（弥补typeof的问题）

Array.isArray([]) //true
typeof [] //object

~valueOf() , toString()

valueOf方法是一个所有对象都拥有的方法，表示该对象求值。不同对象的valueOf方法不尽一致，数组的方法是返回数组本身

		let arr=[1,2,3]
		let obj={name:11,dd:2}
		function fun(){}
		let zhen=/a/
		console.log(arr.valueOf(),obj.valueOf(),fun.valueOf(),zhen.valueOf())

5ab6b42208ccdcd006435ff356747432.png

toString方法也是对象的通用方法，用来返回数组的字符串形式

		let arr=[1,2,3]
		let obj={name:11,dd:2}
		function fun(){}
		let zhen=/a/
		console.log(arr.toString(),obj.toString(),fun.toString(),zhen.toString())

4f2f83098107e6a62c0c60f4d944e608.png

~push() , pop()

push方法用来向数组末尾追加元素。会改变原数组

let arr=[]
arr.push(1) // 1
arr.push('a') // 2
arr.push(true, {}) // 4
arr // [1, 'a', true, {}]

pop方法用来删除数组最后一个元素，并且返回他，改变原数组

let arr=[1,2]
arr.pop() //2
arr //[1]

~shift() , unshift()

shift方法用于删除数组第一个元素

let arr=[1,2,3]
arr.shift() //1
arr //[2,3]

unshift方法用于向数组头部追加一个元素，会改变原数组，并且返回新数组的length

let arr=[1,2,3]
arr.unshift('x',6) //5
arr //['x',6，1，2，3]

~join()

join方法可以用指定字符作为分隔符，将数组连接为一个字符串。不提供参数默认以 , 逗号分割

let arr=[1,2,3]
arr.join() // '1,2,3'
arr.join('') // '123'

用call分割伪数组的对象

		let obj={
			0:12,
			1:33,
			length:2
		}
               [].join.call(obj,' ') // '12 33'

~concat()

concat方法用来合并数组。他将新成员添加到数组后部，返回一个新数组，原数组不变

let arr= [1].concat([2,3])
arr //[1,2,3]

let arr= [1].concat([2,3],[4,5])
arr //[1,2,3,4,5]

参数除了接收数组，也可以接收其他类型的参数

let arr=[1,2].concat(3,4)
arr //[1,2,3,4]

let arr=[1,2].concat({name:123})
arr //[1,2,{name:123}]

如果参数中带有对象，concat返回一个浅拷贝，只是拷贝原对象的引用

let obj={name:123}
let arr=[1,2].concat(obj)
arr[2].name=333
obj // {name:333}

~reverse()

reverse方法方法用来颠倒数组

[1,2,3].reverse() //[3,2,1]

~slice()

slice方法用来截取数组，返回一个新数组，原数组不变，string也可以用

第一个参数从哪开始，第二参数结束位置。没有第二个参数截取完

let arr=[1,2,3]
arr.slice(1) //[2,3]
arr.slice(1,1) //[2]
arr // [1,2,3]

slice一个重要的作用就是把类数组转化为真正的数组

[].slice.call({0:12,1:22,length:2}) //[12,22]
[].slice.call(doucument,querySelectorAll('div'))

~splice()

splice方法用来删除数组元素，也可以用来添加新元素，会改变原数组

第一个参数是删除的起始位置，第二个是删除元素的个数，第三个是在删除的位置追加的元素

let arr=[1,2,3]
arr.splice(0,1)
arr //[2,3]
arr.splice(0,0,3,3)
arr //[3,3,2,3]


~sort()

sort方法用来对数组进行排序，默认是按照字典顺序进行排序。排序后原数组将会改变

['d','a','c','b'].sort()  //[a,b,c,d]
[4,2,3,1].sort() //[1,2,3,4]

sort()方法可以将一个函数传入当作参数，第一个参数是第二个比较的值，第二个参数是第一个比较的值

		[1,2,3,4,5,6].sort((two,one)=>{
			console.log(two,one)
		})

73d06a0a7f56ea1c08e0d2b7b79f554f.png
[10111, 1101, 111].sort(function (a, b) {
  return a - b; //a - b是升序
  return b - a; //b - a是降序
})
// [111, 1101, 10111]
// [10111, 1101,111]

~map()

map方法将将数组成员一次传入函数，然后把每一次的执行结果组成一个新数组返回

函数传入三个参数（当前元素,下标，原数组）

	 	let arr=[1,2,3]
		let x=arr.map(function(item){
			return item+1
		})
		console.log(arr) //[1,2,3]
		console.log(x) [2,3,4]

map第二个参数可以传入this

		let arr2=[]
	 	let arr=[1,2,3]
		function fun(v,i,arr){
			this[i]=v
		}
		arr.forEach(fun,arr2)
		console.log(arr2) //[1,2,3]

~forEach()

foreach与map很像，但是foreach没有返回值，只是为了操作数据。如果想返回新数组使用map

function log(element, index, array) {
  console.log('[' + index + '] = ' + element);
}

[2, 5, 9].forEach(log);

forEach也可以传入this和map一样

~filter()

filter方法用于过滤数组成员，满足条件的组成一个新的成员返回

它的参数是一个函数，所有数组成员依次执行该函数，返回结果为 true 的成员组成一个新数组返回

它也可以传this

~some() every()

some与every判断传入数组的每一项，some中有一个符合条件，就返回true，every则必须全部符合条件 才返回true

var arr = [1, 2, 3, 4, 5];
arr.some(function (elem, index, arr) {
  return elem >= 3;
});
// true

var arr = [1, 2, 3, 4, 5];
arr.every(function (elem, index, arr) {
  return elem >= 3;
});
// false

~reduce() reduceRight()

reduce方法和reduceRight依次处理数组成员，最终累计一个最终值返回。reduce是从左往右处理成员，right相反。

let num=[1,2,3,4,5].reduce((a,b)=>{
   console.log(a,b)
   return a+b
})
num //15

6908be3ab8dcf1ec0e7cac3778249add.png
第一次循环的a是数组第一个成员，b是第二个成员。到了第一次以后时，a变成了上一次计算的结果，b是下一个成员

reduce（(a,b,index,arr)=>{}） reduce和reduceRight 传入的函数有四个参数

		function max(arr){
			return arr.reduce((a,b)=>{
				return a.length>b.length?a:b
			})
		}
		console.log(max(['a','bbb','cc']))  //bbb

reduce 用来比较数组中特定的值比较好

~indexOf() lastIndexOf()

这两个返回查找元素，在数组的位置，用法和字符串使用一样

['a','g','s'].indexOf('g') //1
['a','g','s'].indexOf('x') //-1 -1没找到

~链式使用

		var users = [
		  {name: 'tom', email: 'tom@example.com'},
		  {name: 'peter', email: 'peter@example.com'}
		];
		users.map((item)=>{
			return item.email
		})
		.filter((email)=>{
			return /^t/.test(email)
		})
		.forEach((item)=>{
			console.log(item) // tom@example.com
		})
版权声明：本文为weixin_36486217原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。