js数组实例方法-lastIndexOf，join，keys，map

Array.prototype.lastIndexOf()

• lastIndexOf() 方法返回数组中给定元素最后一次出现的索引，如果不存在则返回 -1。该方法从 fromIndex 开始向前搜索数组
• 语法
  • lastIndexOf(searchElement)
  • lastIndexOf(searchElement, fromIndex)
• 参数
  • searchElement：被查找的元素
  • fromIndex：以 0 起始的索引，表明反向搜索的起始位置，会被转换为整数
    • 如果 fromIndex < 0，则从数组末尾开始倒数计数——即使用 fromIndex + array.length 的值
    • 如果 fromIndex < -array.length，则不搜索数组并返回 -1。从概念上讲，你可以把它想象成从数组开始之前不存在的位置开始反向搜索，这条路径上没有任何数组元素，因此 searchElement 永远不会被找到
    • 如果 fromIndex >= array.length 或者省略了 fromIndex，则使用 array.length - 1，这会导致搜索整个数组。可以将其理解为从数组尾部之后不存在的位置开始向前搜索。最终会访问到数组最后一个元素，并继续向前开始实际搜索数组元素
• 返回值
  • 数组中该元素最后一次出现的索引，如未找到返回 -1
• Array.prototype.myLastIndexOf

Array.prototype.myLastIndexOf = function (searchElement, fromIndex) {
  const len = this.length
  switch (true) {
    case typeof fromIndex === 'symbol' || typeof fromIndex === 'bigint':
      throw new TypeError(
        `Cannot convert a ${Object.prototype.toString
          .call(fromIndex)
          .slice(8, -1)} value to a number`
      )
    case fromIndex >= len || fromIndex === undefined:
      fromIndex = len - 1
      break
    case fromIndex >= -len && fromIndex < 0:
      fromIndex = len + fromIndex
      break
    case fromIndex < -len:
      return -1
    case fromIndex >= 0:
      break
    default:
      return 0
  }
  while (fromIndex >= 0) {
    // 掉过空槽位置
    if (this.hasOwnProperty(fromIndex)) {
      if (this[fromIndex] === searchElement) {
        return fromIndex
      }
    }
    fromIndex--
  }
  return -1
}

Array.prototype.join()

• join() 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串，用逗号或指定的分隔符字符串分隔。如果数组只有一个元素，那么将返回该元素而不使用分隔符
• 语法
  • join()
  • join(separator)
• 参数
  • separator：指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。如果省略，数组元素用逗号（,）分隔。如果 separator 是空字符串（""），则所有元素之间都没有任何字符
• 返回值
  • 一个所有数组元素连接的字符串。如果 arr.length 为 0，则返回空字符串
• Array.prototype.myJoin

Array.prototype.myJoin = function (separator = ',') {
  let newStr = `${this[0] === undefined || this[0] === null ? '' : this[0]}`
  const len = this.length
  for (let i = 1; i < len; i++) {
    newStr = `${newStr}${separator}${
      this[i] === undefined || this[i] === null ? '' : this[i]
    }`
  }
  return newStr
} 

Array.prototype.keys()

• keys() 方法返回一个新的数组迭代器对象，其中包含数组中每个索引的键
• 语法
  • keys()
• 返回值
  • 一个新的可迭代迭代器对象
• Array.prototype.myKeys

Array.prototype.myKeys = function () {
  const len = this.length
  const keys = []
  for (let i = 0; i < len; i++) {
    keys.push(i)
  }
  return Iterator.from(keys)
}

Array.prototype.map()

• map() 方法创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成
• 语法
  • map(callbackFn)
  • map(callbackFn, thisArg)
• 参数
  • callbackFn：为数组中的每个元素执行的函数。它的返回值作为一个元素被添加为新数组中。该函数被调用时将传入以下参数：
    • element：数组中当前正在处理的元素
    • index：正在处理的元素在数组中的索引
    • array：调用了 map() 的数组本身
      -thisArg 可选：执行 callbackFn 时用作 this 的值。参见迭代方法
• 返回值
  • 一个新数组，每个元素都是回调函数的返回值
• Array.prototype.myMap

Array.prototype.myMap = function (callbackFn, thisArg) {
  const newArray = []
  const len = this.length
  for (let i = 0; i < len; i++) {
    // 空槽不进行处理，保留位置
    if (this.hasOwnProperty(i)) {
      newArray[i] = callbackFn.call(thisArg, this[i], i, this)
    }
  }
  return newArray
}