ජාවා හි ඔබට forපහත දැක්වෙන පරිදි අරාවෙහි ඇති වස්තූන් ගමන් කිරීමට ලූපයක් භාවිතා කළ හැකිය :

String[] myStringArray = {"Hello", "World"};
for (String s : myStringArray)
{
    // Do something
}

ඔබට ජාවාස්ක්‍රිප්ට් තුළද එසේ කළ හැකිද?

ඔබට විකල්ප කිහිපයක් තිබේ:

1. අනුක්‍රමික forපුඩුවක්:

var myStringArray = ["Hello","World"];
var arrayLength = myStringArray.length;
for (var i = 0; i < arrayLength; i++) {
    console.log(myStringArray[i]);
    //Do something
}

වාසි

• සෑම පරිසරයකම ක්රියා කරයි
• ඔබට භාවිතා කළ හැකි breakහා continueපාලනය ප්රකාශ ගලා

අවාසි

• ඉතා වාචික
• අත්‍යවශ්‍යයි
• එකින් එක දෝෂ තිබීම පහසුය (සමහර විට එය වැට කණුවක් ලෙසද හැඳින්වේ )

2. Array.prototype.forEach

ES5 පිරිවිතරයන් ප්‍රයෝජනවත් අරා ක්‍රම රාශියක් හඳුන්වා දුන් අතර, ඉන් එකක් වන අතර, Array.prototype.forEachඑය අපට අරාව හරහා නැවත සැකසීමට සංක්ෂිප්ත ක්‍රමයක් ලබා දෙයි:

const array = ["one", "two", "three"]
array.forEach(function (item, index) {
  console.log(item, index);
});

ඊඑස් 5 පිරිවිතර නිකුත් කරන ලද වසර 2009 ට ආසන්න කාලයක් (2009 දෙසැම්බරයේ), එය ඩෙස්ක්ටොප්, සර්වර් සහ ජංගම පරිසරවල ඇති සියලුම නවීන එන්ජින් විසින් ක්‍රියාත්මක කර ඇති බැවින් ඒවා භාවිතා කිරීම ආරක්ෂිත වේ.

ඊඑස් 6 ඊතල ශ්‍රිත සින්ටැක්ස් සමඟ, එය ඊටත් වඩා සංක්ෂිප්ත ය:

array.forEach(item => console.log(item));

පුරාණ වේදිකාවලට (උදා: IE11) සහය දැක්වීමට ඔබ අදහස් නොකරන්නේ නම් ඊතල කාර්යයන් ද පුළුල් ලෙස ක්‍රියාත්මක වේ; ඔබත් යන්න ආරක්ෂිතයි.

වාසි

• ඉතා කෙටි හා සංක්ෂිප්ත ය.
• ප්‍රකාශන

අවාසි

• භාවිතා කළ නොහැක break/continue

සාමාන්‍යයෙන්, breakඅරා මූලද්‍රව්‍ය නැවත සැකසීමට පෙර පෙරීමෙන් ඔබට අත්‍යවශ්‍ය ලූපවලින් ඉවත් වීමේ අවශ්‍යතාවය ප්‍රතිස්ථාපනය කළ හැකිය , උදාහරණයක් ලෙස:

array.filter(item => item.condition < 10)
     .forEach(item => console.log(item))

මතක තබා ගන්න ඔබ එයින් අරා එකක් සාදන්නේ නම් එය භාවිතා කළ යුතුය, ඔබ භාවිතා කළ යුතුය map, මම මෙම ප්‍රති-රටාව බොහෝ වාරයක් දැක ඇත්තෙමි.

රටා විරෝධී:

const numbers = [1,2,3,4,5], doubled = [];

numbers.forEach((n, i) => { doubled[i] = n * 2 });

සිතියම නිසි ලෙස භාවිතා කිරීමේ අවස්ථාව :

const numbers = [1,2,3,4,5];
const doubled = numbers.map(n => n * 2);

console.log(doubled);

එසේම, ඔබ අරාව අගයකට අඩු කිරීමට උත්සාහ කරන්නේ නම් , උදාහරණයක් ලෙස, ඔබට සංඛ්‍යා සමූහයක් එකතු කිරීමට අවශ්‍ය නම්, ඔබ අඩු කිරීමේ ක්‍රමය භාවිතා කළ යුතුය .

රටා විරෝධී:

const numbers = [1,2,3,4,5];
const sum = 0;
numbers.forEach(num => { sum += num });

අඩු කිරීම නිසි ලෙස භාවිතා කිරීම :

const numbers = [1,2,3,4,5];
const sum = numbers.reduce((total, n) => total + n, 0);

console.log(sum);

3. ES6 for-ofප්‍රකාශය

ES6 ප්‍රමිතිය මඟින් නැවත ලබා ගත හැකි වස්තූන් පිළිබඳ සංකල්පය හඳුන්වා දෙන අතර දත්ත ගමන් කිරීම සඳහා නව ඉදිකිරීමක් නිර්වචනය කරයි for...of.

මෙම ප්‍රකාශය ඕනෑම ආකාරයක නැවත සැකසිය හැකි වස්තුවක් සඳහා සහ උත්පාදක යන්ත්‍ර සඳහා ( [Symbol.iterator]දේපලක් ඇති ඕනෑම වස්තුවක් ) ක්‍රියා කරයි.

අරා වස්තූන් අර්ථ දැක්වීම අනුව ES6 හි සාදන ලද පුනරාවර්තන වේ, එබැවින් ඔබට ඒවා මත මෙම ප්‍රකාශය භාවිතා කළ හැකිය:

let colors = ['red', 'green', 'blue'];
for (const color of colors){
    console.log(color);
}

වාසි

• එයට විවිධාකාර වස්තූන් හරහා නැවත යෙදිය හැකිය.
• සාමාන්‍ය ප්‍රවාහ පාලන ප්‍රකාශ භාවිතා කළ හැකිය ( break/continue ) .
• අනුක්‍රමික අසමමුහුර්ත අගයන් නැවත සැකසීමට ප්‍රයෝජනවත් වේ.

අවාසි

• ඔබ පැරණි බ්‍රව්සර් ඉලක්ක කරන්නේ නම්, සම්ප්‍රේෂණය කළ ප්‍රතිදානය ඔබව පුදුමයට පත් කළ හැකිය .

පාවිච්චි කරන්න එපා for...in

ipzipcodeman for...inප්‍රකාශය භාවිතා කිරීමට යෝජනා කරයි , නමුත් අරා for-inනැවත යෙදීම වළක්වා ගත යුතුය, එම ප්‍රකාශය වස්තු ගුණාංග ගණනය කිරීම සඳහා අදහස් කෙරේ .

එය අරාව වැනි වස්තු සඳහා භාවිතා නොකළ යුතුය:

• පුනරාවර්තනයේ අනුපිළිවෙල සහතික නොවේ; අරාව දර්ශක සංඛ්‍යාත්මකව බැලීමට නොයනු ඇත.
• උරුම වූ ගුණාංග ද ගණනය කෙරේ.

දෙවන කරුණ නම්, එය ඔබට ගැටලු රාශියක් ලබා දිය හැකි ය, නිදසුනක් ලෙස, ඔබ Array.prototypeඑහි ක්‍රමයක් ඇතුළත් කිරීම සඳහා වස්තුව දිගු කළහොත් , එම දේපල ද ගණනය කරනු ලැබේ.

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

Array.prototype.foo = "foo!";
var array = ['a', 'b', 'c'];

for (var i in array) {
    console.log(array[i]);
}

ඉහත කේතය "a", "b", "c" සහ "foo!"

ඔබ ස්වදේශික මූලාකෘති වර්ධන (MooTools වැනි) මත දැඩි ලෙස රඳා පවතින සමහර පුස්තකාලයක් භාවිතා කරන්නේ නම් එය විශේෂයෙන් ගැටළුවක් විය හැකිය.

මෙම for-inප්රකාශය මම පෙර කී ලෙස කිරීමට ඇති කීයක් උදාහරණයක් ලෙස, වස්තුවක ගුණාංගයන්ගේ:

var obj = {
    "a": 1,
    "b": 2,
    "c": 3
};

for (var prop in obj) {
    if (obj.hasOwnProperty(prop)) { 
        // or if (Object.prototype.hasOwnProperty.call(obj,prop)) for safety...
        console.log("prop: " + prop + " value: " + obj[prop])
    }
}

ඉහත උදාහරණයේ දී, hasOwnPropertyක්‍රමවේදය මඟින් ඔබට ස්වකීය ගුණාංග පමණක් ගණනය කිරීමට ඉඩ ලබා දේ , එය එයයි, වස්තුව භෞතිකව ඇති ගුණාංග පමණි, උරුම වූ ගුණාංග නොමැත.

ඊළඟ ලිපිය කියවීමට මම ඔබට නිර්දේශ කරමි:

• ගණන් බැලීම VS අනුකරණය

ඔව්, ඔබේ ක්‍රියාත්මක කිරීම ECMAScript 2015 හි හඳුන්වා දුන් for...of අංගය ඇතුළත් යැයි උපකල්පනය කරන්න ("සමගිය" නිකුතුව) ... මේ දිනවල එය ඉතා සුරක්ෂිත උපකල්පනයකි.

එය මේ ආකාරයට ක්‍රියා කරයි:

// REQUIRES ECMASCRIPT 2015+
var s, myStringArray = ["Hello", "World"];
for (s of myStringArray) {
  // ... do something with s ...
}

හෝ වඩා හොඳ තවමත්, ECMAScript 2015 ද බ්ලොක්-ස්කෝප් විචල්‍යයන් සපයන බැවින්:

// REQUIRES ECMASCRIPT 2015+
const myStringArray = ["Hello", "World"];
for (const s of myStringArray) {
  // ... do something with s ...
}
// s is no longer defined here

(විචල්‍යය s එක් එක් නැවතීමේ වෙනස් වේ, නමුත් constඑය වෙනස් නොකරන තාක් කල් ලූප් බොඩි තුළ ප්‍රකාශ කළ හැකිය .)

විරල අරා පිළිබඳ සටහනක්: ජාවාස්ක්‍රිප්ට් හි අරාවක් ඇත්ත වශයෙන්ම එහි වාර්තා කර ඇති තරම් අයිතම ගබඩා නොකරයි length; එම වාර්තා කළ අගය හුදෙක් අගය ගබඩා කර ඇති ඉහළම දර්ශකයට වඩා එකකි. අරාවෙහි දිගට වඩා අඩු මූලද්‍රව්‍යයක් තිබේ නම්, එය නැතිවූ මූලද්‍රව්‍ය සඳහා විරල . නිදසුනක් ලෙස, 3, 12 සහ 247 දර්ශකවල පමණක් අයිතම සමඟ අරාවක් තිබීම පරිපූර්ණ නීත්‍යානුකූල ය; මෙම යැයි කියනු ලැබේ , නැතහොත් ඇත්ත වශයෙන්ම පවතින මූලද්‍රව්‍යයන් පමණක් සැකසීමට ඔබට අවශ්‍යද? ප්රවේශයන් දෙකම සඳහා යෙදුම් ඕනෑ තරම් තිබේ; එය රඳා පවතින්නේ ඔබ අරාව භාවිතා කරන දේ මත ය.length පමණක් 3 වටිනාකම් ගබඩා වුවත් එවැනි අරාව, 248 වාර්තා වී ඇත. ඔබ වෙනත් ඕනෑම දර්ශකයකින් අයිතමයකට ප්‍රවේශ වීමට උත්සාහ කරන්නේ නම්, අරාවෙහි එහි undefinedවටිනාකම ඇති බව පෙනේ. එබැවින් ඔබට අරාව "හරහා ලූප්" කිරීමට අවශ්‍ය වූ විට, ඔබට පිළිතුරු දීමට ප්‍රශ්නයක් ඇත: එහි දිග හා ක්‍රියාවලිය මඟින් දක්වා ඇති සම්පූර්ණ පරාසය පුරා ලූප කිරීමට ඔබට අවශ්‍යද?undefined

ඔබ for.. සමඟ අරාව හරහා නැවත ක්‍රියා කරන්නේ නම් of, ලූපයේ සිරුර ක්‍රියාත්මක වන lengthවේලාවන් වන undefinedඅතර, අරාවෙහි සත්‍ය වශයෙන්ම නොපවතින ඕනෑම අයිතමයක් සඳහා ලූප් පාලන විචල්‍යය සකසා ඇත . ඔබගේ "සමඟ යමක් කරන්න" කේතයේ විස්තර මත පදනම්ව, එම හැසිරීම ඔබට අවශ්‍ය දේ විය හැකි නමුත් එසේ නොවේ නම්, ඔබ වෙනත් ප්‍රවේශයක් භාවිතා කළ යුතුය.

ඇත්ත වශයෙන්ම, ඇතැම් සංවර්ධකයින් වෙන විකල්පයක් නෑ නමුත් කුමන හේතුවක් නිසා ඔවුන් ඉන්නේ තවමත් සහය නොදක්වන බව JavaScript වෙළුමක් ඉලක්ක නිසා, කෙසේ හෝ වෙනත් ප්රවේශයක් භාවිතා කිරීමට for... of.

ඔබගේ ජාවාස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීම ඊසීඑම්එස්ක්‍රිප්ට් පිරිවිතරයේ පෙර සංස්කරණයට අනුකූල වන තාක් කල් (එය 9 ට පෙර ඉන්ටර්නෙට් එක්ස්ප්ලෝරර්ගේ අනුවාදයන් බැහැර කරයි), එවිට ඔබට Array#forEachලූපයක් වෙනුවට ඉටරේටර් ක්‍රමය භාවිතා කළ හැකිය . එවැනි අවස්ථාවකදී, ඔබ අරාවෙහි ඇති සෑම අයිතමයක් සඳහාම කැඳවිය යුතු ශ්‍රිතයක් සම්මත කරයි:

var myStringArray = [ "Hello", "World" ];
myStringArray.forEach( function(s) { 
     // ... do something with s ...
} );

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

ජාවාස්ක්‍රිප්ට් හි සියලුම සංස්කරණ වල ක්‍රියා කරන අවසාන විකල්පය පැහැදිලි ගණන් කිරීමේ ලූපයකි . ඔබ දිගට 0 සිට 1 දක්වා අඩුවෙන් ගණන් කර කවුන්ටරය දර්ශකයක් ලෙස භාවිතා කරන්න. මූලික ලූපය මේ වගේ ය:

var i, s, myStringArray = [ "Hello", "World" ], len = myStringArray.length;
for (i=0; i<len; ++i) {
  s = myStringArray[i];
  // ... do something with s ...
}

මෙම ප්‍රවේශයේ එක් වාසියක් නම් ඔබට විරල අරා හැසිරවිය යුතු ආකාරය තෝරා ගත හැකිය; ඉහත කේතය පුඩුවක් ශරීරය පූර්ණ ධාවනය වනු ඇත lengthසමග, වරක් sකිරීමට හැකි undefinedඕනෑම අඩුපාඩුව වගේ, සඳහා for.. of. ඔබට ඒ වෙනුවට විරල අරාවක ඇත්ත වශයෙන්ම පවතින අංග පමණක් හැසිරවීමට අවශ්‍ය නම්, ඔබට දර්ශකයේ .forEachසරල inපරීක්ෂණයක් එක් කළ හැකිය :

var i, s, myStringArray = [ "Hello", "World" ], len = myStringArray.length;
for (i=0; i<len; ++i) {
  if (i in myStringArray) {
    s = myStringArray[i];
    // ... do something with s ...
  }
}

දේශීය විචල්‍යයට දිග අගය පැවරීම ( myStringArray.lengthලූප් තත්වයේ සම්පූර්ණ ප්‍රකාශනය ඇතුළත් කිරීමට වඩා වෙනස්ව) කාර්ය සාධනයෙහි සැලකිය යුතු වෙනසක් ඇති කළ හැකි අතර එය සෑම අවස්ථාවකදීම දේපල සොයා බැලීම මඟ හැරේ; මගේ යන්ත්‍රයේ රයිනෝ භාවිතා කරමින්, වේගය 43% කි.

ලූප් ආරම්භක වගන්තියේ දිග හැඹිලිය ඔබට දැක ගත හැකිය, මේ ආකාරයට:

var i, len, myStringArray = [ "Hello", "World" ];
for (len = myStringArray.length, i=0; i<len; ++i) {

පැහැදිලි ගණන් කිරීමේ ලූපය යන්නෙන් අදහස් කරන්නේ ඔබට අවශ්‍ය නම් එක් එක් අගයේ දර්ශකයට ඔබට ප්‍රවේශය ඇති බවයි. දර්ශකය ඔබ සම්මත කරන ශ්‍රිතයේ අතිරේක පරාමිතියක් ලෙසද සම්මත කර ඇති forEachබැවින් ඔබට එයද ඒ ආකාරයෙන් ප්‍රවේශ කළ හැකිය:

myStringArray.forEach( function(s, i) {
   // ... do something with s and i ...
});

for... ofඑක් එක් වස්තුව හා සම්බන්ධ දර්ශකය ඔබට ලබා නොදේ, නමුත් ඔබ නැවත යෙදෙන වස්තුව ඇත්ත වශයෙන්ම Array( for.. ofමෙම ක්‍රමය නොමැති වෙනත් ක්‍රියාකාරී වර්ග සඳහා ක්‍රියා කරයි), ඔබට අරාව භාවිතා කළ හැකිය. #entries ක්‍රමය එය [දර්ශකය, අයිතමය] යුගල සමූහයකට වෙනස් කර ඉන්පසු එය නැවත කියවීමට :

for (const [i, s] of myStringArray.entries()) {
  // ... do something with s and i ...
}

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

ඔබට භාවිතා කළ හැකිය map, එය ක්‍රියාකාරී ක්‍රමලේඛන තාක්‍ෂණයකි, එය පයිතන් සහ හැස්කල් වැනි වෙනත් භාෂාවලින්ද ලබාගත හැකිය .

[1,2,3,4].map( function(item) {
     alert(item);
})

සාමාන්‍ය වාක්‍ය ඛණ්ඩය:

array.map(func)

සාමාන්‍යයෙන් funcඅරාවෙහි අයිතමයක් වන එක් පරාමිතියක් ගනී. නමුත් ජාවාස්ක්‍රිප්ට් සම්බන්ධයෙන් ගත් කල, එයට අයිතමයේ දර්ශකය වන දෙවන පරාමිතිය ද, අරාව වන තුන්වන පරාමිතිය ද ගත හැකිය.

ප්‍රතිලාභ අගය array.mapතවත් අරාවකි, එබැවින් ඔබට එය මේ ආකාරයෙන් භාවිතා කළ හැකිය:

var x = [1,2,3,4].map( function(item) {return item * 10;});

දැන් x වේ [10,20,30,40].

ශ්‍රිතය පේළියේ ලිවීමට ඔබට අවශ්‍ය නැත. එය වෙනම කාර්යයක් විය හැකිය.

var item_processor = function(item) {
      // Do something complicated to an item
}

new_list = my_list.map(item_processor);

එය සමාන වන්නේ:

 for (item in my_list) {item_processor(item);}

ඔබට ලැබෙන්නේ නැත්නම් new_list.

ජාවාස්ක්‍රිප්ට් හි දී-සඳහා ලූපයක් සහිත අරාව හරහා ලූප කිරීම සුදුසු නොවේ, නමුත් forලූපයක් භාවිතා කිරීම වඩා හොඳය :

for(var i=0, len=myArray.length; i < len; i++){}

එය ද ප්‍රශස්තිකරණය කර ඇත (අරාවෙහි දිග "හැඹිලි"). ඔබ වැඩිදුර ඉගෙන ගැනීමට කැමති නම්, මෙම විෂය පිළිබඳ මගේ සටහන කියවන්න .

සඳහා (myStringArray හි ඉඩ දෙන්න) {

(ඔබේ ප්‍රශ්නයට කෙලින්ම පිළිතුරු සැපයීම: දැන් ඔබට පුළුවන්!)

වෙනත් බොහෝ පිළිතුරු නිවැරදිය, නමුත් ඔවුන් සඳහන් නොකරයි (මෙම ලිවීම අනුව) ECMA ස්ක්‍රිප්ට්  6  2015 නැවත ක්‍රියා කිරීම සඳහා නව යාන්ත්‍රණයක් ගෙන එන බව, for..ofලූපය.

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

එය දැනට ෆයර්ෆොක්ස් 13+, ක්‍රෝම් 37+ සමඟ ක්‍රියා කරන අතර එය වෙනත් බ්‍රව්සර් සමඟ ස්වදේශීයව ක්‍රියා නොකරයි (පහත බ්‍රව්සර් අනුකූලතාව බලන්න). වාසනාවකට මෙන් අපට JS සම්පාදකයින් ( බාබෙල් වැනි ) ඇත, එය අද ඊළඟ පරම්පරාවේ විශේෂාංග භාවිතා කිරීමට අපට ඉඩ සලසයි.

එය නෝඩ් මත ද ක්‍රියා කරයි (මම එය 0.12.0 අනුවාදයෙන් පරීක්ෂා කළෙමි).

අරාව අනුකරණය කිරීම

// You could also use "let" instead of "var" for block scope.
for (var letter of ["a", "b", "c"]) { 
   console.log(letter); 
}

වස්තු සමූහයක් අනුකරණය කිරීම

var band = [
  {firstName : 'John', lastName: 'Lennon'}, 
  {firstName : 'Paul', lastName: 'McCartney'}
];

for(var member of band){
  console.log(member.firstName + ' ' + member.lastName); 
}

උත්පාදක යන්ත්රයක් අනුකරණය කිරීම:

(උදාහරණය https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of වෙතින් උපුටා ගන්නා ලදි )

function* fibonacci() { // a generator function
  let [prev, curr] = [1, 1];
  while (true) {
    [prev, curr] = [curr, prev + curr];
    yield curr;
  }
}

for (let n of fibonacci()) {
  console.log(n);
  // truncate the sequence at 1000
  if (n >= 1000) {
    break;
  }
}

අනුකූලතා වගුව: http://kangax.github.io/es5-compat-table/es6/#For..of loops

පිරිවිතර: http://wiki.ecmascript.org/doku.php?id=harmony:iterator

}

ඔපෙරා, සෆාරි, ෆයර්ෆොක්ස් සහ ක්‍රෝම් දැන් බොහෝ පොදු ලූප ප්‍රශස්තිකරණය කිරීම සඳහා වැඩි දියුණු කළ අරා ක්‍රම කිහිපයක් බෙදා ගනී.

ඔබට ඒවා සියල්ලම අවශ්‍ය නොවනු ඇත, නමුත් ඒවා ඉතා ප්‍රයෝජනවත් විය හැකිය, නැතහොත් සෑම බ්‍රව්සරයක්ම ඔවුන්ට සහාය දැක්වුවහොත් විය හැකිය.

මොසිල්ලා ලැබ්ස් ඔවුන් සහ වෙබ්කිට් යන දෙකම භාවිතා කරන ඇල්ගොරිතම ප්‍රකාශයට පත් කළ අතර එමඟින් ඔබට ඒවා එකතු කළ හැකිය.

ෆිල්ටරය කිසියම් කොන්දේසියක් හෝ පරීක්ෂණයක් තෘප්තිමත් කරන අයිතම සමූහයක් ලබා දෙයි.

සෑම අරා සාමාජිකයෙක්ම පරීක්ෂණයෙන් සමත් වුවහොත් සෑම ප්‍රතිලාභයක්ම සත්‍ය වේ.

සමහරක් පරීක්ෂණයෙන් සමත් වුවහොත් සමහර ඒවා සත්‍ය වේ.

forEach එක් එක් මාලාවක් සාමාජිකයකු උත්සවයකට යන්නාවූ දෙයක් ආපසු නැත.

සිතියම සෑම එකක් සඳහාම සමාන ය, නමුත් එය එක් එක් මූලද්‍රව්‍යය සඳහා වූ ක්‍රියාකාරිත්වයේ ප්‍රති results ල සමූහයක් ලබා දෙයි.

මෙම ක්‍රම සියල්ලම ඔවුන්ගේ පළමු තර්කය සඳහා ශ්‍රිතයක් ගන්නා අතර විකල්ප දෙවන තර්කයක් ඇත, එය අරාවෙහි සාමාජිකයන් ශ්‍රිතය හරහා ලූප වන විට ඔවුන් මත පැටවීමට අවශ්‍ය විෂය පථයකි.

ඔබට අවශ්‍ය වන තෙක් එය නොසලකා හරින්න.

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

(function(){
    var p, ap= Array.prototype, p2={
        filter: function(fun, scope){
            var L= this.length, A= [], i= 0, val;
            if(typeof fun== 'function'){
                while(i< L){
                    if(i in this){
                        val= this[i];
                        if(fun.call(scope, val, i, this)){
                            A[A.length]= val;
                        }
                    }
                    ++i;
                }
            }
            return A;
        },
        every: function(fun, scope){
            var L= this.length, i= 0;
            if(typeof fun== 'function'){
                while(i<L){
                    if(i in this && !fun.call(scope, this[i], i, this))
                        return false;
                    ++i;
                }
                return true;
            }
            return null;
        },
        forEach: function(fun, scope){
            var L= this.length, i= 0;
            if(typeof fun== 'function'){
                while(i< L){
                    if(i in this){
                        fun.call(scope, this[i], i, this);
                    }
                    ++i;
                }
            }
            return this;
        },
        indexOf: function(what, i){
            i= i || 0;
            var L= this.length;
            while(i< L){
                if(this[i]=== what)
                    return i;
                ++i;
            }
            return -1;
        },
        lastIndexOf: function(what, i){
            var L= this.length;
            i= i || L-1;
            if(isNaN(i) || i>= L)
                i= L-1;
            else
                if(i< 0) i += L;
            while(i> -1){
                if(this[i]=== what)
                    return i;
                --i;
            }
            return -1;
        },
        map: function(fun, scope){
            var L= this.length, A= Array(this.length), i= 0, val;
            if(typeof fun== 'function'){
                while(i< L){
                    if(i in this){
                        A[i]= fun.call(scope, this[i], i, this);
                    }
                    ++i;
                }
                return A;
            }
        },
        some: function(fun, scope){
            var i= 0, L= this.length;
            if(typeof fun== 'function'){
                while(i<L){
                    if(i in this && fun.call(scope, this[i], i, this))
                        return true;
                    ++i;
                }
                return false;
            }
        }
    }
    for(p in p2){
        if(!ap[p])
            ap[p]= p2[p];
    }
    return true;
})();

හැඳින්වීම

මගේ විද්‍යාලයේ සිටම, මම ජාවා, ජාවාස්ක්‍රිප්ට්, පැස්කල්, ඒබීඒපී හි වැඩසටහන්ගත කර ඇත්තෙමි ඉගෙන ගත් , , ප්‍රගති 4 ජීඑල්, ​​සී / සී ++ සහ සමහර විට මට සිතිය නොහැකි වෙනත් භාෂා කිහිපයකින් වැඩසටහන්ගත කර ඇත්තෙමි.

ඔවුන් සියල්ලන්ටම ඔවුන්ගේම භාෂාමය අනන්‍යතා ඇති අතර, මෙම සෑම භාෂාවක්ම එකම මූලික සංකල්ප බොහොමයක් බෙදා ගනී. එවැනි සංකල්පවලට ක්‍රියා පටිපාටි / කාර්යයන්, IF-ස්ථාන, FOR-ලූප් සහ WHILE-ලූප් ඇතුළත් වේ.

සාම්ප්‍රදායික- forලූප්

සාම්ප්‍රදායික forපුඩුවක් සංරචක තුනක් ඇත:

1. ආරම්භ කිරීම: පළමු වරට පෙනුමේ කොටස ක්‍රියාත්මක කිරීමට පෙර ක්‍රියාත්මක වේ
2. කොන්දේසිය: ලූප් බ්ලොක් ක්‍රියාත්මක කිරීමට පෙර සෑම අවස්ථාවකම කොන්දේසියක් පරික්ෂා කර, අසත්‍ය නම් ලූපයෙන් ඉවත් වේ
3. පසු සිතිවිල්ල: ලූප් බ්ලොක් ක්‍රියාත්මක කිරීමෙන් පසු සෑම අවස්ථාවකම සිදු කරනු ලැබේ

මෙම සංරචක තුන ;සංකේතයකින් එකිනෙකාගෙන් වෙන් කරනු ලැබේ . මෙම එක් එක් සංරචක තුන සඳහා අන්තර්ගතය අත්‍යවශ්‍ය නොවේ, එයින් අදහස් කරන්නේ පහත දැක්වෙන්නේ forහැකි අවම අවම ලූපයයි:

for (;;) {
    // Do stuff
}

ඇත්ත වශයෙන්ම, ධාවනය නැවැත්වීම සඳහා ඔබට එම ලූපය තුළ if(condition === true) { break; } හෝ if(condition === true) { return; }කොතැනක හෝ ඇතුළත් කිරීමට අවශ්‍ය වනු ඇත for.

සාමාන්‍යයෙන්, ආරම්භය දර්ශකයක් ප්‍රකාශ කිරීම සඳහා භාවිතා කරනු ලැබේ, කොන්දේසිය එම දර්ශකය අවම හෝ උපරිම අගයක් සමඟ සංසන්දනය කිරීමට භාවිතා කරයි, සහ පසු සිතිවිල්ල දර්ශකය වැඩි කිරීමට භාවිතා කරයි:

for (var i = 0, length = 10; i < length; i++) {
    console.log(i);
}

forඅරාවක් හරහා ලූප් කිරීමට සාම්ප්‍රදායික ලූපයක් භාවිතා කිරීම

අරාව හරහා ලූප් කිරීමේ සාම්ප්‍රදායික ක්‍රමය මෙයයි:

for (var i = 0, length = myArray.length; i < length; i++) {
    console.log(myArray[i]);
}

නැතහොත්, ඔබ පසුපසට ලූප කිරීමට කැමති නම්, ඔබ මෙය කරන්නේ:

for (var i = myArray.length - 1; i > -1; i--) {
    console.log(myArray[i]);
}

කෙසේ වෙතත්, බොහෝ වෙනස්කම් ඇත, උදාහරණයක් ලෙස මෙය:

for (var key = 0, value = myArray[key], length = myArray.length; key < length; value = myArray[++key]) {
    console.log(value);
}

... නැත්නම් මේ ...

var i = 0, length = myArray.length;
for (; i < length;) {
    console.log(myArray[i]);
    i++;
}

... හෝ මේ:

var key = 0, value;
for (; value = myArray[key++];){
    console.log(value);
}

වඩාත්ම සුදුසු දෙය බොහෝ දුරට පුද්ගලික රසය හා ඔබ ක්‍රියාත්මක කරන විශේෂිත භාවිත අවස්ථාව යන දෙකටම අදාළ වේ.

මෙම සෑම වෙනස්කමක්ම ඉතා පැරණි ඒවා ඇතුළුව සියලුම බ්‍රව්සර් මගින් සහාය දක්වන බව සලකන්න!

ඒ whileපුඩුවක්

ලූපයකට එක් විකල්පයක් forවන්නේ whileලූපයකි. අරාව හරහා ලූප වීමට, ඔබට මෙය කළ හැකිය:

var key = 0;
while(value = myArray[key++]){
    console.log(value);
}

සාම්ප්‍රදායික forලූප මෙන් , whileපැරණිම බ්‍රව්සර් පවා ලූප සඳහා සහය දක්වයි.

සෑම ලූපයක්ම ලූපයක් ලෙස නැවත ලිවිය හැකි බව සලකන්න for. නිදසුනක් ලෙස, මෙහි ඇති whileලූපය මෙම for-ලූප් ආකාරයටම ක්‍රියා කරයි :

for(var key = 0; value = myArray[key++];){
    console.log(value);
}

For...in හා for...of

JavaScript හි, ඔබට මෙයද කළ හැකිය:

for (i in myArray) {
    console.log(myArray[i]);
}

කෙසේ වෙතත්, මෙය forසෑම අවස්ථාවකම සාම්ප්‍රදායික පුඩුවක් ලෙස හැසිරෙන්නේ නැති නිසාත්, සලකා බැලිය යුතු අතුරු ආබාධ ඇතිවිය හැකි නිසාත් මෙය ප්‍රවේශමෙන් භාවිතා කළ යුතුය. අරාව පුනරාවර්තනය සමඟ "සඳහා ... සඳහා" භාවිතා කිරීම නරක අදහසක් වන්නේ මන්දැයි බලන්න. වැඩි විස්තර සඳහා.

විකල්පයක් ලෙස for...in, දැන් ද තිබේ for...of. පහත උදාහරණයෙන් දැක්වෙන්නේ for...ofලූපයක් සහ ලූපයක් අතර වෙනසයි for...in:

var myArray = [3, 5, 7];
myArray.foo = "hello";

for (var i in myArray) {
  console.log(i); // logs 0, 1, 2, "foo"
}

for (var i of myArray) {
  console.log(i); // logs 3, 5, 7
}

මීට අමතරව, ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් හි කිසිදු සංස්කරණයක් for...of( එජ් 12+ සහාය නොදක්වයි) සහ for...inඅවම වශයෙන් ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් 10 ක් අවශ්‍ය බව ඔබ සලකා බැලිය යුතුය.

Array.prototype.forEach()

for-Lops සඳහා විකල්පයක් වන්නේ Array.prototype.forEach(), එය පහත දැක්වෙන වාක්‍ය ඛණ්ඩය භාවිතා කරයි:

myArray.forEach(function(value, key, myArray) {
    console.log(value);
});

Array.prototype.forEach() සියලුම නවීන බ්‍රව්සර් මෙන්ම ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් 9 සහ ඊට පසු සහය දක්වයි.

පුස්තකාල

අවසාන වශයෙන්, බොහෝ උපයෝගිතා පුස්තකාලවල ද ඒවායේ foreachවෙනස්කමක් ඇත. AFAIK, වඩාත් ජනප්‍රිය ඒවා තුන නම්:

jQuery.each(), jQuery හි :

$.each(myArray, function(key, value) {
    console.log(value);
});

_.each(), Underscore.js හි :

_.each(myArray, function(value, key, myArray) {
    console.log(value);
});

_.forEach(), Lodash.js හි :

_.forEach(myArray, function(value, key) {
    console.log(value);
});

අතරතුර ලූපය භාවිතා කරන්න ...

var i=0, item, items = ['one','two','three'];
while(item = items[i++]){
    console.log(item);
}

ලොග්: 'එකක්', 'දෙක', 'තුන'

ප්‍රතිලෝම අනුපිළිවෙල සඳහා ඊටත් වඩා කාර්යක්ෂම ලූපයක්

var items = ['one','two','three'], i = items.length;
while(i--){
    console.log(items[i]);
}

ලොග්: 'තුන', 'දෙක', 'එකක්'

නැතහොත් සම්භාව්‍ය forලූපය

var items = ['one','two','three']
for(var i=0, l = items.length; i < l; i++){
    console.log(items[i]);
}

ලොග්: 'එකක්', 'දෙක', 'තුන'

යොමුව: http://www.sitepoint.com/google-closure-how-not-to-write-javascript/

වේගවත් පුඩුවක් ලිවීමට ඔබට දැඩි ක්‍රමයක් අවශ්‍ය නම් සහ ඔබට ආපසු හැරවිය හැකිය:

for (var i=myArray.length;i--;){
  var item=myArray[i];
}

ටයිප් කිරීමට අක්ෂර අඩු වන අතර දිග (සමාන for (var i=0, len=myArray.length; i<len; ++i)හා වෙනස් for (var i=0; i<myArray.length; ++i)) හැඹිලි කිරීමේ වාසිය මෙයට ඇත .

සජීවී නෝඩ්ලිස්ට් එකක් හරහා නැවත යෙදීම වැනි සමහර අවස්ථා වලදී ඔබ ප්‍රතිලෝමව නැවත යෙදිය යුතුය , නැවත ක්‍රියාත්මක කිරීමේදී DOM වෙතින් අයිතම ඉවත් කිරීමට ඔබ සැලසුම් කරයි.

සමහරු ජාවාස්ක්‍රිප්ට් හි ක්‍රියාකාරී ක්‍රමලේඛන ආකාරයෙන් අරාව හරහා ලූප් කිරීමේ අවස්ථා භාවිතා කරති :

1. අරාව හරහා ලූප් කරන්න

const myArray = [{x:100}, {x:200}, {x:300}];

myArray.forEach((element, index, array) => {
    console.log(element.x); // 100, 200, 300
    console.log(index); // 0, 1, 2
    console.log(array); // same myArray object 3 times
});

සටහන: Array.prototype.forEach () යනු දැඩි ලෙස කථා කරන ක්‍රියාකාරී ක්‍රමයක් නොවේ, ආදාන පරාමිතිය ලෙස ගන්නා ශ්‍රිතය අගයක් ආපසු ලබා දිය යුතු නැත, එබැවින් එය පිරිසිදු ශ්‍රිතයක් ලෙස සැලකිය නොහැකිය.

2. අරාවෙහි ඇති කිසියම් මූලද්‍රව්‍යයක් පරීක්ෂණයකින් සමත් වී ඇත්දැයි පරීක්ෂා කරන්න

const people = [
    {name: 'John', age: 23}, 
    {name: 'Andrew', age: 3}, 
    {name: 'Peter', age: 8}, 
    {name: 'Hanna', age: 14}, 
    {name: 'Adam', age: 37}];

const anyAdult = people.some(person => person.age >= 18);
console.log(anyAdult); // true

3. නව අරාවකට පරිවර්තනය කරන්න

const myArray = [{x:100}, {x:200}, {x:300}];

const newArray= myArray.map(element => element.x);
console.log(newArray); // [100, 200, 300]

සටහන: සිතියම් () ක්‍රමය මඟින් ඇමතුම් අරාවේ සෑම අංගයකම සපයා ඇති ශ්‍රිතයක් ඇමතීමේ ප්‍රති with ල සමඟ නව අරාවක් නිර්මාණය කරයි.

4. කිසියම් දේපලක් සාරාංශ කොට එහි සාමාන්‍යය ගණනය කරන්න

const myArray = [{x:100}, {x:200}, {x:300}];

const sum = myArray.map(element => element.x).reduce((a, b) => a + b, 0);
console.log(sum); // 600 = 0 + 100 + 200 + 300

const average = sum / myArray.length;
console.log(average); // 200

5. මුල් පිටපත පදනම් කරගෙන නවීකරණයකින් තොරව නව අරාවක් සාදන්න

const myArray = [{x:100}, {x:200}, {x:300}];

const newArray= myArray.map(element => {
    return {
        ...element,
        x: element.x * 2
    };
});

console.log(myArray); // [100, 200, 300]
console.log(newArray); // [200, 400, 600]

6. එක් එක් කාණ්ඩයේ ගණන ගණන් කරන්න

const people = [
    {name: 'John', group: 'A'}, 
    {name: 'Andrew', group: 'C'}, 
    {name: 'Peter', group: 'A'}, 
    {name: 'James', group: 'B'}, 
    {name: 'Hanna', group: 'A'}, 
    {name: 'Adam', group: 'B'}];

const groupInfo = people.reduce((groups, person) => {
    const {A = 0, B = 0, C = 0} = groups;
    if (person.group === 'A') {
        return {...groups, A: A + 1};
    } else if (person.group === 'B') {
        return {...groups, B: B + 1};
    } else {
        return {...groups, C: C + 1};
    }
}, {});

console.log(groupInfo); // {A: 3, C: 1, B: 2}

7. නිශ්චිත නිර්ණායක මත පදනම්ව අරාවක උප කුලකයක් ලබා ගන්න

const myArray = [{x:100}, {x:200}, {x:300}];

const newArray = myArray.filter(element => element.x > 250);
console.log(newArray); // [{x:300}] 

සටහන: පෙරහන් () ක්‍රමය මඟින් සපයන ලද ශ්‍රිතය මඟින් ක්‍රියාත්මක කරන ලද පරීක්ෂණයෙන් සමත් වන සියලුම අංග සමඟ නව අරාවක් නිර්මාණය කරයි.

8. අරාවක් වර්ග කරන්න

const people = [
  { name: "John", age: 21 },
  { name: "Peter", age: 31 },
  { name: "Andrew", age: 29 },
  { name: "Thomas", age: 25 }
];

let sortByAge = people.sort(function (p1, p2) {
  return p1.age - p2.age;
});

console.log(sortByAge);

9. අරාවෙහි මූලද්‍රව්‍යයක් සොයා ගන්න

const people = [ {name: "john", age:23},
                {name: "john", age:43},
                {name: "jim", age:101},
                {name: "bob", age:67} ];

const john = people.find(person => person.name === 'john');
console.log(john);

Array.prototype.find () ක්‍රමය මඟින් අරාවෙහි පළමු මූලද්‍රව්‍යයේ අගය ලබා දී ඇති පරීක්ෂණ ශ්‍රිතය තෘප්තිමත් කරයි.

යොමුව

• Array.prototype.some ()
• Array.prototype.forEach ()
• Array.prototype.map ()
• Array.prototype.filter ()
• Array.prototype.sort ()
• සින්ටැක්ස් පැතිරීම
• Array.prototype.find ()

ඔබේ ලූපය තුළ ඉතා සුළු ව්‍යංගාර්ථයක් ඇති අතර අමතර විචල්‍යයන් ඉවත් කර ගත හැකි ක්‍රමයක් තිබේ.

var i = 0,
     item;

// note this is weak to sparse arrays or falsey values
for ( ; item = myStringArray[i++] ; ){ 
    item; // This is the string at the index.
}

නැතහොත් ඔබට සැබවින්ම හැඳුනුම්පත ලබා ගැනීමට අවශ්‍ය නම් සහ සම්භාව්‍ය forපුඩුවක් තිබිය යුතුය:

var i = 0,
    len = myStringArray.length; // cache the length

for ( ; i < len ; i++ ){
    myStringArray[i]; // Don't use this if you plan on changing the length of the array
}

නූතන වෙබ් බ්රව්සර සහාය iterator ක්රම forEach, map, reduce, filterසහ අනෙකුත් ක්රම රැසක් Array මූලාකෘතිය .

ජාවාස්ක්‍රිප්ට් හි අරාව හරහා ලූප් කිරීමට විවිධ ක්‍රම තිබේ.

සාමාන්‍ය පුඩුවක්:

var i;
for (i = 0; i < substr.length; ++i) {
    // Do something with `substr[i]`
}

සෑම ES5 සඳහාම:

substr.forEach(function(item) {
    // Do something with `item`
});

jQuery.each:

jQuery.each(substr, function(index, item) {
    // Do something with `item` (or `this` is also `item` if you like)
});

බලන්න කියලා මේ සවිස්තරාත්මක තොරතුරු සඳහා හෝ ඔබ පරීක්ෂා කිරීමද කළ හැක MDN JavaScript දී මාලාවක් හරහා ප්රහාරක සහ jQuery චෙක්පත භාවිතා කිරීම සඳහා එක් එක් සඳහා jQuery .

මම තරයේ පාවිච්චි කිරීම නිර්දේශ underscore.js පුස්තකාලය . අරා / එකතු කිරීම් හරහා නැවත සැකසීමට ඔබට භාවිතා කළ හැකි විවිධ කාර්යයන් එය ඔබට සපයයි.

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

_.each([1, 2, 3], function(num){ alert(num); });
=> alerts each number in turn...

අරාව ලූපය:

for(var i = 0; i < things.length; i++){
    var thing = things[i];
    console.log(thing);
}

වස්තු පුඩුවක්:

for(var prop in obj){
    var propValue = obj[prop];
    console.log(propValue);
}

ඔව් , ඔබට ලාවා භාවිතයෙන් ජාවාස්ක්‍රිප්ට් තුළද එසේ කළ හැකිය, නමුත් එයට පමණක් සීමා නොවී, ජාවාස්ක්‍රිප්ට් හි අරා හරහා ලූපයක් කිරීමට බොහෝ ක්‍රම තිබේ. ඔබට මෙම අරාව පහතින් ඇති බව සිතන්න, ඔබ එයට ඉහළින් ලූපයක් කිරීමට කැමතියි:

var arr = [1, 2, 3, 4, 5];

මේවා විසඳුම්:

1) ලූප සඳහා

ඒ forපුඩුවක් JavaScript දී පෙලගැස්මක් හරහා ප්රහාරක පොදු ක්රමයක් වන අතර, නමුත් විශාල පෙලගැස්මක් සඳහා වේගවත්ම විසඳුම් ලෙස කිසිදු සැලකිය:

for (var i=0, l=arr.length; i<l; i++) {
  console.log(arr[i]);
}

2) ලූප අතර

දිගු අරා හරහා ලූප් කිරීමේ වේගවත්ම ක්‍රමය ලෙස ටික වේලාවක් සලකනු ලැබේ, නමුත් එය සාමාන්‍යයෙන් ජාවාස්ක්‍රිප්ට් කේතයේ අඩු ලෙස භාවිතා කරයි:

let i=0;

while (arr.length>i) {
    console.log(arr[i]);
    i++;
}

3) පහත දැක්වෙන සින්ටැක්ස් වෙනස සමඟ
A do whileඑකම දේ කරන අතරතුර කරන්නwhile :

let i=0;
do {
  console.log(arr[i]);
  i++;
}
while (arr.length>i);

ජාවාස්ක්‍රිප්ට් ලූප කිරීමට ප්‍රධාන ක්‍රම මේවාය, නමුත් එය කිරීමට තවත් ක්‍රම කිහිපයක් තිබේ.

for inජාවාස්ක්‍රිප්ට් හි ඇති වස්තූන් ලූප කිරීම සඳහා අපි ලූපයක් භාවිතා කරමු .

ද බලන්න map(), filter(), reduce()ජාවාස්ක්රිප්ට් තුල Array මත, ආදිය කටයුතු. ඔවුන් දේවල් ඉතා වේගයෙන් හා වඩා හොඳ භාවිතා වඩා කරන්න පුළුවන් whileහා for.

ජාවාස්ක්‍රිප්ට් හි අරා හරහා අසමමුහුර්ත කාර්යයන් ගැන වැඩිදුර දැන ගැනීමට ඔබ කැමති නම් මෙය හොඳ ලිපියකි.

ක්‍රියාකාරී වැඩසටහන් මේ දිනවල සංවර්ධන ලෝකයේ බෙහෙවින් කැපී පෙනේ. හොඳ හේතුවක් නිසා: බැලූ බැල්මට, ප්‍රතික්‍රියාකාරකයට සහ පරීක්ෂණයකට තේරුම් ගැනීමට පහසු වන ප්‍රකාශන කේත ලිවීමට ක්‍රියාකාරී ශිල්පීය ක්‍රම ඔබට උපකාරී වේ.

ක්‍රියාකාරී ක්‍රමලේඛනයේ එක් ප්‍රධාන ගලක් වන්නේ එහි විශේෂ ලැයිස්තු සහ ලැයිස්තු මෙහෙයුම් භාවිතා කිරීමයි. ඒ දේවල් හරියටම හරියට ඒවා වගේ ය: දේවල් පෙළ සහ ඔබ ඔවුන්ට කරන දේවල්. නමුත් ක්‍රියාකාරී මානසිකත්වය ඔබ බලාපොරොත්තු වනවාට වඩා ටිකක් වෙනස් ලෙස සලකයි.

මෙම ලිපිය "විශාල තුන" ලැයිස්තු මෙහෙයුම් ලෙස හැඳින්වීමට මා කැමති දේ දෙස සමීප බැල්මක් හෙළනු ඇත: සිතියම, පෙරණය සහ අඩු කිරීම. මෙම කාර්යයන් තුන වටා ඔබේ හිස ඔතා ගැනීම පිරිසිදු ක්‍රියාකාරී කේතයක් ලිවීමට හැකි වැදගත් පියවරක් වන අතර ක්‍රියාකාරී හා ප්‍රතික්‍රියාශීලී වැඩසටහන්කරණයේ අතිමහත් ප්‍රබල ක්‍රමවේදයන්ට දොර විවර කරයි.

එයින් කියවෙන්නේ ඔබට නැවත කිසි දිනෙක ලූපයක් ලිවීමට සිදු නොවන බවයි.

වැඩිදුර කියවන්න >> මෙහි :

අරා පුනරාවර්තන සඳහා ඇති බහු යාන්ත්‍රණවල ක්‍රියාකාරීත්වය ගැන යමෙකු උනන්දු වන්නේ නම්, මම පහත JSPerf පරීක්ෂණ සකස් කර ඇත්තෙමි.

https://jsperf.com/fastest-array-iterator

ප්රතිපල:

සාම්ප්‍රදායික for()ඉරේටරය, වේගවත්ම ක්‍රමය වේ, විශේෂයෙන් අරාව දිග හැඹිලි සමඟ භාවිතා කරන විට .

let arr = [1,2,3,4,5];

for(let i=0, size=arr.length; i<size; i++){
    // Do something
}

මෙම Array.prototype.forEach()සහ Array.prototype.map()ක්රම බොහෝ විට ප්රතිඵලයක් ලෙස මන්දගාමී වේ ආසන්න වේ කාර්යය ඇමතුමක් පොදු කාර්ය .

ඔබ jQuery පුස්තකාලය භාවිතා කරන්නේ නම්, භාවිතා කිරීම සලකා බලන්න http://api.jquery.com/jQuery.each/

ප්‍රලේඛනයෙන්:

jQuery.each( collection, callback(indexInArray, valueOfElement) )

ප්‍රතිලාභ: වස්තුව

විස්තර: සාමාන්‍ය පුනරාවර්තක ශ්‍රිතයක් වන අතර එය වස්තූන් හා අරා යන දෙකටම බාධාවකින් තොරව නැවත යෙදීමට භාවිතා කළ හැකිය. දිග ගුණාංගයක් සහිත අරාව සහ අරාව වැනි වස්තූන් (ශ්‍රිතයේ තර්ක වස්තුව වැනි) සංඛ්‍යාත්මක දර්ශකයෙන් 0 සිට දිග -1 දක්වා පුනරාවර්තනය වේ. වෙනත් වස්තූන් ඒවායේ නම් කරන ලද ගුණාංග හරහා පුනරාවර්තනය වේ.

මෙම $.each()කාර්යය සමාන නොවේ $(selector).each()එය සඟවන්න වස්තුව කෙරෙහි, පමණක්ම, අවංකව කිරීම සඳහා භාවිතා කල හැකි,. මෙම $.each() කාර්යය එහි සිතියමක් (JavaScript වස්තුව) හෝ මාලාවක් ද යන්න, ඕනෑම එකතු පුරා වඩාත් කැපීපෙනේ කිරීම සඳහා භාවිතා කල හැක. අරාව සම්බන්ධයෙන් ගත් කල, ඇමතුම නැවත ලබා දෙන්නේ අරාව දර්ශකයක් සහ අනුරූප අරාව අගය සෑම අවස්ථාවකම ය. (මෙම අගය ද හරහා ප්රවේශ කළ හැක thisඉඟි පද, නමුත් කරුණාකර Javascript සෑම විටම ඔලුවේ thisලෙස අගය Objectඑය සරල string හෝ අංකයක් අගය නම් පවා.) මෙම ක්රමය එහි පළමු වාදය, ශාඛාවයි කරන ලද වස්තුවක් පැමිණේ.

මම පෞද්ගලිකව වඩාත්ම කැමති මෙම විචලනය මම තවම දැක නැත:

අරාවක් දී ඇත:

var someArray = ["some", "example", "array"];

දිග දේපල වෙත ප්‍රවේශ නොවී ඔබට එය හරහා ලූපයක් තැබිය හැකිය:

for (var i=0, item; item=someArray[i]; i++) {
  // item is "some", then "example", then "array"
  // i is the index of item in the array
  alert("someArray[" + i + "]: " + item);
}

මෙය නිරූපණය කරන මෙම JsFiddle බලන්න: http://jsfiddle.net/prvzk/

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

පහත දැක්වෙන අදහසක CMS සඳහන් කර ඇති පරිදි, ඔබට මෙය භාවිතා කළ හැක්කේ ව්‍යාජ අගයන් අඩංගු නොවන අරා වල පමණි. උදාහරණයේ ඇති නූල් පෙළ ක්‍රියා කරයි, නමුත් ඔබට හිස් නූල් හෝ 0 හෝ NaN වැනි සංඛ්‍යා තිබේ නම් ලූපය අකාලයේ කැඩී යයි. නැවතත් ප්‍රායෝගිකව මෙය මට කිසිසේත්ම ගැටලුවක් නොවේ, නමුත් එය මතක තබා ගත යුතු දෙයකි, මෙය ඔබ එය භාවිතා කිරීමට පෙර සිතා බැලිය යුතු ලූපයක් බවට පත් කරයි ... එය සමහර පුද්ගලයින් සඳහා නුසුදුස්සකු විය හැකිය :)

මෙම ලූපයට මා කැමති දේ:

• එය ලිවීමට කෙටි ය
• දිග දේපල වෙත ප්‍රවේශ වීමට අවශ්‍ය නැත (හැඹිලි කිරීමට ඉඩ දෙන්න)
• ප්‍රවේශ වීමට ඇති අයිතමය ඔබ තෝරාගත් නම යටතේ ලූප් බොඩි තුළ ස්වයංක්‍රීයව අර්ථ දැක්වේ.
• ලැයිස්තු / තොග වැනි අරා භාවිතා කිරීම සඳහා ඉතා ස්වාභාවිකවම array.push සහ array.splice සමඟ ඒකාබද්ධ කරයි

මෙය ක්‍රියාත්මක වීමට හේතුව, ඔබ දර්ශකයකින් අයිතමයක් කියවන විට> = අරාවෙහි දිග, එය නිර්වචනය නොකෙරේ. ඔබ එවැනි ස්ථානයකට ලියන විට එය ඇත්ත වශයෙන්ම දිග යාවත්කාලීන කරනු ඇත.

මට නම්, මෙම ඉදිකිරීම මා ආදරය කරන ජාවා 5 සින්ටැක්ස් වඩාත් සමීපව අනුකරණය කරයි:

for (String item : someArray) {
}

... ලූපය තුළ ඇති වත්මන් දර්ශකය ගැන දැන ගැනීමේ අමතර වාසිය සමඟ

මූලාකෘති ඇතුළත් නොව, තමන්ගේම වස්තු ගුණාංග පමණක් නැවත කියවීමට ක්‍රමයක් තිබේ:

for (var i in array) if (array.hasOwnProperty(i)) {
    // Do something with array[i]
}

නමුත් එය තවමත් අභිරුචි-නිර්වචනය කළ ගුණාංග මත නැවත ක්‍රියාත්මක වේ.

ජාවාස්ක්‍රිප්ට් හි ඕනෑම අභිරුචි දේපලක් අරාව ඇතුළුව ඕනෑම වස්තුවකට පැවරිය හැකිය.

එක් sparsed අරාව, කට වඩාත් කැපීපෙනේ කිරීමට අවශ්ය නම් for (var i = 0; i < array.length; i++) if (i in array)හෝ array.forEachසමග es5shimභාවිතා කළ යුතුය.

ජාවාස්ක්‍රිප්ට් හි එය කිරීමට ක්‍රම කිහිපයක් තිබේ. පළමු උදාහරණ දෙක වන්නේ ජාවාස්ක්‍රිප්ට් සාම්පල ය. තෙවනුව ජාවාස්ක්‍රිප්ට් පුස්තකාලයක් භාවිතා කරයි, එනම් jQuery .each()ශ්‍රිතය භාවිතා කරයි.

var myStringArray = ["hello", "World"];
for(var i in myStringArray) {
  alert(myStringArray[i]);
}

var myStringArray = ["hello", "World"];
for (var i=0; i < myStringArray.length; i++) {
  alert(myStringArray[i]);
}

var myStringArray = ["hello", "World"];
$.each(myStringArray, function(index, value){
  alert(value);
})

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>

වඩාත්ම අලංකාර හා වේගවත් මාර්ගය

var arr = [1, 2, 3, 1023, 1024];
for (var value; value = arr.pop();) {
    value + 1
}

http://jsperf.com/native-loop-performance/8

සංස්කරණය කරන ලදි (මා වැරදියි නිසා)

අයිතම 100000 ක් හරහා ලූප කිරීම සඳහා ක්‍රම සංසන්දනය කිරීම සහ සෑම විටම නව අගය සමඟ අවම මෙහෙයුමක් කරන්න.

• http://jsben.ch/#/BQhED

සකස් කිරීම:

<script src="//code.jquery.com/jquery-2.1.0.min.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/underscore.js/1.6.0/underscore-min.js"></script>
<script>
    Benchmark.prototype.setup = function() {
        // Fake function with minimal action on the value
        var tmp = 0;
        var process = function(value) {
            tmp = value; // Hold a reference to the variable (prevent engine optimisation?)
        };

        // Declare the test Array
        var arr = [];
        for (var i = 0; i < 100000; i++)
            arr[i] = i;
    };
</script>

පරීක්ෂණ:

<a href="http://jsperf.com/native-loop-performance/16" 
   title="http://jsperf.com/native-loop-performance/16"
><img src="http://i.imgur.com/YTrO68E.png" title="Hosted by imgur.com" /></a>

ප්‍රශස්තිකරණ ප්‍රවේශය නම් අරාවෙහි දිග හැඹිලිගත කිරීම සහ තනි විචල්‍ය රටාවක් භාවිතා කරමින් සියලු විචල්‍යයන් තනි var යතුරු පදයකින් ආරම්භ කිරීමයි.

var i, max, myStringArray = ["Hello","World"];
for (i = 0, max = myStringArray.length; i < max; i++) {
    alert(myStringArray[i]);
   //Do something
}

ඔබ ආපසු හැරවූ ලූපයක් උත්සාහ කිරීමට වඩා පුනරාවර්තන අනුපිළිවෙල වැදගත් නොවේ නම්, එය වේගවත් වන්නේ එය පොදු කාර්ය තත්වයන් අඩු කිරීම සහ අඩුවීම එක් ප්‍රකාශයක ය:

var i,myStringArray = ["item1","item2"];
for (i =  myStringArray.length; i--) {
    alert(myStringArray[i]);
}

හෝ ලූප අතර භාවිතා කිරීමට වඩා හොඳ සහ පිරිසිදු:

var myStringArray = ["item1","item2"],i = myStringArray.length;
while(i--) {
   // do something with fruits[i]
}

ජාවාස්ක්‍රිප්ට් හි, අරාවක් ලූප කිරීමට බොහෝ විසඳුම් තිබේ.

පහත කේතය ජනප්‍රිය ඒවාය

/** Declare inputs */
const items = ['Hello', 'World']

/** Solution 1. Simple for */
console.log('solution 1. simple for')

for (let i = 0; i < items.length; i++) {
  console.log(items[i])
}

console.log()
console.log()

/** Solution 2. Simple while */
console.log('solution 2. simple while')

let i = 0
while (i < items.length) {
  console.log(items[i++])
}

console.log()
console.log()

/** Solution 3. forEach*/
console.log('solution 3. forEach')

items.forEach(item => {
  console.log(item)
})

console.log()
console.log()

/** Solution 4. for-of*/
console.log('solution 4. for-of')

for (const item of items) {
  console.log(item)
}

console.log()
console.log()

ඔබට jQuery භාවිතා කිරීමට අවශ්‍ය නම්, එහි ලේඛනයේ එය කදිම නිදසුනක් ඇත:

 $.each([ 52, 97 ], function( index, value ) {
      alert( index + ": " + value );
 });

මගේ මතය අනුව හොඳම ක්‍රමය වන්නේ Array.forEach ශ්‍රිතය භාවිතා කිරීමයි. ඔබට එය භාවිතා කළ නොහැකි නම්, MDF වෙතින් පොලිෆිල් ලබා ගැනීමට මම යෝජනා කරමි. එය ලබා ගැනීම සඳහා, එය නිසැකවම ජාවාස්ක්‍රිප්ට් හි අරාව හරහා නැවත යෙදීම සඳහා ආරක්ෂිතම ක්‍රමයයි.

Array.prototype.forEach ()

අනෙක් අය යෝජනා කර ඇති පරිදි, මෙය සැමවිටම ඔබට අවශ්‍ය දේ වේ:

var numbers = [1,11,22,33,44,55,66,77,88,99,111];
var sum = 0;
numbers.forEach(function(n){
  sum += n;
});

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

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

එබැවින්:

var sum = 0;
var numbers = [1,11,22,33,44,55,66,77,88,99,111];

for(var i = 0; i<numbers.length; ++i){
  sum += numbers[i];
}

alert(i);

"11" ප්‍රතිදානය කරයි - එය ඔබට අවශ්‍ය දේ හෝ නොවිය හැකිය.

වැඩ කරන jsFiddle උදාහරණයක්: https://jsfiddle.net/workingClassHacker/pxpv2dh5/7/

එය 100% සමාන නොවේ, නමුත් සමාන ය:

   var myStringArray = ['Hello', 'World']; // array uses [] not {}
    for (var i in myStringArray) {
        console.log(i + ' -> ' + myStringArray[i]); // i is the index/key, not the item
    }

උදාහරණයක් ලෙස, මම ෆයර්ෆොක්ස් කොන්සෝලයක භාවිතා කළෙමි:

[].forEach.call(document.getElementsByTagName('pre'), function(e){ 
   console.log(e);
})

var x = [4, 5, 6];
for (i = 0, j = x[i]; i < x.length; j = x[++i]) {
    console.log(i,j);
}

ගොඩක් පිරිසිදු කරන්නෙක් ...

කෙටි පිළිතුර: ඔව්. ඔබට මෙය කළ හැකිය:

var myArray = ["element1", "element2", "element3", "element4"];

for (i = 0; i < myArray.length; i++) {
  console.log(myArray[i]);
}

බ්රවුසර කොන්සෝලයක, ඔබට "මූලද්රව්ය 1", "මූලද්රව්ය 2" යනාදිය මුද්‍රණය කර ඇති දෙයක් දැකිය හැකිය.

ඔබට භාවිතා කළ හැකිය Array.prototype.forEach(...):

var arr = ["apple", "banana", "cherry", "mango"];
arr.forEach((item, index)=>{
   //Some code...
});

හෝ Array.prototype.map(...):

var arr = ["apple", "banana", "cherry", "mango"];
arr.map((item, index)=>{
   //Some code...
});

හෝ jquery හෝ කලින් සඳහන් කළ ලූප් ක්‍රම සඳහා.