JS方法常用方法，array数据常用方法

字符串-------常用方法

.length------>字符串的长度
.charAt(索引),返回值是指定索引位置的字符串,超出索引,结果是空字符串
.lastIndexOf(要找的字符串);从后向前找,但是索引仍然是从左向右的方式,找不到则返回-1
.indexOf(要找的字符串,从某个位置开始的索引);返回的是这个字符串的索引值,没找到则返回-1
.toLocaleLowerCase();转小写
.toLowerCase();转小写
.toLocaleUpperCase()转大写
.toUpperCase();转大写
.trim();干掉字符串两端的空格
.fromCharCode(数字值,可以是多个参数),返回的是ASCII码对应的值
.concat(字符串1,字符串2,...);返回的是拼接之后的新的字符串
.replace("原来的字符串","新的字符串");用来替换字符串的
.slice(开始的索引,结束的索引); 从索引5的位置开始提取,到索引为10的前一个结束,没有10，并返回这个提取后的字符串
.split("要干掉的字符串",切割后留下的个数);切割字符串
.substr(开始的位置,个数);返回的是截取后的新的字符串
.substring(开始的索引,结束的索引),返回截取后的字符串,不包含结束的索引的字符串

Date对象的用法

var dt=new Date();
var dt=+new Date();//一种特殊的写法,只适用于这个Date的对象
console.log(dt);
dt.getFullYear();//年
dt.getMonth();//月---从0开始
dt.getDate();//日
dt.getHours();//小时
dt.getMinutes();//分钟
dt.getSeconds();//秒
dt.getDay();//星期---从0开始
dt.toDateString();//日期
dt.toLocaleDateString();//日期
dt.toTimeString();//时间
dt.toLocaleTimeString();//时间
dt.valueOf();//毫秒

Array对象的方法

unshift();--->首部添加，返回长度，改变原数组
    var a = [2,3,4]
    var b = a.unshift(0,1)
    console.log(a)  // [0,1,2,3,4]
    console.log(b)  // 5

shift();--->删除首部元素，返回被删元素，改变原数组
    var a = [1,2,3]
    var b = a.shift()
    console.log(a) // [2,3]
    console.log(b) // 1

push(值);---末尾添加，返回长度，改变原数组
    var a = [1,2,3]
    var b = a.push(4)
    console.log(a)  // [1,2,3,4] 
    console.log(b) //4

pop();--->尾部删除，返回被删除的元素，改变原数组
    var a = [1,2,3]
    var b = a.pop()
    console.log(a) // [1,2]
    console.log(b) // 3

splice(index,length,增加的元素1,增加的元素2....,增加的元素N);--->修改删除,对数组进行删除修改，返回被删除的元素组成的数组，表示从index开始删除length    个元素，并从index开始新增元素1~N，放回被删除的元素组成的数组，改变原数组
    var a = [1,2,3]
    var b = a.splice(1,1,3,[2,3,4],5)
    console.log(a)  // [1,3,[2,3,4],5,3]
    console.log(b)  // [2]

concat(数组,数组,数组,...);--->合并两个或多个数组，返回新数组，不会改变原数组
    var a = [1,2,3]
    var b = [4,5]
    var c = a.concat(b)
    console.log(a) // [1,2,3]
    console.log(b) // [4,5]
    console.log(c) // [1,2,3,4,5] 

slice(startIndex,endIndex);--->返回新数组;返回从startIndex开始(包括)，到endIndex(不包括)之间的原属组成的数组，不改变原数组
    var a = [1,2,3]
    var b = a.slice(0,1)
    // 不填参数则表示剪切整个数组  
    var c = a.slice() 
    console.log(a) // [1,2,3] 
    console.log(b) // [1]
    console.log(c) // [1,2,3]    
    console.log(a===c)  // false // 注意 a !== c  
    // 负数表示从后往前数
    var d = a.slice(-1,-2)   
    console.log(d) // []   从左向右截取，所以说为[]
    var e = a.slice(-1)  
    console.log(e)  // [3]

join("字符串");----返回的是一个字符串；返回转换后的字符串  不改变原数组
    var a = [1,2,3,4,5]
    console.log(a.join(','))  // 1,2,3,4,5
    console.log(a)  // [1,2,3,4,5]

sort();---排序，按ascii码排序，返回排序后的数组，改变原数组
    var a = ['a','b','d','c']
    console.log(a.sort())  // ['a','b','c','d']
    console.log(a)  // ['a','b','c','d']

reverse();----->反转数组，方法用于颠倒数组中元素的顺序，返回的是颠倒后的数组，会改变原数组。
    var a  = [1,3,2,7,6] 
    console.log(a.reverse())  // [6,7,2,3,1]
    console.log(a)  // [6,7,2,3,1]

indexOf()和lastIndexOf()
indexOf(某元素,startIndex) 从startIndex开始，查找某元素在数组中的位置，若存在，则返回第一个位置的下标,否则返回-1
lastIndexOf(某元素，startIndex) 和indexOf()相同，区别在于从尾部向首部查询
返回找到的index,否则返回-1，不会改变原数组
若不使用下标，则一般通过includes()方法代替indexOf()
    var a = [1,2,4,3,4,5]
    console.log(a.indexOf(4))  // 2
    console.log(a.indexOf(4,3)) // 4

filter() 过滤
filter() 方法返回数组中满足条件的元素组成的新数组，原数组不变
filter()的参数是一个方法
    var a = [1,2,3,4,11]
    // 第一个参数为一个方法，有三个参数，current:当前值 index:当前值下标 array:这个数组对象
    var b = a.filter(function(current,index,array){
        return current < 10
    })
    console.log(b) // [1,2,3,4]
    console.log(a) // [1,2,3,4,11]

map();--->格式化数组,方法来根据需求格式化原数组，返回格式化后的数组。原数组不变
    var a = [1,2,3,4,5]
    // 参数同filter方法
    var b = a.map(function(current,index,array){
        return current + 1
    })
    console.log(b) // [2,3,4,5,6]
    console.log(a) // [1,2,3,4,5]

every();--->对数组的每一项都运行给定的函数，若每一项都返回 ture,则返回 true
    var a = [1,2,3,4,5] 
    var b = a.every(function(current,index,array){
           return current < 6
    })
    var c = a.every(function(current,index,array){
           return current < 3
    })
    console.log(b)  // true 
    console.log(c)  // false

some();--->对数组的每一项都运行给定的函数，若存在一项或多项返回 ture,则返回 true
    var a = [1,2,3,4,5]
    var b = a.some(function(current,index,array){
           return current > 4
    })
    var c = a.some(function(current,index,array){
           return current > 5
    })
    console.log(b)  // true 
    console.log(c)  // false

forEach();--->数组遍历,遍历整个数组，中途不能中断
    var arr = ['a','b','c']
    var copy = []
    arr.forEach(function(item){
         copy.push(item)   
    })
    console.log(copy)
ES6新增的方法
find()
找到数组中第一次满足条件的元素，并返回，若找不到则返回undefined。不改变原数组。
和filter()方法的区别在于：filter返回值是所有满足条件的元素组成的数组
一般在需要使用找到的元素时，用find()方法
    var a = [1,2,3,4]
    // b在下面需要使用，则一般用find
    var b = a.find(function(ele,index,array){
        return ele == 1
    })
 
    var c = 3
    var d = b + c
    console.log(a) // [1,2,3,4]
    console.log(b) // 1
    console.log(d) // 4 
    // 若只需判断元素是否存在
    // 若果是简单数组(非对象数组)，则一般使用Array.includes(value)方法
    // 如果为对象数组，则可以使用Array.some()方法
 
    var a = [1,2,3]
    console.log(a.includes(1))  // true
 
    var a = [{"name": "xiaoming" },{"name": "xiaohong"}]
     
    console.log(a.some(function(ele){
        return ele.name == 'xiaoming'
    }))                            // true
findIndex()
findIndex()的作用同indexOf()，返回第一个满足条件的下标，并停止寻找
区别是findIndex() 的参数为一个回调函数,且一般用于对象数组
    var a = [1,2,3,4]
    var b = a.findIndex(function(ele,index,array){
        return ele === 2
    })
    var c = a.indexOf(2)  
    console.log(a)  // [1,2,3,4]
    console.log(b)  // 1
    console.log(c)  // 1

includes() 
includes()方法,返回一个布尔值。 参数是一个value,一般用于简单数组。
对于复杂数组，则可以使用some()方法替代includes()方法
    var a = [1,2,3]
    console.log(a.includes(1))  // true

Array.isArray()方法
用来判断一个元素是否为数组
    Array.isArray([])  // true
    Array.isArray({})  // false