javascript数据结构及其常用方法-CSDN博客

方法	语法	示例	备注
数组字面量	let arr = [value1, value2, ..., valueN]	let numbers = [1, 2, 3, 4, 5]	元素间以逗号分隔
Array构造函数	let arr = new Array(value1, value2, ..., valueN)	let arr = new Array('a', 'b', 'c')	多个参数：数组初始元素
		let arr = new Array(3)	单个数值：数组长度（元素均为undefined）
Array.of()	let arr = Array.of(value1, value2, ..., valueN)	let arr = Array.of(5) // [5]	始终创建包含所有传入参数的新数组
...操作符	let arr = [...iterableObject]	let newarr = [...arr,4,5,6]	arr=[1,2,3]
Array.from() (ES6+)	详见js数组、字符串、对象相互转换-CSDN博客	let arr = Array.from('hello')	于将类数组对象或可迭代对象转换为真正的数组
Array.prototype.fill() (ES6+)	let arr = new Array(length).fill(value)	let arr = new Array(5).fill('foo')	用于创建一个指定长度并填充同一值的数组

创建二维数组：let arr = Array(m).fill().map(() => Array(n));

2.增删、排序元素

var arr = ['a','b','c','d']

以下方法均改变原数组

方法名	功能	返回值		备注
push()	添加一或多个元素到数组的末尾	该数组新长度	arr.push('x')
pop()	删除数组中最后一个元素	被删除元素	arr.pop()	数组为空时返回undefined
shift()	删除数组中第一个元素	被删除元素	arr.shift()
unshift()	添加一或多个元素到数组的头	该数组新长度	arr.unshift('x')
sort()	默认按照Unicode排序(如字符串排序)	排序后的数组	升序：arr.sort((a,b)=>{return a-b})	降序：arr.sort((a,b)=>{return b-a})
reverse()	反向排列	倒序后的数组	arr.reverse()

3.迭代方法

1.forEach：对数组的每个元素执行一次给定的函数。

 arr.forEach((element) => console.log(element))

2.map：对原数组每一项进行操作后返回新数组。

 const formatArr = arr.map((e) => return(e.name))

3.find：返回数组中满足要求的第一个元素，否则返回 undefined。

 const found = arr.find(e => e.name==='dfb666')

4.filter：返回满足要求所有元素组成的新数组。

 const filterArr = arr.filter((e) => e > 6)

5.every

6.some

4.操作方法

1.join：用特定字符串连接所有元素，返回连接后的字符串（默认使用','分隔，如果使用""，则所有元素之间都没有任何字符）。

 const str = arr.join()//"a,b,c,d"
 const str = arr.join("")//"abcd"
 const str = arr.join("-")//"a-b-c-d"

2.slice(begin?,end?)：原数组不变，返回新的浅拷贝的数组。

begin：提取起始处的索引，0开始，支持负数，大于数组长度时返回空数组。

end：提取终止处的索引，0开始，支持负数，slice提取原数组包含 begin但不包含 end，被省略或大于数组的长度会一直提取到原数组末尾。

 const sliceArr = arr.splice(5);//从第六个到最后一个（不要前五个元素）
 const sliceArr = arr.splice(-2);//从倒数第二个到最后一个（最后两个）
 const sliceArr = arr.splice(1,4);//索引为1,2,3的元素
 const sliceArr = arr.splice(-2,-1);//倒数第二个（不含倒数第一个）

3.splice(start,deleteCount?,item1?)：原数组改变，返回被删除的元素数组。

start：修改的开始索引，超出数组长度末尾开始添加内容，负值表示倒数第几个开始，绝对值大于数组的长度表示开始位置为第0位。只有该参数时删除从start开始及之后的所有项

deleteCount：要移除的数组元素的个数， deleteCount大于start后的元素总数则删除含第start及之后的所有元素， 0或负数不移除元素。

item1：要添加进数组的元素，start位置后开始。如果不指定splice(start,deleteCount)将只删除

const arr = ['a', 'b', 'c', 'd']
arr.splice(1) //arr：['a']，返回被删除的元素['b', 'c', 'd']
arr.splice(1,2) //arr：['a', 'd']，返回被删除的元素['b', 'c']
arr.splice(1,2,'new','item') //arr：['a','new','item','d']，返回被删除的元素['b', 'c']

4.concat()：原数组不变，返回新的连接后数组的副本。

 const newArr = arr.concat(9,[11,13]);//['a','b','c','d',9,11,13]

5.reduce()：对数组中的每个元素执行一个提供的回调函数，并且将结果汇总为一个单一的输出值。

callback：一个回调函数，用于计算的每一步，它接收四个参数。(accumulator, currentValue, currentIndex, array)

accumulator：累计器，用来累计回调的返回值，是累计的结果。

currentValue：数组中正在处理的当前元素。

currentIndex(可选)：数组中正在处理的当前元素的索引。

array (可选)：调用 reduce 的数组。

initialValue (可选)：作为第一次调用 callbackFn时第一个参数的值。如果没有提供 initialValue，则 reduce会从数组的第二个元素开始执行 callbackFn，且 accumulator 会被初始化为数组的第一个元素。

 const arr = [1,2,3,4]
 const sum = arr.reduce((accumulator, currentValue)=>{accumulator + currentValue}, 0);//10

5.位置方法

1.indexOf：查询某个元素在数组中第一次出现的位置。存在该元素返回下标，不存在返回-1

 const arr = ['a', 'b', 'c', 'c', 'b', 'a']
 var index = list.indexOf('c'); //2
 var index = list.indexOf('e'); //-1

2.lastIndexOf：查询某个元素在数组中做后一次出现的位置。存在该元素返回下标，不存在返回-1

 const arr = ['a', 'b', 'c', 'c', 'b', 'a']
 var index = list.indexOf('b'); //4
 var index = list.indexOf('e'); //-1

6.具体应用

1.数组去重

Array.from(new Set(arr))

2.数组查重

注意：该方法对NaN不适用

 var arr = ['a', 'b', 'c','b', 'a']
  for (var i = arr.length-1; i >= 0; i--) {
      if (ary.indexOf(ary[i]) != ary.lastIndexOf(ary[i])) {
          console.log("下标为:"+i +"数组中有重复元素:"+ary[i]);
      }
  }

3.数组累加求和/积

 numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
 numbers.reduce((accumulator, currentValue) => accumulator * currentValue, 1);

4.找数组最大/小值

 numbers.reduce((accumulator, currentValue) => Math.max(accumulator, currentValue));
 numbers.reduce((accumulator, currentValue) => Math.min(accumulator, currentValue));

5.求平均值

 var AVG = ((eval(arr.join("+")) / arr.length) * 100) / 100; //平均值

6.比较两个数组元素相同

先转换成字符串再比较，缺点是不能区分数字和字符串

 [1,2,3].join('') === ['1', '2', '3'].join('') //true

二、字符串

1.长度/位置

const str = "Hello World"

1.length：获取字符串长度。

str.length //5

2.indexOf(searchVal,start)：查找某个字符串，返回第一次匹配到的位置，否则返回-1。searchvalue必需，需要查找的字符串，start可选，开始查找的位置（含start）

 str.indexOf(searchvalue,fromindex)
 str.indexOf("llo", 4) //2
 str.indexOf("o", 5) //5
 str.indexOf("o", 8) //-1

3.lastIndexOf：查找某个字符，返回最后一次匹配到的位置，否则返回-1。

 str.lastIndexOf('llo') //2
 str.lastIndexOf("o") //7

2.检查包含

1.includes(searchVal,start)：字符串是否包含指定的子字符串，返回 true或false。（不可检查正则表达式）

 str.includes("or", 2) //trur

2.startsWith(startVal,start)：字符串是否以指定的子字符串开始，返回 true或false。start可选。

 str.startsWith("lo",3) //true

3.endsWith(endVal,length)：当前字符串是否是以指定的子字符串结尾，返回 true或false。length可选，字符串的长度（0~length-1）

 str.endsWith("lo") //false
 str.endsWith("lo", 5) //true

3.获取指定位置字符

1.charAt(index)：获取指定位置的字符。index的取值不在str的长度范围内时，str[index]返回undefined，charAt(index)会返回空字符串。

 str.charAt(1) 
 str[1] // 等价于

2.charCodeAt(index)：指定位置字符的Unicode值。

str.charCodeAt(1) // e -> 101

4.截取/拼接

1.concat(string1, string2, ..., stringX)：用于连接两个或多个字符串。该方法不会改变原有字符串，会返回连接两个或多个字符串的新字符串。

 "abc".concat("def", "ghij") //abcdefghij

2.slice(start, end)：截取字符串，返回被提取部分的新字符串。[start,end)

start必须，要截取的片断的起始下标，第一个字符位置为 0，负数则从尾部开始截取。end可选，要截取的片段结尾的下标，未指定从start到结尾。

 str.slice(1,3) // el
 str.slice(-3,10) // lr

3.substr(start, length)：start 必需，要截取的子串起始下标，支持负数。length可选，子串中的字符数，省略则截取到结尾。

 str.substr(1) //ello World

4.substring(from, to)：用法同slice()。不同之处在于from>to时，截取[to,from)

str.substring(7,1) // ello W

5.split(separator,limit)：separator必需，字符串或正则表达式，从该参数指定的地方分割 string。limit可选，指定返回的数组的最大长度。

 const list = "apples,bananas;cherries"; //正则分割
 const fruits = list.split(/[,;]/); //["apples", "bananas", "cherries"]

5.匹配(含正则)

函数	含义	返回值	用例
match()	方法在字符串 str 中找到匹配 regexp 的字符	null或数组	str.match(myReg)
matchAll()	返回包含所有匹配正则表达式的结果及分组捕获组的迭代器	见示例	...str.matchAll(myReg)
search()	返回第一个匹配项的位置	index或-1	str.search(myReg)
replace()	不设置全局匹配`g`时，只替换第一个匹配成功的字符串片段。原串不变	替换后的新串	str.replace(myReg, newVal)
split()	使用正则表达式（或子字符串）作为分隔符来分割字符串

6.格式化

1.大小写转换

方法	含义	用法
toLowerCase()	返回转小写新串	str.toLowerCase() //'hello world'
toUpperCase()	大写	str.toUpperCase() //'HELLO WORLD'

 const firstUpStr = str[0].toUpperCase() + str.substr(1)

2.去除空白符

方法	含义	用法
trim()	移除字符串首尾空白符	str.trim()
trimStart()	移除开头空白符	str.trimStart()
trimEnd()	移除结尾空白符	str.trimEnd()

三、Map

在JavaScript中，new Map() 用于创建一个新的Map对象。Map是一种数据结构，允许存储键值对，其中任何值（对象和原始值）都可以作为一个键或一个值。

特点：

键值对存储：Map是一种键值对的集合，其中每个值都有一个相关联的键。
键的唯一性：Map中的键是唯一的，不允许重复。新的值会覆盖与已存在键相关联的旧值。
键的类型：Map的键可以是任何类型的值，包括基本数据类型、对象和函数。顺序：Map能够记住键的原始插入顺序。
迭代：Map是可迭代的，可以使用for…of循环或其他迭代方法遍历其键值对。

1.创建Map

 let myMap = new Map() //创建空 Map
 let myMap = new Map([  
   ['key1', 'value1'],  
   ['key2', 'value2'],  
   // ... 可以添加更多的键值对  
 ]);

2.Map方法、属性

set、get、has、delete、clear和size属性

//set(key, value): 向 Map 对象中添加一个键值对。如果键已经存在，则更新其对应的值。
 myMap.set('key3', 'value3');
 
 //get(key): 获取指定键对应的值。如果键不存在，则返回 undefined。
 let value = myMap.get('key1'); // value='value1'
 
 //has(key): 判断 Map 对象中是否存在指定的键。存在返回 true，否则返回 false。
 myMap.has('key2'); // true
 
 //delete(key): 删除指定键及其对应的值。成功删除返回 true，否则返回 false
 myMap.delete('key1'); // true
 
 // 清空Map对象中的所有键值对,myMap变为空Map
 myMap.clear(); 
 
 // 返回 Map 对象中键值对的数量
 let size = myMap.size;

3.迭代Map对象

 // 迭代键  
 for (let key of myMap.keys()) {  
   console.log(key);  
 }  
 // 迭代值  
 for (let value of myMap.values()) {  
   console.log(value);  
 } 
 // 迭代键值对  
 for (let [key, value] of myMap.entries()) {  
   console.log(key, value);  
 }

四、Set

ES6新增Set集合类型，Set 在很多方面都像是加强的 Map。Set可以包含任何JS数据类型作为值

方法：

1.创建Set

Set会自动去重

注意Set([...])有[]，直接给Set()传入数组会把数组里的元素放进去，而Set([arr,999])则有数组和另一元素

const mySet = new Set() //创建空Set
 let mySet = new Set(["abc", 1, true, {}, undefined, function fun(){}])

2.Set方法

add、has、delete、clear和size属性

 const s = new Set();
 
 //add(): 添加元素
 s.add(1).add(2).add(3);
 
 //has(): 查询Set实例是否存在某元素(返回布尔值)
 s.has(1); // true
 
 //delete(): 删除Set实例中某个元素(返回布尔值)
 s.delete(1) 
 
 //clear(): 清空Set实例
 s.clear()
 
 //size: 获取Set实例的元素个数
 s.size; // 3

3.迭代Set对象

 // 迭代键  
 for (let key of s.keys()) {  
   console.log(key);  
 }  
 // 迭代值  
 for (let value of s.values()) {  
   console.log(value);  
 } 
 // 迭代键值对  
 for (let [key, value] of s.entries()) {  
   console.log(key, value);  
 }
 
 const s = new Set();
 s.add(1).add(2).add(3);
 Array.from(s.keys()); // [1, 2, 3]
 Array.from(s.values()); // [1, 2, 3]
 Array.from(s.entries()); // [[1, 1], [2, 2], [3, 3]]