js数组-实例方法:Array.prototype.findLast(),Array.prototype.findLastIndex(),Array.prototype.flat()

Array.prototype.findLast()

• findLast() 方法反向迭代数组，并返回满足提供的测试函数的第一个元素的值。如果没有找到对应元素，则返回 undefined
• 语法
  • findLast(callbackFn)
  • findLast(callbackFn, thisArg)
• 参数
  • callbackFn:数组中测试元素的函数。回调应该返回一个真值，表示已找到匹配的元素，否则返回一个假值。函数在被调用时会传递以下参数
    • element:当前遍历到的元素
    • index:当前遍历到的元素的索引（位置）
    • array:调用 findLast() 的数组本身
  • thisArg
    • 执行 callbackFn 时，用作 this 的值
• 返回值:数组中满足提供的测试函数索引最高的元素；如果没有元素匹配，返回 undefined
• Array.prototype.myFindLast()

Array.prototype.myFindLast = function (callbackFn, thisArg) {
  if (typeof callbackFn !== 'function') {
    throw new TypeError(`${typeof callbackFn} is not a function`)
  }
  const len = this.length
  for (let i = len - 1; i >= 0; i--) {
    if (callbackFn.call(thisArg, this[i], i, this)) {
      return this[i]
    }
  }
  return undefined
}

Array.prototype.findLastIndex()

• findLastIndex() 方法反向迭代数组，并返回满足所提供的测试函数的第一个元素的索引。若没有找到对应元素，则返回 -1
• 语法
  • findLastIndex(callbackFn)
  • findLastIndex(callbackFn, thisArg)
• 参数
  • callbackFn:对数组中的每个元素执行的函数。回调必须返回一个真值，表示已找到匹配的元素，否则返回一个假值。函数在被调用时会传递以下参数：
    • element:当前遍历到的元素
    • index:当前正在处理的元素的索引
    • array:调用 findLastIndex() 的数组本身
  • thisArg:执行 callbackFn 时，用作 this 的值
• 返回值:数组中通过测试的最后一个（索引最大）元素的索引。如果没有找到任何匹配的元素，则返回 -1
• Array.prototype.myFindLastIndex()

Array.prototype.myFindLastIndex = function (callbackFn, thisArg) {
  if (typeof callbackFn !== 'function') {
    throw new TypeError(`${typeof callbackFn} is not a function`)
  }
  const len = this.length
  for (let i = len - 1; i >= 0; i--) {
    if (callbackFn.call(thisArg, this[i], i, this)) {
      return i
    }
  }
  return -1
}

Array.prototype.flat()

• flat() 方法创建一个新的数组，并根据指定深度递归地将所有子数组元素拼接到新的数组中
• 语法
  • flat()
  • flat(depth)
• 参数
  • depth:指定要提取嵌套数组的结构深度，默认值为 1
• 返回值:一个新的数组，其中包含拼接后的子数组元素
• Array.prototype.myFlat()

Array.prototype.myFlat = function (depth = 1) {
  // 如果this不是含有length属性的元素，则返回空数组;包含Set，Map等等具有[Symbol.iterator]
  if (this.length === undefined) {
    return []
  }
  // 创建一个新数组
  let newArr = []

  // 两种情况
  if (Object.prototype.toString.call(this) === '[object Array]') {
    // 如果this是数组的情况
    // 需要先将稀疏数组中的空槽去掉
    const len = this.length
    // 循环：根据值的类型和depth进行判断：如果depth>0且值是数组，则继续对值进行展开
    // 如果depth小于等于0，则将原有值添加到新函数里边
    // 如果depth是Infinity，则在递归函数调用完成后即可返回结果
    for (let i = 0; i < len; i++) {
      if (this.hasOwnProperty(i)) {
        if (Array.isArray(this[i]) && depth > 0) {
          depth--
          newArr.push(...this[i].myFlat(depth))
        } else {
          newArr.push(this[i])
        }
      }
    }
  } else {
    // 如果是含有length属性的对象
    newArr = Array.from(this)
    // 如果有元素的值为数组，需要根据depth对数组进行对应的展开
    newArr = newArr.myFlat(depth)
  }
  // 返回的是新数组
  return newArr
}

Array.prototype.flatMap()

• flatMap() 方法对数组中的每个元素应用给定的回调函数，然后将结果展开一级，返回一个新数组。它等价于在调用 map() 方法后再调用深度为 1 的 flat() 方法（arr.map(...args).flat()），但比分别调用这两个方法稍微更高效一些
• 语法
  • flatMap(callbackFn)
  • flatMap(callbackFn, thisArg)
• 参数
  • callbackFn:一个在数组的每个元素上执行的函数。它应该返回一个包含新数组元素的数组，或是要添加到新数组中的单个非数组值。该函数将被传入以下参数：
    • element:数组中正在处理的当前元素
    • index:数组中正在处理的当前元素的索引
    • array:调用 flatMap() 的当前数组
  • thisArg:在执行 callbackFn 时用作 this 的值
• 返回值:一个新的数组，其中每个元素都是回调函数的结果，并且被展开一级
• Array.prototype.myFlatMap()

Array.prototype.myFlatMap = function (callbackFn, thisArg) {
  if (typeof callbackFn !== 'function') {
    throw new TypeError(`${typeof callbackFn} not is a function`)
  }
  let newArr = []
  for (let i = 0; i < this.length; i++) {
    if (this.hasOwnProperty(i)) {
      const arr = callbackFn.call(thisArg, this[i], i, this)
      newArr.push(arr)
    }
  }
  newArr = newArr.flat()
  return newArr
}