<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Document</title>
</head>
<body>
<script>
// 检测
// Array.isArray(paraDetermine)
// 参数必须,返回bool
console.log(Array.isArray(‘ty‘));
console.log("h"
instanceof Array);
// arr instanceof Array
// 操作符,在一个网页框架中可以使用
/**
*
*/
// para.toString()
// 这里是数组,说下数组的情况
// [a,b,c]
// 返回值是 a.toString(),b.toString(),c.toString()
// 每项执行方法会返回的字符串以,的形式拼接
// toLocaleString(),valueOf()也是同样的道理
var person1 = {
toString: function() {
return "nike";
},
toLocaleString: function() {
return "like";
}
}
var person2 = {
toString: function() {
return "nike2";
},
toLocaleString: function() {
return "like2";
}
}
var people = [person1, person2, null, , , 1];
console.log(people)
console.log(people.valueOf())
console.log(people.toString())
console.log(people.toLocaleString())
console.log(people.join())
// 在说说 arr.join([spliter])
// 参数可选,返回值是 item.toString() 之后以参数spliter为分隔符 连接字符串,默认是逗号
// 自然item 如果是null,undefined,将会返回"",空字符串
/**
*
*/
// 栈方法:往瓶子里塞饼干
// arr.push([addVal1,addVal2..........])
// 参数可选,在原数组后面添加数据,返回修改后的长度
// arr.pop()
// 在原数组后面删除数据,返回删除的元素,也就是最后一个元素
var colors = [1];
console.log(colors.push())
console.log(colors)
console.log(colors.push(2, [1, 2], null, undefined, {}))
console.log(colors)
console.log(colors.pop())
console.log(colors);
/**
*
*/
// 队列方法:排队拿东西
// arr.unshift([addVal1,addVal2..........])
// 参数可选,在原数组前面添加数据,返回修改后的长度
// arr.shift()
// 在原数组前面删除数据,返回删除的元素,也就是第一个元素
// var colors = [1];
console.log(colors.unshift())
console.log(colors)
console.log(colors.unshift(2, [1, 2], null, undefined, {}))
console.log(colors)
console.log(colors.shift())
console.log(colors);
/**
*
*/
// 重排序方法
// arr.reverse()
// 无参数,返回值是原数组的每项倒序排列
// arr.sort([orderFn])
// 默认是 item.toString之后, 在按照字符串的从小到大排列,返回排序后的原数组
// 可选参数是 排序函数
// 从小到大按数字大小排列
var arrNum = [12,34,21,5413,34,54321,2];
var up = function (a,b) {
if(a<b){return a-b}
// 返回值为负数,数组的两项交换位置
// 这里用的是 冒泡法
// 首先 传入12,34 返回负数则不交换顺序
// 然后 传入34,21 返回正数则交换顺序
// 再 传入34,5431 自动脑补接下来的事
// 也就是第一个冒泡之后排序:arr.length-1次
// 第二次arr.length-2
// 设arr.length = n
// sum = n-1+n-2+n-3+n-4.............+1
// sum = 1 +2 +3 +4.....+n-3+n-2+n-1
// 2sum = n*(n-1)
// sum = n*(n-1)/2
}
console.log(arrNum.sort(up));
// 想要数组随机排序
var ruffle = function (a,b) {
return Math.random()-0.5;
// 不一定非得0.5,0~1之间就行
// 再演绎一遍
// 第一次:12,34, 返回谁知道是啥,正负不一定,可能调用顺序可能不
// 第二次:34,21 也有可能是12,21 , 返回谁知道是啥,正负不一定,可能调用顺序可能不
// 在sum = n*(n-1)/2之后,呵呵
// 要不要玩玩排列组合呀,(n-1)*(n-2)*(n-3)*......*2*1 恩随机排序
//
}
console.log(arrNum.sort(ruffle))
console.log(arrNum.sort(ruffle))
console.log(arrNum.sort(ruffle))
/**
*
*/
// 操作方法
// arr.concat([addVal1,addVal2,....])
// 默认是复制数组,并返回复制的数组
// 参数,是数组的话,则会把每项添加到结果数组中 ,如果传递的不是数组则会简单的添加结果,返回结果数组
// 显然不改变原数组
var animals = [‘cat‘,‘dog‘,‘duck‘];
var flowers = [‘biahe‘,‘mudan‘];
console.log(animals.concat())
console.log(animals.concat(flowers))
console.log(animals.concat(flowers,1,2,‘dfdsa‘,{}))
// arr.slice([startIndex][,endIndex]);
// 默认,是复制数组,并返回复制的数组
// 传一个参数,复制数组,返回筛选的从该参数的位置到数组末尾的所有项
// 传两个个参数,复制数组,返回从该第一个参数的位置到第二个参数位置的所有项组成但不包括结束位置的项的新数组
// 若参数是负数,则将转换为 负数+arr.length ,也就是最后一项的索引就是 -1 = arr.length-1
// 第一个参数小于0则= 0
// 第二个参数或转化之后的值 小于第一个参数则返回空数组
// 改变原数组
console.log(animals.slice())
console.log(animals.slice(1))
console.log(animals.slice(1,2))
console.log(animals.slice(1,-1))
console.log(animals.slice(-2,-1))
console.log(animals.slice(-22,-1))
console.log(animals.slice(0,-22))
// arr.splice([startDelIndex][,delNum][,addVal1,addVal2,....])
// 默认返回空数组
// 只传第一个参数n,原数组将只剩n个项,删除arr.length-n个项,返回的新数组将有arr.length-n个项
var arr2 = [0,1,2,3,4,5]
console.log(arr2.splice(2))
console.log(arr2)
// 传两个参数,n,m 表示要删除的的开始项和删除几个
var arr3 = [0,1,2,3,4,5]
console.log(arr3.splice(1,2))
console.log(arr3)
// 传三个参数 表示开始删除的位置删除几个元素,在加入几个元素,有点像替换
var arr4 = [0,1,2,3,4,5]
console.log(arr4.splice(1,2,‘a‘,‘b‘))
console.log(arr4)
/**
*
*/
// 位置方法
// arr.indexOf([item])
// 一般用来找某项是否在arr中
// 不填的话默认是找 undefinded或者是不填的项
// 参数有就是找参数的索引 有返回相应的索引 没有返回-1
// arr.lastIndexOf([item])
// 从数组的最后一项开始找,不赘述
var arr5 = ["i","dd",{d:3},undefined,"",,null];
console.log(arr5.indexOf())
console.log(arr5.indexOf("{d:3}")) // 这个不灵
console.log(arr5.lastIndexOf(null))
/**
*
*/
// 迭代方法: 线性结构的按顺序循环 或者数学里面每次循环更接近结果,遍历一般是指树形结构
// arr.every(fn[,thisArg]),arr.some(fn[,thisArg]),arr.filter(fn[,thisArg]),arr.forEach(fn[,thisArg]),arr.map(fn[,thisArg]),
// 每个方法接受两个参数,如上,表示要在数组每项上运行的函数和运行该函数的作用域对象-变相的指定了this的值
// fn可以接受三个参数,curItem,index,array 正在执行函数的当前项,当前项的索引,当前的这个数组
// 根据使用方法的不同,每项执行函数后的返回值可能影响也可能不影响 方法所返回的值,比如每项执行之后都返回true,那么最终的返回值不一定是true
// every对数组的每项运行给定函数,每项都返回true,才会返回true
// some对数组的每项运行给定函数,某一个返回true,返回true
// forEach对数组的每项运行给定函数,无返回值
// map对数组的每项运行给定函数,返回值是 每项的返回值组成的新数组
// filter对数组的每项运行给定函数 返回值是 每项返回值为true组成的数组
// 原数组均不改变
var numbers = [1,2,3,4,5,10];
var sum = 0;
console.log(numbers.every(function(curItem){
curItem+=1;
return curItem>4;
}))
console.log(numbers);
console.log(numbers.some(function(curItem){
curItem+=1;
return curItem>4;
}))
console.log(numbers);
console.log(numbers.forEach(function(curItem){
curItem+=1;
sum+=curItem;
console.log(sum)
}))
console.log(numbers);
console.log(numbers.filter(function(curItem){
curItem+=1;
return curItem>4;
}))
console.log(numbers);
console.log(numbers.map(function(curItem){
curItem+=1;
return curItem>4;
}))
console.log(numbers);
/**
*
*/
// 归并方法
//
// arr.reduce(fn[,init]),对数组的每项运行给定函数,从第一个开始执行函数返回最后一项返回的值
// fn可以接受四个参数 前一项返回的值,当前项,当前索引,当前数组
// 第一次运行的时候,如果没写init的值则前一项返回的值就是第一项,当前项会变成第二项
// 写了init的值,init就是前一项返回的值,当前项是第一项
// arr.reduceRight(fn[,init]) 从最后一项开始执行 不赘述
// 不改变原数组
var nums = [1,2,3,4,5];
console.log(nums.reduce(function (prevReturn,curItem) {
curItem += 1;
return prevReturn+curItem;
}))
console.log(nums)
/**
*
*/
// 改变原数组的方法:length(虽然不算方法),index(虽然也不算方法),splice,reverse,sort,pop,push,shift,unshift
//
</script>
</body>
</html>