實作陣列內建函式

自己做做看。

Array.map

function map(arr, handler) {
  // 新陣列
  let newArr = []
  // 遍歷陣列內容
  for(let i=0; i<arr.length; i++) {
    // 將回傳值寫入新陣列
    // 傳入三個參數：
    // 1. 目前元素
    // 2. 索引值
    // 3. 來源陣列
    newArr[i] = handler(arr[i], i, arr)
  }
  return newArr
}

const result = map([1, 2, 3], (elem, index, src) => {
  // 來源陣列
  console.log('srcArray:', src)
  // 索引值
  console.log('index:', index)
  // 目前元素
  console.log('elem:', elem)
  // 元素處理後的回傳值
  return elem * 2
})
console.log('return value:', result)

// output: srcArray: [1, 2, 3]
// output: index: 0
// output: elem: 1

// output: srcArray: [1, 2, 3]
// output: index: 1
// output: elem: 2

// output: srcArray: [1, 2, 3]
// output: index: 2
// output: elem: 3

// output: return value: [2, 4, 6]

Array.lastIndexOf

function lastIndexOf(arr, target) {
  // 反向迴圈
  for(let i=arr.length; i>=0; i--) {
    // 符合 target 就回傳目前索引值
    if(target === arr[i]) {
      return i
    }
  }
  // 沒有符合的 target 回傳 -1
  return -1
}
console.log(lastIndexOf([1, 2, 2, 3], 2))  // 2 
console.log(lastIndexOf([1, 2, 2, 3], 3))  // 3
console.log(lastIndexOf([1, 2, 2, 3], 4))  // -1

Array.indexOf

function indexOf(arr, searchElement) {
  // 遍歷陣列元素
  for(let i=0; i<arr.length; i++) {
    // 找到目標
    if(arr[i] === searchElement) {
      // 回傳索引值
      return i
    }
  }
  // 找不到
  return -1
}
console.log(indexOf([1, 2, 2, 3], 2)) // 1
console.log(indexOf([1, 2, 2, 3], 3)) // 3
console.log(indexOf([1, 2, 2, 3], 4)) // -1

Array.reverse

解法 1 => 反向迴圈 + push：

function reverse(arr) {
  let result = []
  // 反向迴圈
  for(let i=arr.length-1; i>=0; i--) {
    result.push(arr[i])
  }
  // 修改原陣列
  for(let i=0; i<arr.length; i++) {
    arr[i] = result[i]
  }
  // 回傳值
  return result
}
const array1 = [1, 2, 3]
const array2 = reverse(array1)
console.log(array1)  // [3, 2, 1] 
console.log(array2)  // [3, 2, 1] 

解法 2 => 迴圈 + 動態索引值：

function reverse(arr) {
  // 動態索引值
  // i=0 => k=2
  // i=1 => k=1
  // i=2 => k=0
  let k = arr.length - 1
  let result = []
  // 正向迴圈
  for(let i=0; i<arr.length; i++) {
    result[i] = arr[k-i]
  }
  // 修改原陣列
  for(let i=0; i<arr.length; i++) {
    arr[i] = result[i]
  }
  // 回傳值
  return result
}
const array1 = [1, 2, 3]
const array2 = reverse(array1)
console.log(array1)  // [3, 2, 1] 
console.log(array2)  // [3, 2, 1] 

Array.fill

function fill(arr, value) {
  const result = []
  // 遍歷陣列元素
  for(let i=0; i<arr.length; i++) {
    result[i] = value
  }
  // 修改原陣列
  for(let i=0; i<arr.length; i++) {
    // 把值填入新陣列
    arr[i] = result[i]
  }
  // 回傳結果
  return result
}
const array1 = [1, 2, 3]
const array2 = fill(array1, 'A')
console.log(array1)  // ['A', 'A', 'A']
console.log(array2)  // ['A', 'A', 'A']

Array.join

function join(arr, separator) {
  let result = ''
  // 遍歷陣列元素
  for(let i=0; i<arr.length; i++) {
    // 不是最後一個元素才插值
    if(i !== arr.length-1) {
      result += arr[i] + separator
    } else {
      // 最後一個元素直接填入
      result += arr[i]
    }
  }
  // 回傳結果
  return result
}
const str = join([1, 2, 3], ',')
console.log(str)  // '1,2,3' 

Array.filter

function filter(arr, callback) {
  let result = []
  let k = 0
  for(let i=0; i<arr.length; i++) {
    // 把回傳 true 的元素加入到結果陣列
    // 傳入三個參數
    // 1. 目前的元素
    // 2. 索引值
    // 3. 來源陣列
    if(callback(arr[i], i, arr)) {
      result[k] = arr[i]
      // 更新索引值
      k++
    }
  }
  // 回傳結果陣列
  return result
}

const newArray = filter([1, 2, 3, 4, 5], (elem, index, src) => {
  // 來源陣列
  console.log('srcArray:', src)
  // 索引值
  console.log('index:', index)
  // 目前元素
  console.log('elem: ', elem)
  // 回傳判斷結果
  return elem > 2
})
console.log('newArray:', newArray) 

// output: srcArray: [1, 2, 3, 4, 5]
// output: index: 0
// output: elem: 1
// output: srcArray: [1, 2, 3, 4, 5]
// output: index: 1
// output: elem: 2
// output: srcArray: [1, 2, 3, 4, 5]
// output: index: 2
// output: elem: 3
// output: srcArray: [1, 2, 3, 4, 5]
// output: index: 3
// output: elem: 4
// output: srcArray: [1, 2, 3, 4, 5]
// output: index: 4
// output: elem: 5

// output: newArray: [3, 4, 5]

Array.slice

var arr = [1, 2, 3, -1, -2]
var myResult = mySlice(arr, 1)

function mySlice(array, optionStart, optionEnd) {
  var result = []
  var start = optionStart || 0  
  var end = optionEnd || array.length
  
  if (start > array.length) start = 0
  if (end > array.length) end = array.length
  
  for(var i=start; i<end; i++) {
    result.push(array[i])
  }
  return result
}

Array.reduce

function reduce(arr, Afunction) {
  // 累加器
  let accumulator = 0
  for(let i=0; i<arr.length; i++) {
    // 更新累加器的值
    accumulator = Afunction(accumulator, arr[i])
  }
  // 回傳累加結果
  return accumulator
}
const result = reduce([1, 2, 3, 4 ,5],(acc, elem) => acc + elem)
console.log(result) // 15