波多野结衣不打码视频,国产69精品久久久久9999不卡

首頁

web前端

js教程

JavaScript 數(shù)組方法背后的算法

Susan Sarandon

Nov 03, 2024 am 07:10 AM

Algorithms Behind JavaScript Array Methods

JavaScript 數(shù)組方法背后的算法。

JavaScript 數(shù)組帶有各種內(nèi)置方法，允許操作和檢索數(shù)組中的數(shù)據(jù)。以下是從大綱中提取的數(shù)組方法列表：

concat()
加入()
填充()
包括()
indexOf()
反向()
排序()
拼接()
在()
copyWithin()
平()
Array.from()
findLastIndex()
forEach()
每個()
條目()
值()
toReversed()（創(chuàng)建數(shù)組的反向副本而不修改原始數(shù)組）
toSorted()（創(chuàng)建數(shù)組的排序副本而不修改原始數(shù)組）
toSpliced()（創(chuàng)建一個新數(shù)組，添加或刪除元素，而不修改原始數(shù)組）
with()（返回替換了特定元素的數(shù)組副本）
Array.fromAsync()
Array.of()
地圖()
flatMap()
減少()
reduceRight()
一些()
查找()
findIndex()
findLast()

讓我分解一下每個 JavaScript 數(shù)組方法所使用的常用算法：

1. concat()

算法：線性追加/合并
時間復(fù)雜度：O(n)，其中 n 是所有數(shù)組的總長度
內(nèi)部使用迭代來創(chuàng)建新數(shù)組并復(fù)制元素

// concat()
Array.prototype.myConcat = function(...arrays) {
  const result = [...this];
  for (const arr of arrays) {
    for (const item of arr) {
      result.push(item);
    }
  }
  return result;
};

2. 加入（）

算法：字符串連接的線性遍歷
時間復(fù)雜度：O(n)
迭代數(shù)組元素并構(gòu)建結(jié)果字符串

// join()
Array.prototype.myJoin = function(separator = ',') {
  let result = '';
  for (let i = 0; i < this.length; i++) {
    result += this[i];
    if (i < this.length - 1) result += separator;
  }
  return result;
};

3. 填充（）

算法：帶賦值的線性遍歷
時間復(fù)雜度：O(n)
帶有賦值的簡單迭代

// fill()
Array.prototype.myFill = function(value, start = 0, end = this.length) {
  for (let i = start; i < end; i++) {
    this[i] = value;
  }
  return this;
};

4. 包含()

算法：線性搜索
時間復(fù)雜度：O(n)
順序掃描直到找到元素或到達結(jié)束

// includes()
Array.prototype.myIncludes = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i < this.length; i++) {
    if (this[i] === searchElement || (Number.isNaN(this[i]) && Number.isNaN(searchElement))) {
      return true;
    }
  }
  return false;
};

5.indexOf()

算法：線性搜索
時間復(fù)雜度：O(n)
從開始順序掃描直到找到匹配

// indexOf()
Array.prototype.myIndexOf = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i < this.length; i++) {
    if (this[i] === searchElement) return i;
  }
  return -1;
};

6. 反向()

算法：兩指針交換
時間復(fù)雜度：O(n/2)
從開始/結(jié)束向內(nèi)移動元素

// reverse()
Array.prototype.myReverse = function() {
  let left = 0;
  let right = this.length - 1;

  while (left < right) {
    // Swap elements
    const temp = this[left];
    this[left] = this[right];
    this[right] = temp;
    left++;
    right--;
  }

  return this;
};

7. 排序（）

算法：通常為 TimSort（合并排序和插入排序的混合）
時間復(fù)雜度：O(n log n)
現(xiàn)代瀏覽器使用自適應(yīng)排序算法

// sort()
Array.prototype.mySort = function(compareFn) {
  // Implementation of QuickSort for simplicity
  // Note: Actual JS engines typically use TimSort
  const quickSort = (arr, low, high) => {
    if (low < high) {
      const pi = partition(arr, low, high);
      quickSort(arr, low, pi - 1);
      quickSort(arr, pi + 1, high);
    }
  };

  const partition = (arr, low, high) => {
    const pivot = arr[high];
    let i = low - 1;

    for (let j = low; j < high; j++) {
      const compareResult = compareFn ? compareFn(arr[j], pivot) : String(arr[j]).localeCompare(String(pivot));
      if (compareResult <= 0) {
        i++;
        [arr[i], arr[j]] = [arr[j], arr[i]];
      }
    }
    [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
    return i + 1;
  };

  quickSort(this, 0, this.length - 1);
  return this;
};

8. 拼接（）

算法：線性數(shù)組修改
時間復(fù)雜度：O(n)
就地移動元素并修改數(shù)組

// splice()
Array.prototype.mySplice = function(start, deleteCount, ...items) {
  const len = this.length;
  const actualStart = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
  const actualDeleteCount = Math.min(Math.max(deleteCount || 0, 0), len - actualStart);

  // Store deleted elements
  const deleted = [];
  for (let i = 0; i < actualDeleteCount; i++) {
    deleted[i] = this[actualStart + i];
  }

  // Shift elements if necessary
  const itemCount = items.length;
  const shiftCount = itemCount - actualDeleteCount;

  if (shiftCount > 0) {
    // Moving elements right
    for (let i = len - 1; i >= actualStart + actualDeleteCount; i--) {
      this[i + shiftCount] = this[i];
    }
  } else if (shiftCount < 0) {
    // Moving elements left
    for (let i = actualStart + actualDeleteCount; i < len; i++) {
      this[i + shiftCount] = this[i];
    }
  }

  // Insert new items
  for (let i = 0; i < itemCount; i++) {
    this[actualStart + i] = items[i];
  }

  this.length = len + shiftCount;
  return deleted;
};

9. 在()

算法：直接索引訪問
時間復(fù)雜度：O(1)
帶有邊界檢查的簡單數(shù)組索引

// at()
Array.prototype.myAt = function(index) {
  const actualIndex = index >= 0 ? index : this.length + index;
  return this[actualIndex];
};

10. 復(fù)制（）

算法：塊內(nèi)存復(fù)制
時間復(fù)雜度：O(n)
內(nèi)存復(fù)制和移位操作

// copyWithin()
Array.prototype.myCopyWithin = function(target, start = 0, end = this.length) {
  const len = this.length;
  let to = target < 0 ? Math.max(len + target, 0) : Math.min(target, len);
  let from = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
  let final = end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
  const count = Math.min(final - from, len - to);

  // Copy to temporary array to handle overlapping
  const temp = new Array(count);
  for (let i = 0; i < count; i++) {
    temp[i] = this[from + i];
  }

  for (let i = 0; i < count; i++) {
    this[to + i] = temp[i];
  }

  return this;
};

11. 平（）

算法：遞歸深度優(yōu)先遍歷
時間復(fù)雜度：單層為 O(n)，深度 d 為 O(d*n)
遞歸展平嵌套數(shù)組

// flat()
Array.prototype.myFlat = function(depth = 1) {
  const flatten = (arr, currentDepth) => {
    const result = [];
    for (const item of arr) {
      if (Array.isArray(item) && currentDepth < depth) {
        result.push(...flatten(item, currentDepth + 1));
      } else {
        result.push(item);
      }
    }
    return result;
  };

  return flatten(this, 0);
};

12. 數(shù)組.from()

算法：迭代和復(fù)制
時間復(fù)雜度：O(n)
從可迭代創(chuàng)建新數(shù)組

// Array.from()
Array.myFrom = function(arrayLike, mapFn) {
  const result = [];
  for (let i = 0; i < arrayLike.length; i++) {
    result[i] = mapFn ? mapFn(arrayLike[i], i) : arrayLike[i];
  }
  return result;
};

13. 查找最后一個索引()

算法：反向線性搜索
時間復(fù)雜度：O(n)
從末尾開始順序掃描直到找到匹配項

// findLastIndex()
Array.prototype.myFindLastIndex = function(predicate) {
  for (let i = this.length - 1; i >= 0; i--) {
    if (predicate(this[i], i, this)) return i;
  }
  return -1;
};

14. forEach()

算法：線性迭代
時間復(fù)雜度：O(n)
帶有回調(diào)執(zhí)行的簡單迭代

// forEach()
Array.prototype.myForEach = function(callback) {
  for (let i = 0; i < this.length; i++) {
    if (i in this) {  // Skip holes in sparse arrays
      callback(this[i], i, this);
    }
  }
};

15. 每個（）

算法：短路線性掃描
時間復(fù)雜度：O(n)
在第一個錯誤條件下停止

// concat()
Array.prototype.myConcat = function(...arrays) {
  const result = [...this];
  for (const arr of arrays) {
    for (const item of arr) {
      result.push(item);
    }
  }
  return result;
};

16. 條目()

算法：迭代器協(xié)議實現(xiàn)
時間復(fù)雜度：創(chuàng)建 O(1)，完整迭代 O(n)
創(chuàng)建迭代器對象

// join()
Array.prototype.myJoin = function(separator = ',') {
  let result = '';
  for (let i = 0; i < this.length; i++) {
    result += this[i];
    if (i < this.length - 1) result += separator;
  }
  return result;
};

17. 值（）

算法：迭代器協(xié)議實現(xiàn)
時間復(fù)雜度：創(chuàng)建 O(1)，完整迭代 O(n)
為值創(chuàng)建迭代器

// fill()
Array.prototype.myFill = function(value, start = 0, end = this.length) {
  for (let i = start; i < end; i++) {
    this[i] = value;
  }
  return this;
};

18. toReversed()

算法：反向迭代復(fù)制
時間復(fù)雜度：O(n)
創(chuàng)建新的反轉(zhuǎn)數(shù)組

// includes()
Array.prototype.myIncludes = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i < this.length; i++) {
    if (this[i] === searchElement || (Number.isNaN(this[i]) && Number.isNaN(searchElement))) {
      return true;
    }
  }
  return false;
};

19. toSorted()

算法：復(fù)制然后 TimSort
時間復(fù)雜度：O(n log n)
使用標(biāo)準(zhǔn)排序創(chuàng)建排序副本

// indexOf()
Array.prototype.myIndexOf = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i < this.length; i++) {
    if (this[i] === searchElement) return i;
  }
  return -1;
};

20. toSpliced()

算法：修改復(fù)制
時間復(fù)雜度：O(n)
創(chuàng)建修改后的副本

// reverse()
Array.prototype.myReverse = function() {
  let left = 0;
  let right = this.length - 1;

  while (left < right) {
    // Swap elements
    const temp = this[left];
    this[left] = this[right];
    this[right] = temp;
    left++;
    right--;
  }

  return this;
};

21. 與()

算法：單次修改的淺拷貝
時間復(fù)雜度：O(n)
創(chuàng)建更改了一個元素的副本

// sort()
Array.prototype.mySort = function(compareFn) {
  // Implementation of QuickSort for simplicity
  // Note: Actual JS engines typically use TimSort
  const quickSort = (arr, low, high) => {
    if (low < high) {
      const pi = partition(arr, low, high);
      quickSort(arr, low, pi - 1);
      quickSort(arr, pi + 1, high);
    }
  };

  const partition = (arr, low, high) => {
    const pivot = arr[high];
    let i = low - 1;

    for (let j = low; j < high; j++) {
      const compareResult = compareFn ? compareFn(arr[j], pivot) : String(arr[j]).localeCompare(String(pivot));
      if (compareResult <= 0) {
        i++;
        [arr[i], arr[j]] = [arr[j], arr[i]];
      }
    }
    [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
    return i + 1;
  };

  quickSort(this, 0, this.length - 1);
  return this;
};

22. Array.fromAsync()

算法：異步迭代和收集
時間復(fù)雜度：O(n) 異步操作
處理承諾和異步迭代

// splice()
Array.prototype.mySplice = function(start, deleteCount, ...items) {
  const len = this.length;
  const actualStart = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
  const actualDeleteCount = Math.min(Math.max(deleteCount || 0, 0), len - actualStart);

  // Store deleted elements
  const deleted = [];
  for (let i = 0; i < actualDeleteCount; i++) {
    deleted[i] = this[actualStart + i];
  }

  // Shift elements if necessary
  const itemCount = items.length;
  const shiftCount = itemCount - actualDeleteCount;

  if (shiftCount > 0) {
    // Moving elements right
    for (let i = len - 1; i >= actualStart + actualDeleteCount; i--) {
      this[i + shiftCount] = this[i];
    }
  } else if (shiftCount < 0) {
    // Moving elements left
    for (let i = actualStart + actualDeleteCount; i < len; i++) {
      this[i + shiftCount] = this[i];
    }
  }

  // Insert new items
  for (let i = 0; i < itemCount; i++) {
    this[actualStart + i] = items[i];
  }

  this.length = len + shiftCount;
  return deleted;
};

23. 數(shù)組.of()

算法：直接創(chuàng)建數(shù)組
時間復(fù)雜度：O(n)
從參數(shù)創(chuàng)建數(shù)組

// at()
Array.prototype.myAt = function(index) {
  const actualIndex = index >= 0 ? index : this.length + index;
  return this[actualIndex];
};

24. 地圖（）

算法：變換迭代
時間復(fù)雜度：O(n)
使用轉(zhuǎn)換后的元素創(chuàng)建新數(shù)組

// copyWithin()
Array.prototype.myCopyWithin = function(target, start = 0, end = this.length) {
  const len = this.length;
  let to = target < 0 ? Math.max(len + target, 0) : Math.min(target, len);
  let from = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
  let final = end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
  const count = Math.min(final - from, len - to);

  // Copy to temporary array to handle overlapping
  const temp = new Array(count);
  for (let i = 0; i < count; i++) {
    temp[i] = this[from + i];
  }

  for (let i = 0; i < count; i++) {
    this[to + i] = temp[i];
  }

  return this;
};

25. 平面地圖()

算法：地圖展平
時間復(fù)雜度：O(n*m)，其中 m 是平均映射數(shù)組大小
結(jié)合了映射和展平

// flat()
Array.prototype.myFlat = function(depth = 1) {
  const flatten = (arr, currentDepth) => {
    const result = [];
    for (const item of arr) {
      if (Array.isArray(item) && currentDepth < depth) {
        result.push(...flatten(item, currentDepth + 1));
      } else {
        result.push(item);
      }
    }
    return result;
  };

  return flatten(this, 0);
};

26. 減少（）

算法：線性累加
時間復(fù)雜度：O(n)
帶回調(diào)的順序累加

// Array.from()
Array.myFrom = function(arrayLike, mapFn) {
  const result = [];
  for (let i = 0; i < arrayLike.length; i++) {
    result[i] = mapFn ? mapFn(arrayLike[i], i) : arrayLike[i];
  }
  return result;
};

27.reduceRight()

算法：反向線性累加
時間復(fù)雜度：O(n)
從右到左累積

// findLastIndex()
Array.prototype.myFindLastIndex = function(predicate) {
  for (let i = this.length - 1; i >= 0; i--) {
    if (predicate(this[i], i, this)) return i;
  }
  return -1;
};

28. 一些（）

算法：短路線性掃描
時間復(fù)雜度：O(n)
在第一個真實條件下停止

// forEach()
Array.prototype.myForEach = function(callback) {
  for (let i = 0; i < this.length; i++) {
    if (i in this) {  // Skip holes in sparse arrays
      callback(this[i], i, this);
    }
  }
};

29. 查找（）

算法：線性搜索
時間復(fù)雜度：O(n)
順序掃描直到條件滿足

// every()
Array.prototype.myEvery = function(predicate) {
  for (let i = 0; i < this.length; i++) {
    if (i in this && !predicate(this[i], i, this)) {
      return false;
    }
  }
  return true;
};

30. 查找索引()

算法：線性搜索
時間復(fù)雜度：O(n)
順序掃描匹配條件

// entries()
Array.prototype.myEntries = function() {
  let index = 0;
  const array = this;

  return {
    [Symbol.iterator]() {
      return this;
    },
    next() {
      if (index < array.length) {
        return { value: [index, array[index++]], done: false };
      }
      return { done: true };
    }
  };
};

31. 查找最后一個()

算法：反向線性搜索
時間復(fù)雜度：O(n)
從末尾開始順序掃描

// concat()
Array.prototype.myConcat = function(...arrays) {
  const result = [...this];
  for (const arr of arrays) {
    for (const item of arr) {
      result.push(item);
    }
  }
  return result;
};

我已經(jīng)提供了您請求的所有 31 種數(shù)組方法的完整實現(xiàn)。

？在 LinkedIn 上與我聯(lián)系：

讓我們一起深入了解軟件工程的世界！我定期分享有關(guān) JavaScript、TypeScript、Node.js、React、Next.js、數(shù)據(jù)結(jié)構(gòu)、算法、Web 開發(fā)等方面的見解。無論您是想提高自己的技能還是在令人興奮的主題上進行合作，我都樂意與您聯(lián)系并與您一起成長。

跟我來：Nozibul Islam

以上是JavaScript 數(shù)組方法背后的算法的詳細內(nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！

本站聲明

本文內(nèi)容由網(wǎng)友自發(fā)貢獻，版權(quán)歸原作者所有，本站不承擔(dān)相應(yīng)法律責(zé)任。如您發(fā)現(xiàn)有涉嫌抄襲侵權(quán)的內(nèi)容，請聯(lián)系admin@php.cn

熱AI工具

Undresser.AI Undress

人工智能驅(qū)動的應(yīng)用程序，用于創(chuàng)建逼真的裸體照片

熱工具

熱門話題

gmail郵箱登陸入口在哪里

8648

Java教程

1790

CakePHP 教程

1733

Laravel 教程

1583

PHP教程

1453

Related knowledge

如何在JS中與日期和時間合作？ Jul 01, 2025 am 01:27 AM

JavaScript中的日期和時間處理需注意以下幾點：1.創(chuàng)建Date對象有多種方式，推薦使用ISO格式字符串以保證兼容性；2.獲取和設(shè)置時間信息可用get和set方法，注意月份從0開始；3.手動格式化日期需拼接字符串，也可使用第三方庫；4.處理時區(qū)問題建議使用支持時區(qū)的庫，如Luxon。掌握這些要點能有效避免常見錯誤。

為什么要將標(biāo)簽放在的底部？ Jul 02, 2025 am 01:22 AM

PlacingtagsatthebottomofablogpostorwebpageservespracticalpurposesforSEO,userexperience,anddesign.1.IthelpswithSEObyallowingsearchenginestoaccesskeyword-relevanttagswithoutclutteringthemaincontent.2.Itimprovesuserexperiencebykeepingthefocusonthearticl

什么是在DOM中冒泡和捕獲的事件？ Jul 02, 2025 am 01:19 AM

事件捕獲和冒泡是DOM中事件傳播的兩個階段，捕獲是從頂層向下到目標(biāo)元素，冒泡是從目標(biāo)元素向上傳播到頂層。1.事件捕獲通過addEventListener的useCapture參數(shù)設(shè)為true實現(xiàn)；2.事件冒泡是默認(rèn)行為，useCapture設(shè)為false或省略；3.可使用event.stopPropagation()阻止事件傳播；4.冒泡支持事件委托，提高動態(tài)內(nèi)容處理效率；5.捕獲可用于提前攔截事件，如日志記錄或錯誤處理。了解這兩個階段有助于精確控制JavaScript響應(yīng)用戶操作的時機和方式。

如何減少JavaScript應(yīng)用程序的有效載荷大??？ Jun 26, 2025 am 12:54 AM

如果JavaScript應(yīng)用加載慢、性能差，問題往往出在payload太大，解決方法包括：1.使用代碼拆分（CodeSplitting），通過React.lazy()或構(gòu)建工具將大bundle拆分為多個小文件，按需加載以減少首次下載量；2.移除未使用的代碼（TreeShaking），利用ES6模塊機制清除“死代碼”，確保引入的庫支持該特性；3.壓縮和合并資源文件，啟用Gzip/Brotli和Terser壓縮JS，合理合并文件并優(yōu)化靜態(tài)資源；4.替換重型依賴，選用輕量級庫如day.js、fetch

JavaScript模塊上的確定JS綜述：ES模塊與COMPORJS Jul 02, 2025 am 01:28 AM

ES模塊和CommonJS的主要區(qū)別在于加載方式和使用場景。1.CommonJS是同步加載，適用于Node.js服務(wù)器端環(huán)境；2.ES模塊是異步加載，適用于瀏覽器等網(wǎng)絡(luò)環(huán)境；3.語法上，ES模塊使用import/export，且必須位于頂層作用域，而CommonJS使用require/module.exports，可在運行時動態(tài)調(diào)用；4.CommonJS廣泛用于舊版Node.js及依賴它的庫如Express，ES模塊則適用于現(xiàn)代前端框架和Node.jsv14 ；5.雖然可混合使用，但容易引發(fā)問題

如何在node.js中提出HTTP請求？ Jul 13, 2025 am 02:18 AM

在Node.js中發(fā)起HTTP請求有三種常用方式：使用內(nèi)置模塊、axios和node-fetch。1.使用內(nèi)置的http/https模塊無需依賴，適合基礎(chǔ)場景，但需手動處理數(shù)據(jù)拼接和錯誤監(jiān)聽，例如用https.get()獲取數(shù)據(jù)或通過.write()發(fā)送POST請求；2.axios是基于Promise的第三方庫，語法簡潔且功能強大，支持async/await、自動JSON轉(zhuǎn)換、攔截器等，推薦用于簡化異步請求操作；3.node-fetch提供類似瀏覽器fetch的風(fēng)格，基于Promise且語法簡單

編寫清潔和可維護的JavaScript代碼的最佳實踐是什么？ Jun 23, 2025 am 12:35 AM

要寫出干凈、可維護的JavaScript代碼，應(yīng)遵循以下四點：1.使用清晰一致的命名規(guī)范，變量名用名詞如count，函數(shù)名用動詞開頭如fetchData()，類名用PascalCase如UserProfile；2.避免過長函數(shù)和副作用，每個函數(shù)只做一件事，如將更新用戶信息拆分為formatUser、saveUser和renderUser；3.合理使用模塊化和組件化，如在React中將頁面拆分為UserProfile、UserStats等小組件；4.寫注釋和文檔時點到為止，重點說明關(guān)鍵邏輯、算法選

垃圾收集如何在JavaScript中起作用？ Jul 04, 2025 am 12:42 AM

JavaScript的垃圾回收機制通過標(biāo)記-清除算法自動管理內(nèi)存，以減少內(nèi)存泄漏風(fēng)險。引擎從根對象出發(fā)遍歷并標(biāo)記活躍對象，未被標(biāo)記的則被視為垃圾并被清除。例如，當(dāng)對象不再被引用（如將變量設(shè)為null），它將在下一輪回收中被釋放。常見的內(nèi)存泄漏原因包括：①未清除的定時器或事件監(jiān)聽器；②閉包中對外部變量的引用；③全局變量持續(xù)持有大量數(shù)據(jù)。V8引擎通過分代回收、增量標(biāo)記、并行/并發(fā)回收等策略優(yōu)化回收效率，降低主線程阻塞時間。開發(fā)時應(yīng)避免不必要的全局引用、及時解除對象關(guān)聯(lián)，以提升性能與穩(wěn)定性。

See all articles

国产av日韩一区二区三区精品,成人性爱视频在线观看,国产,欧美,日韩,一区,www.成色av久久成人,2222eeee成人天堂