ටීඑල්; ඩී.ආර්
එහෙත්, එහි ගේ ගොඩක් වැඩි කියවීමට, ගවේෂණය කිරීමට ...
ජාවාස්ක්‍රිප්ට්හි අරා සහ අරා වැනි වස්තූන් හරහා ලූප කිරීම සඳහා ප්‍රබල අර්ථකථන ඇත. මම පිළිතුර කොටස් දෙකකට බෙදා ඇත: අව්‍යාජ අරා සඳහා විකල්ප, සහ වස්තුව, වෙනත් නැවත සැකසිය හැකි වස්තු (ES2015 +), DOM එකතු කිරීම් සහ යනාදිය වැනි අරාව වැනි දේ සඳහා විකල්ප arguments.
මම ඉක්මනින් ඔබ විකල්ප ES2015 භාවිතා කළ හැකි බව කරුණාවෙන් කරන්නම් දැන් පවා ES5 යන්ත්ර තුල, විසින් transpiling ES5 කිරීමට ES2015. වැඩි විස්තර සඳහා "ES2015 සම්ප්‍රේෂණය" / "ES6 සම්ප්‍රේෂණය" සඳහා සොයන්න ...
හරි, අපි අපගේ විකල්ප දෙස බලමු:
තථ්‍ය අරා සඳහා
ඔබට ECMAScript 5 ("ES5") හි විකල්ප තුනක් ඇත, මේ මොහොතේ වඩාත්ම පුළුල් ලෙස සහාය දක්වන අනුවාදය, සහ ECMAScript 2015 ("ES2015", "ES6") හි තවත් දෙකක් එකතු කර ඇත :
- භාවිතය
forEachසහ අදාළ (ES5 +)
- සරල
forපුඩුවක් භාවිතා කරන්න
- නිවැරදිව භාවිතා කරන්න
for-in
- භාවිතා කරන්න
for-of(ව්‍යංගයෙන් iterator භාවිතා කරන්න ) (ES2015 +)
- පැහැදිලිවම iterator භාවිතා කරන්න (ES2015 +)
විස්තර:
1. භාවිතා කිරීම forEachහා අදාළ
ArrayES5 විසින් එකතු කරන ලද විශේෂාංග වෙත (සෘජුව හෝ පොලිෆිල්ස් භාවිතා කරමින්) ඔබට ප්‍රවේශය ඇති ඕනෑම නොපැහැදිලි-නවීන පරිසරයක (එබැවින්, IE8 නොවේ ), ඔබට භාවිතා කළ හැකිය forEach( spec| MDN):
var a = ["a", "b", "c"];
a.forEach(function(entry) {
console.log(entry);
});
forEachඇමතුම් ආපසු ගැනීමේ ශ්රිතයක් පිළිගන්නා අතර, විකල්පයක් ලෙස, thisඑම ඇමතුම ඇමතීමේදී භාවිතා කළ යුතු අගයක් (ඉහත භාවිතා නොකෙරේ). අරාවෙහි එක් එක් ප්‍රවේශය සඳහා ඇමතුම් ලබා ගැනීම කැඳවනු ලැබේ, පිළිවෙලින්, විරල අරා වල නොපවතින ඇතුළත් කිරීම් මඟ හැරීම. මම ඉහත එක් තර්කයක් පමණක් භාවිතා කළද, ඇමතුම තුනකින් හැඳින්වේ: එක් එක් ප්‍රවේශයේ වටිනාකම, එම ප්‍රවේශයේ දර්ශකය, සහ ඔබ නැවත නැවත අරාව වෙත යොමු කිරීම (ඔබේ ශ්‍රිතය දැනටමත් එය සතුව නොමැති නම් ).
ඔබ IE8 වැනි යල්පැනගිය බ්‍රව්සර් සඳහා සහය නොදක්වන්නේ නම් (2016 සැප්තැම්බර් මාසයේදී මෙම ලිවීමට අනුව NetApps 4% කට වඩා වෙළඳපල කොටසකින් පෙන්වයි), ඔබට කිසිදු සතුටක් forEachනොමැතිව පොදු අරමුණු සහිත වෙබ් පිටුවක සතුටින් භාවිතා කළ හැකිය . යල්පැනගිය බ්‍රව්සර් සඳහා ඔබට සහාය වීමට අවශ්ය නම්, දිලිසීම / බහු පිරවීම forEachපහසුවෙන් සිදු කරයි (විකල්ප කිහිපයක් සඳහා "es5 shim" සොයන්න).
forEach පුනරාවර්තන ශ්‍රිතයට තර්ක ලෙස ඒවා සපයා ඇති බැවින්, එම විෂය පථය තුළ සුචිගත කිරීම් සහ අගය විචල්‍යයන් ප්‍රකාශ කිරීමට ඔබට අවශ්ය නොවන වාසියක් ඇත.
එක් එක් අරාව ඇතුළත් කිරීම සඳහා ක්රියාකාරී ඇමතුමක් ලබා ගැනීමේ ධාවන කාලය ගැන ඔබ කනස්සල්ලට පත්ව සිටී නම්, එසේ නොවන්න; විස්තර .
මීට අමතරව, forEach“ඒවා සියල්ලම හරහා ලූපය” ශ්‍රිතය වේ, නමුත් ES5 තවත් ප්රයෝජනවත් “අරාව හරහා වැඩ කර දේවල් කරන්න” යන කාර්යයන් කිහිපයක් නිර්වචනය කර ඇත.
every(පළමු වරට falseඇමතුම ආපසු පැමිණීම හෝ වැරදි දෙයක් සිදුවීම නතර කිරීම)some( trueඇමතුම ආපසු පැමිණි විට හෝ සත්‍යවාදී යමක් පළමු වරට ලූප කිරීම නතර කරයි)filter(එහිදී පෙරහන ශ්රිතයේ කොටස් ද ඇතුලු නව මාලාවක් නිර්මාණය trueහා එය නැවත ඇති අය සැර බාල false)map (ඇමතුම් ලබා දීමෙන් ලැබෙන අගයන්ගෙන් නව අරාවක් නිර්මාණය කරයි)reduce (නැවත නැවත ඇමතුමක් ලබා දීමෙන්, පෙර අගයන් පසුකරමින් වටිනාකමක් ගොඩනංවයි; විස්තර සඳහා පිරිවිතර බලන්න; අරාවෙහි අන්තර්ගතය සාරාංශ කිරීමට සහ තවත් බොහෝ දේ ප්රයෝජනවත් වේ)reduceRight(වැනි reduce, නමුත් නැගී එන අනුපිළිවෙලට වඩා බැසයාමේ වැඩ කරයි)
2. සරල forලූපයක් භාවිතා කරන්න
සමහර විට පැරණි ක්රම හොඳම වේ:
var index;
var a = ["a", "b", "c"];
for (index = 0; index < a.length; ++index) {
console.log(a[index]);
}
අරාව දිග කම්බියක් තුළ වෙනස් නොහැකි නම්, එය කාර්ය සාධන සංවේදී කේතය (අසම්භාව්ය) හි, මෙය, ඉදිරිපස දක්වා දිග පැහැර ගැනීම තරමක් වැඩි සංකීර්ණ අනුවාදය එකක් වෙන්න පුළුවන් කුඩා ටිකක් වේගවත්:
var index, len;
var a = ["a", "b", "c"];
for (index = 0, len = a.length; index < len; ++index) {
console.log(a[index]);
}
සහ / හෝ පසුපසට ගණන් කිරීම:
var index;
var a = ["a", "b", "c"];
for (index = a.length - 1; index >= 0; --index) {
console.log(a[index]);
}
නමුත් නවීන ජාවාස්ක්‍රිප්ට් එන්ජින් සමඟ, ඔබ අවසන් වරට යුෂ පානය කිරීම කලාතුරකිනි.
ES2015 සහ ඊට ඉහළින්, ඔබට ඔබේ දර්ශකය සහ අගය විචල්‍යයන් ලූපයට දේශීය කළ හැකිය for:
let a = ["a", "b", "c"];
for (let index = 0; index < a.length; ++index) {
let value = a[index];
console.log(index, value);
}
//console.log(index); // would cause "ReferenceError: index is not defined"
//console.log(value); // would cause "ReferenceError: value is not defined"
let a = ["a", "b", "c"];
for (let index = 0; index < a.length; ++index) {
let value = a[index];
console.log(index, value);
}
try {
console.log(index);
} catch (e) {
console.error(e); // "ReferenceError: index is not defined"
}
try {
console.log(value);
} catch (e) {
console.error(e); // "ReferenceError: value is not defined"
}
ඔබ එය කරන විට, එක් එක් ලූප පුනරාවර්තනය සඳහා පමණක් valueනොව indexප්‍රතිනිර්මාණය කරනු ලැබේ, එයින් අදහස් වන්නේ ලූප් ශරීරය තුළ නිර්මාණය කරන ලද වසා දැමීම් එම නිශ්චිත ක්‍රියාවලිය සඳහා නිර්මාණය කරන ලද index(සහ value) වෙත යොමු වීමකි:
let divs = document.querySelectorAll("div");
for (let index = 0; index < divs.length; ++index) {
divs[index].addEventListener('click', e => {
console.log("Index is: " + index);
});
}
let divs = document.querySelectorAll("div");
for (let index = 0; index < divs.length; ++index) {
divs[index].addEventListener('click', e => {
console.log("Index is: " + index);
});
}
<div>zero</div>
<div>one</div>
<div>two</div>
<div>three</div>
<div>four</div>
ඔබට බෙදීම් පහක් තිබුනේ නම්, ඔබ පළමු ක්ලික් කළහොත් ඔබට "දර්ශකය: 0" සහ අන්තිම ක්ලික් කළහොත් "දර්ශකය: 4" ලැබෙනු ඇත. මෙම වන්නේ නැහැ ඔබ භාවිතා කරන්නේ නම් වැඩ varවෙනුවට let.
3. නිවැරදිව භාවිතා කරන්නfor-in
ඔබ භාවිතා කිරීමට ඔබට කියන්නේ කරන්නම් for-in, නමුත් ඒ ගැන නෙවෙයි for-inසඳහා . අරාවෙහි දර්ශක නොව වස්තුවක ගණන් කළ නොහැකි ගුණාංගfor-in හරහා ලූප . ඇණවුම ES2015 (ES6) තුළ පවා සහතික නොවේ. ES2015 + මඟින් දේපල වස්තු කිරීම සඳහා ඇණවුමක් අර්ථ දක්වයි (හරහා , සහ ඒවා භාවිතා කරන දේවල් ), නමුත් එය එම අනුපිළිවෙල අනුගමනය කරනු ඇතැයි අර්ථ දක්වා නැත ; ES2020 කළා. ( මෙම අනෙක් පිළිතුරේ විස්තර .)[[OwnPropertyKeys]][[Enumerate]]Object.getOwnPropertyKeysfor-in
for-inඅරාව සඳහා ඇති එකම සැබෑ භාවිත අවස්ථා :
- එය තියෙන්නේ විරල පෙලගැස්මක් සමග දැවැන්ත එය හිඩැස්, හෝ
- ඔබ මූලද්රව්ය නොවන ගුණාංග භාවිතා කරන අතර ඔබට ඒවා ලූපයට ඇතුළත් කිරීමට අවශ්‍යය
එම පළමු උදාහරණය දෙස පමණක් බලන්න: ඔබ for-inසුදුසු ආරක්ෂණ ක්රම භාවිතා කරන්නේ නම් එම විරල අරා අංග බැලීමට ඔබට භාවිතා කළ හැකිය :
// `a` is a sparse array
var key;
var a = [];
a[0] = "a";
a[10] = "b";
a[10000] = "c";
for (key in a) {
if (a.hasOwnProperty(key) && // These checks are
/^0$|^[1-9]\d*$/.test(key) && // explained
key <= 4294967294 // below
) {
console.log(a[key]);
}
}
චෙක්පත් තුන සැලකිල්ලට ගන්න:
වස්තුව එහි ඇති බව ම ඒ නම (එක් නොවන එහි මූලාකෘතිය සිට උරුම) විසින් දේපළ හා
යතුර සියලු දශම සංඛ්‍යා (උදා: සාමාන්ය නූල් ආකෘතිය, විද්‍යාත්මක අංකනය නොවේ), සහ
අංකයකට බල කරන විට යතුරේ අගය <= 2 ^ 32 - 2 (එය 4,294,967,294). එම අංකය පැමිණෙන්නේ කොහෙන්ද? එය පිරිවිතරයේ අරාව දර්ශකයේ අර්ථ දැක්වීමේ කොටසකි . වෙනත් සංඛ්‍යා (පූර්ණ සංඛ්‍යා නොවන, negative ණ සංඛ්‍යා, 2 ^ 32 - 2 ට වඩා වැඩි සංඛ්‍යා) අරාව දර්ශක නොවේ. එය 2 ^ 32 - 2 වීමට හේතුව, එමඟින් විශාලතම දර්ශක අගය 2 ^ 32 - 1 ට වඩා අඩු වීමයි, එය අරාවකට lengthතිබිය හැකි උපරිම අගය වේ . (උදා:, 32-bit නිලකුණු පූර්ණ සංඛ්යාමය දී මාලාවක් ගේ දිග පණ අදිමින් වුවත්.) (RobG කිරීමට මුක්කු අදහසක් දී පෙන්වා දෙමින් සඳහා මගේ බ්ලොග් මත මීට කලින් මගේ ටෙස්ට් හරි නැති බව.)
ඇත්ත වශයෙන්ම ඔබ එය පේළිගත කේතයෙන් නොකරනු ඇත. ඔබ උපයෝගිතා ශ්රිතයක් ලියනු ඇත. සමහර විට:
// Utility function for antiquated environments without `forEach`
var hasOwn = Object.prototype.hasOwnProperty;
var rexNum = /^0$|^[1-9]\d*$/;
function sparseEach(array, callback, thisArg) {
var index;
for (var key in array) {
index = +key;
if (hasOwn.call(a, key) &&
rexNum.test(key) &&
index <= 4294967294
) {
callback.call(thisArg, array[key], index, array);
}
}
}
var a = [];
a[5] = "five";
a[10] = "ten";
a[100000] = "one hundred thousand";
a.b = "bee";
sparseEach(a, function(value, index) {
console.log("Value at " + index + " is " + value);
});
4. භාවිතා කරන්න for-of(ව්‍යංගයෙන් අනුකාරකයක් භාවිතා කරන්න ) (ES2015 +)
ES2015 එකතු iterators JavaScript කිරීමට. ඉරේටර භාවිතා කිරීමට ඇති පහසුම ක්රමය නව for-ofප්‍රකාශයයි. එය මේ වගේ ය:
const a = ["a", "b", "c"];
for (const val of a) {
console.log(val);
}
ආවරණ යටතේ, එය අරාව වෙතින් අනුකාරකයක් ලබා ගෙන එය හරහා ලූප, එයින් අගයන් ලබා ගනී. මෙය භාවිතා කිරීමේ ගැටලුවක් නොමැත for-in, මන්ද එය වස්තුව (අරාව) මගින් නිර්වචනය කර ඇති අනුකාරකයක් භාවිතා කරන අතර අරා විසින් අර්ථ දක්වනුයේ ඒවායේ අනුකාරකයන් ඔවුන්ගේ ඇතුළත් කිරීම් හරහා (ඒවායේ ගුණාංග නොව) නැවත ක්රියාත්මක වන බවයි. for-inES5 හි මෙන් නොව , ඇතුළත් කිරීම් නැරඹූ අනුපිළිවෙල ඒවායේ දර්ශකවල සංඛ්‍යාත්මක අනුපිළිවෙලයි.
5. පැහැදිලිවම iterator භාවිතා කරන්න (ES2015 +)
සමහර විට, ඔබට පැහැදිලිවම iterator භාවිතා කිරීමට අවශ්ය විය හැකිය . ඔබටත් එය කළ හැකිය . එය මේ වගේ ය:for-of
const a = ["a", "b", "c"];
const it = a.values();
let entry;
while (!(entry = it.next()).done) {
console.log(entry.value);
}
Iterator යනු පිරිවිතරයේ අනුකාරක අර්ථ දැක්වීමට ගැලපෙන වස්තුවකි. එහි nextක්රමය ඔබ එය අමතන සෑම අවස්ථාවකම නව ප්‍රති result ල වස්තුවක් ලබා දෙයි. ප්‍රති object ල වස්තුවට දේපලක් ඇත, doneඑය සිදු වී ඇත්දැයි අපට කියයි, සහ එම ක්‍රියාවලිය valueසඳහා වටිනාකමක් ඇති දේපලක් ඇත. ( doneඑය වනු ඇත නම් විකල්ප වේ false, valueඑය වනු ඇත නම් විකල්ප වේ undefined.)
valueඅනුකාරකය අනුව අර්ථය වෙනස් වේ; අරා ආධාරක (අවම වශයෙන්) පුනරාවර්තන නැවත ලබා දෙන කාර්යයන් තුනක්:
values(): මම ඉහත භාවිතා කළ ක්රමය මෙයයි. එය එක් එක් අවස්ථාවකට iterator නැවත valueබව ප්රතිඵලයක්ම සඳහා අරාව ප්රවේශයකි ( "a", "b"සහ "c"මීට පෙර උදාහරණය තුල).keys(): එක් එක් අවස්ථාවකට iterator ආයෙත් valueබව ප්රතිඵලයක්ම සඳහා යතුර (එසේ අපගේ සඳහා aඉහත, ගත යුතු බවත් "0", එසේ නම් "1", එසේ නම් "2").entries(): එක් එක් එම අර්‍ථනය valueසඳහා ආකෘතියේ අරාව ඇති අනුකාරකයක් [key, value]ලබා දෙයි.
අරාව වැනි වස්තු සඳහා
සත්‍ය අරා හැරුණු විට, සංඛ්‍යාත්මක නම් සහිත දේපළක් හා ගුණාංග ඇති අරාව වැනි වස්තූන් ද ඇත length: NodeListනිදසුන්, argumentsවස්තුව යනාදිය. ඒවායේ අන්තර්ගතය හරහා අප ලූප කරන්නේ කෙසේද?
අරා සඳහා ඉහත ඕනෑම විකල්පයක් භාවිතා කරන්න
ඉහත දැක්වෙන අරාව ප්‍රවේශයන් අවම වශයෙන් සමහරක්, සහ බොහෝ විට හෝ සියල්ලම, නිරන්තරයෙන් අරාව වැනි වස්තූන් සඳහා සමානවම අදාළ වේ:
භාවිතය forEachසහ අදාළ (ES5 +)
මත ඇති විවිධ කාර්යයන් Array.prototype"හිතාමතාම ජනක" වන අතර සාමාන්යයෙන් අරාව වැනි වස්තූන් හරහා Function#callහෝ හරහා භාවිතා කළ හැකිය Function#apply. ( මෙම පිළිතුර අවසානයේ ධාරක විසින් සපයන ලද වස්තූන් සඳහා Caveat බලන්න , නමුත් එය දුර්ලභ කාරණයක් වේ.)
ඔබ භාවිතා කිරීමට අවශ්ය සිතන්න forEachමත Nodeගේ childNodesදේපළ. ඔබ මෙය කරනු ඇත:
Array.prototype.forEach.call(node.childNodes, function(child) {
// Do something with `child`
});
ඔබ එය බොහෝ දේ කිරීමට යන්නේ නම්, නැවත භාවිතා කිරීම සඳහා ශ්‍රිත යොමුවෙහි පිටපතක් විචල්‍යයකට ලබා ගැනීමට ඔබට අවශ්ය විය හැකිය, උදා:
// (This is all presumably in some scoping function)
var forEach = Array.prototype.forEach;
// Then later...
forEach.call(node.childNodes, function(child) {
// Do something with `child`
});
සරල forපුඩුවක් භාවිතා කරන්න
නිසැකවම, සරල forපුඩුවක් අරාව වැනි වස්තූන් සඳහා අදාළ වේ.
නිවැරදිව භාවිතා කරන්නfor-in
for-inඅරාව සමඟ ඇති එකම ආරක්ෂාව සමඟ අරාව වැනි වස්තූන් සමඟ ද ක්රියා කළ යුතුය; ඉහත # 1 හි ධාරක විසින් සපයන ලද වස්තු සඳහා වන අවවාදය අදාළ විය හැකිය.
භාවිතා කරන්න for-of(ව්‍යංගයෙන් iterator භාවිතා කරන්න ) (ES2015 +)
for-ofවස්තුව විසින් සපයන ලද iterator භාවිතා කරයි (ඇත්නම්). එයට සත්කාරක සපයන වස්තු ඇතුළත් වේ. උදාහරණයක් වශයෙන්, සඳහා පිරිවිතර NodeListසිට querySelectorAllප්රතිඵලයක්ම සහය දීමට යාවත් කරන ලදී. සඳහා පිරිවිතර HTMLCollectionසිට getElementsByTagNameනොවේ.
පැහැදිලිවම iterator භාවිතා කරන්න (ES2015 +)
# 4 බලන්න.
සත්‍ය අරාවක් සාදන්න
වෙනත් වේලාවක, ඔබට අරාව වැනි වස්තුවක් සත්‍ය අරාව බවට පරිවර්තනය කිරීමට අවශ්ය විය හැකිය. එය කිරීම පුදුම හිතෙන තරම් පහසු ය:
sliceඅරා ක්රමය භාවිතා කරන්න
අපට sliceඅරා ක්‍රමවේදය භාවිතා කළ හැකිය , ඉහත සඳහන් කළ වෙනත් ක්රම මෙන් “හිතාමතාම ජනක” වන අතර අරා වැනි වස්තූන් සමඟද භාවිතා කළ හැකිය:
var trueArray = Array.prototype.slice.call(arrayLikeObject);
උදාහරණයක් ලෙස, අපට NodeListසත්‍ය අරාව බවට පරිවර්තනය කිරීමට අවශ්ය නම් , අපට මෙය කළ හැකිය:
var divs = Array.prototype.slice.call(document.querySelectorAll("div"));
ධාරකයෙන් සපයන ලද වස්තු සඳහා Caveat බලන්න . විශේෂයෙන්, මෙය IE8 සහ ඊට පෙර අසමත් වන බව සලකන්න, එමඟින් සත්කාරක විසින් සපයන ලද වස්තු ඒ හා thisසමාන ලෙස භාවිතා කිරීමට ඔබට ඉඩ නොදේ .
පැතිරීමේ සින්ටැක්ස් භාවිතා කරන්න ( ...)
මෙම අංගයට සහය දක්වන ජාවාස්ක්‍රිප්ට් එන්ජින් සමඟ ES2015 හි පැතිරීමේ සින්ටැක්ස් භාවිතා කිරීමට ද හැකිය . හරියට for-of, මෙය වස්තුව විසින් සපයන ලද iterator භාවිතා කරයි (පෙර කොටසේ # 4 බලන්න):
var trueArray = [...iterableObject];
උදාහරණයක් ලෙස, අපට NodeListසත්‍ය අරා බවට පරිවර්තනය කිරීමට අවශ්ය නම් , පැතිරෙන සින්ටැක්ස් සමඟ මෙය තරමක් සංක්ෂිප්ත වේ:
var divs = [...document.querySelectorAll("div")];
භාවිත Array.from
Array.from (පිරිවිතර) | (MDN) (ES2015 +, නමුත් පහසුවෙන් පොලිෆිල්ඩ්) අරාව වැනි වස්තුවකින් අරාවක් නිර්මාණය කරයි. ඒ නිසා:
var divs = Array.from(document.querySelectorAll("div"));
හෝ ඔබට දී ඇති පන්තියක් සමඟ මූලද්‍රව්‍යයන්ගේ ටැග් නම් පෙළක් ලබා ගැනීමට අවශ්ය නම්, ඔබ සිතියම්කරණ ශ්‍රිතය භාවිතා කරයි:
// Arrow function (ES2015):
var divs = Array.from(document.querySelectorAll(".some-class"), element => element.tagName);
// Standard function (since `Array.from` can be shimmed):
var divs = Array.from(document.querySelectorAll(".some-class"), function(element) {
return element.tagName;
});
ධාරකයෙන් සපයන ලද වස්තු සඳහා කේවියට්
ඔබ ධාරක-සපයන අරා වැනි වස්තූන් (ජාවාස්ක්‍රිප්ට් එන්ජිමට වඩා බ්‍රව්සරය විසින් සපයන ලද DOM ලැයිස්තු සහ වෙනත් දේ) Array.prototypeසමඟ කාර්යයන් භාවිතා කරන්නේ නම් , ධාරක විසින් සපයන ලද වස්තුව නිසි ලෙස හැසිරෙන බවට වග බලා ගැනීම සඳහා ඔබේ ඉලක්ක පරිසරයන් තුළ පරීක්ෂා කිරීමට වග බලා ගත යුතුය. . බොහෝ දෙනෙක් නිසි ලෙස හැසිරෙති (දැන්), නමුත් පරීක්ෂා කිරීම වැදගත්ය. හේතුව, ඔබ භාවිතා කිරීමට කැමති බොහෝ ක්රම වියුක්ත මෙහෙයුමට අවංක පිළිතුරක් ලබා දෙමින් ධාරක විසින් සපයන ලද වස්තුව මත රඳා සිටීමයි . මෙම ලිවීමට අනුව, බ්‍රව්සර් මේ සඳහා ඉතා හොඳ කාර්යයක් ඉටු කරයි, නමුත් 5.1 පිරිවිතර මඟින් ධාරක විසින් සපයන ලද වස්තුවක් අවංක නොවිය හැකිය. එය section8.6.2 හි ඇත , එම කොටසේ ආරම්භයට ආසන්නයේ විශාල වගුවට පහළින් ඡේද කිහිපයක්), එහි මෙසේ සඳහන් වේ:Array.prototype[[HasProperty]]
වෙනත් ආකාරයකින් දක්වා නොමැති නම් ධාරක වස්තු මෙම අභ්‍යන්තර ක්රම ඕනෑම ආකාරයකින් ක්රියාත්මක කළ හැකිය; උදාහරණයක් ලෙස, එක් හැකියාව බව ය [[Get]]සහ [[Put]]ඇත්ත වශයෙන්ම දේපළ වටිනාකම ෙනොලැබී සිටින නමුත් යම් සත්කාරක වස්තුව සඳහා [[HasProperty]]සෑම විටම ජනනය බොරු .
පොදු සත්කාරක-ලබා අරා වැනි නවීන බ්රවුසරයන් වස්තු ලියන මේ වන විට, (මම ES2015 පිරිවිතර ඒ සමාන verbiage සොයා ගත හැකි, නමුත් එය තවමත් මෙම නඩුව විය. බැඳී ඇති) නැවතත් [ NodeListඋදාහරණයක් අවස්ථා,] කරන්න හසුරුව [[HasProperty]]නිවැරදිව, නමුත් පරීක්ෂා කිරීම වැදගත් වේ.)
forEachනිකම්ම නොවේfor. c # හි එය ටිකක් වෙනස් වූ අතර එය මා ව්‍යාකූල කළේය :)