JavaScript数组元素进行字典升序排列 js数组some every

1、some()

此方法为参数传递的函数测试数组。依次执行数组的每个元素：
如果有一个元素与测试元素匹配，则返回true， 剩余的元素不会再执行检测。
如果没有满足条件的元素，则返回false
some() 方法接受三个参数：当前元素值，当前索引，原数组

注意： some() 不会对空数组进行检测；some() 不会改变原始数组

let arr = ["a", "b", "c", "d", "e"]
let result = arr.some(test => test === "d")
console.log(result)
// 输出：true

 2、every()

此方法是对数组中每项运行给定函数，如果数组的每个元素都与测试匹配，则返回true，反之则返回false。
every() 方法接受三个参数：当前元素值，当前索引，原数组

注意： every() 不会对空数组进行检测；every() 不会改变原始数组。

let arr = ["a", "b", "c", "d", "e"]
let result = arr.every(test => test === "d")
console.log(result)
// 输出：false
arr = ["a", "a", "a", "a", "a"]
result = arr.every(test => test === "a")
console.log(result)
// 输出：true

 3、reduce()

此方法接收一个函数作为累加器。它为数组中的每个元素依次执行回调函数，不包括数组中被删除或者从未被赋值的元素。函数应用于累加器，数组中的每个值最后只返回一个值。
reduce() 方法接受四个参数：初始值（上一次回调的返回值），当前元素值，当前索引，原数组

let arr = [1, 2, 3, 4, 5]
let result = arr.reduce((total, value) => total * value)
console.log(result)
// 输出：120

 4、map()

该方法会返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。它按照原始数组元素顺序依次处理元素。
map() 方法接受三个参数：当前元素值，当前索引，原数组

注意：map() 不会对空数组进行检测；map() 不会改变原始数组

let arr = [5, 4, 3, 2, 1]
let result = arr.map(x => x * x)
console.log(result)
// 输出：[25, 16, 9, 4, 1]

 5、flat()

此方法创建一个新数组，其中包含子数组上的元素，并将其平整到新数组中。

注意：此方法只能进行一个级别的深度。

let arr = [[1, 2], [3, 4], 5]
let result = arr.flat()
console.log(result)
// 输出：[1, 2, 3, 4, 5]

 6、flatMap()

该方法将函数应用于数组的每个元素，然后将结果压缩为一个新数组。它在一个函数中结合了flat（）和map（）。

let arr = [[1], [2], [3], [4], [5]]
let result = arr.flatMap(item => item * 10)
console.log(result)
// 输出：[10, 20, 30, 40, 50]
result = arr.flat().map(item => item * 10)
console.log(result)
// 输出：[10, 20, 30, 40, 50]

 7、filter()

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

filter() 方法是对数据中的元素进行过滤，是不能修改原数组中的数据，只能读取原数组中的数据，callback需要返回布尔值；为true的时候，对应的元素留下来；为false的时候，对应的元素过滤掉。

filter() 方法接受三个参数：当前元素值，当前索引，原数组

注意： filter() 不会对空数组进行检测；filter() 不会改变原始数组。

let arr = [{ id: 1, name: "Alisa" }, { id: 2, name: "William" }, { id: 3, name: "Jorge" }, { id: 4, name: "Cynthia" }, { id: 5, name: "Cynthia" }]
let result = arr.filter(element => element.name === "Cynthia")
console.log(result)
// 输出：[{id: 4, name: "Cynthia"}, {id: 5, name: "Cynthia"}]

 8、forEach()

此方法用于调用数组的每个元素。并将元素传递给回调函数。

forEach() 方法接受三个参数：当前元素值，当前索引，原数组

注意： forEach() 对于空数组是不会执行回调函数的。

let arr = [{ id: 1, name: "Alisa" }, { id: 2, name: "William" }, { id: 3, name: "Jorge" }, { id: 4, name: "Cynthia" }]
arr.forEach(element => console.log(element.name))
// 输出：Alisa
// William
// Jorge
// Cynthia

关于遍历：

（1）最原始的for循环

var arr = ['Alisa', 'Marco', 'William', 'Jorge', 'Cynthia']

for (var index = 0; index < arr.length; index++) {
  console.log(index) // 0 1 2 3 4
  console.log(arr[index]) // Alisa Marco William Jorge Cynthia
}

（2）for...in循环

• 数组的键名是数字，但是for...in循环是以字符串作为键名“0”、“1”、“2”
• for...in循环不仅遍历数字键名，还会遍历手动添加的其他键，甚至包括原型链上的键
• 某些情况下，for...in循环会以任意顺序遍历键名

注意：for...in循环主要是为遍历对象而设计的，不适用于遍历数组

var arr = ['Alisa', 'Marco', 'William', 'Jorge', 'Cynthia']

for (let item in arr) {
  console.log(item) // 0 1 2 3 4
}

（3）forEach循环

无法中途跳出forEach循环，break命令或return命令都不能奏效

var arr = ['Alisa', 'Marco', 'William', 'Jorge', 'Cynthia']

arr.forEach((item, index) => {
  console.log(index) // 0 1 2 3 4
  console.log(item) // Alisa Marco William Jorge Cynthia
  if (item === 'Marco') {
    return
  }
})

（4）for...of循环

• 有着同for...in一样的简洁语法，但是没有for...in那些缺点。
• 不同于forEach方法，它可以与break、continue和return配合使用。
• 提供了遍历所有数据结构的统一操作接口。

var arr = ['Alisa', 'Marco', 'William', 'Jorge', 'Cynthia']

for (let item of arr) {
  console.log(item) // Alisa Marco William
  if (item === 'William') {
    break
  }
}

 9、findIndex()

此方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置。

它为数组中的每个元素都调用一次函数执行，

当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引位置，之后的值不会再调用执行函数。

如果没有符合条件的元素返回 -1

findIndex() 方法接受三个参数：当前元素值，当前索引，原数组

注意: findIndex() 对于空数组，函数是不会执行的；findIndex() 并没有改变数组的原始值。

let arr = [{ id: 1, name: "William" }, { id: 2, name: "William" }, { id: 3, name: "Jorge" }, { id: 4, name: "Cynthia" }]
let result = arr.findIndex(element => element.id === 4)
console.log(result)
// 输出：3
result = arr.findIndex(element => element.id === 8)
console.log(result)
// 输出：-1

 10、find()

此方法返回通过测试（函数内判断）的数组的第一个元素的值。

find() 方法为数组中的每个元素都调用一次函数执行：

当数组中的元素在测试条件时回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。

如果没有符合条件的元素返回 undefined。

find() 方法接受三个参数：当前元素值，当前索引，原数组

注意: find() 对于空数组，函数是不会执行的；find() 并没有改变数组的原始值。

let arr = [{ id: 1, name: "William" }, { id: 2, name: "William" }, { id: 3, name: "Jorge" }, { id: 4, name: "Cynthia" }]
let result = arr.find(element => element.id === 4)
console.log(result)
// 输出：{id: 4, name: "Cynthia"}
result = arr.find(element => element.id === 8)
console.log(result)
// 输出：undefined

 11、sort()

此方法接收一个函数作为参数。它对数组的元素进行排序并返回它。也可以使用含有参数的sort()方法进行排序。

注意：当数字是按字母顺序排列时"40"将排在"5"前面。

使用数字排序，你必须通过一个函数作为参数来调用。

函数指定数字是按照升序还是降序排列。

注意： 这种方法会改变原始数组！

let arr = [5, 4, 3, 2, 1]
let result = arr.sort((a, b) => a - b)
console.log(result)
// 输出：[1, 2, 3, 4, 5]
console.log(arr)
// 输出：[1, 2, 3, 4, 5]
result = arr.sort((a, b) => b - a)
console.log(result)
// 输出：[5, 4, 3, 2, 1]
console.log(arr)
// 输出：[5, 4, 3, 2, 1]

 12、concat()

此方法用于连接两个或多个数组/值，它不会改变现有的数组。而仅仅返回被连接数组的一个新数组。

注意： 该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本

let arr1 = [5, 4, 3, 2, 1]
let arr2 = [50, 40, 30, 20, 10]
let result = arr1.concat(arr2)
console.log(result)
// 输出：[5, 4, 3, 2, 1, 50, 40, 30, 20, 10]
console.log(arr1)
// 输出：[5, 4, 3, 2, 1]
console.log(arr2)
// 输出：[50, 40, 30, 20, 10]

 13、fill()

此方法的作用是使用一个固定值来替换数组中的元素。该固定值可以是字母、数字、字符串、数组等等。它还有两个可选参数，表示填充起来的开始位置（默认为0）与结束位置（默认为array.length）。

fill() 方法接受三个参数：填充的值，开始填充位置，停止填充位置 (默认为 array.length)

let arr = [5, 4, 3, 2, 1]
let result = arr.fill(0, 1, 3)
console.log(result)
// 输出：[5, 0, 0, 2, 1]

 14、includes()

此方法用于判断字符串是否包含指定的子字符串。如果找到匹配的字符串则返回 true，否则返回 false。

includes() 方法接受三个参数：需要查找的元素值，fromIndex（ 从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。）

注意：includes() 方法区分大小写。

let arr = [5, 4, 3, 2, 1]
let result = arr.includes(3)
console.log(result)
// 输出：true
result = arr.includes(8)
console.log(result)
// 输出：false

 15、reverse()

此方法用于颠倒数组中元素的顺序。第一个元素成为最后一个，最后一个元素将成为第一个。

let arr = ['a', 'b', 'c', 'd', 'e']
let result = arr.reverse()
console.log(result)
// 输出：["e", "d", "c", "b", "a"]