前言

• 我們已經(jīng)介紹了radash的相關(guān)信息和部分Array相關(guān)方法，詳情可前往主頁查看；
• 本篇我們繼續(xù)介紹radash中Array的相關(guān)方法；
• 下期我們將介紹解析radash中剩余的 Array相關(guān)方法，并整理出Array方法使用目錄，包括文章說明和腦圖說明。

Radash的Array相關(guān)方法詳解

iterate：把一個(gè)函數(shù)迭代執(zhí)行指定次數(shù)

1. 使用說明
   • 參數(shù)：迭代次數(shù)、每次迭代調(diào)用的函數(shù)、迭代初始值。
   • 返回值：返回最終一次循環(huán)迭代的值。
2. 使用代碼示例

   import { iterate } from 'radash'
   
   const value = iterate(
    ?4,
     (acc, idx) => {
    ? ?return acc + idx
     },
    ?0
   ) // => 10
   

3. 源碼解析

   // 定義一個(gè)泛型函數(shù) `iterate`，它接收三個(gè)參數(shù)：
   // `count` 是一個(gè)數(shù)字，表示迭代的次數(shù)；
   // `func` 是一個(gè)函數(shù)，它在每次迭代中被調(diào)用，接收當(dāng)前值和迭代次數(shù)作為參數(shù)，并返回一個(gè)新的值；
   // `initValue` 是迭代的初始值，它的類型為泛型 `T`。
   export const iterate = <T>(
    ?count: number,
    ?func: (currentValue: T, iteration: number) => T,
    ?initValue: T
   ) => {
    ?// 初始化一個(gè)變量 `value`，用于存儲(chǔ)當(dāng)前的迭代值，起始值設(shè)置為 `initValue`。
    ?let value = initValue
    ?// 使用一個(gè) `for` 循環(huán)進(jìn)行 `count` 次迭代。循環(huán)變量 `i` 從 1 開始，以確保迭代次數(shù)正確。
    ?for (let i = 1; i <= count; i++) {
    ? ?// 在每次迭代中，調(diào)用函數(shù) `func`，傳入當(dāng)前的 `value` 和迭代次數(shù) `i`，
    ? ?// 然后將 `func` 函數(shù)返回的新值賦給 `value`，以便在下一次迭代中使用。
    ? ?value = func(value, i)
     }
    ?// 循環(huán)結(jié)束后，返回最終的迭代值 `value`。
    ?return value
   }
   

   • 方法流程說明：
     1. 接收 count、func 和 initValue 作為參數(shù)。
     2. 初始化變量 value 為 initValue。
     3. 進(jìn)行 count 次迭代，每次迭代中調(diào)用 func 函數(shù)，傳入當(dāng)前的 value 和迭代次數(shù) i。
     4. func 函數(shù)返回一個(gè)新值，這個(gè)新值成為下一次迭代的 value。
     5. 迭代完成后，返回最后一次 func 函數(shù)調(diào)用的結(jié)果。

last：輸出數(shù)組的最后一項(xiàng)，如果數(shù)組為空則輸出傳入的默認(rèn)值

1. 使用說明

   • 參數(shù)：目標(biāo)數(shù)組，或者空數(shù)組和默認(rèn)值。
   • 返回值：數(shù)組最后一項(xiàng)，如果數(shù)組為空則輸出傳入的默認(rèn)值。

2. 使用代碼示例

   import { last } from 'radash'
   
   const fish = ['marlin', 'bass', 'trout']
   
   const lastFish = last(fish) // => 'trout'
   const lastItem = last([], 'bass') // => 'bass'
   

3. 源碼解析

   // 定義一個(gè)泛型函數(shù) `last`，它接收一個(gè)具有只讀屬性的泛型數(shù)組 `array`，
   // 和一個(gè)可選的默認(rèn)值 `defaultValue`，其類型可以是泛型 `T` 或 `null` 或 `undefined`，默認(rèn)值為 `undefined`。
   export const last = <T>(
    ?array: readonly T[],
    ?defaultValue: T | null | undefined = undefined
   ) => {
    ?// 如果數(shù)組存在且長(zhǎng)度大于0，返回?cái)?shù)組的最后一個(gè)元素。
    ?// 否則，返回提供的默認(rèn)值 `defaultValue`。
    ?return array?.length > 0 ? array[array.length - 1] : defaultValue
   }
   

   • 方法流程說明：
     1. 檢查傳入的數(shù)組 array 是否存在且長(zhǎng)度大于0。
     2. 如果數(shù)組存在且不為空（長(zhǎng)度大于0），則返回?cái)?shù)組的最后一個(gè)元素 array[array.length - 1]。
     3. 如果數(shù)組不存在或?yàn)榭?，返?defaultValue。
     4. 這個(gè)函數(shù)對(duì)于需要安全地訪問數(shù)組最后一個(gè)元素而不拋出錯(cuò)誤的情況很有用，特別是在不確定數(shù)組是否為空的情況下。通過提供一個(gè)默認(rèn)值，你可以避免在數(shù)組為空時(shí)訪問未定義的索引。如果沒有提供默認(rèn)值，函數(shù)將默認(rèn)返回 undefined。

list：創(chuàng)建包含特定項(xiàng)的數(shù)組

1. 使用說明
   • 參數(shù)：start、end、值，步長(zhǎng)。
   • 返回值：從start開始遍歷到end，輸出一個(gè)數(shù)組，包含特定項(xiàng)（值）的數(shù)組。
2. 使用代碼示例

   import { list } from 'radash'
   
   list(3) ? ? ? ? ? ? ? ? ?// [0, 1, 2, 3]
   list(0, 3) ? ? ? ? ? ? ? // [0, 1, 2, 3]
   list(0, 3, 'y') ? ? ? ? ?// [y, y, y, y]
   list(0, 3, () => 'y') ? ?// [y, y, y, y]
   list(0, 3, i => i) ? ? ? // [0, 1, 2, 3]
   list(0, 3, i => `y${i}`) // [y0, y1, y2, y3]
   list(0, 3, obj) ? ? ? ? ?// [obj, obj, obj, obj]
   list(0, 6, i => i, 2) ? ?// [0, 2, 4, 6]
   

3. 源碼解析

   // 定義一個(gè)泛型函數(shù) `list`，它接受一個(gè)默認(rèn)類型參數(shù) `T`，默認(rèn)為 `number`。
   // 函數(shù)接受四個(gè)參數(shù)：起始值或長(zhǎng)度 `startOrLength`，可選的結(jié)束值 `end`，
   // 可選的值或映射函數(shù) `valueOrMapper` 用于生成數(shù)組中的值，以及可選的步長(zhǎng) `step`。
   export const list = <T = number>(
    ?startOrLength: number,
    ?end?: number,
    ?valueOrMapper?: T | ((i: number) => T),
    ?step?: number
   ): T[] => {
    ?// 使用 `Array.from` 方法來創(chuàng)建一個(gè)數(shù)組，它接受 `range` 生成器函數(shù)作為參數(shù)。
    ?// `range` 函數(shù)根據(jù)提供的參數(shù)生成一個(gè)序列的值。
    ?return Array.from(range(startOrLength, end, valueOrMapper, step))
   }
   

   • 方法流程說明：
     1. 調(diào)用 range 函數(shù)，傳入 startOrLength（起始值或長(zhǎng)度）、end（結(jié)束值）、valueOrMapper（值或映射函數(shù)）、step（步長(zhǎng)）四個(gè)參數(shù)。這些參數(shù)都是可選的，除了 startOrLength 必須提供。
     2. range 函數(shù)是一個(gè)生成器，根據(jù)提供的參數(shù)生成一個(gè)數(shù)字序列。如果指定了 end，那么 startOrLength 作為起始值，end 作為結(jié)束值。如果沒有指定 end，startOrLength 作為序列的長(zhǎng)度。valueOrMapper 可以是一個(gè)值，此時(shí)序列中的每個(gè)元素都是這個(gè)值；也可以是一個(gè)函數(shù)，此時(shí)序列中的每個(gè)元素都是這個(gè)函數(shù)的返回值。step 指定了序列中每個(gè)元素之間的間隔。
     3. Array.from 方法用于從 range 生成器創(chuàng)建一個(gè)數(shù)組。生成器的每次迭代返回的值都會(huì)成為數(shù)組中的一個(gè)元素。
     4. 最終，list 函數(shù)返回這個(gè)數(shù)組。

max：獲取對(duì)象數(shù)組中指定標(biāo)識(shí)符最大的項(xiàng)

1. 使用說明
   • 參數(shù)：目標(biāo)對(duì)象數(shù)組、指定標(biāo)識(shí)符的回調(diào)函數(shù)。
   • 返回值：符合條件的對(duì)象。
2. 使用代碼示例

   import { max } from 'radash'
   
   const fish = [
     {
    ? ?name: 'Marlin',
    ? ?weight: 105,
    ? ?source: 'ocean'
     },
     {
    ? ?name: 'Bass',
    ? ?weight: 8,
    ? ?source: 'lake'
     },
     {
    ? ?name: 'Trout',
    ? ?weight: 13,
    ? ?source: 'lake'
     }
   ]
   
   max(fish, f => f.weight) // => {name: "Marlin", weight: 105, source: "ocean"}
   

3. 源碼解析

   // 定義一個(gè)泛型函數(shù) `max`，它接受一個(gè)具有只讀屬性的泛型數(shù)組 `array`，
   // 以及一個(gè)可選的函數(shù) `getter`，該函數(shù)用于從數(shù)組元素中提取一個(gè)數(shù)字用于比較大小。
   export function max<T>(
    ?array: readonly T[],
    ?getter?: (item: T) => number
   ): T | null {
    ?// 如果 `getter` 函數(shù)未提供，則使用默認(rèn)函數(shù)，它將元素作為其自己的值。
    ?const get = getter ?? ((v: any) => v)
    ?// 調(diào)用 `boil` 函數(shù)，傳入數(shù)組和一個(gè)比較函數(shù)，
    ?// 比較函數(shù)用 `get` 函數(shù)獲取的值來決定哪個(gè)元素更大。
    ?return boil(array, (a, b) => (get(a) > get(b) ? a : b))
   }
   
   // 定義一個(gè)泛型函數(shù) `boil`，它接受一個(gè)具有只讀屬性的泛型數(shù)組 `array`，
   // 以及一個(gè)比較函數(shù) `compareFunc`，該函數(shù)用于比較兩個(gè)元素并返回其中一個(gè)。
   export const boil = <T>(
    ?array: readonly T[],
    ?compareFunc: (a: T, b: T) => T
   ) => {
    ?// 如果傳入的數(shù)組不存在，或者其長(zhǎng)度為0，則返回 null。
    ?if (!array || (array.length ?? 0) === 0) return null
    ?// 使用數(shù)組的 `reduce` 方法應(yīng)用 `compareFunc`，將數(shù)組歸約為單一的值。
    ?return array.reduce(compareFunc)
   }
   

   • 方法流程說明：
     1. 接收一個(gè)數(shù)組 array 和一個(gè)可選的 getter 函數(shù)。如果 getter 函數(shù)提供，它將用于從每個(gè)元素中提取用于比較的數(shù)字值。
     2. 如果沒有提供 getter 函數(shù)，使用一個(gè)默認(rèn)的函數(shù)，這個(gè)函數(shù)簡(jiǎn)單地返回元素本身作為比較值。
     3. 調(diào)用 boil 函數(shù)，傳入數(shù)組和一個(gè)比較函數(shù)。這個(gè)比較函數(shù)使用 get 函數(shù)從兩個(gè)元素 a 和 b 中提取值，并返回較大值對(duì)應(yīng)的元素。
     4. boil 函數(shù)通過 reduce 方法遍歷數(shù)組，應(yīng)用比較函數(shù)，并最終返回單一的元素，即數(shù)組中的最大元素。如果數(shù)組為空或未定義，boil 函數(shù)返回 null。
     5. max 函數(shù)最終返回 boil 函數(shù)的結(jié)果，即數(shù)組中的最大元素，如果數(shù)組為空，則返回 null。

merge：合并數(shù)組中符合條件的項(xiàng)，并且會(huì)覆蓋第一個(gè)數(shù)組

1. 使用說明

   • 參數(shù)：數(shù)組1、數(shù)組2、條件函數(shù)。
   • 返回值：合并覆蓋后的數(shù)組。

2. 使用代碼示例

   import { merge } from 'radash'
   
   const gods = [
     {
    ? ?name: 'Zeus',
    ? ?power: 92
     },
     {
    ? ?name: 'Ra',
    ? ?power: 97
     }
   ]
   
   const newGods = [
     {
    ? ?name: 'Zeus',
    ? ?power: 100
     }
   ]
   
   merge(gods, newGods, f => f.name) // => [{name: "Zeus" power: 100}, {name: "Ra", power: 97}]
   

3. 源碼解析

   export const merge = <T>(
    ?root: readonly T[],
    ?others: readonly T[],
    ?matcher: (item: T) => any
   ) => {
    ?if (!others && !root) return []
    ?if (!others) return root
    ?if (!root) return []
    ?if (!matcher) return root
    ?return root.reduce((acc, r) => {
    ? ?const matched = others.find(o => matcher(r) === matcher(o))
    ? ?if (matched) acc.push(matched)
    ? ?else acc.push(r)
    ? ?return acc
     }, [] as T[])
   }
   

   • 方法流程說明：
     1. 進(jìn)行一系列的檢查，如果 others 和 root 兩個(gè)數(shù)組都不存在或?yàn)榭?，或者沒有提供 matcher 函數(shù)，就返回 root 或者一個(gè)空數(shù)組。
     2. 使用 root 數(shù)組的 reduce 方法構(gòu)建最終的合并數(shù)組。在每次迭代中，使用 matcher 函數(shù)檢查 root 數(shù)組中的當(dāng)前元素是否在 others 數(shù)組中有匹配的元素。
     3. 如果在 others 數(shù)組中找到了一個(gè)匹配的元素，就把這個(gè)匹配的元素添加到累加器數(shù)組 acc 中。
     4. 如果沒有找到匹配的元素，就把 root 數(shù)組中的當(dāng)前元素添加到累加器 acc 中。
     5. 繼續(xù)處理 root 數(shù)組的下一個(gè)元素，直到所有元素都被處理完畢。
     6. 返回累加器 acc，它現(xiàn)在包含了合并后的元素。

min：獲取對(duì)象數(shù)組中指定標(biāo)識(shí)符最小的項(xiàng)

1. 使用說明
   • 參數(shù)：目標(biāo)對(duì)象數(shù)組、指定標(biāo)識(shí)符的條件函數(shù)。
   • 返回值：符合條件的的項(xiàng)
2. 使用代碼示例

   import { min } from 'radash'
   
   const fish = [
     {
    ? ?name: 'Marlin',
    ? ?weight: 105,
    ? ?source: 'ocean'
     },
     {
    ? ?name: 'Bass',
    ? ?weight: 8,
    ? ?source: 'lake'
     },
     {
    ? ?name: 'Trout',
    ? ?weight: 13,
    ? ?source: 'lake'
     }
   ]
   
   min(fish, f => f.weight) // => {name: "Bass", weight: 8, source: "lake"}
   

3. 源碼解析

   // 這是 `min` 函數(shù)的第一種聲明，它要求傳遞一個(gè) `getter` 函數(shù)。
   export function min<T>(
    ?array: readonly T[],
    ?getter: (item: T) => number
   ): T | null
   
   // 這是 `min` 函數(shù)的第二種聲明，它允許 `getter` 函數(shù)是可選的。
   export function min<T>(
    ?array: readonly T[],
    ?getter?: (item: T) => number
   ): T | null {
    ?// 如果沒有提供 `getter` 函數(shù)，使用默認(rèn)函數(shù)，它將元素作為其自己的值。
    ?const get = getter ?? ((v: any) => v)
    ?// 調(diào)用 `boil` 函數(shù)，傳入數(shù)組和一個(gè)比較函數(shù)，
    ?// 比較函數(shù)用 `get` 函數(shù)獲取的值來決定哪個(gè)元素更小。
    ?return boil(array, (a, b) => (get(a) < get(b) ? a : b))
   }
   

   • 方法流程說明：
     1. 函數(shù)接收一個(gè)數(shù)組 array 和一個(gè)可選的 getter 函數(shù)。如果提供了 getter 函數(shù)，它將用于從每個(gè)元素中提取用于比較的數(shù)字值。
     2. 如果沒有提供 getter 函數(shù)，則使用一個(gè)默認(rèn)的函數(shù)，這個(gè)函數(shù)簡(jiǎn)單地返回元素本身作為比較值。
     3. 調(diào)用 boil 函數(shù)，傳入數(shù)組和一個(gè)比較函數(shù)。這個(gè)比較函數(shù)使用 get 函數(shù)從兩個(gè)元素 a 和 b 中提取值，并返回較小值對(duì)應(yīng)的元素。
     4. boil 函數(shù)通過 reduce 方法遍歷數(shù)組，應(yīng)用比較函數(shù)，并最終返回單一的元素，即數(shù)組中的最小元素。如果數(shù)組為空或未定義，boil 函數(shù)返回 null。
     5. min 函數(shù)最終返回 boil 函數(shù)的結(jié)果，即數(shù)組中的最小元素，如果數(shù)組為空，則返回 null。

objectify：根據(jù)函數(shù)映射的鍵與值把數(shù)組轉(zhuǎn)換為字典對(duì)象

1. 使用說明
   • 參數(shù)：目標(biāo)對(duì)象數(shù)組、條件函數(shù)1用于提取鍵、[條件函數(shù)2用于提取值]
   • 返回值：字典對(duì)象
2. 使用代碼示例

   import { objectify } from 'radash'
   
   const fish = [
     {
    ? ?name: 'Marlin',
    ? ?weight: 105
     },
     {
    ? ?name: 'Bass',
    ? ?weight: 8
     },
     {
    ? ?name: 'Trout',
    ? ?weight: 13
     }
   ]
   
   objectify(fish, f => f.name) // => { Marlin: [marlin object], Bass: [bass object], ... }
   objectify(
    ?fish,
    ?f => f.name,
    ?f => f.weight
   ) // => { Marlin: 105, Bass: 8, Trout: 13 }
   

3. 源碼解析

   // 定義一個(gè)泛型函數(shù) `objectify`，它接受三個(gè)參數(shù)：
   // `array` 是一個(gè)具有只讀屬性的泛型數(shù)組，
   // `getKey` 是一個(gè)函數(shù)，用于從數(shù)組元素中提取鍵，
   // `getValue` 是一個(gè)可選的函數(shù)，用于從數(shù)組元素中提取值，默認(rèn)情況下，它會(huì)返回元素本身作為值。
   export const objectify = <T, Key extends string | number | symbol, Value = T>(
    ?array: readonly T[],
    ?getKey: (item: T) => Key,
    ?getValue: (item: T) => Value = item => item as unknown as Value
   ): Record<Key, Value> => {
    ?// 使用數(shù)組的 `reduce` 方法來累積一個(gè)對(duì)象，該對(duì)象將數(shù)組元素映射為鍵值對(duì)。
    ?return array.reduce((acc, item) => {
    ? ?// 使用 `getKey` 函數(shù)從當(dāng)前元素 `item` 中提取鍵，并使用 `getValue` 函數(shù)提取值。
    ? ?// 將這個(gè)鍵值對(duì)添加到累加器對(duì)象 `acc` 中。
    ? ?acc[getKey(item)] = getValue(item)
    ? ?// 返回更新后的累加器 `acc`。
    ? ?return acc
     }, {} as Record<Key, Value>) // 初始化累加器 `acc` 為一個(gè)空對(duì)象。
   }
   

   • 方法流程說明：
     1. 函數(shù)接收一個(gè)數(shù)組 array，一個(gè) getKey 函數(shù)用于提取每個(gè)元素的鍵，以及一個(gè)可選的 getValue 函數(shù)用于提取每個(gè)元素的值。
     2. 如果沒有提供 getValue 函數(shù)，則使用一個(gè)默認(rèn)的函數(shù)，這個(gè)函數(shù)簡(jiǎn)單地將元素本身作為值。
     3. 使用 reduce 方法遍歷數(shù)組。reduce 方法的累加器 acc 是一個(gè)對(duì)象，用于存儲(chǔ)鍵值對(duì)。
     4. 對(duì)于數(shù)組中的每個(gè)元素 item，使用 getKey 函數(shù)提取鍵，并使用 getValue 函數(shù)提取值。
     5. 將提取的鍵和值作為一個(gè)鍵值對(duì)添加到累加器對(duì)象 acc 中。
     6. 繼續(xù)處理數(shù)組的下一個(gè)元素，直到所有元素都被處理完畢。
     7. 返回累加器 acc，它現(xiàn)在是一個(gè)完整的對(duì)象，包含了從數(shù)組元素映射而來的鍵值對(duì)。

range：根據(jù)步長(zhǎng)生成一個(gè)數(shù)值范圍內(nèi)的迭代值

1. 使用說明
   • 參數(shù)：起始值、[結(jié)束值]、[迭代函數(shù)]、步長(zhǎng)。
   • 返回值：用在for循環(huán)中循環(huán)輸出處理的結(jié)果值。
2. 使用代碼示例

   import { range } from 'radash'
   
   range(3) ? ? ? ? ? ? ? ? ?// yields 0, 1, 2, 3
   range(0, 3) ? ? ? ? ? ? ? // yields 0, 1, 2, 3
   range(0, 3, 'y') ? ? ? ? ?// yields y, y, y, y
   range(0, 3, () => 'y') ? ?// yields y, y, y, y
   range(0, 3, i => i) ? ? ? // yields 0, 1, 2, 3
   range(0, 3, i => `y${i}`) // yields y0, y1, y2, y3
   range(0, 3, obj) ? ? ? ? ?// yields obj, obj, obj, obj
   range(0, 6, i => i, 2) ? ?// yields 0, 2, 4, 6
   
   for (const i of range(0, 200, 10)) {
    ?console.log(i) // => 0, 10, 20, 30 ... 190, 200
   }
   
   for (const i of range(0, 5)) {
    ?console.log(i) // => 0, 1, 2, 3, 4, 5
   }
   

3. 源碼解析

   // 定義一個(gè)泛型生成器函數(shù) `range`，它接受一個(gè)默認(rèn)類型參數(shù) `T`，默認(rèn)為 `number`。
   // 函數(shù)接受四個(gè)參數(shù)：起始值或長(zhǎng)度 `startOrLength`，可選的結(jié)束值 `end`，
   // 可選的值或映射函數(shù) `valueOrMapper` 用于生成序列中的值，以及可選的步長(zhǎng) `step`，默認(rèn)為 1。
   export function* range<T = number>(
    ?startOrLength: number,
    ?end?: number,
    ?valueOrMapper: T | ((i: number) => T) = i => i as T,
    ?step: number = 1
   ): Generator<T> {
    ?// 確定 `valueOrMapper` 是一個(gè)函數(shù)還是一個(gè)固定值。如果是函數(shù)，則直接使用；如果不是，則創(chuàng)建一個(gè)總是返回該值的函數(shù)。
    ?const mapper = isFunction(valueOrMapper) ? valueOrMapper : () => valueOrMapper
    ?// 如果提供了 `end` 值，則 `start` 為 `startOrLength`；如果沒有提供 `end` 值，則 `start` 默認(rèn)為 0。
    ?const start = end ? startOrLength : 0
    ?// `final` 是序列的結(jié)束值，如果提供了 `end` 值，則使用它；如果沒有，則 `final` 為 `startOrLength`。
    ?const final = end ?? startOrLength
    ?// 從 `start` 開始，到 `final` 結(jié)束，每次迭代增加 `step`。
    ?for (let i = start; i <= final; i += step) {
    ? ?// 使用 `yield` 關(guān)鍵字產(chǎn)生由 `mapper` 函數(shù)處理的當(dāng)前迭代值 `i`。
    ? ?yield mapper(i)
    ? ?// 如果下一次增加步長(zhǎng)后的值會(huì)超過 `final`，則提前終止循環(huán)。
    ? ?if (i + step > final) break
     }
   }
   

   • 方法流程說明：
     1. 確定 valueOrMapper 參數(shù)是一個(gè)函數(shù)還是一個(gè)值。如果是函數(shù)，直接用作映射器；如果是值，創(chuàng)建一個(gè)總是返回該值的函數(shù)作為映射器。
     2. 確定起始值 start。如果提供了 end 參數(shù)，start 是 startOrLength；否則 start 默認(rèn)為 0。
     3. 確定結(jié)束值 final。如果提供了 end 參數(shù)，final 是 end；否則 final 是 startOrLength。
     4. 使用一個(gè) for 循環(huán)從 start 遍歷到 final，每次迭代增加步長(zhǎng) step。
     5. 在每次迭代中，使用 yield 關(guān)鍵字來產(chǎn)出 mapper 函數(shù)處理過的當(dāng)前值。
     6. 如果在下一次迭代步長(zhǎng)加上當(dāng)前值 i 會(huì)超過 final，則提前退出循環(huán)。
     7. 提示：這個(gè) range 函數(shù)提供了類似于 Python 中的 range 函數(shù)的功能，允許在迭代中產(chǎn)生一系列的值。通過使用生成器，我們可以惰性地產(chǎn)生這些值，這意味著直到迭代器被消費(fèi)時(shí)，這些值才會(huì)被計(jì)算和產(chǎn)生。這在處理大范圍的值時(shí)非常有用，因?yàn)樗恍枰淮涡詫⑺兄导虞d到內(nèi)存中。

replaceOrAppend：替換對(duì)象數(shù)組中的項(xiàng)或是追加項(xiàng)（條件函數(shù)不滿足時(shí)追加）；

1. 使用說明

   • 參數(shù)：被替換數(shù)組、用來的替換的數(shù)組、條件函數(shù)。
   • 返回值：替換或者追加后的數(shù)組。

2. 使用代碼示例

   import { replaceOrAppend } from 'radash'
   
   const fish = [
     {
    ? ?name: 'Marlin',
    ? ?weight: 105
     },
     {
    ? ?name: 'Salmon',
    ? ?weight: 19
     },
     {
    ? ?name: 'Trout',
    ? ?weight: 13
     }
   ]
   
   const salmon = {
    ?name: 'Salmon',
    ?weight: 22
   }
   
   const sockeye = {
    ?name: 'Sockeye',
    ?weight: 8
   }
   
   replaceOrAppend(fish, salmon, f => f.name === 'Salmon') // => [marlin, salmon (weight:22), trout]
   replaceOrAppend(fish, sockeye, f => f.name === 'Sockeye') // => [marlin, salmon, trout, sockeye]
   

3. 源碼解析文章來源地址http://www.zghlxwxcb.cn/news/detail-848808.html

   // 定義一個(gè)泛型函數(shù) `replaceOrAppend`，它接受三個(gè)參數(shù)：
   // `list` 是一個(gè)具有只讀屬性的泛型數(shù)組，
   // `newItem` 是一個(gè)新的元素，將被添加到數(shù)組中，
   // `match` 是一個(gè)函數(shù)，用于確定新元素應(yīng)該替換數(shù)組中的哪個(gè)現(xiàn)有元素。
   export const replaceOrAppend = <T>(
    ?list: readonly T[],
    ?newItem: T,
    ?match: (a: T, idx: number) => boolean
   ) => {
    ?// 如果 `list` 和 `newItem` 都不存在或?yàn)榭眨瑒t返回一個(gè)空數(shù)組。
    ?if (!list && !newItem) return []
    ?// 如果 `newItem` 不存在或?yàn)榭眨瑒t返回 `list` 數(shù)組的副本。
    ?if (!newItem) return [...list]
    ?// 如果 `list` 不存在或?yàn)榭?，則返回一個(gè)只包含 `newItem` 的數(shù)組。
    ?if (!list) return [newItem]
    ?// 遍歷 `list` 數(shù)組，尋找一個(gè)匹配的元素。
    ?for (let idx = 0; idx < list.length; idx++) {
    ? ?const item = list[idx]
    ? ?// 如果 `match` 函數(shù)返回 `true`，則在該位置替換元素。
    ? ?if (match(item, idx)) {
    ? ? ?// 創(chuàng)建一個(gè)新數(shù)組，其中包含從 `list` 開始到匹配位置之前的所有元素，
    ? ? ?// 然后是 `newItem`，然后是從匹配位置之后到 `list` 結(jié)束的所有元素。
    ? ? ?return [
    ? ? ? ?...list.slice(0, idx),
    ? ? ? ?newItem,
    ? ? ? ?...list.slice(idx + 1, list.length)
    ? ?  ]
    ?  }
     }
    ?// 如果沒有找到匹配的元素，將 `newItem` 追加到 `list` 數(shù)組的末尾。
    ?return [...list, newItem]
   }
   

   • 方法流程說明：
     1. 進(jìn)行一系列的檢查，如果 list 和 newItem 都不存在或?yàn)榭?，或者只?newItem 不存在或?yàn)榭?，或者只?list 不存在或?yàn)榭眨瑒t返回相應(yīng)的結(jié)果。
     2. 如果 list 和 newItem 都存在，遍歷 list 數(shù)組，對(duì)于每個(gè)元素和它的索引，調(diào)用 match 函數(shù)。
     3. 如果 match 函數(shù)對(duì)某個(gè)元素返回 true，說明找到了應(yīng)該被替換的元素。函數(shù)將創(chuàng)建一個(gè)新數(shù)組，該數(shù)組由以下部分組成：從 list 的開始到匹配元素之前的部分，newItem，以及從匹配元素之后到 list 結(jié)尾的部分。
     4. 如果遍歷完成后沒有找到任何匹配的元素，函數(shù)將 newItem 添加到 list 的末尾，并返回新數(shù)組。

下期我們將介紹 radash 中剩余的數(shù)組相關(guān)方法

• replace ：查找指定項(xiàng)，并用傳入的去替換；
• select ：對(duì)數(shù)組同時(shí)進(jìn)行過濾和映射，輸出映射后的value數(shù)組；
• shift ：把目標(biāo)數(shù)組向右移動(dòng) n 個(gè)位置返回為一個(gè)新數(shù)組；
• sift：過濾調(diào)列表中值為false的項(xiàng)，返回剩余為true的項(xiàng)組成的數(shù)組；
• sort ：把數(shù)組按照條件函數(shù)指定的項(xiàng)的數(shù)值大小排序，支持升序和降序；
• sum：數(shù)組對(duì)象根據(jù)條件函數(shù)指定想的數(shù)組求和；
• toggle：查找數(shù)組中是否有我們給定的項(xiàng)，有則刪除，沒有則添加；
• unique：數(shù)組去重，去除數(shù)組中重復(fù)的項(xiàng)；
• zipToObject：將第一個(gè)數(shù)組中的鍵映射到第二個(gè)數(shù)組中對(duì)應(yīng)的值；
• zip：把兩個(gè)數(shù)組變?yōu)槎S數(shù)組，二維數(shù)組中的每個(gè)數(shù)組包含兩個(gè)項(xiàng)分別為兩個(gè)傳入數(shù)組的相同位置的項(xiàng)。

寫在后面

• 后續(xù)作者會(huì)整理一份radash完整方法目錄上傳，方便沒法訪問外網(wǎng)的朋友查看使用。
• 下期方法分享完后，會(huì)同步整理分享Array方法的使用說明目錄，方便大家查閱對(duì)照使用。
• 小tips：不出意外的話博主每周五會(huì)定時(shí)更新，出意外的話就是出意外了。
• 大家有任何問題或見解，歡迎評(píng)論區(qū)留言交流和批評(píng)指正！??！
• 點(diǎn)擊訪問：radash官網(wǎng)

到了這里，關(guān)于lodash已死？radash最全使用介紹（附源碼說明）—— Array方法篇（3）的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！