JS-Array

数组的创建
数组的清空
数组的首位之前追加
数组的末尾之后追加
数组的首位删除
数组的末位删除
数组的替换|插入|删除
数组的截取
数组的合并
数组的排序
数组转字符串
数组随机排序
数组的遍历
找出第一个符合条件的数组成员索引值
数组值的’过滤’功能
数组值的累加
数组检测
检查数组中是否存在某个值
找出第一个符合条件的数组成员
找出第一个符合条件的数组成员的位置(索引值)
数组相关

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

数组的创建

数组的清空

数组的首位之前追加

数组的末尾之后追加

数组的首位删除

数组的末位删除

数组的替换|插入|删除

数组的截取

数组的合并

数组的排序

数组转字符串

数组随机排序

数组的遍历

找出第一个符合条件的数组成员索引值

数组值的’过滤’功能

数组值的累加

数组检测

检查数组中是否存在某个值

找出第一个符合条件的数组成员

找出第一个符合条件的数组成员的位置(索引值)

数组相关

var arr=[];
console.log(arr)//[]

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

var arr=new Array();
console.log(arr)//[]

1 2	var arr=new Array(); console.log(arr)//[]

var arr=new Array(1);
console.log(arr)//[empty]

1 2	var arr=new Array(1); console.log(arr)//[empty]

var arr =[1,2,3,7,8,33,55]
arr.length=0;//清空数组的方法一，让length等于0；
console.log(arr)//[]

1

2

3

var arr =[1,2,3,7,8,33,55]

arr.length=0;//清空数组的方法一，让length等于0；

console.log(arr)//[]

var arr =[1,2,3,7,8,33,55]
arr=[];//清空数组的方法二，给arr赋值为空数组即可
console.log(arr)//[]

1

2

3

var arr =[1,2,3,7,8,33,55]

arr=[];//清空数组的方法二，给arr赋值为空数组即可

console.log(arr)//[]

//unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度,直接修改原有的数组
var arr =[1,2,3,7,8,33,55]
console.log(arr.unshift(99,88))//9
console.log(arr)// [99, 88, 1, 2, 3, 7, 8, 33, 55]

1

2

3

4

//unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度,直接修改原有的数组

var arr =[1,2,3,7,8,33,55]

console.log(arr.unshift(99,88))//9

console.log(arr)// [99, 88, 1, 2, 3, 7, 8, 33, 55]

//push() 方法可向数组的末尾添加一个或更多元素，并返回新的长度,直接修改原有的数组
var arr =[1,2,3,7,8,33,55]
console.log(arr.push(88))//8
console.log(arr)//[1, 2, 3, 7, 8, 33, 55, 88]

1

2

3

4

//push() 方法可向数组的末尾添加一个或更多元素，并返回新的长度,直接修改原有的数组

var arr =[1,2,3,7,8,33,55]

console.log(arr.push(88))//8

console.log(arr)//[1, 2, 3, 7, 8, 33, 55, 88]

//shift() 方法用于把数组的第一个元素从其中删除，并返回被删除的值,直接修改原有的数组
var arr =[1,2,3,7,8,33,55]
console.log(arr.shift())//1
console.log(arr)//[2, 3, 7, 8, 33, 55]

1

2

3

4

//shift() 方法用于把数组的第一个元素从其中删除，并返回被删除的值,直接修改原有的数组

var arr =[1,2,3,7,8,33,55]

console.log(arr.shift())//1

console.log(arr)//[2, 3, 7, 8, 33, 55]

//pop() 方法用于删除数组的最后一个元素,并返回被删除的值,直接修改原有的数组
var arr =[1,2,3,7,8,33,55]
console.log(arr.pop())//55
console.log(arr)//[1,2, 3, 7, 8, 33]

1

2

3

4

//pop() 方法用于删除数组的最后一个元素,并返回被删除的值,直接修改原有的数组

var arr =[1,2,3,7,8,33,55]

console.log(arr.pop())//55

console.log(arr)//[1,2, 3, 7, 8, 33]

//替换 比push和unshift方法更灵活,并且可以在数组中的其他位置添加删除替换
var arr =[1,2,3,7,8,33,55]
console.log(arr.splice(1,1,'sanrenbiji'))//'sanrenbiji'替换掉数组索引值为1的值，直接修改原有的数组
console.log(arr)//[1, "sanrenbiji", 3, 7, 8, 33, 55]

1

2

3

4

//替换比push和unshift方法更灵活,并且可以在数组中的其他位置添加删除替换

var arr =[1,2,3,7,8,33,55]

console.log(arr.splice(1,1,'sanrenbiji'))//'sanrenbiji'替换掉数组索引值为1的值，直接修改原有的数组

console.log(arr)//[1, "sanrenbiji", 3, 7, 8, 33, 55]

//插入 比push和unshift方法更灵活,并且可以在数组中的其他位置添加删除替换
var arr =[1,2,3,7,8,33,55]
arr.splice(1,0,'sanrenbiji')//'sanrenbiji'插入到索引值为1的值前面,原有索引值为1的往后排变成2，直接修改原有的数组
console.log(arr)//[1, "sanrenbiji", 2, 3, 7, 8, 33, 55]

1

2

3

4

//插入比push和unshift方法更灵活,并且可以在数组中的其他位置添加删除替换

var arr =[1,2,3,7,8,33,55]

arr.splice(1,0,'sanrenbiji')//'sanrenbiji'插入到索引值为1的值前面,原有索引值为1的往后排变成2，直接修改原有的数组

console.log(arr)//[1, "sanrenbiji", 2, 3, 7, 8, 33, 55]

//删除 比push和unshift方法更灵活,并且可以在数组中的其他位置添加删除替换
var arr =[1,2,3,7,8,33,55]
console.log(arr.splice(1,1))// [2] 从数组索引值为1开始删除1个，返回被删除的值，直接修改原有的数组
console.log(arr)//[1, 3, 7, 8, 33, 55]

1

2

3

4

//删除比push和unshift方法更灵活,并且可以在数组中的其他位置添加删除替换

var arr =[1,2,3,7,8,33,55]

console.log(arr.splice(1,1))// [2] 从数组索引值为1开始删除1个，返回被删除的值，直接修改原有的数组

console.log(arr)//[1, 3, 7, 8, 33, 55]

//delete 也可以删除数组的值,删除数组的值后被empty代替
var arr=[1,2,3,4]
delete arr[1]
console.log(arr)//[1, empty, 3, 4]
console.log(arr.length)//4
//只删除值长度不改变

1

2

3

4

5

6

//delete 也可以删除数组的值,删除数组的值后被empty代替

var arr=[1,2,3,4]

delete arr[1]

console.log(arr)//[1, empty, 3, 4]

console.log(arr.length)//4

//只删除值长度不改变

var arr =[1,2,3,7,8,33,55]
console.log(arr.slice(1,3))//[2,3]  截取从arr数组的索引值2开始，到索引值3结束，包含开始索引值的值，不包含结束索引值的值
console.log(arr)//[1,2,3,7,8,33,55]

1

2

3

var arr =[1,2,3,7,8,33,55]

console.log(arr.slice(1,3))//[2,3] 截取从arr数组的索引值2开始，到索引值3结束，包含开始索引值的值，不包含结束索引值的值

console.log(arr)//[1,2,3,7,8,33,55]

var arr =[1,2,3]
var arr1=[4,5,6]
var arr2=[7,8,9]
console.log(arr.concat(arr1,arr2)) //[1, 2, 3, 4, 5, 6, 7, 8, 9]

1

2

3

4

var arr =[1,2,3]

var arr1=[4,5,6]

var arr2=[7,8,9]

console.log(arr.concat(arr1,arr2)) //[1, 2, 3, 4, 5, 6, 7, 8, 9]

arr.sort();//数组排序，默认以字符串大小编码排序
arr.sort(function( a , b ){ return a – b });//标准排序传入比较函数，
arr.reverse();//数组前后调换位置(倒置)

1

2

3

arr.sort();//数组排序，默认以字符串大小编码排序

arr.sort(function( a , b ){ return a – b });//标准排序传入比较函数，

arr.reverse();//数组前后调换位置(倒置)

var arr =['我','可','劲','学'];
console.log(arr.join(''))//我可劲学
//把数组变成字符串

1

2

3

var arr =['我','可','劲','学'];

console.log(arr.join(''))//我可劲学

//把数组变成字符串

arr.sort(function{
  return Math.random() > 0.5 ? -1 : 1;
});

1

2

3

arr.sort(function{

return Math.random() > 0.5 ? -1 : 1;

});

var arr =[1,2,3,7,8,33,55]
for(var i=0;i<arr.length;i++){
	console.log(arr[i])
	console.log(i)
}

1

2

3

4

5

var arr =[1,2,3,7,8,33,55]

for(var i=0;i<arr.length;i++){

console.log(arr[i])

console.log(i)

}

var arr =[1,2,3,7,8,33,55]
arr.forEach(function(e,i){
	console.log(e)
	console.log(i)
})

1

2

3

4

5

var arr =[1,2,3,7,8,33,55]

arr.forEach(function(e,i){

console.log(e)

console.log(i)

})

var arr =[1,2,3,7,8,33,55]
arr.map(function(e,i){
	console.log(e)
	console.log(i)
})

1

2

3

4

5

var arr =[1,2,3,7,8,33,55]

arr.map(function(e,i){

console.log(e)

console.log(i)

})

//for in 遍历数组可以输出数组的索引值和对应的值
var arr =[1,2,3,7,8,33,55]
for(var i in arr){
	console.log('索引值'+i+'的值是:'+arr[i])
}

1

2

3

4

5

//for in 遍历数组可以输出数组的索引值和对应的值

var arr =[1,2,3,7,8,33,55]

for(var i in arr){

console.log('索引值'+i+'的值是:'+arr[i])

}

//for of 是ES6的方法,只返回每一项的值
var arr =[1,2,3,7,8,33,55]
for(var v of arr){
	console.log(v)
}

1

2

3

4

5

//for of 是ES6的方法,只返回每一项的值

var arr =[1,2,3,7,8,33,55]

for(var v of arr){

console.log(v)

}

//从数组第一项往后查找给出的值,找到第一个就立即返回该值在数组里的索引值,如果查到最后都没有找到就返回-1
var arr =[1,2,3,7,8,33,55]
console.log(arr.indexOf(3))//2
console.log(arr.indexOf(1000))//-1
PS:应用场景之一:检查是否包含某个值;ES7的includes()也可以检查是否包含某个值

1

2

3

4

5

//从数组第一项往后查找给出的值,找到第一个就立即返回该值在数组里的索引值,如果查到最后都没有找到就返回-1

var arr =[1,2,3,7,8,33,55]

console.log(arr.indexOf(3))//2

console.log(arr.indexOf(1000))//-1

PS:应用场景之一:检查是否包含某个值;ES7的includes()也可以检查是否包含某个值

//从数组最后一项往前查找给出的值,找到第一个就立即返回该值在数组里的索引值,如果查到最后都没有找到就返回-1
var arr =[1,2,3,7,8,33,55]
console.log(arr.lastIndexOf(3))//2
console.log(arr.lastIndexOf(1000))//-1

1

2

3

4

//从数组最后一项往前查找给出的值,找到第一个就立即返回该值在数组里的索引值,如果查到最后都没有找到就返回-1

var arr =[1,2,3,7,8,33,55]

console.log(arr.lastIndexOf(3))//2

console.log(arr.lastIndexOf(1000))//-1

//filter():过滤功能,数组中的每一项运行给定函数,返回满足条件组成的数组
var arr =[1,2,3,-1,-2,-3]
var filterRes=arr.filter(function(item,index){
	return item<0
})
console.log(filterRes)//[-1, -2, -3]
console.log(arr)//[1, 2, 3, -1, -2, -3]

1

2

3

4

5

6

7

//filter():过滤功能,数组中的每一项运行给定函数,返回满足条件组成的数组

var arr =[1,2,3,-1,-2,-3]

var filterRes=arr.filter(function(item,index){

return item<0

})

console.log(filterRes)//[-1, -2, -3]

console.log(arr)//[1, 2, 3, -1, -2, -3]

/*
语法:array.reduce(function(total, currentValue, currentIndex, arr), initialValue)
total:       必需。初始值, 或者计算结束后的返回值。
currentValue:必需。当前元素
currentIndex:可选。当前元素的索引
arr:         可选。当前元素所属的数组对象。
initialValue:可选。传递给函数的初始值

注意:如果是空数组会报错,翻译大概就是空数组没有有效值
*/
var arr =[1,2,3]
var sum=arr.reduce(function(total, currentValue, currentIndex, arr){
	return total+=currentValue
})
console.log(sum)//6
console.log(arr)//[1,2,3]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

/*

语法:array.reduce(function(total, currentValue, currentIndex, arr), initialValue)

total: 必需。初始值, 或者计算结束后的返回值。

currentValue:必需。当前元素

currentIndex:可选。当前元素的索引

arr: 可选。当前元素所属的数组对象。

initialValue:可选。传递给函数的初始值

注意:如果是空数组会报错,翻译大概就是空数组没有有效值

*/

var arr =[1,2,3]

var sum=arr.reduce(function(total, currentValue, currentIndex, arr){

return total+=currentValue

})

console.log(sum)//6

console.log(arr)//[1,2,3]

var arr =[1,2,3]
var sum=arr.reduce(function(total, currentValue, currentIndex, arr){
	return total+=currentValue
},10)
console.log(sum)//16
console.log(arr)//[1,2,3]

1

2

3

4

5

6

var arr =[1,2,3]

var sum=arr.reduce(function(total, currentValue, currentIndex, arr){

return total+=currentValue

},10)

console.log(sum)//16

console.log(arr)//[1,2,3]

/*
reduceRight:从数组的最后一项开始,向前遍历到第一项 ,其他和reduce一样
语法:array.reduceRight(function(total, currentValue, currentIndex, arr), initialValue)
total:必需。初始值, 或者计算结束后的返回值。
currentValue:必需。当前元素
currentIndex:可选。当前元素的索引
arr:可选。当前元素所属的数组对象。
initialValue:可选。传递给函数的初始值
注意:如果是空数组会报错,翻译大概就是空数组没有有效值
*/
var arr =[1,2,3]
var sum=arr.reduceRight(function(total, currentValue, currentIndex, arr){
	return total+=currentValue
})
console.log(sum)//6
console.log(arr)//[1,2,3]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

/*

reduceRight:从数组的最后一项开始,向前遍历到第一项 ,其他和reduce一样

语法:array.reduceRight(function(total, currentValue, currentIndex, arr), initialValue)

total:必需。初始值, 或者计算结束后的返回值。

currentValue:必需。当前元素

currentIndex:可选。当前元素的索引

arr:可选。当前元素所属的数组对象。

initialValue:可选。传递给函数的初始值

注意:如果是空数组会报错,翻译大概就是空数组没有有效值

*/

var arr =[1,2,3]

var sum=arr.reduceRight(function(total, currentValue, currentIndex, arr){

return total+=currentValue

})

console.log(sum)//6

console.log(arr)//[1,2,3]

/*
every()方法测试数组中的所有元素是否都通过了由提供的函数实现的测试。
every() 方法使用指定函数检测数组中的所有元素：
	如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
	如果所有元素都满足条件，则返回 true。
every() 不会对空数组进行检测。
every() 不会改变原始数组。	
对于空数组，它返回true
语法   :array.every(function(currentValue,index,arr), thisValue)
currentValue:必须。当前元素的值
index:可选。当前元素的索引值
arr:可选。当前元素属于的数组对象
thisValue:可选的。this执行时使用的值callback。
*/
var arr =[1,2,3]
var checkResult=arr.every(function(currentValue,index,arr){
	if(currentValue<0){
		return false
	}else{
		return true
	}
})
console.log(checkResult)//true
console.log(arr)//[1,2,3]
//PS:常应用与全选和全不选,例如购物车案例

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

/*

every()方法测试数组中的所有元素是否都通过了由提供的函数实现的测试。

every() 方法使用指定函数检测数组中的所有元素：

如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。

如果所有元素都满足条件，则返回 true。

every() 不会对空数组进行检测。

every() 不会改变原始数组。

对于空数组，它返回true

语法 :array.every(function(currentValue,index,arr), thisValue)

currentValue:必须。当前元素的值

index:可选。当前元素的索引值

arr:可选。当前元素属于的数组对象

thisValue:可选的。this执行时使用的值callback。

*/

var arr =[1,2,3]

var checkResult=arr.every(function(currentValue,index,arr){

if(currentValue<0){

return false

}else{

return true

}

})

console.log(checkResult)//true

console.log(arr)//[1,2,3]

//PS:常应用与全选和全不选,例如购物车案例

/*
some()方法测试数组中是否至少有一个元素通过了由提供的函数实现的测试。
语法:array.some(function(currentValue,index,arr),thisValue)
currentValue:	必须。当前元素的值
index:可选。当前元素的索引值
arr:可选。当前元素属于的数组对象
thisValue:this执行时使用的值callback。
空数组返回false
*/
var arr =[1,2,3]
var checkResult=arr.some(function(currentValue,index,arr){
	return currentValue>2
})
console.log(checkResult)//true
console.log(arr)//[1,2,3]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

/*

some()方法测试数组中是否至少有一个元素通过了由提供的函数实现的测试。

语法:array.some(function(currentValue,index,arr),thisValue)

currentValue: 必须。当前元素的值

index:可选。当前元素的索引值

arr:可选。当前元素属于的数组对象

thisValue:this执行时使用的值callback。

空数组返回false

*/

var arr =[1,2,3]

var checkResult=arr.some(function(currentValue,index,arr){

return currentValue>2

})

console.log(checkResult)//true

console.log(arr)//[1,2,3]

var fruits = ['apple', 'banana', 'mango', 'guava'];
function checkAvailability(arr, val) {
  return arr.some(function(arrVal) {
    return val === arrVal;
  });
}
console.log(checkAvailability(fruits, 'kela'))    // false
console.log(checkAvailability(fruits, 'banana'))  // true

1

2

3

4

5

6

7

8

var fruits = ['apple', 'banana', 'mango', 'guava'];

function checkAvailability(arr, val) {

return arr.some(function(arrVal) {

return val === arrVal;

});

}

console.log(checkAvailability(fruits, 'kela')) // false

console.log(checkAvailability(fruits, 'banana')) // true

var fruits = ['apple', 'banana', 'mango', 'guava'];
console.log(fruits.includes('kela'))    // false
console.log(fruits.includes('banana'))  // true

1

2

3

var fruits = ['apple', 'banana', 'mango', 'guava'];

console.log(fruits.includes('kela')) // false

console.log(fruits.includes('banana')) // true

/*
find方法用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。
如果没有符合条件的成员，则返回undefined。如果需要查找元素的位置或元素是否存在于数组中，请使用indexOf()或includes()。
*/
var value=[1, 4, -5, 10].find(function(item){
	return item<0
})
console.log(value)    // -5
/*find方法比较好理解，这里的参数item代表数组里的每一项，然后find方法内部通过遍历数组里的每一项，找到＜0的这一项( - 5 )。*/

1

2

3

4

5

6

7

8

9

/*

find方法用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。

如果没有符合条件的成员，则返回undefined。如果需要查找元素的位置或元素是否存在于数组中，请使用indexOf()或includes()。

*/

var value=[1, 4, -5, 10].find(function(item){

return item<0

})

console.log(value) // -5

/*find方法比较好理解，这里的参数item代表数组里的每一项，然后find方法内部通过遍历数组里的每一项，找到＜0的这一项( - 5 )。*/

var index = [1, 4, -5, 10].findIndex(function(value,index,arr){
	return value < 0
})
console.log(index)  // 2
/*在这个例子当中，value代表这个数组的每一项，1，4，-5，10。index代表每一项的索引值，arr代表这个数组[1, 4, -5, 10]，然后我们需要返回的是＜0的这一项的索引值，即是2了。*/

1

2

3

4

5

var index = [1, 4, -5, 10].findIndex(function(value,index,arr){

return value < 0

})

console.log(index) // 2

/*在这个例子当中，value代表这个数组的每一项，1，4，-5，10。index代表每一项的索引值，arr代表这个数组[1, 4, -5, 10]，然后我们需要返回的是＜0的这一项的索引值，即是2了。*/

<!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title>Array.form</title>
</head>
<style>
body,ul,li{margin: 0;padding: 0;}
ul{width: 250px;height: 50px;display: flex;margin: 50px auto;}
ul li{background: pink;width: 25%;text-align: center;line-height: 50px;list-style: none;border: 1px solid #666}
</style>
<body>
<ul>
	<li class="li-1">li-1</li>
	<li class="li-2">li-2</li>
	<li class="li-3">li-2</li>
	<li class="li-4">li-4</li>
	<li class="li-5">li-5</li>
</ul>
<button id="btrn">按钮</button>
</body>
<script>
	/*Array.from方法用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象（包括 ES6 新增的数据结构 Set 和 Map）。*/
	let aLi=document.querySelectorAll('ul li');
	var filterLi=Array.from(aLi).filter(function(e){
		return e.textContent=='li-2'
	})
	console.log(filterLi)//[li.li-2, li.li-3]
</script>
</html>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

<!DOCTYPE html>

<head>

<title>Array.form</title>

</head>

<style>

body,ul,li{margin: 0;padding: 0;}

ul{width: 250px;height: 50px;display: flex;margin: 50px auto;}

ul li{background: pink;width: 25%;text-align: center;line-height: 50px;list-style: none;border: 1px solid #666}

</style>

<body>

<ul>

</ul>

</body>

/*Array.from方法用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象（包括 ES6 新增的数据结构 Set 和 Map）。*/

let aLi=document.querySelectorAll('ul li');

var filterLi=Array.from(aLi).filter(function(e){

return e.textContent=='li-2'

})

console.log(filterLi)//[li.li-2, li.li-3]

</script>

</html>

let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
};

// ES5的写法
var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']

// ES6的写法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

1

2

3

4

5

6

7

8

9

10

11

12

let arrayLike = {

'0': 'a',

'1': 'b',

'2': 'c',

length: 3

};

// ES5的写法

var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']

// ES6的写法

let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

/*实际应用中，常见的类似数组的对象是 DOM 操作返回的 NodeList 集合，以及函数内部的arguments对象。Array.from都可以将它们转为真正的数组。*/
// NodeList对象
let ps = document.querySelectorAll('p');
Array.from(ps).filter(p => {
  return p.textContent.length > 100;
});

// arguments对象
function foo() {
  var args = Array.from(arguments);
  // ...
}

1

2

3

4

5

6

7

8

9

10

11

12

/*实际应用中，常见的类似数组的对象是 DOM 操作返回的 NodeList 集合，以及函数内部的arguments对象。Array.from都可以将它们转为真正的数组。*/

// NodeList对象

let ps = document.querySelectorAll('p');

Array.from(ps).filter(p => {

return p.textContent.length > 100;

});

// arguments对象

function foo() {

var args = Array.from(arguments);

// ...

}

Array.from('hello')
// ['h', 'e', 'l', 'l', 'o']

let namesSet = new Set(['a', 'b'])
Array.from(namesSet) // ['a', 'b']

1

2

3

4

5

Array.from('hello')

// ['h', 'e', 'l', 'l', 'o']

let namesSet = new Set(['a', 'b'])

Array.from(namesSet) // ['a', 'b']

Array.from([1, 2, 3])
// [1, 2, 3]

1 2	Array.from([1, 2, 3]) // [1, 2, 3]

// arguments对象
function foo() {
  const args = [...arguments];
}

// NodeList对象
[...document.querySelectorAll('div')]

1

2

3

4

5

6

7

// arguments对象

function foo() {

const args = [...arguments];

}

// NodeList对象

[...document.querySelectorAll('div')]

var arr1=[1,[2,[3,[4,[5]]]],6,[7]]
var arr2=[8,[9,[10],11],12]
var ary1=arr1.join(',').split(',');//arr1降成一维数组
var ary2=arr2.join(',').split(',');//arr2降成一维数组
console.log(ary1)//["1", "2", "3", "4", "5", "6", "7"]
console.log(ary2)//["8", "9", "10", "11", "12"]
console.log(ary1.concat(ary2))//["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"]

1

2

3

4

5

6

7

var arr1=[1,[2,[3,[4,[5]]]],6,[7]]

var arr2=[8,[9,[10],11],12]

var ary1=arr1.join(',').split(',');//arr1降成一维数组

var ary2=arr2.join(',').split(',');//arr2降成一维数组

console.log(ary1)//["1", "2", "3", "4", "5", "6", "7"]

console.log(ary2)//["8", "9", "10", "11", "12"]

console.log(ary1.concat(ary2))//["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"]

function tmp(count){
	var _arr=[];
	for(var i=0;i<count;i++){
		var randomNum=Math.floor(count*Math.random());
		_arr.indexOf(randomNum)==-1&&_arr.push(randomNum)
	}
	return _arr
}
console.log(tmp(20))

1

2

3

4

5

6

7

8

9

function tmp(count){

var _arr=[];

for(var i=0;i<count;i++){

var randomNum=Math.floor(count*Math.random());

_arr.indexOf(randomNum)==-1&&_arr.push(randomNum)

}

return _arr

}

console.log(tmp(20))

function tmp(count){
	var _arr=[];
	for(var i=0;i<count;i++){
		_arr.push(Math.floor(count*Math.random()))
		_arr=[...new Set(_arr)]
	}
	return _arr
}
console.log(tmp(20))

1

2

3

4

5

6

7

8

9

function tmp(count){

var _arr=[];

for(var i=0;i<count;i++){

_arr.push(Math.floor(count*Math.random()))

_arr=[...new Set(_arr)]

}

return _arr

}

console.log(tmp(20))

function tmp(count){
	var _arr=[];
	for(var i=0;i<count;i++){
		var randomNum=Math.floor(count*Math.random());
		_arr.indexOf(randomNum)==-1&&_arr.push(randomNum)
	}
	if(_arr.length==10){
		return _arr
	}else{
		return tmp(count)
	}
}
console.log(tmp(20))

1

2

3

4

5

6

7

8

9

10

11

12

13

function tmp(count){

var _arr=[];

for(var i=0;i<count;i++){

var randomNum=Math.floor(count*Math.random());

_arr.indexOf(randomNum)==-1&&_arr.push(randomNum)

}

if(_arr.length==10){

return _arr

}else{

return tmp(count)

}

console.log(tmp(20))

/*
count : 0-count范围 (确定生成随机数的起始范围，默认从0开始)
n     : 生成的个数
ps    : 随机不重复
*/
function tmp(count,n){
	var _arr=[]
	while(_arr.length<n){
		var randomNum=Math.floor(Math.random()*count);
		if(_arr.length===0){
			_arr.push(randomNum)
		}else{
			for(var i=0;i<_arr.length;i++){
				if(_arr.indexOf(randomNum)==-1){
					_arr.push(randomNum)
				}
			}
		}
	}
	return _arr
}
console.log(tmp(20,5))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

/*

count : 0-count范围 (确定生成随机数的起始范围，默认从0开始)

n : 生成的个数

ps : 随机不重复

*/

function tmp(count,n){

var _arr=[]

while(_arr.length<n){

var randomNum=Math.floor(Math.random()*count);

if(_arr.length===0){

_arr.push(randomNum)

}else{

for(var i=0;i<_arr.length;i++){

if(_arr.indexOf(randomNum)==-1){

_arr.push(randomNum)

}

return _arr

}

console.log(tmp(20,5))

var arr=[1,2,3,3,2,1,5,6,7,5]
function uniq(arr){
	let ary=[]
	let i=0,len=arr.length
	for(;i<len;i++){
		if(ary.indexOf(arr[i])==-1){
			ary.push(arr[i])
		}
	}
	return ary
}
console.log(uniq(arr))//[1, 2, 3, 5, 6, 7]

1

2

3

4

5

6

7

8

9

10

11

12

var arr=[1,2,3,3,2,1,5,6,7,5]

function uniq(arr){

let ary=[]

let i=0,len=arr.length

for(;i<len;i++){

if(ary.indexOf(arr[i])==-1){

ary.push(arr[i])

}

return ary

}

console.log(uniq(arr))//[1, 2, 3, 5, 6, 7]

var arr=[1,2,3,3,2,1,5,6,7,5]
function uniq(arr){
	for(var i=0; i<arr.length; i++){
		for(var j=i+1; j<arr.length; j++){
			if(arr[i]===arr[j]){
				arr.splice(j,1)
				j--
			}
		}
	}
	return arr 
}

console.log(uniq(arr))//[1, 2, 3, 5, 6, 7]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

var arr=[1,2,3,3,2,1,5,6,7,5]

function uniq(arr){

for(var i=0; i<arr.length; i++){

for(var j=i+1; j<arr.length; j++){

if(arr[i]===arr[j]){

arr.splice(j,1)

j--

}

return arr

}

console.log(uniq(arr))//[1, 2, 3, 5, 6, 7]

//ES6
var arr=[1,2,3,3,2,1,5,6,7,5]
console.log([...new Set(arr)])//[1, 2, 3, 5, 6, 7]
console.log(Array.from(new Set(arr)))//[1, 2, 3, 5, 6, 7]

1

2

3

4

//ES6

var arr=[1,2,3,3,2,1,5,6,7,5]

console.log([...new Set(arr)])//[1, 2, 3, 5, 6, 7]

console.log(Array.from(new Set(arr)))//[1, 2, 3, 5, 6, 7]

var arr=[1,2,3]
var arr1=[1,2,3]
var arr2=[1,2,3,4]
function arrIsEqual(){
    var array=[];
    for(var i=0;i<arguments.length;i++){
        array.push(JSON.stringify(arguments[i]))
    }
    return !array.some(function(value, index) {
        return value !== array[0];
    });
}
console.log(arrIsEqual(arr,arr1))//true
console.log(arrIsEqual(arr,arr2))//false

1

2

3

4

5

6

7

8

9

10

11

12

13

14

var arr=[1,2,3]

var arr1=[1,2,3]

var arr2=[1,2,3,4]

function arrIsEqual(){

var array=[];

for(var i=0;i<arguments.length;i++){

array.push(JSON.stringify(arguments[i]))

}

return !array.some(function(value, index) {

return value !== array[0];

});

}

console.log(arrIsEqual(arr,arr1))//true

console.log(arrIsEqual(arr,arr2))//false

var arr=[1,2,3]
var arr1=[1,1,1]
function isAllEqual(array) {
    if (array.length > 0) {
        return !array.some(function(value, index) {
            return value !== array[0];
        });
    } else {
        return true;
    }
}
console.log(isAllEqual(arr))//false
console.log(isAllEqual(arr1))//true

1

2

3

4

5

6

7

8

9

10

11

12

13

var arr=[1,2,3]

var arr1=[1,1,1]

function isAllEqual(array) {

if (array.length > 0) {

return !array.some(function(value, index) {

return value !== array[0];

});

} else {

return true;

}

console.log(isAllEqual(arr))//false

console.log(isAllEqual(arr1))//true

var arr=[1,2,3]
var arr1=[1,1,1]
function isAllEqual(array) {
    if (array.length > 0) {
        for(var i=1;i<array.length;i++){
        	if(array[i]!==array[0]){
        		return false
        	}
        }
        return true
    } else {
        return true;
    }
}
console.log(isAllEqual(arr))//false
console.log(isAllEqual(arr1))//true

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

var arr=[1,2,3]

var arr1=[1,1,1]

function isAllEqual(array) {

if (array.length > 0) {

for(var i=1;i<array.length;i++){

if(array[i]!==array[0]){

return false

}

return true

} else {

return true;

}

console.log(isAllEqual(arr))//false

console.log(isAllEqual(arr1))//true

var arr=[1,2,3,4,5,4,1,2] //1,2,4

function getRepeatItem(arr){
	var ary0=[],ary1=[]
	for(var i=0;i<arr.length;i++){
		if(ary0.indexOf(arr[i])==-1){
			ary0.push(arr[i])
		}else{
			ary1.push(arr[i])
		}
	}
	return ary1
}
console.log(getRepeatItem(arr))//[4, 1, 2]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

var arr=[1,2,3,4,5,4,1,2] //1,2,4

function getRepeatItem(arr){

var ary0=[],ary1=[]

for(var i=0;i<arr.length;i++){

if(ary0.indexOf(arr[i])==-1){

ary0.push(arr[i])

}else{

ary1.push(arr[i])

}

return ary1

}

console.log(getRepeatItem(arr))//[4, 1, 2]

散人博客

One Hundred Years of Solitude

本作品采用知识共享署名-相同方式共享 4.0 国际许可协议进行许可

发表评论取消回复

One Hundred Years of Solitude

本作品采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可

发表评论 取消回复

本作品采用知识共享署名-相同方式共享 4.0 国际许可协议进行许可

发表评论取消回复