JS常用的字符串，数组，对象及遍历操作方法整理

一、字符串常用操作方法

split

不传参直接切割整个字符串 ; 若传入一个指定的参数，则按照该参数把字符分割成数组

例：var str = "a.b.c";
	str.split("");   //  arr =  ['a','.','b','.','c']
    str.split(".");   //  arr =  ['a','b','c']

slice

若传入一个指定的参数，则从该参数开始截取字符串；传两个则，从第一个开始截取到第二个参数，包括第一个不包括第二个参数的字符串

例：var str = "abcd"
	str.slice(2,4);   //  cd

substr

它并非JavaScript核心语言的一部分，未来将可能会被移除掉
接收两个参数 : 第一个是必须的，第一个参数是从某个位置开始，如果是负数，那么该参数从字符串的尾部的位置开始算起。
第二个参数非必须，第二参数是截取字符串的长度length。

例：var str=  'abcdef'
   str.substr(1);   //  bcdef
   str.substr(3,4);   //  def

substring

substring 接收两个参数，不接受负的参数
第一个参数必须，从某位置开始(包含该位置)，第二参数是到这个位置结束(不包含该位置)

例：var str=  'abcdef'
   str.substring     (2);   //  cdef
   str.substring     (3,4);   //  d

indexOf和lastIndexOf

返回字符串中匹配子串的第一个字符的索引；若没有匹配到就返回 -1；数组也一样；
两者区别在于开始查询方向index是从左往右，而lastIndexOf则相反

例：str="abca";       str.indexOf("d")  // -1  
    str.indexOf("abc");   // 0  

replace

用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。

例：str="abca";     
    str.indexOf("ca",'d')  // 'abd
     str.indexOf(/ab/g,'s')  // 'sca

match

接收一个参数，在字符串内检索指定的值，或找到一个或多个( 正则表达式的匹配 )；没有则返回 null，有则数组。

例：var str="1ab2cd3"
	str.match('b')	 // ["b", index:2,input:'1ab2cd3',groups:undefined]
    str.match(/\d+/g)	 // ["1", "2", "3"]
    \d是元字符用于查找数字字符，+是匹配一次或多次，g是正则对象属性，全局匹配的意思

charAt

charAt() 方法可返回指定位置的字符；接收一个参数，字符串中某个位置的数字，即字符在字符串中的位置

例："abc".charAt(1)	 // b

二、对象常用操作方法

Object.assign

用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。

例：var obj=  {a:1,b:2}
  Object.assign(obj,{c: 3});  //{a:1,b:2,c: 3}

keys

接收一个对象参数

例：var obj=  {a:1,b:2}
   Object.keys(obj);   //  ['a','b']

values

接收一个对象参数，返回一个数组包含对象的值

例：var obj=  {a:1,b:2}
   Object.values(obj);   //  [1,2]

entries

接收一个对象参数，把对象转成键值对数组

例：var obj=  {a:1,b:2}
   Object.entries(obj);   //  [['a',1],['b',2]]

fromEntries

跟entries相反，把键值对数组转成对象

例：var arr=  [['a',1],['b',2]]
   Object.fromEntries(arr);   //  {a:1,b:2}

三、数组常用操作方法

slice

从已有的数组中返回选定的元素。接收两个参数，第一个必需，从何处开始选取。如果是负数则从数组尾部开始倒数算起。第二个非必需，若不传则直到数组结尾，否则指定结束位置。

例：var arr=  ['a','b','c']
   arr.slice(1,2);   //  arr =  ['b']  

splice

该方法可以添加或删除多个数组元素。接收三个参数。第一个必填，整数，添加/删除的位置（负数则从数组结尾处开始）；第二个必填，要删除的数量， 0则不删除；第三个非必填，向数组添加的新元素

例：var arr=  [1,2,3,4]
   arr.splice(1,2,6);   //  arr =  [1,6,4] 

join

用于把数组中所有元素放入拼接成一个字符串。接收一个参数(非必须)，元素是通过指定的分隔符进行分隔的，若不传参数，则默认使用逗号作为分隔符。

例： ["jpg","bmp"].join("|")   // jpg|bmp

reverse

该方法用于颠倒数组中元素的顺序。该方法会改变原来的数组，而不会创建新的数组。

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

includes

该方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。

例：[1,2,3].includes('2')   //  false
	[1,2,3].includes(2)   //  true

sort

用于对数组的元素进行排序。接收一个参数（非必传），规定排序顺序，必须是函数。

例：var arr = [1,'f',4,'','a',3,undefined,2,NaN,6,{},5]
    arr.sort()   // ["", 1, 2, 3, 4, 5, 6, NaN, {…},"a","f", undefined]

concat

用于连接两个或多个数组，该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本

例：var arr = [1,2,3]
   arr.concat([4],[5,6])   // [ 1, 2, 3, 4, 5, 6]

flat

数组扁平化方法。该方法方法返回一个新数组，接收一个参数及处理的层数，若不传只会处理一层，若不确定层数，可以用Infinity关键字作为参数处理全部。

例：var arr = [1, [2, 3, [4, 5]], [6, 7]]
   arr.flat()   // [ 1, 2, 3, [4, 5], 6,7]
   
   
   Array.prototype.flat_arr = function (){    
		while (arr.some(item => Array.isArray(item))) {
   			arr = [].concat(...arr)
		}
		return arr
	}
	arr.flat_arr()  //  [ 1, 2, 3, 4, 5, 6,7]

push、pop、unshift、shift

push 是从数组尾部添加元素
pop 是从数组尾部删除一个元素

unshift 是从数组头部添加元素；
shift 是从数组头部删除一个元素

四、常用的遍历操作方法

for of

遍历数组

for in

遍历对象属性key值

例：var obj=  {a:1,b:2}
	for(it in obj){
        console.log(it);
     }
	// a; b;

while

while 循环会在指定条件为true时循环执行代码块。只要指定条件为 true，就会一直执行循环代码块。

例：let i = 5
while( i > 0 // 判断条件 ){
	i--     // 最后必须使判断条件为false，否则无限循环
}

forEach

对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值。参数都是function类型，默认有传参，参数分别为：遍历的数组内容；第对应的数组索引，数组本身。

map

指“映射”，对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。

filter()

“过滤”功能，数组中的每一项运行给定函数，返回满足过滤条件元素组成的数组。

every()和some()

every：判断数组中的元素都是否满足条件，要所有都满足条件，才会返回true。

some：判断数组中是否存在满足条件的元素，只要有一个满足条件，就会返回true。

every和some常用来判断并获取数组对象的交、并集
例：
let a=[{id:1,a:123,b:1234}]

let b=[{id:1,a:123,b:1234},{id:2,a:123,b:1234}]
let arr = [...b].filter(x => [...a].every(y => y.id !== x.id));

// arr = {id:2,a:123,b:1234}]
====================================================================
let a=[{id:1,a:123,b:1234}]
let b=[{id:1,a:123,b:1234},{id:2,a:123,b:1234}]
let arr = [...b].filter(x => [...a].some(y => y.id === x.id));

// arr = [{id:1,a:123,b:1234}]

reduce()和reduceRight()

这两个方法都会实现迭代数组的所有项，然后构建一个最终返回的值。区别就是reduce从左往右，reduceRight从右往左

该方法接收两个参数：第一个(必须)是回调函数；第二个（非必须）是初始值

回调函数包含四个参数：前一个值（若有初始值则第一次遍历为初始值）、当前值、当前索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数就是数组的第二项。