静态方法：
Array.isArray()
实例方法：
valueOf(): 返回数组本身
改变原数组：
push()：
在末尾添加一个元素，返回新数组长度
pop() :
删除数组的最后一个元素，返回被删除的元素
shift():
删除数组的第一个元素并返回该元素(遍历清空数组)
unshift():
在数组的第一个位置添加一个元素，并返回数组长度
reverse():
颠倒原数组的排列顺序
splice(start，sum(个数)，new1，new2):
删除数组的一部分(两个参数),在数组的指定位置插入元素(0,插入的元素),替换数组元素(三个参数以上),
如果只有一个参数，则把原数组分为两个数组
var old1 = [1,2,3,4].splice(2) // 1,2 此时，原数组的值为 3，4
sort(function(a,b){两个形参之间的对比，根据返回结果进行排列}):
对数组成员进行默认排序，无参按照默认排序，有参根据自定义函数排序(函数返回值须为数值,根据从小到大排序)
arr.sort(function(a,b){return a-b})
不改变原素组：
join():
以参数作为分隔符，将数组元素连接为一个字符串返回，不传参则默认分隔符为逗号
concat():
数组合并，将新数组合并到原数组的后面并返回(返回的值根据原数组的改变而改变，合并的只是原数组的引用)，原数组不变
slice(起点，终点):
截取目标数组的一部分，省略第二个参数就一直截取到最后一个，参数为负数则倒数计算
重要应用：真伪数组转换： [].slice.call()
var real = Array.prototype.slice.call({ 0: ‘a’, 1: ‘b’, length: 2 }) 注意这里的 “length：2” 必须有 否则返回""
console.log(Array.isArray(real)) // true
map(function(item，index，arraySelf){return n++}):
将数组内的元素逐个放入函数中处理，最后返回一个新数组 如果有第二个参数，map内函数的this就指向map的第二个参数
forEach(): 除了不会返回数据，其它的跟map一致。 此方法无法像for一样可以中断执行，总是会遍历完所有元素
此方法遍历元素时，不会跳过undefined和null但是会跳过 空位 “”
filter(function(item,index,arr){return n === true},arr):
元素过滤，在函数中自定义过滤规则，通过规则的元素组成新数组返回
some(function(item,index,arr){},arr):
返回布尔值，数组中只要有一个元素符合规则，则返回true
every(function(item,index,arr){},arr):
返回布尔值，数组中只要有一个元素不符合规则，则返回false
reduce(function(a,b,index,arr){return a+b},sum) /reduceRight()元素倒过来操作:
a:累加值(默认为第一个元素) b:当前值(默认为第二个元素) index:当前位置(默认为0) sum:默认初始值 arr:原数组
处理数组内的内一个元素，最终累加为一个值
indexOf(ele,index):
返回给定元素第一次在数组中出现的位置，如果没有，返回 -1 ele:搜索的值， index：从哪里开始搜索
lastIndexOf(ele,index):
返回给定元素最后一次在数组中出现的位置，如果没有，返回 -1 ele:搜索的值， index：从哪里开始搜索
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>数组的元素可以是任意的数据类型甚至是函数</title>
<script>
// 真伪数组转换
var real = Array.prototype.slice.call({
0: 'a',
1: 'b',
length: 2
})
console.log(Array.isArray(real)) // true
// map(function(item,index,arrSelf){}) map只有一个参数
var result = [1, 2, 3].map(function(n) {
return n + 1
})
console.log(result) // 2,3,4
// map可以有两个参数 map(function(item,index,arrSelf){},arr)
result = [1, 2, 3].map(function(item, index, arr) {
// 这里的 this 绑定 [4,5,6] function 的实参为数组 [1,2,3]
item = this[index] + 1
return item
}, [4, 5, 6])
console.log(result) // 5,6,7
//reduce
result = [1, 2, 3, 4, 5].reduce(function(a, b) {
return a + b
})
console.log(result)
//新建数组语法1：
var arr = new Array();
arr[arr.length] = 1;
arr[arr.length] = 2;
arr[arr.length] = 3;
console.log(arr) // 1,2,3
//新建数组语法2：
var arr2 = [0, 1, 2, 3, 4, 5, 6];
//新建数组语法3：(不推荐)
var arr = new Array(7, 8, 9, 10, 11);
//创建一个长度为5的数组：
var arr3 = new Array(5);
console.log("获取数组长度" + arr.length);
//修改数组的长度：小了，删除，多了，超出,添加null值
arr.length = 4;
console.log("修改数组长度为4：" + arr);
arr.length = 2;
console.log("修改数组长度为2：" + arr);
console.log("unshift方法向开头添加元素并返回新长度：" + arr.unshift(1, 2, 3));
console.log(arr); //插入元素以后其他元素的会依次调整
console.log("push()方法向数组的末尾添加一个元素并返回数组的长度：" + arr.push(arr.length));
console.log("使用push()方法后的数组：" + arr);
console.log("shift()删除并返回数组的第一个元素：" + arr.shift());
console.log("shift()后的数组：" + arr);
console.log("使用pop()方法删除数组的最后一个元素并返回该元素的值:" + arr.pop());
console.log("使用pop()方法后的数组：" + arr);
//slice()方法不改变数组原来的结构，用于获取某段元素，例0~3之间：包含开始不包含结尾
//参数可以使用一个负值，表示倒着数
console.log("使用slice从数组提取第一，二个元素：" + arr.slice(0, 2));
/*splice()方法会影响数组的结构 多功能方法
* 第一个参数：开始位置；
* 第二个参数：操作的数量；
* 第三及更多参数：可插入到开始位置：
* 若操作数为0，则实现插入；
* 若操作数为1或以上，则实现替换；
* 若无第三个参数，则实现删除。
*/
console.log("使用splice前的数组：" + arr);
console.log("splice()方法用于删除并返回指定的数组元素：" + arr.splice(0, 2))
console.log("使用splice后的数组：" + arr);
//concat()可以连接两个或多个数组，并将新的数组返而不改变原数组
var a = [1, 2, 3];
var b = [4, 5, 6];
console.log("合并后的数组：" + a.concat(b));
console.log("合并后的原数组a：" + a);
console.log("合并后的原数组b：" + b);
/*join()方法：
* 1、将结果作为字符串返回(将元素的类型转换为String)
* 2、将参数作为字符串间的连接符并返回字符串(默认为 , )
*/
console.log("join的参数作为字符串的连接符：" + a.join("--"));
//reverse()：用于反转数组：该方法会直接修改原数组：
console.log("reverse方法用于反转数组：" + a.reverse());
//练习：将数组中age大于18的信息输出
function Person(name, age) {
this.name = name;
this.age = age;
}
// filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
var ages = [32, 33, 16, 40];
function checkAdult(age) {
return age >= 18;
}
console.log(ages.filter(function(age){
return age >= 18 // [ 32, 33, 40 ]
}));
//reduce(acc,cur) 方法：接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
/*最少两个参数
Accumulator (acc) (累计器)
Current Value (cur) (当前值)
Current Index (idx) (当前索引)
Source Array (src) (源数组)
*/
//两个参数：
// console.log([1, 3, 5].reduce( (a, b) => (a * b) ) );//求数组元素的积：15
// map(function) 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
var arra = [1, 2, 3, 4]
var arra1 = arra.map(function(n) {
return n + 1
})
console.log('arra1： ' + arra1); //arra1： 2,3,4,5
// sort()方法：用于数组的排序：默认使用Unicode编码排序：
// 所以对数字进行排序会得到错误的结果 解决：自定义排序规则：
// 利用包含两个形参的匿名函数：浏览器回自动调用该实参做比较，且a一定在b的前面
// 浏览器根据回调函数的返回值确定排序的位置：大于零：交换位置；小于等于零：位置不变：
var aa = [5, 8, 7, 9, 4, 2, 5, 3, 6, 7];
aa.sort(function(a, b) {
// return a - b;
return b - a;
});
console.log("自定义sort()回调用于数组的排序：" + aa.sort());
Person.prototype.toString = function() {
return " name:" + this.name + " age:" + this.age;
}
var fun1 = new Person("lili", 10);
var fun2 = new Person("amy", 18);
var fun3 = new Person("tom", 19);
var fun4 = new Person("toy", 20);
var fun5 = new Person("jerry", 15);
var funArr = [fun1, fun2, fun3, fun4, fun5];
function Adult(arr) {
var arr1 = [];
for(var i = 0; i < arr.length; i++) {
if(arr[i].age > 18) {
arr1.push(arr[i]);
} else {
continue;
}
}
return arr1;
}
// console.log(Adult(funArr));//输出练习结果
//练习：祛除数组中 重复的数字：
var arr5 = [1, 2, 3, 4, 5, 6, 1, 2, 2, 2, 2, 2, 2, 2, 4, 2, 3, 7, 8, 5, 9, 4];
function DeleteRepeat(arr) {
var arr1 = new Array();
for(var i = 0; i < arr.length; i++) { //元素从头开始比较
for(var j = i + 1; j < arr.length; j++) { //j+1表示从当前元素后面的元素开始比较
if(arr[i] == arr[j]) {
arr.splice(j, 1);
j--; //删除掉一个元素后，后面的元素会向前推进，导致不能跟下一个元素比较，故j需要自减
} else continue;
}
}
return arr;
}
// console.log("原数组："+arr5);
// console.log("祛除重复后的数组："+DeleteRepeat(arr5)); //祛除重复练习
</script>
</head>
<body>
</body>
</html>
834
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
