你真的會寫迴圈嗎–8種遍歷方法執行速度深度°對比

路易斯發表於2019-03-04

關於陣列或物件遍歷，相信很多人都沒有深入觀察過執行效率。這是一個曾在群裡吵翻天的話題，讀懂後你將成為遍歷效率話題的大師。

關於

我的部落格：louis blog
SF專欄：路易斯前端深度課
原文連結：詳解JS遍歷

導讀

遍歷陣列或物件是一名程式設計師的基本素養之一. 然而遍歷卻不是一件簡單的事, 優秀的程式設計師知道怎麼去選擇合適的遍歷方法, 優化遍歷效率. 本篇將帶你走進JavaScript遍歷的世界, 享受分析JS迴圈的快感. 本篇所有程式碼都可以直接執行, 希望您通讀本篇後, 不止是瀏覽, 最好是親手去實踐下.

概述

js有如下兩種資料需要經常遍歷

陣列(Array)
物件(Object)

同時又提供瞭如下8種方法方便我們遍歷元素

for
while(或do~while)
forEach
for in
$.each
$(selecter).each
map
every

最終我們將分析遍歷效率選出最佳遍歷選手.

本文將針對如下兩種資料進行詳細的分析和舉慄. 下面舉慄中如果不加特殊說明將會用到如下資料.

var array = ["囚徒","過客","領袖"];//職場3種人
var o = {0:"linda",1:"style",2:"nick",length:3};複製程式碼

for

語法: for(初始化; 迴圈執行條件; 每遍歷一個元素後做的事情;){}

(function(){//迴圈置於閉包之內
  for(var i=0,length=array.length;i<length;i++){//快取陣列長度
      console.log(array[i]);//內部方法若有可能相互影響,也要置於閉包之內
  }
})();複製程式碼

for迴圈只能遍歷陣列, 不能遍歷物件. 寫for迴圈時有兩點需要注意.

其一, 為了避免遍歷時執行多遍計算陣列長度的操作, 影響效率, 建議在迴圈開始以變數的形式快取下陣列長度, 若在迴圈內部有可能改變陣列長度, 請務必慎重處理, 避免陣列越界.
JavaScript中並沒有類似java的塊級作用域, for迴圈內部定義的變數會直接暴露在外(如 i,迴圈退出後,i變數將等於陣列長度, 後續程式碼將能訪問到 i 變數的值), 因此建議將for迴圈置於閉包內. 特別要注意的是: 如果在迴圈內部, 前一個元素的遍歷有可能影響到後一個元素的遍歷, 那麼for迴圈內部方法也需要置於閉包之內.

do/while

語法: do{…}while(true);

 do while
(function() {
    var i = 0,
        len = array.length;
    do {
        if (i == 2) {
            break; // 迴圈被終止, 此處如果是continue就會造成迴圈無法退出
        };
        console.log(`array[`+ i +`]:` + array[i]);
        i++;//此句建議放置迴圈while頭部
    } while(i<len);
})();複製程式碼

do/while的語法簡化了迴圈的實現, 只保留對迴圈條件的判斷, 所以我們要在迴圈內部構造出迴圈退出的條件, 否則有可能造成死迴圈. 特別要注意的是: 使用 continue 跳出本次遍歷時, 要保證迴圈能夠自動進入到下一次遍歷, 因此保證迴圈走到下一次遍歷的語句需要放到 continue 前面執行, 建議置於迴圈頭部.(如上, i++ 語句最好放置迴圈頭部)

do/while 迴圈與for迴圈大體差不多,只支援陣列遍歷, 多用於對迴圈退出條件不是很明確的場景. 一般來說不建議使用這種方式遍歷陣列.

forEach

語法: array.forEach(function(item){}), 引數item表示陣列每一項的元素

array.forEach(function(item){
  if(item=="囚徒")
    return;//這裡只能使用return跳過當前元素處理
  console.log(item);
});複製程式碼

forEach回撥function預設有三個引數: item, index, array.

使用forEach迴圈有幾點需要特別注意:

forEach無法遍歷物件
forEach無法在IE中使用，只是在firefox和chrome中實現了該方法
forEach無法使用break，continue跳出迴圈，使用return時，效果和在for迴圈中使用continue一致

for in

語法: for(var item in array){}

for(var item in array){
  console.log(item);
}//0 1 2
for(var item in o){
  console.log(item);
}//0 1 2 length複製程式碼

for in 可用於遍歷陣列和物件, 但它輸出的只是陣列的索引和物件的key, 我們可以通過索引和key取到對應的值. 如下:

for(var item in array){
  console.log(array[item]);
}//"囚徒" "過客" "領袖"
for(var item in o){
  console.log(o[item]);
}//"linda" "style" "nick" "length"複製程式碼

$.each

語法: $.each(array|o, function(i, ele){}) 支援陣列和物件

$.each(array, function(i, ele){
  console.log(i,ele,this==ele);
});
//0 "囚徒" true
//1 "過客" true
//2 "領袖" true
$.each(o, function(i, ele){
  console.log(i,ele,this==ele);
});
//0 "linda" true
//1 "style" true
//2 "nick" true複製程式碼

這裡我們注意到 this物件指向當前屬性的值,這是因為:

參考jQuery api:

$.each() 方法會迭代jQuery物件中的每一個DOM元素。每次回撥函式執行時，會傳遞當前迴圈次數作為引數(從0開始計數)。更重要的是，回撥函式是在當前DOM元素為上下文的語境中觸發的。因此關鍵字 this 總是指向這個元素。

同時,上述遍歷時, o 物件的屬性中有一個length屬性並沒有被輸出. 這是為什麼呢? 請耐心往下看.

首先, 我們來看看遍歷物件o時, 當前的this物件到底是什麼?

$.each(o, function(i, ele){
  if(this=="linda"){//我們隨機選取第一個屬性
    console.log(this,this==ele);
    $.each(this, function(e, ele2) {
        console.log(e, ele2);
    });
  }
});
//String {0: "l", 1: "i", 2: "n", 3: "d", 4: "a", length: 5, [[PrimitiveValue]]: "linda"} true
//0 "l"
//1 "i"
//2 "n"
//3 "d"
//4 "a"複製程式碼

我們發現, this物件等於回撥函式的第二個形參. 且它的 length 屬性和 [[PrimitiveValue]] 屬性並沒有被列印出來, 為此我們來檢視下length的內部屬性.

$.each(o, function(i, ele){
  if(this=="linda")//我們還是隨機選取第一個屬性(這還是隨機嗎?)
    console.log(Object.getOwnPropertyDescriptor(this, `length`));
});
//Object {value: 5, writable: false, enumerable: false, configurable: false}複製程式碼

可見, this物件的length屬性的 enumerable 屬性被設定成了false, 這表示該物件不能被列舉或遍歷, 同時還不能被配置(configurable: false), 也不能被賦值(writable: false).

此時, 前面遍歷 o 物件時,它的 length 屬性沒有被列印出來的疑問似乎有解了. 讓我們來看看 o.length 的內部屬性吧.

console.log(Object.getOwnPropertyDescriptor(o, `length`));
//Object {value: 3, writable: true, enumerable: true, configurable: true}複製程式碼

o.length 值為3, 可賦值, 可列舉, 可配置. 這可不對, 剛剛不是說 enumerable 屬性被設定成了false 才不會被遍歷嗎. 現在該值為 true, 並且還不可遍歷. 這不合常理, 自然該有別的原因. 我們接著往下看.

var o = {0:"linda",1:"style",2:"nick",length:1}; // 試著改變length的值
$.each(o, function(i, ele){//再遍歷一次
  console.log(i,ele);
});
//0 "linda"

var o = {0:"linda",1:"style",2:"nick",length:5}; // 堅持改變length的值
$.each(o, function(i, ele){//再遍歷一次
  console.log(i,ele);
});
// 0 linda
// 1 style
// 2 nick
// length 5

var o = {0:"linda",1:"style",2:"nick"}; // 試試去掉length屬性
$.each(o, function(i, ele){//再遍歷一次
  console.log(i,ele);
});
// 0 linda
// 1 style
// 2 nick複製程式碼

現象明瞭, 結合jquery原始碼, 當物件中存在length屬性時, $.each 內部使用for迴圈去遍歷物件, 否則它將使用for in迴圈去遍歷, 因此$.each遍歷物件遵循如下規律:

如果物件中存在 length 屬性, 遍歷深度以length屬性為準, 即length多大, 遍歷多少個元素.
如果物件中不存在 length 屬性, 遍歷深度以實際內部屬性個數為準.

不僅如此, $.each的具體使用過程中還有以下幾點需要注意:

使用 return 或者 return true 為跳過一個元素，繼續執行後面的迴圈;
使用 return false 為終止迴圈的執行, 這是因為在 jquery.each 中, 若返回值指定為false, 才跳出迴圈, 如果感興趣請翻看 jquery.each 原始碼;
無法使用 break 與 continue 來跳過迴圈.

$(selecter).each

語法: $(selecter|array|o).each(function(i, ele){}) 支援陣列和物件, 該方法基本上與$.each方法相同.

$(`div`).each(function(i,ele){
  console.log(this,i,this == ele);
});
//dom... 0 dom.... true
$(array).each(function(i,ele){//處理陣列
  if(this == "領袖")
      console.log(this,i,this == ele);
});
//String {0: "領", 1: "袖", length: 2, [[PrimitiveValue]]: "領袖"} 2 true
$(o).each(function(i,ele){//處理物件
  if(this == "nick")
      console.log(this,i,this == ele);
});
//String {0: "n", 1: "i", 2: "c", 3: "k", length: 4, [[PrimitiveValue]]: "nick"} 2 true複製程式碼

dom表示div元素, 由於this恆等ele, 說明this也表示div元素, 所以this並不是jquery物件, 而是普通的DOM物件(可以在this上隨意使用DOM方法). 使用$(selecter).each方法,請注意以下幾點:

i: 即序列值 ele: 表示當前被遍歷的DOM元素
this 表示當前被遍歷的DOM元素，不能呼叫jQuery方法, 如需呼叫jquery方法需要用$符號包裹.如, $(this)

map

即 Array.prototype.map,該方法只支援陣列

語法: array.map(callback[,thisArg]) map方法使用其提供函式的每次返回結果生成一個新的陣列.

var array = [1, 4, 9];
var roots = array.map(Math.sqrt);//map包裹方法名
// roots is now [1, 2, 3], array is still [1, 4, 9]
var array = [1, 4, 9];
var doubles = array.map(function(num) {//map包裹方法實體
  return num * 2;
});
// doubles is now [2, 8, 18]. array is still [1, 4, 9]複製程式碼

實際上,由於map方法被設計成支援 [鴨式辨型][] , 該方法也可以用來處理形似陣列的物件, 例如 NodeList.

var elems = document.querySelectorAll(`select option:checked`);
var values = Array.prototype.map.call(elems, function(obj) {
  return obj.value;
});複製程式碼

甚至還可以用來處理字串, 如下:

var map = Array.prototype.map;
var array = map.call(`Hello 中國`, function(x) { 
  return x.charCodeAt(0);
});
console.log(array);
//[72, 101, 108, 108, 111, 32, 20013, 22269]複製程式碼

map處理字串的方式多種多樣, 例如反轉等.

var str = `12345`;
var output = Array.prototype.map.call(str, function(x) {
  return x;
}).reverse().join(``);
console.log(output);//54321複製程式碼

例如將字串陣列轉換為數字陣列, 只需一條語句, 如下:

console.log([`1`, `2`, `3`].map(Number));//[1,2,3]複製程式碼

目前map方法被大部分瀏覽器支援, 除了IE 6,7,8.

every

即 Array.prototype.every, 該方法同上述map方法也只支援陣列

語法: arr.every(callback[, thisArg]) every 方法用於檢驗陣列中的每一項是否符合某個條件, 若符合則放回true, 反之則返回false.

function isBigEnough(element, index, array) {
  return element >= 10;
}
[12, 5, 8, 130, 44].every(isBigEnough);   // false
[12, 54, 18, 130, 44].every(isBigEnough); // true複製程式碼

該方法還有簡寫方式, 如下:

[12, 5, 8, 130, 44].every(elem => elem >= 10); // false
[12, 54, 18, 130, 44].every(elem => elem >= 10); // true複製程式碼

以上, 遍歷陣列和物件的8種方法簡單的介紹完, 小結如下:

for in , $.each , $().each 既支援物件也支援陣列遍歷;
for , do/while , forEach 只支援陣列;
Array.prototype.map, Array.prototype.every 只支援陣列和形似陣列的物件;
forEach不能退出迴圈,只能通過return來進入到下一個元素的遍歷中(相當於for迴圈的continue), 且在IE沒有實現該方法;
$.each和$().each迴圈只能通過return false 來退出迴圈, 使用return 或 return true 將跳過一個元素, 繼續執行後面的迴圈.

測試各方法效率

下面我們來測試下上述方法的效率.

注: array陣列預設為空, 依次賦值陣列長度為1 000 000, 10 000 000, 100 000 000, 分別在 Chrome, Firefox, Safari 瀏覽器上進行兩輪測試, 取測試時間平均值作為比較物件, 時間單位為ms. 如下是測試程式碼:

var array = [],
    length = array.length = 10000000;//(一千萬)
//for(var i=0;i<length;i++){
//  array[i] = `louis`;
//}
console.log(array[0]);
//-------------------------for
var t1 = +new Date();
for(var i=0;i<length;i++){
}
var t2 = +new Date();
console.log(`for:` + (t2-t1));

//-------------------------do/while
var t1 = +new Date();
var i = 0;
do {
    i++;
} while(i<length);
var t2 = +new Date();
console.log(`do while:` + (t2-t1));

//-------------------------forEach
var t1 = +new Date();
array.forEach(function(item){
});
var t2 = +new Date();
console.log(`forEach:` + (t2-t1));

//-------------------------for in
var t1 = +new Date();
for(var item in array){
}
var t2 = +new Date();
console.log(`for in:` + (t2-t1));

//------------------------- $.each
var t1 = +new Date();
$.each(array, function(i, ele){
});
var t2 = +new Date();
console.log(`$.each:` + (t2-t1));

//-------------------------$().each
var t1 = +new Date();
$(array).each(function(i,ele){
});
var t2 = +new Date();
console.log(`$(ele).each:` + (t2-t1));

//-------------------------map
var t1 = +new Date();
array.map(function(num){
});
var t2 = +new Date();
console.log(`map:` + (t2-t1));

//-------------------------every
var t1 = +new Date();
array.every(function(e,i,arr){
});
var t2 = +new Date();
console.log(`every:` + (t2-t1));複製程式碼

測試機器正常執行 IDE, 編輯器, 瀏覽器, qq, 微信等常用應用, 系統空閒. 硬體裝置如下:

作業系統: OSX EI Capitan 版本 10.11.5
MacBook Pro（13 英寸，2015 年初期）
處理器: 2.7 GHz Intel Core i5
記憶體: 8 GB 1867 MHz DDR3

以上多輪測試結果彙總如下三張表(單位:ms):

陣列長度為10^6

陣列長度為10^6	chrome 52.0.2743.116 (64-bit)	Firefox Developer Edition 49.0a2 (2016-08-01)	Safari 9.1.1 (11601.6.17)
for	(16+19)/2 = 17.5	(6+7)/2 = 6.5	(6+7)/2 = 6.5
do while	(24+17)/2 = 20.5	(7+5)/2 = 6	(5+5)/2 = 5
for in	(19+28)/2 = 23.5	(0+0)/2 = 0	(0+0)/2 = 0
forEach	(41+28)/2 = 34.5	(4+4)/2 = 4	(31+29)/2 = 30
map	(26+32)/2 = 28	(4+4)/2 = 4	(32+26)/2 = 28
every	(22+24)/2 = 23	(4+5)/2 = 4.5	(41+45)/2 = 43
$.each	(29+27)/2 = 28	(306+311)/2 = 308.5	(111+97)/2 = 104
$(e).each	(94+98)/2 = 96	(484+488)/2 = 486	(79+64)/2 = 71.5

陣列長度為10^7

陣列長度為10^7	chrome 52.0.2743.116 (64-bit)	Firefox Developer Edition 49.0a2 (2016-08-01)	Safari 9.1.1 (11601.6.17)
for	(164+161)/2 = 162.5	(26+30)/2 = 28	(30+31)/2 = 30.5
do while	(163+157)/2 = 160	(27+25)/2 = 26	(28+27)/2 = 27.5
for in	(78+86)/2 = 82	(0+0)/2 = 0	(0+0)/2 = 0
forEach	(211+205)/2 = 208	(31+30)/2 = 30.5	(291+289)/2 = 290
map	(349+282)/2 = 315.5	(24+22)/2 = 23	(259+260)/2 = 259.5
every	(221+219)/2 = 220	(24+24)/2 = 24	(251+257)/2 = 254
$.each	(210+215)/2 = 212.5	(2868+2789)/2 = 2828.5	(699+724)/2 = 711.5
$(e).each	(730+669)/2 = 699.5	(4674+4722)/2 = 4698	(523+546)/2 = 534.5

陣列長度為10^8

陣列長度為10^8	chrome 52.0.2743.116 (64-bit)	Firefox Developer Edition 49.0a2 (2016-08-01)	Safari 9.1.1 (11601.6.17)
for	(1486+1583)/2 = 1534.5	(222+238)/2 = 230	(261+251)/2 = 256
do while	(1548+1608)/2 = 1578	(236+247)/2 = 241.5	(272+265)/2 = 268.5
for in	(0+0)/2 = 0	(0+0)/2 = 0	(0+0)/2 = 0
forEach	(25838+22307)/2 = 24072.5	(212+209)/2 = 210.5	(2565+2568)/2 = 2566.5
map	(23795+22787)/2 = 23291	(215+206)/2 = 210.5	(2556+2573)/2 = 2564.5
every	(22393+22378)/2 = 22385.5	(212+215)/2 = 213.5	(2550+2548)/2 = 2549
$.each	(14523+14776)/2 = 14649.5	(28007+27698)/2 = 27852.5	(7109+7156)/2 = 7132.5
$(e).each	chrome 奔潰了…	(49352+49530)/2 = 49441	(5505+4616)/2 = 5060.5

綜上, 我們發現for in 迴圈的效能不穩定, 猜測它可能沒有進入迴圈. 因此將陣列各元素進行如下賦值. 重新進行如下兩輪測試.

var array = [],
    length = array.length = 1000000;
for(var i=0;i<length;i++){
  array[i] = `louis`;
}複製程式碼

陣列賦值後, 陣列長度為10^6

陣列長度為10^6	chrome 52.0.2743.116 (64-bit)	Firefox Developer Edition 49.0a2 (2016-08-01)	Safari 9.1.1 (11601.6.17)
for	(21+22)/2 = 21.5	(8+10)/2 = 9	(6+5)/2 = 5.5
do while	(22+19)/2 = 20.5	(6+6)/2 = 6	(6+5)/2 = 5.5
for in	(178+184)/2 = 181	(318+268)/2 = 293	(413+464)/2 = 438.5
forEach	(42+45)/2 = 43.5	(4+4)/2 = 4	(21+24)/2 = 22.5
map	(137+153)/2 = 145	(9+8)/2 = 8.5	(38+43)/2 = 40.5
every	(0+0)/2 = 0	(0+0)/2 = 0	(0+0)/2 = 0
$.each	(85+84)/2 = 84.5	(15+19)/2 = 17	(37+25)/2 = 31
$(e).each	(81+83)/2 = 82	(34+31)/2 = 32.5	(37+46)/2 = 41.5

陣列賦值後, 陣列長度為10^7

陣列長度為10^7	chrome 52.0.2743.116 (64-bit)	Firefox Developer Edition 49.0a2 (2016-08-01)	Safari 9.1.1 (11601.6.17)
for	(171+157)/2 = 164	(27+26)/2 = 26.5	(26+28)/2 = 27
do while	(168+158)/2 = 163	(27+27)/2 = 27	(28+29)/2 = 28.5
for in	(1469+1715)/2 = 1592	(2922+3123)/2 = 3022.5	(5755+5742)/2 = 5748.5
forEach	(347+329)/2 = 338	(32+36)/2 = 34	(171+174)/2 = 172.5
map	(1320+1335)/2 = 1327.5	(147+137)/2 = 142	(448+469)/2 = 458.5
every	(0+0)/2 = 0	(0+0)/2 = 0	(0+0)/2 = 0
$.each	(438+441)/2 = 439.5	(142+141)/2 = 141.5	(254+248)/2 = 251
$(e).each	(876+935)/2 = 905.5	(315+328)/2 = 321.5	(450+402)/2 = 426

可見, 對陣列進行賦值後, 程式碼執行基本穩定.(every還不清楚為什麼執行時間為0.歡迎大神告知原因.)

分析總結

通過以上 30 次執行測試(實際上為了得到比較穩定的資料, 擯棄了許多異常的測試資料), 我們發現在陣列長度為10^6, 10^7, 10^8 時, 程式碼執行基本穩定. 各方法執行需要的時間大致排序如下:

for ~= do while < forEach ~= map ~= every < $.each < $(e).each < for in

根據統計資料, 可得這8個方法的執行速度大致排序為:

for 與 do while
forEach map every (這3個不相上下,可認為執行速度差不多)
$.each
$(e).each
for in

我們翻看jquery程式碼就會知道, $.each方法內部通過呼叫for迴圈來實現, 而$().each是先用jquery包裹陣列物件, 然後再呼叫for迴圈, 因此後者效率略低於前者.

綜上, 最佳遍歷選手是 for/do while迴圈, 推薦大家優先考慮使用它. ( Firefox瀏覽器由於對forEach迴圈做了底層優化, 效率接近native,不在我們考慮範圍內 ).

基於測試結果的兩點思考

從測試資料上猜測, Firefox 與 Safari 似乎對於 for, do while 等都進行了底層優化. 迴圈執行效率明顯優於Chrome.
每次瀏覽器執行到 for in 迴圈處, 便會出現卡頓, 猜測瀏覽器可能正在預載入迴圈所需資源（後續我將專門分析此處）.

想要進一步優化迴圈效率, 推薦您閱讀下篇 《詳解JS作用域鏈及閉包》.

宣告: 本文所有資料均為單機測試, 難免存在誤差, 如果發現本文測試資料不對之處, 歡迎批評斧正.

本文就討論這麼多內容,大家有什麼問題或好的想法歡迎在下方參與留言和評論.

本文作者: louis

本文連結: louiszhai.github.io/2015/12/18/…

參考文章

陣列常見的遍歷迴圈方法、陣列的迴圈遍歷的效率對比
2019-02-17
陣列
JavaScript中的12種迴圈遍歷方法
2018-05-31
JavaScript
JS迴圈遍歷方法總結
2019-10-26
JS
pandas中的遍歷方式速度對比
2021-02-03
Map迴圈遍歷
2018-08-13
程式設計師，你真的會寫簡歷嗎？
2019-01-11
程式設計師
【JavaScript實用技巧（一）】迴圈遍歷與跳出迴圈遍歷
2021-10-26
JavaScript
js 跳出迴圈/結束遍歷的方法
2021-10-18
JS
遍歷 Dictionary，你會幾種方式？
2020-09-28
Golang for迴圈遍歷小坑
2023-05-11
Golang
Java中執行緒池，你真的會用嗎？
2018-10-31
Java執行緒
JavaScript遍歷方法總結與對比
2019-03-30
JavaScript
迴圈遍歷中幾個高頻使用的方法
2018-06-25
js陣列迴圈方法對比
2019-07-09
JS陣列
迴圈遍歷二叉樹
2018-11-05
二叉樹
python 元組,列表迴圈遍歷
2020-11-09
Python
遍歷物件鍵值對的兩種方法
2018-04-04
物件
python for迴圈遍歷位置的查詢
2021-09-11
Python
Go的迴圈遍歷使用小坑
2021-02-10
Go
JavaScript中迴圈遍歷JSON響應！
2021-05-24
JavaScriptJSON
提高App的啟動速度，你真的做對了嗎？
2021-09-09
APP
【轉】Promise迴圈序列執行寫法
2019-03-04
Promise
細思極恐-你真的會寫java嗎?
2019-01-02
Java
細思極恐 - 你真的會寫 Java 嗎?
2021-12-17
Java
使用Typora編寫Markdown你真的會了嗎
2021-05-31
二叉樹的遍歷 → 不用遞迴，還能遍歷嗎
2021-12-27
二叉樹遞迴
你真的懂 == 比較嗎
2018-05-23
pl/sql中三種遊標迴圈效率對比
2018-08-17
SQL
java8 對list集合中的物件遍歷,重新賦值兩種方法，遍歷某個屬性返回陣列
2020-01-11
Java物件賦值陣列
Python實現二叉樹的三種深度遍歷方法！
2021-04-29
Python二叉樹
JS筆記(2) JS中的迴圈遍歷
2019-04-15
JS筆記
vue中使用Checkbox 多選框迴圈遍歷
2024-05-09
Vue
2020-11-18 Vue-07迴圈遍歷
2020-12-20
Vue
你真的會寫單例模式嗎——Java實現
2019-02-21
單例模式Java
golang for range 遍歷對比 PHP、python
2020-06-02
GolangPHPPython
for 迴圈執行流程
2024-12-03
for in 迴圈遍歷物件時需要注意的事項
2018-04-12
物件
Python中使用 for 迴圈來拿遍歷 List 的值
2022-07-15
Python