අරාව පුනරාවර්තනය සඳහා “for… in” භාවිතා කිරීම නරක අදහසක් වන්නේ ඇයි?

for...inජාවාස්ක්‍රිප්ට් හි අරා සමඟ භාවිතා නොකරන ලෙස මට පවසා ඇත . ඇයි නැත්තේ?

හේතුව එක් ඉදිකිරීමක්:

var a = []; // Create a new empty array.
a[5] = 5;   // Perfectly legal JavaScript that resizes the array.

for (var i = 0; i < a.length; i++) {
    // Iterate over numeric indexes from 0 to 5, as everyone expects.
    console.log(a[i]);
}

/* Will display:
   undefined
   undefined
   undefined
   undefined
   undefined
   5
*/

සමහර විට අනෙකට වඩා සම්පූර්ණයෙන්ම වෙනස් විය හැකිය:

var a = [];
a[5] = 5;
for (var x in a) {
    // Shows only the explicitly set index of "5", and ignores 0-4
    console.log(x);
}

/* Will display:
   5
*/

එසේම, ඒ ගැන සලකා JavaScript ඔබට නිර්මාණය ඕනෑම මාලාවක් බලපානු ඇත අතර, පුස්තකාල මේ වගේ දේවල් කරන්න පුළුවන්:

// Somewhere deep in your JavaScript library...
Array.prototype.foo = 1;

// Now you have no idea what the below code will do.
var a = [1, 2, 3, 4, 5];
for (var x in a){
    // Now foo is a part of EVERY array and 
    // will show up here as a value of 'x'.
    console.log(x);
}

/* Will display:
   0
   1
   2
   3
   4
   foo
*/

මෙම for-inවිසින්ම ප්රකාශය "නරක පුරුදු" නොවේ, කෙසේ වෙතත් එය විය හැකි වැරදි අර්ථයක් ඇති වන භාවිතා , උදාහරණයක් ලෙස, කිරීමට අවංකව පෙලගැස්මක් හෝ අරා වැනි වස්තූන්.

for-inප්‍රකාශයේ පරමාර්ථය වන්නේ වස්තු ගුණාංග ගණනය කිරීමයි. මෙම ප්රකාශය, පතිරූපක දාම දැවී ගොස් ඇත ද වැඩි කරගැනීම් විස්තර උරුම දෙයක් බව ගුණ, සමහර විට එය අපේක්ෂා නොකරන .

එසේම, පුනරාවර්තනයේ අනුපිළිවෙල පිරිවිතරයෙන් සහතික නොවේ. එයින් අදහස් කරන්නේ ඔබට අරාව වස්තුවක් "නැවත" කිරීමට අවශ්‍ය නම්, මෙම ප්‍රකාශය සමඟ සංඛ්‍යා (අනුපිළිවෙල දර්ශක) සංඛ්‍යා අනුපිළිවෙලට පැමිණෙනු ඇති බවට ඔබට සහතික විය නොහැක.

උදාහරණයක් ලෙස, JScript (IE <= 8) හි, ගුණාංග නිර්මාණය කරන විට අරාව වස්තු මත පවා ගණන් කිරීමේ අනුපිළිවෙල අර්ථ දැක්වේ:

var array = [];
array[2] = 'c';
array[1] = 'b';
array[0] = 'a';

for (var p in array) {
  //... p will be "2", "1" and "0" on IE
}

එසේම, උරුම වූ දේපල ගැන කථා කිරීම, ඔබ, උදාහරණයක් ලෙස, Array.prototypeවස්තුව දිගු කළහොත් (MooTools වැනි සමහර පුස්තකාල මෙන්), එම ගුණාංග ද ගණන් ගනු ලැබේ:

Array.prototype.last = function () { return this[this.length-1]; };

for (var p in []) { // an empty array
  // last will be enumerated
}

මම පෙර කී ලෙස කැපීපෙනේ පෙලගැස්මක් හෝ අරා වැනි වස්තූන්, හොඳම දේ භාවිතා කිරීමට සිදු වේ අනුක්රමික පුඩුවක් එවැනි සරල වයස ලෙස, for/ whileපුඩුවක්.

ඔබට වස්තුවක ගුණාංග පමණක් උරුම කර ගැනීමට අවශ්‍ය වූ විට (උරුම නොවූ ඒවා), ඔබට මෙම hasOwnPropertyක්‍රමය භාවිතා කළ හැකිය :

for (var prop in obj) {
  if (obj.hasOwnProperty(prop)) {
    // prop is not inherited
  }
}

Object.prototypeකවුරුහරි hasOwnPropertyඅපේ වස්තුවට නම් කළ දේපලක් එකතු කළහොත් ගැටළු ඇතිවීම වළක්වා ගැනීම සඳහා සමහර අය කෙලින්ම මෙම ක්‍රමය ඇමතීමට නිර්දේශ කරති :

for (var prop in obj) {
  if (Object.prototype.hasOwnProperty.call(obj, prop)) {
    // prop is not inherited
  }
}

for..inඅරාවෙහි මූලද්‍රව්‍යයන් නැවත සැකසීමට ඔබ භාවිතා නොකිරීමට හේතු තුනක් තිබේ :

• for..inනැති අරාව වස්තුවෙහි සියලු සහ උරුම වූ ගුණාංග ඉක්මවා යයි DontEnum; එයින් අදහස් වන්නේ යමෙකු නිශ්චිත අරාව වස්තුවට ගුණාංග එකතු කළහොත් (මේ සඳහා වලංගු හේතු තිබේ - මම එසේ කර ඇත්තෙමි) හෝ වෙනස් කර ඇත Array.prototype(එය වෙනත් ස්ක්‍රිප්ට් සමඟ හොඳින් ක්‍රියා කළ යුතු කේතයේ නරක පුරුද්දක් ලෙස සලකනු ලැබේ), මෙම ගුණාංග නැවත නැවත කියන්න; පරික්ෂා කිරීමෙන් උරුම වූ ගුණාංග බැහැර කළ හැකි hasOwnProperty()නමුත්, අරාව වස්තුව තුළම සැකසූ ගුණාංග සඳහා එය ඔබට උදව් නොකරනු ඇත

• for..in මූලද්‍රව්‍ය අනුපිළිවෙල ආරක්ෂා කිරීමට සහතික නොවේ

• එය මන්දගාමී බැවින් ඔබට අරාව වස්තුවේ සියලු ගුණාංග සහ එහි සමස්ත මූලාකෘති දාමය ගමන් කළ යුතු අතර දේපලෙහි නම පමණක් ලැබෙනු ඇත, එනම් වටිනාකම ලබා ගැනීම සඳහා අතිරේක විමසුමක් අවශ්‍ය වේ

මක්නිසාද යත් ... අරාව රඳවාගෙන සිටින වස්තුව හරහා ගණනය කිරීමේදී මිස අරාවම නොවේ. මම අරා මූලාකෘති දාමයට ශ්‍රිතයක් එකතු කළහොත් එයද ඇතුළත් වේ. එනම්

Array.prototype.myOwnFunction = function() { alert(this); }
a = new Array();
a[0] = 'foo';
a[1] = 'bar';
for(x in a){
 document.write(x + ' = ' + a[x]);
}

මෙය ලියනු ඇත:

0 = foo
1 = තීරුව
myOwnFunction = ශ්‍රිතය () {අනතුරු ඇඟවීම (මෙය); }

මූලාකෘති දාමයට කිසිවක් එකතු නොවන බවට ඔබට කිසි විටෙකත් සහතික විය නොහැකි බැවින් අරාව ගණනය කිරීම සඳහා ලූපයක් භාවිතා කරන්න:

for(i=0,x=a.length;i<x;i++){
 document.write(i + ' = ' + a[i]);
}

මෙය ලියනු ඇත:

0 = foo
1 = තීරුව

හුදකලා කිරීමේදී, අරා සඳහා for-in භාවිතා කිරීමේ කිසිදු වරදක් නොමැත. වස්තුවක දේපල නාමයන් සඳහා නැවත නැවත යෙදෙන අතර, "පිටත සිට" අරාව සම්බන්ධයෙන්, ගුණාංග අරාව දර්ශක වලට අනුරූප වේ. (ගොඩනඟන ලද නිසි පරිදි length, toStringසහ යනාදිය පුනරාවර්තනයට ඇතුළත් නොවේ.)

කෙසේ වෙතත්, ඔබේ කේතය (හෝ ඔබ භාවිතා කරන රාමුව) අරා වලට හෝ අරාව මූලාකෘතියට අභිරුචි ගුණාංග එකතු කරන්නේ නම්, මෙම ගුණාංග නැවත සැකසීමට ඇතුළත් වනු ඇත, එය බොහෝ විට ඔබට අවශ්‍ය දේ නොවේ.

මූලාකෘති වැනි සමහර JS රාමු අරාව මූලාකෘතිය වෙනස් කරයි. JQuery වැනි වෙනත් රාමු එසේ නොවේ, එබැවින් JQuery සමඟ ඔබට ආරක්ෂිතව භාවිතා කළ හැකිය.

ඔබට සැකයක් ඇත්නම්, ඔබ බොහෝ විට භාවිතා කිරීම නොකළ යුතුය.

අරාව හරහා නැවත යෙදීම සඳහා විකල්ප ක්‍රමයක් වන්නේ for-loop එකක් භාවිතා කිරීමයි:

for (var ix=0;ix<arr.length;ix++) alert(ix);

කෙසේ වෙතත්, මෙය වෙනස් ගැටළුවක් ඇත. ගැටළුව වන්නේ ජාවාස්ක්‍රිප්ට් අරාවකට "සිදුරු" තිබිය හැකිය. ඔබ මෙසේ අර්ථ දක්වන්නේ arrනම්:

var arr = ["hello"];
arr[100] = "goodbye";

එවිට අරාවෙහි අයිතම දෙකක් ඇත, නමුත් දිග 101 කි. For-in භාවිතා කිරීමෙන් දර්ශක දෙකක් ලැබෙනු ඇති අතර, for-loop මඟින් දර්ශක 101 ක් ලබා දෙනු ඇත, එහිදී 99 හි අගය ඇත undefined.

for…ofජෝන් ස්ලෙගර්ස් දැනටමත් දැක ඇති පරිදි, 2016 (ES6) වන විට අපි අරාව පුනරාවර්තනය සඳහා භාවිතා කළ හැකිය .

දේවල් පැහැදිලි කිරීම සඳහා මෙම සරල නිරූපණ කේතය එක් කිරීමට මම කැමතියි:

Array.prototype.foo = 1;
var arr = [];
arr[5] = "xyz";

console.log("for...of:");
var count = 0;
for (var item of arr) {
    console.log(count + ":", item);
    count++;
    }

console.log("for...in:");
count = 0;
for (var item in arr) {
    console.log(count + ":", item);
    count++;
    }

කොන්සෝලය පෙන්වන්නේ:

for...of:

0: undefined
1: undefined
2: undefined
3: undefined
4: undefined
5: xyz

for...in:

0: 5
1: foo

වෙනත් විදිහකින්:

• for...of0 සිට 5 දක්වා ගණන් කරන අතර නොසලකා හරියි Array.prototype.foo. එය අරාව අගයන් පෙන්වයි .

• for...inලැයිස්තුගත කරන්නේ 5, නිර්වචනය නොකළ අරාව දර්ශක නොසලකා හැරීම, නමුත් එකතු කිරීම පමණි foo. එය අරාව දේපල නම් පෙන්වයි .

කෙටි පිළිතුර: එය වටින්නේ නැත.

දීර් answer පිළිතුර: අනුක්‍රමික මූලද්‍රව්‍ය අනුපිළිවෙල සහ ප්‍රශස්ත ක්‍රියාකාරිත්වය අවශ්‍ය නොවුවද එය වටින්නේ නැත.

දිගු පිළිතුර: එය වටින්නේ නැත ...

• භාවිතා කිරීම වස්තුවක් ලෙස නැවත සැකසීමට for (var property in array)හේතු වන අතර, වස්තු මූලාකෘති දාමය හරහා ගමන් කර අවසානයේ දර්ශක පාදක ලූපයකට වඩා මන්දගාමීව ක්‍රියා කරයි.arrayfor
• for (... in ...) යමෙකු අපේක්ෂා කළ පරිදි, වස්තු ගුණාංග අනුක්‍රමික අනුපිළිවෙලට ආපසු ලබා දීමට සහතික නොවේ.
• වස්තු ගුණාංග පෙරීම සඳහා භාවිතා කිරීම hasOwnProperty()සහ !isNaN()පරීක්ෂා කිරීම අතිරේක පොදු කාර්යයක් වන අතර එය ඊටත් වඩා මන්දගාමී වීමට හේතු වන අතර එය මුලින් භාවිතා කිරීමට ප්‍රධාන හේතුව ප්‍රතික්ෂේප කරයි, එනම් වඩාත් සංක්ෂිප්ත ආකෘතිය නිසා.

මෙම හේතු නිසා කාර්ය සාධනය සහ පහසුව අතර පිළිගත හැකි වෙළඳාමක් පවා නොපවතී. අරාව වස්තුවක් ලෙස හැසිරවීම සහ අරාවෙහි වස්තු ගුණාංග මත මෙහෙයුම් සිදු කිරීම හැරෙන්නට කිසිදු ප්‍රතිලාභයක් නොමැත .

වෙනත් පිළිතුරු වල දක්වා ඇති හේතු වලට අමතරව, ඔබට කවුන්ටරයේ විචල්‍යය සමඟ ගණිතය කිරීමට අවශ්‍ය නම් "සඳහා ... in" ව්‍යුහය භාවිතා කිරීමට ඔබට අවශ්‍ය නොවනු ඇත, මන්දයත් ලූපය වස්තුවේ ගුණාංගවල නම් හරහා පුනරාවර්තනය වන අතර විචල්‍යය නූලකි.

උදාහරණයක් වශයෙන්,

for (var i=0; i<a.length; i++) {
    document.write(i + ', ' + typeof i + ', ' + i+1);
}

ලියනු ඇත

0, number, 1
1, number, 2
...

ෙකෙසේෙවතත්,

for (var ii in a) {
    document.write(i + ', ' + typeof i + ', ' + i+1);
}

ලියනු ඇත

0, string, 01
1, string, 11
...

ඇත්ත වශයෙන්ම, ඇතුළත් කිරීමෙන් මෙය පහසුවෙන් ජය ගත හැකිය

ii = parseInt(ii);

ලූපය තුළ, නමුත් පළමු ව්‍යුහය වඩාත් .ජු ය.

කාරණය හැරුණු විට for... inසියලු ගණන් කළ නොහැකි ගුණාංග (එය "සියලු අරාව මූලද්‍රව්‍යයන්" ට සමාන නොවේ !), Http://www.ecma-international.org/publications/files/ECMA-ST/Ecma බලන්න -262.pdf , 12.6.4 (5 වන සංස්කරණය) හෝ 13.7.5.15 (7 වන සංස්කරණය):

ගුණාංග ගණනය කිරීමේ යාන්ත්‍ර විද්‍යාව හා අනුපිළිවෙල ... නිශ්චිතව දක්වා නැත ...

(මගේ අවධාරණය අවධාරණය කරන්න.)

එයින් අදහස් වන්නේ බ්‍රව්සරයකට අවශ්‍ය නම්, ඒවා ඇතුළත් කළ අනුපිළිවෙලෙහි ඇති ගුණාංග හරහා යා හැකි බවයි. නැතහොත් සංඛ්‍යාත්මක අනුපිළිවෙලින්. හෝ ශබ්දකෝෂ අනුපිළිවෙලින් ("30" "4" ට පෙර පැමිණෙන තැන! සියලු වස්තු යතුරු මතක තබා ගන්න - මේ අනුව, සියලු අරාව දර්ශක - ඇත්ත වශයෙන්ම නූල් වන අතර එමඟින් සම්පූර්ණ අර්ථය ලැබේ). එය වස්තූන් හැෂ් වගු ලෙස ක්‍රියාත්මක කරන්නේ නම් එය බාල්දියකින් ඒවා හරහා යා හැකිය. නැතහොත් එයින් කිසිවක් ගෙන "පසුපසට" එකතු කරන්න. බ්‍රව්සරයකට අහඹු ලෙස නැවත ක්‍රියා කළ හැකි අතර ECMA-262 අනුකූල විය හැකිය, එය එක් එක් දේපල හරියටම එක් වරක් බැලූ තාක් කල්.

ප්‍රායෝගිකව, බොහෝ බ්‍රව්සර් දැනට දළ වශයෙන් එකම අනුපිළිවෙලට නැවත යෙදීමට කැමතියි. නමුත් ඔවුන්ට කියන්න දෙයක් නැහැ. එය ක්‍රියාත්මක කිරීම විශේෂිත වන අතර වෙනත් ක්‍රමයක් වඩා කාර්යක්ෂම බව සොයාගතහොත් ඕනෑම වේලාවක වෙනස් විය හැකිය.

කෙසේ හෝ වේවා, for... ඒ inසමඟ අනුපිළිවෙලක් නැත. ඔබ ඇණවුම ගැන සැලකිලිමත් වන්නේ නම්, ඒ පිළිබඳව පැහැදිළි වන්න සහ forදර්ශකයක් සමඟ සාමාන්‍ය ලූපයක් භාවිතා කරන්න .

ප්රධාන වශයෙන් හේතු දෙකක්:

එක

අනෙක් අය පවසා ඇති පරිදි, ඔබේ අරාවෙහි නොමැති හෝ මූලාකෘතියෙන් උරුම වූ යතුරු ඔබට ලැබෙනු ඇත. එබැවින්, පුස්තකාලයක් අරාව හෝ වස්තු මූලාකෘති වලට දේපලක් එකතු කරන්නේ නම්:

Array.prototype.someProperty = true

සෑම අරාවකම කොටසක් ලෙස ඔබට එය ලැබෙනු ඇත:

for(var item in [1,2,3]){
  console.log(item) // will log 1,2,3 but also "someProperty"
}

ඔබට මෙය hasOwnProperty ක්‍රමය සමඟ විසඳා ගත හැකිය:

var ary = [1,2,3];
for(var item in ary){
   if(ary.hasOwnProperty(item)){
      console.log(item) // will log only 1,2,3
   }
}

නමුත් ඕනෑම වස්තුවක් සඳහා ලූපයක් සමඟ නැවත යෙදීම සඳහා මෙය සත්‍ය වේ.

දෙක

සාමාන්‍යයෙන් අරාවෙහි ඇති අයිතමවල අනුපිළිවෙල වැදගත් වේ, නමුත් for-in loop අනිවාර්යයෙන්ම නිවැරදි අනුපිළිවෙලට පුනරාවර්තනය නොවනු ඇත, එයට හේතුව එය අරාව වස්තුවක් ලෙස සලකන නිසාය, එය JS හි ක්‍රියාත්මක වන ආකාරය මිස නොවේ අරාව ලෙස. මෙය කුඩා දෙයක් සේ පෙනේ, නමුත් එය සැබවින්ම යෙදුම් ඉස්කුරුප්පු කළ හැකි අතර එය නිදොස් කිරීමට අපහසුය.

මන්ද එය ගණනය කරනු ලබන්නේ දර්ශක නොව වස්තු ක්ෂේත්‍ර හරහා ය. ඔබට "දිග" දර්ශකය සමඟ අගය ලබා ගත හැකි අතර ඔබට මෙය අවශ්‍ය යැයි මම සැක කරමි.

උදා: මට එකතු කිරීමට බොහෝ දේ ඇතැයි මම නොසිතමි. සමහර අවස්ථාවල භාවිතා කිරීම වළක්වා ගත යුත්තේ ඇයිද යන්න පිළිබඳ ට්‍රිප්ටිච්ගේ පිළිතුර හෝ සීඑම්එස් පිළිතුරfor...in .

කෙසේ වෙතත්, නවීන බ්‍රව්සර්වලfor...in භාවිතා for...inකළ නොහැකි අවස්ථාවන්හිදී ඒ සඳහා විකල්පයක් ඇති බව මම එකතු කිරීමට කැමැත්තෙමි . එම විකල්පය නම් for...of:

for (var item of items) {
    console.log(item);
}

සටහන :

අවාසනාවකට මෙන්, ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් හි කිසිදු සංස්කරණයක් සහාය නොදක්වයි for...of( එජ් 12+ එසේ නොකරයි), එබැවින් ඔබට එය ඔබේ සේවාදායක පාර්ශව නිෂ්පාදන කේතයේ භාවිතා කිරීමට හැකි වන තෙක් මඳ වේලාවක් බලා සිටීමට සිදු වේ. කෙසේ වෙතත්, ඔබගේ සේවාදායක පැත්තේ JS කේතය භාවිතා කිරීම ආරක්ෂිත විය යුතුය (ඔබ Node.js භාවිතා කරන්නේ නම් ).

ගැටලුව for ... in ...- සහ මෙය ගැටළුවක් බවට පත්වන්නේ ක්‍රමලේඛකයෙකුට භාෂාව සැබවින්ම නොතේරෙන විට පමණි; එය සැබවින්ම දෝෂයක් හෝ කිසිවක් නොවේ - එය වස්තුවක සියලුම සාමාජිකයින්ට වඩා ඉහළින් ක්‍රියා කරයි (හොඳයි, සියලු ගණන් කළ හැකි සාමාජිකයන්, නමුත් එය දැනට විස්තරයකි). ඔබ කෙරෙහි වඩාත් කැපීපෙනේ යාමට අවශ්ය වූ විට පමණක් මාලාවක් වන සුචිගත ගුණ, ශබ්දාර්ථයෙන් ස්ථාවර දේවල් තබා ගැනීමට පමණක් සහතික ක්රමය යනු පූර්ණ සංඛ්යාවකි දර්ශකය භාවිතා කිරීමට (එනම්, යනු for (var i = 0; i < array.length; ++i)ශෛලිය පුඩුවක්).

ඕනෑම වස්තුවකට ඒ හා සම්බන්ධ අත්තනෝමතික ගුණාංග තිබිය හැකිය. අතිරේක ගුණාංග අරා උදාහරණයකට පැටවීම ගැන භයානක දෙයක් නැත. සුචිගත කරන ලද අරාව වැනි ගුණාංග පමණක් දැකීමට අවශ්‍ය කේතය පූර්ණ සංඛ්‍යා දර්ශකයකට ඇලී සිටිය යුතුය . සියලු දේ දැකීමට අවශ්‍ය දේ for ... inසහ සැබවින්ම අවශ්‍ය වන කේතය , එයද හරි.

එසේම, අර්ථ නිරූපණය හේතුවෙන්, for, inඅරා සලකන ආකාරය (එනම් වෙනත් ජාවාස්ක්‍රිප්ට් වස්තුවකට සමාන) වෙනත් ජනප්‍රිය භාෂාවන් සමඟ නොගැලපේ.

// C#
char[] a = new char[] {'A', 'B', 'C'};
foreach (char x in a) System.Console.Write(x); //Output: "ABC"

// Java
char[] a = {'A', 'B', 'C'};
for (char x : a) System.out.print(x);          //Output: "ABC"

// PHP
$a = array('A', 'B', 'C');
foreach ($a as $x) echo $x;                    //Output: "ABC"

// JavaScript
var a = ['A', 'B', 'C'];
for (var x in a) document.write(x);            //Output: "012"

ටීඑල් ඇන්ඩ් ඩීආර්:for in අරා වල ලූප භාවිතා කිරීම නපුරක් නොවේ, ඇත්ත වශයෙන්ම ඊට හාත්පසින්ම වෙනස් ය.

අරා වල නිවැරදිවfor in භාවිතා කරන්නේ නම් ලූපය JS හි මැණික් වර්ගයක් යැයි මම සිතමි . ඔබේ මෘදුකාංගය පිළිබඳ පූර්ණ පාලනයක් ඔබ අපේක්ෂා කරන අතර ඔබ කරන්නේ කුමක්දැයි දැන ගනු ඇත. අපි සඳහන් කළ අඩුපාඩු දෙස බලා ඒවා එකින් එක ප්‍රතික්ෂේප කරමු.

1. එය උරුම වූ දේපල හරහා ද ලූප වේ: පළමුවෙන්ම කළ යුතු ඕනෑම දිගුවක් Array.prototypeභාවිතා කිරීමෙන් සිදු කළ යුතු Object.defineProperty()අතර ඒවායේ enumerableවිස්තරය සැකසිය යුතුය false. එසේ නොකරන ඕනෑම පුස්තකාලයක් කිසිසේත් භාවිතා නොකළ යුතුය.
2. උරුම දාමයට ඔබ එකතු කරන ගුණාංග පසුව ගණන් ගනු ලැබේ: පන්තියෙන් Object.setPrototypeOfහෝ අනුව අරා උප වර්ගීකරණය කරන විට extend. නැවත භාවිත කළ යුතුය Object.defineProperty()පෙරනිමි කට්ටල විසින් කරන writable, enumerableසහ configurableදේපළ විස්තරයන් කිරීමට false. අරාව උප වර්ගීකරණ උදාහරණයක් මෙහි බලමු ...

function Stack(...a){
  var stack = new Array(...a);
  Object.setPrototypeOf(stack, Stack.prototype);
  return stack;
}
Stack.prototype = Object.create(Array.prototype);                                 // now stack has full access to array methods.
Object.defineProperty(Stack.prototype,"constructor",{value:Stack});               // now Stack is a proper constructor
Object.defineProperty(Stack.prototype,"peak",{value: function(){                  // add Stack "only" methods to the Stack.prototype.
                                                       return this[this.length-1];
                                                     }
                                             });
var s = new Stack(1,2,3,4,1);
console.log(s.peak());
s[s.length] = 7;
console.log("length:",s.length);
s.push(42);
console.log(JSON.stringify(s));
console.log("length:",s.length);

for(var i in s) console.log(s[i]);

ඉතින් ඔබට පෙනේ .. for inඔබ ඔබේ කේතය ගැන සැලකිලිමත් වූ බැවින් දැන් ලූපය ආරක්ෂිතයි.

3. මෙම for inලූපය මන්දගාමී වේ: නිරය නැත. වරින් වර අවශ්‍ය වන විරල අරා හරහා ඔබ ලූපයක් ඇත්නම් එය වේගවත්ම පුනරාවර්තන ක්‍රමය වේ. මෙය යමෙකු දැනගත යුතු වැදගත්ම කාර්ය සාධන උපක්‍රමයකි. උදාහරණයක් බලමු. අපි විරල අරාවකට උඩින් ලූප් කරන්නෙමු.

var a = [];
a[0] = "zero";
a[10000000] = "ten million";
console.time("for loop on array a:");
for(var i=0; i < a.length; i++) a[i] && console.log(a[i]);
console.timeEnd("for loop on array a:");
console.time("for in loop on array a:");
for(var i in a) a[i] && console.log(a[i]);
console.timeEnd("for in loop on array a:");

අනෙක් ගැටළු වලට අමතරව, "for..in" සින්ටැක්ස් බොහෝ විට මන්දගාමී වේ, මන්ද දර්ශකය යනු නූලක් මිස පූර්ණ සංඛ්‍යාවක් නොවේ.

var a = ["a"]
for (var i in a)
    alert(typeof i)  // 'string'
for (var i = 0; i < a.length; i++)
    alert(typeof i)  // 'number'

වැදගත් අංගයක් බව ය for...inගුණ වැඩි පමණක් දයානන්ද් ඔවුන්ගේ ඇති වස්තුවක් අඩංගු ගණ්ය දේපල විශේෂණය සැබෑ කිරීමට හැකි. එබැවින් යමෙකු යම් වස්තුවක් භාවිතා කර for...inනැවත උත්සාහ කිරීමට උත්සාහ කරන්නේ නම්, ඒවායේ ගණන් කළ නොහැකි දේපල ගුණාංගය අසත්‍ය නම් අත්තනෝමතික ගුණාංග මඟ හැරෙනු ඇත. සාමාන්‍ය අරා වස්තූන් සඳහා ගණන් කළ නොහැකි දේපල ගුණාංග වෙනස් කිරීමට හැකි වන අතර එමඟින් ඇතැම් මූලද්‍රව්‍ය ගණනය නොකෙරේ. පොදුවේ ගත් කල, දේපල ගුණාංග වස්තුවක් තුළ ඇති ක්‍රියාකාරී ගුණාංග සඳහා අදාළ වේ.

දේපලවල ගණන් කළ නොහැකි දේපල ගුණාංගයක වටිනාකම යමෙකුට පරීක්ෂා කළ හැකිය:

myobject.propertyIsEnumerable('myproperty')

නැතහොත් දේපල ගුණාංග හතරම ලබා ගැනීම සඳහා:

Object.getOwnPropertyDescriptor(myobject,'myproperty')

මෙය ECMAScript 5 හි ඇති අංගයකි - පෙර සංස්කරණ වලදී ගණන් කළ නොහැකි දේපල ගුණාංගයේ වටිනාකම වෙනස් කිරීමට නොහැකි විය (එය සැමවිටම සත්‍ය ලෙස සකසා ඇත).

මෙම for/ inhashtables (associative පෙලගැස්මක්) සහ අරා (-associative නොවන): විචල්ය වර්ග දෙකක් සමග ක්රියා කරයි.

ජාවාස්ක්‍රිප්ට් ස්වයංක්‍රීයව අයිතම හරහා ගමන් කරන ආකාරය තීරණය කරයි. එබැවින් ඔබේ අරාව සැබවින්ම සහායක නොවන බව ඔබ දන්නේ නම් ඔබට භාවිතා කළ හැකි for (var i=0; i<=arrayLen; i++)අතර ස්වයංක්‍රීයව හඳුනාගැනීමේ ක්‍රියාවලිය මඟ හරින්න.

නමුත් මගේ මතය, එය භාවිතා කිරීම වඩා හොඳ for/ inඒ ස්වයංක්රීය-හඳුනාගැනීම සඳහා අවශ්ය ක්රියාදාමය ඉතා කුඩා වේ.

මේ සඳහා සත්‍ය පිළිතුරක් රඳා පවතින්නේ බ්‍රව්සරය ජාවාස්ක්‍රිප්ට් කේතය විග්‍රහ කරන ආකාරය / අර්ථ නිරූපණය කරන ආකාරය මත ය. එය බ්‍රව්සර් අතර වෙනස් විය හැකිය.

මම භාවිතා නොකරන වෙනත් අරමුණු සිතා ගත නොහැකි for/ in;

//Non-associative
var arr = ['a', 'b', 'c'];
for (var i in arr)
   alert(arr[i]);

//Associative
var arr = {
   item1 : 'a',
   item2 : 'b',
   item3 : 'c'
};

for (var i in arr)
   alert(arr[i]);

මන්ද ඔබ පරෙස්සම් නොවන්නේ නම් එය මූලාකෘති දාමය දක්වා ඇති වස්තූන්ට අයත් දේපල මත නැවත ක්‍රියා කරයි.

ඔබට භාවිතා කළ හැකිය for.. in, hasOwnProperty සමඟ එක් එක් දේපල පරීක්ෂා කිරීමට වග බලා ගන්න .

එය අනිවාර්යයෙන්ම නරක නැත (ඔබ කරන දේ මත පදනම්ව), නමුත් අරා සම්බන්ධයෙන්, යමක් එකතු කර ඇත්නම් Array.prototype, එවිට ඔබට අමුතු ප්‍රති .ල ලැබෙනු ඇත. මෙම ලූපය තුන් වරක් ක්‍රියාත්මක වේ යැයි ඔබ අපේක්ෂා කරන තැන:

var arr = ['a','b','c'];
for (var key in arr) { ... }

නමින් කාර්යය නම් helpfulUtilityMethodද එක් කර ඇත Arrayගේ prototype, එසේ නම් ඔබේ පුඩුවක් හතර වතාවක් පවත්වා අවසන් බව: keyවනු ඇත 0, 1, 2, සහ helpfulUtilityMethod. ඔබ අපේක්‍ෂා කළේ පූර්ණ සංඛ්‍යා පමණක් නම්, අපොයි.

ඔබ භාවිතා කළ for(var x in y)යුත්තේ දේපල ලැයිස්තු මත මිස වස්තූන් මත නොවේ (ඉහත විස්තර කර ඇති පරිදි).

for...inයමෙකු ඔබට එසේ කීවේ මන්දැයි මට අනුමාන කළ හැකි වුවද, අරාව සඳහා ලූපය භාවිතා කිරීම වැරදිය.

1.) දැනටමත් ඉහළ පෙළේ ශ්‍රිතයක් හෝ ක්‍රමයක් ඇත, එය අරාව සඳහා එම අරමුණ ඇත, නමුත් වැඩි ක්‍රියාකාරීත්වයක් සහ සිහින් සින්ටැක්ස් ඇත, එය 'forEach' ලෙස හැඳින්වේ: Array.prototype.forEach(function(element, index, array) {} );

2.) අරා සෑම විටම දිග ඇති, නමුත් for...inසහ forEachඇති ඕනෑම අගය සඳහා ක්රියාත්මක කරන්නේ නෑ 'undefined'අර්ථ අගය ඇති බව දර්ශක සඳහා පමණක්. එබැවින් ඔබ එක් අගයක් පමණක් පවරන්නේ නම්, මෙම ලූප මඟින් එක් වරක් පමණක් ශ්‍රිතයක් ක්‍රියාත්මක කරනු ඇත, නමුත් අරාව ගණනය කර ඇති බැවින්, එය සැමවිටම අර්ථ දක්වා ඇති ඉහළම දර්ශකය දක්වා දිගක් ඇත, නමුත් මේවා භාවිතා කරන විට එම දිග නොදැනේ. ලූප.

3.) ලූප් සඳහා වන ප්‍රමිතිය ඔබ පරාමිතීන් තුළ අර්ථ දක්වන වාර ගණනක් මෙන් ශ්‍රිතයක් ක්‍රියාත්මක කරනු ඇති අතර, අරාව අංකනය කර ඇති බැවින්, ඔබට ශ්‍රිතයක් ක්‍රියාත්මක කිරීමට අවශ්‍ය වාර ගණන නිර්වචනය කිරීම වඩාත් අර්ථවත් කරයි. අනෙක් ලූප මෙන් නොව, for for loop හට අගය අර්ථ දක්වා තිබුණත් නැතත් අරාවෙහි සෑම දර්ශකයක් සඳහාම ශ්‍රිතයක් ක්‍රියාත්මක කළ හැකිය.

සාරාංශයක් ලෙස, ඔබට ඕනෑම ලූපයක් භාවිතා කළ හැකිය, නමුත් ඒවා ක්‍රියා කරන ආකාරය ඔබ මතක තබා ගත යුතුය. විවිධ ලූපයන් පුනරුච්චාරණය කරන කොන්දේසි, ඒවායේ වෙනම ක්‍රියාකාරිත්වය සහ විවිධ අවස්ථා සඳහා ඒවා අඩු හෝ වැඩි වශයෙන් සුදුසු බව වටහා ගන්න.

එසේම, පොදුවේ ලූපයට forEachවඩා ක්‍රමවේදය භාවිතා කිරීම වඩා හොඳ භාවිතයක් ලෙස සැලකිය හැකිය for...in, මන්ද එය ලිවීමට පහසු වන අතර වැඩි ක්‍රියාකාරීත්වයක් ඇත, එබැවින් ඔබට මෙම ක්‍රමය සහ ප්‍රමිතිය පමණක් භාවිතා කිරීමේ පුරුද්ද ඇති කර ගැනීමට අවශ්‍ය විය හැකිය, නමුත් ඔබේ අමතන්න.

පළමු ලූප දෙක ක්‍රියාත්මක කරන්නේ එක් වරක් පමණක් console.log ප්‍රකාශයන් බව පහත බලන්න, ලූප් සඳහා වන ප්‍රමිතිය මඟින් ශ්‍රිතය නිශ්චිතව දක්වා ඇති වාර ගණනක් ක්‍රියාත්මක කරයි, මේ අවස්ථාවේ දී, array.length = 6.

var arr = [];
arr[5] = 'F';

for (var index in arr) {
console.log(index);
console.log(arr[index]);
console.log(arr)
}
// 5
// 'F'
// => (6) [undefined x 5, 6]

arr.forEach(function(element, index, arr) {
console.log(index);
console.log(element);
console.log(arr);
});
// 5
// 'F'
// => Array (6) [undefined x 5, 6]

for (var index = 0; index < arr.length; index++) {
console.log(index);
console.log(arr[index]);
console.log(arr);
};
// 0
// undefined
// => Array (6) [undefined x 5, 6]

// 1
// undefined
// => Array (6) [undefined x 5, 6]

// 2
// undefined
// => Array (6) [undefined x 5, 6]

// 3
// undefined
// => Array (6) [undefined x 5, 6]

// 4
// undefined
// => Array (6) [undefined x 5, 6]

// 5
// 'F'
// => Array (6) [undefined x 5, 6]

මෙය (සාමාන්‍යයෙන්) නරක පුරුද්දක් වීමට හේතු මෙන්න:

1. for...inවළළු සියලු තමන්ගේ ගණ්ය ගුණ වැඩි වඩාත් කැපීපෙනේ හා ඔවුන්ගේ මූලාකෘතියක් (වල) ගණ්ය ගුණ. සාමාන්‍යයෙන් අරාව පුනරාවර්තනයක දී අපට අවශ්‍ය වන්නේ අරාව හරහා නැවත යෙදීම පමණි. ඔබ විසින්ම අරාව වෙත කිසිවක් එකතු නොකළද, ඔබේ පුස්තකාල හෝ රාමුව විසින් යමක් එකතු කළ හැකිය.

උදාහරණය :

Array.prototype.hithere = 'hithere';

var array = [1, 2, 3];
for (let el in array){
    // the hithere property will also be iterated over
    console.log(el);
}

2. for...inලූප නිශ්චිත පුනරාවර්තන අනුපිළිවෙලක් සහතික නොකරයි . මේ දිනවල බොහෝ නවීන බ්‍රව්සර්වල ඇණවුම සාමාන්‍යයෙන් දක්නට ලැබුණද, තවමත් 100% සහතිකයක් නොමැත.
3. for...inලූප මඟින් undefinedඅරාව මූලද්‍රව්‍ය නොසලකා හරිනු ලැබේ, එනම් තවමත් පවරා නොමැති අරාව මූලද්‍රව්‍ය.

උදාහරණය: :

const arr = []; 
arr[3] = 'foo';   // resize the array to 4
arr[4] = undefined; // add another element with value undefined to it

// iterate over the array, a for loop does show the undefined elements
for (let i = 0; i < arr.length; i++) {
    console.log(arr[i]);
}

console.log('\n');

// for in does ignore the undefined elements
for (let el in arr) {
    console.log(arr[el]);
}

ජාවාස්ක්‍රිප්ට් හි වස්තුවක් මත වැඩ කිරීමේදී ... in ප්‍රයෝජනවත් වේ, නමුත් අරාව සඳහා නොවේ, නමුත් තවමත් අපට එය වැරදි ක්‍රමයක් යැයි පැවසිය නොහැක, නමුත් එය නිර්දේශ කර නැත, පහත දැක්වෙන උදාහරණය බලන්න ... ලූප් සඳහා:

let txt = "";
const person = {fname:"Alireza", lname:"Dezfoolian", age:35}; 
for (const x in person) {
    txt += person[x] + " ";
}
console.log(txt); //Alireza Dezfoolian 35 

හරි, අපි දැන් අරේ සමඟ එය කරමු :

let txt = "";
const person = ["Alireza", "Dezfoolian", 35]; 
for (const x in person) {
   txt += person[x] + " ";
}
console.log(txt); //Alireza Dezfoolian 35 

ප්‍රති result ලය ඔබ දකින ආකාරයටම ...

ඒත් අපි උත්සාහ දෙයක්, එහෙනම් අපි මූලාකෘති දෙයක් කිරීමට ඉඩ Array ...

Array.prototype.someoneelse = "someoneelse";

දැන් අපි නව අරා () නිර්මාණය කරමු;

let txt = "";
const arr = new Array();
arr[0] = 'Alireza';
arr[1] = 'Dezfoolian';
arr[2] = 35;
for(x in arr) {
 txt += arr[x] + " ";
}
console.log(txt); //Alireza Dezfoolian 35 someoneelse

ඔබට යමෙක් පෙනේ !!! ... අපි ඇත්ත වශයෙන්ම මේ අවස්ථාවේ දී නව අරා වස්තුව හරහා ලූප ගසමු !

ඒ නිසා අපි භාවිතා කිරීමට අවශ්ය හේතු ගේ එක් බව for..in ප්රවේශමෙන්, නමුත් එය සැම විටම එය එසේ නොවේ ය ...

A for ... loop සෑම විටම යතුරු ගණනය කරයි. වස්තු ගුණාංග යතුරු සැමවිටම නූල් වේ, අරාවෙහි සුචිගත කළ ගුණාංග පවා:

var myArray = ['a', 'b', 'c', 'd'];
var total = 0
for (elem in myArray) {
  total += elem
}
console.log(total); // 00123

ජාවාස්ක්‍රිප්ට් මූලද්‍රව්‍ය සම්මත වස්තු ගුණාංග ලෙස සුරකින බැවින්, සාමාන්‍ය මූලද්‍රව්‍ය සහ සියලු ගණන් කළ හැකි ගුණාංග ලැයිස්තුගත වන හෙයින්, ලූප සඳහා ... ජාවාස්ක්‍රිප්ට් අරා හරහා ... ලූප සඳහා නැවත යෙදීම සුදුසු නොවේ.

Https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Indexed_collections වෙතින්

මෙම ප්‍රශ්නයෙන් නිශ්චිතවම ආමන්ත්‍රණය නොකළද, කිසි විටෙකත් භාවිතා නොකිරීමට ඉතා හොඳ හේතුවක් ඇති බව මම එකතු කරමි ... NodeList( querySelectorAllඇමතුමකින් කෙනෙකු ලබා ගන්නා පරිදි , ආපසු එන මූලද්‍රව්‍යයන් කිසිසේත් නොපෙනෙන නිසා, ඒ වෙනුවට නැවත සැකසීම නෝඩ්ලිස්ට් ගුණාංග හරහා පමණි.

තනි ප්‍රති result ලයකදී, මට ලැබුණේ:

var nodes = document.querySelectorAll(selector);
nodes
▶ NodeList [a._19eb]
for (node in nodes) {console.log(node)};
VM505:1 0
VM505:1 length
VM505:1 item
VM505:1 entries
VM505:1 forEach
VM505:1 keys
VM505:1 values

එය මා for (node in nodes) node.href = newLink;අසමත් වීමට හේතුව පැහැදිලි කළේය.