Pasikartokite „javascript“ masyvą

„Java“ galite naudoti kilpą, kad perkeltumėte tokius objektus kaip:

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

Ar galite padaryti tą patį ir „JavaScript“?

2600
10 июня '10 в 3:04 2010-06-10 03:04 Markas Szymanski yra nustatytas birželio 10 d. 10.00 val. 2010-06-10 03:04
@ 39 atsakymų
  • 1
  • 2

Naudokite nuoseklią kilpą:

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

„@zipcodeman“ siūlo naudoti „ for...in operatoriui, tačiau norint pakartoti for-in masyvus, šis operatorius turi išvardyti objekto savybes.

Jis neturėtų būti naudojamas masyvo tipo objektams, nes:

  • Iteracijų eiliškumas negarantuojamas, matricų indeksai negali būti peržiūrimi eilės tvarka.
  • Taip pat išvardytos paveldėtos savybės.

Antras dalykas yra tai, kad jis gali suteikti jums daug problemų, pavyzdžiui, jei Array.prototype objektą, kad į jį būtų įtrauktas būdas, ši nuosavybė taip pat bus įtraukta į sąrašą.

Pavyzdžiui:

 Array.prototype.foo = "foo!"; var array = ['a', 'b', 'c']; for (var i in array) { alert(array[i]); } 

Pirmiau pateiktame kode pasirodys „a“, „b“, „c“ ir „foo!“.

Tai ypač problemiška, jei naudojate tam tikrą biblioteką, kuri labai priklauso nuo savo prototipų išplėtimo (pvz., „MooTools“).

Kaip minėjau anksčiau, for-in operatorius turėtų išvardyti objekto savybes, pavyzdžiui:

 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... alert("prop: " + prop + " value: " + obj[prop]) } } 

Pirmiau pateiktame pavyzdyje hasOwnProperty metodas leidžia jums įrašyti tik savo savybes, kad jis, tik savybės, kurias objektas fiziškai turi, neturi paveldėtų savybių.

Aš rekomenduoju perskaityti šį straipsnį:

3210
10 июня '10 в 3:07 2010-06-10 03:07 atsakymą CMS pateikė 10 birželio 10 d. 3:07 2010-06-10 03:07

Taip, daroma prielaida, kad jūsų įgyvendinimas apima „ ECMAScript 2015 “ įvestą funkciją ... („Harmonijos“ išleidimas) ... kuri šiandien yra gana saugi prielaida.

Jis veikia taip:

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

Arba dar geriau, nes „ECMAScript 2015“ taip pat pateikia kintamuosius bloko taikymo srityje, naudojant „ let ir „ const :

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

Tačiau kai kurie „JavaScript“ kūrėjai vis dar dirba aplinkoje, kuri dar neegzistuoja - ypač jei jie rašo kodą, skirtą veikti naršyklėse, kur svetainių kūrėjai dažnai negali būti tikri, kokia naršyklė / versija bus naudojama.

Jei galite daryti prielaidą, kad „JavaScript“ vertėjas yra suderinamas su ankstesne ECMAScript specifikacijos versija (kuri, pavyzdžiui, neįtraukia „Internet Explorer“ versijų iki 9), tuomet vietoj kilpos galite naudoti forEach iteratoriaus metodą. Tokiu atveju perduodate funkciją, kuri bus iškviesta kiekvienam masyvo elementui:

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

Bet net jei tai yra per daug prisiimti ir norite kažką, kuris veikia visose „JavaScript“ versijose, tuomet turėtumėte naudoti aiškų skaičiavimo ciklą. Saugiausia versija, kuri teisingai tvarko retas masyvus, atrodo taip:

 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 ... } } 

Ilgio reikšmės priskyrimas vietiniam kintamajam (priešingai nei įtraukiant visą išraišką myStringArray.length į kilpos būseną) gali iš esmės myStringArray.length dėl našumo, nes jis praleidžia ieškoti savybių kiekvieną kartą iki pabaigos; Naudojant Rhino ant mano automobilio, pagreitis yra 43%.

Dažnai matysite ilgio talpyklą kilpos inicijavimo sąlygoje, pavyzdžiui:

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

Kita sintaksė, for ... in naudojama kilti aplink objekto savybes; Kadangi „JavaScript“ masyvas yra tik objektas su skaitmeniniais nuosavybės pavadinimais (ir automatiškai atnaujinto length nuosavybė), galite teoriškai susieti masyvą su juo. Tačiau problema yra ta, kad ji neapsiriboja tik skaitmeninėmis savybių reikšmėmis (nepamirškite, kad net metodai iš tikrųjų yra tik savybės, kurių vertė yra uždarymas), o taip pat jų neišsiskyrimas skaitmenine tvarka. Todėl for sintaksės lauką „ for ... in neturėtų būti naudojamas kilpas per masyvus.

958
16 апр. Mark Reed atsakymas, pateiktas balandžio 16 d 2012-04-16 05:03 '12 at 5:03 2012-04-16 05:03

Galite naudoti map , kuris yra funkcinis programavimo metodas, kuris taip pat yra prieinamas kitomis kalbomis, pvz., Python ir Haskell .

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

Bendra sintaksė:

 array.map(func) 

Apskritai, func užima vieną parametrą, kuris yra masyvo elementas. Tačiau „JavaScript“ atveju gali būti antras parametras, ty elementų indeksas, ir trečiasis parametras, kuris yra pats masyvas.

array.map “ grįžimo vertė yra dar viena masyvas, todėl galite jį naudoti taip:

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

Ir dabar x - [10,20,30,40] .

Nereikia rašyti eilutės funkcijos. Tai gali būti atskira funkcija.

 var item_processor = function(item) { // Do something complicated to an item } new_list = my_list.map(item_processor); 

kuris bus lygiavertis:

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

Be to, jūs negausite naujo new_list .

410
10 июня '10 в 3:09 2010-06-10 03:09 atsakymą pateikė hasenas birželio 10 d. 10 d. 03:09 2010-06-10 03:09

„JavaScript“ sistemoje nerekomenduojama pereiti per masyvą su „for-in“ kilpa, tačiau geriau naudoti „loop“, pvz .:

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

Jis taip pat yra optimizuotas („talpyklos“ masyvo ilgis). Jei norite sužinoti daugiau, perskaitykite mano temą .

105
07 дек. atsakymas duotas sebarmeli 07 Dec 2010-12-07 10:24 '10, 10:24, 2010-12-07 10:24

už (var s myStringArray) {

(Tiesiogiai atsakydami į jūsų klausimą: dabar galite!)

Dauguma kitų atsakymų yra teisingi, tačiau jie nenurodo (kaip parašyta), kad „ ECMA Script 6 2015“ pristato naują mechanizmą, skirtą iteracijai, „ for..of .

Ši nauja sintaksė yra elegantiškiausias būdas kartoti per masyvą javascript'e (nes jums nereikia iteracijos indekso), tačiau naršyklės to dar nepalaiko.

Šiuo metu jis veikia su „Firefox 13+“, „Chrome“ 37+ ir neveikia su kitomis naršyklėmis (žr. Toliau pateiktą naršyklės suderinamumą). Laimei, turime JS kompiliatorius (pvz., „ Babel“ ), kurie leidžia šiandien naudoti naujos kartos bruožus.

Jis taip pat veikia „Node“ (bandau jį 0.12.0 versijoje).

Array Iteration

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

Įvairių objektų masyvas

 var band = [ {firstName : 'John', lastName: 'Lennon'}, {firstName : 'Paul', lastName: 'McCartney'} ]; for(var member of band){ console.log(member.firstName + ' ' + member.lastName); } 

Generatoriaus iteracija:

(pavyzdys paimtas iš 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; } } 

Suderinamumo lentelė: http://kangax.github.io/es5-compat-table/es6/ # Kilpos

Spec: http://wiki.ecmascript.org/doku.php?id=harmony:iterators

}

97
11 авг. atsakymą pateikė Marlon Bernardes, rugpjūčio 11 d. 2013-08-11 18:54 '13, 18:54, 2013-08-11 18:54

„Opera“, „Safari“, „Firefox“ ir „Chrome“ dabar naudoja bendrą pažangių „Array“ metodų rinkinį, kad optimizuotų keletą bendrų kilpų.

Jums gali prireikti ne visi, bet jie gali būti labai naudingi arba bus, jei kiekviena naršyklė juos palaiko.

„Mozilla Labs“ paskelbė algoritmus, kuriuos jie ir „ WebKit“ naudoja, kad galėtumėte juos pridėti.

Filtras grąžina elementų, atitinkančių tam tikrą būklę ar bandymą, masyvą.

kiekvienas grįžta tiesa, jei kiekvienas masyvo elementas praeina bandymą.

kai kurie grįžta tiesa, jei kas nors praeina bandymą.

Kiekvienas elementas atlieka funkciją kiekvienam masyvo elementui ir grąžina nieko.

Šis žemėlapis yra panašus į „ForEach“, bet grąžina kiekvieno elemento veiklos rezultatus.

Visi šie metodai atlieka savo pirmojo argumento funkciją ir turi pasirinktinį antrąjį argumentą, kuris yra objektas, kurio apimtį norite nustatyti masyvo elementams, kai jūs einate per funkciją.

Ignoruokite jį, kol jam nereikės.

indexOf ir lastIndexOf suranda norimą pirmojo arba paskutinio elemento, kuris tiksliai atitinka jo argumentą, padėtį.

 (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; })(); 
82
10 июня '10 в 5:43 2010-06-10 05:43 Atsakymą pateikė kennebec birželio 10 d. 10 val. 5:43 2010-06-10 05:43

Naudokite truputį kilpą ...

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

žurnalai: „vienas“, „du“, „trys“

Ir atvirkštine tvarka dar efektyvesnis ciklas

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

žurnalai: „trys“, „du“, „vienas“

Arba klasikinė kilpa

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

žurnalai: „vienas“, „du“, „trys“

Nuoroda: http://www.sitepoint.com/google-closure-how-not-to-write-javascript/

62
05 янв. Atsakyti Timo Huovinenui 05 Jan 2012-01-05 12:15 '12 12:15 2012-01-05 12:15

įvadas

Nuo mano kolegijos laiko buvau programavęs „Java“, „JavaScript“, „Pascal“, „ ABAP“ , „PHP“, „Progress 4GL“, „C / C ++“ ir galbūt keliomis kitomis kalbomis, apie kurias dabar negaliu galvoti.

Nors jie visi turi savo lingvistines savybes, kiekviena iš šių kalbų dalijasi daugeliu tų pačių pagrindinių sąvokų. Tokios sąvokos apima procedūras / funkcijas, IF pateiktis, FOR-kilpos ir WHILE kilpos.


Tradicinis, for -loop“

Tradicinę kilpą sudaro trys komponentai:

  1. Inicijavimas: atliekamas prieš tai, kai pirmą kartą vykdomas išvaizdos blokas.
  2. Būklė: tikrina būseną kiekvieną kartą prieš vykdant kilpą ir užbaigia kilpą, jei ji yra klaidinga
  3. Vėlesnė mintis: vykdoma kiekvieną kartą po kilpos

Šie trys komponentai yra atskirti vienas nuo kito ; pobūdžio. Kiekvienos iš šių trijų komponentų turinys yra neprivalomas, o tai reiškia, for minimalaus ciklo metu galima:

 for (;;) { // Do stuff } 

Žinoma, jums reikės įjungti, if(condition === true) { break; } if(condition === true) { break; } if(condition === true) { break; } if(condition === true) { break; } arba if(condition === true) { return; } if(condition === true) { return; } if(condition === true) { return; } if(condition === true) { return; } kažkur viduje, for galėtumėte jį sustabdyti.

Paprastai inicijavimas naudojamas indeksui deklaruoti, ši sąlyga naudojama norint palyginti šį rodiklį su minimalia ar maksimalia verte, o ši mintis naudojama indeksui padidinti:

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

Naudojant tradicines kilpas, skirtas kilti per masyvą

Tradicinis būdas kartoti per masyvą yra toks:

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

Arba, jei norite grįžti atgal, tai darote:

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

Tačiau, pavyzdžiui, yra daug galimybių:

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

... ar tai ...

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

... arba šis:

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

Tai, kas geriausiai veikia, labai priklauso nuo asmeninio skonio ir konkrečių naudojimo atvejų, kuriuos įgyvendinate.

Atminkite, kad visas šias parinktis palaiko visos naršyklės, įskaitant labai senas!


Tuo while kilpa

Viena iš for loop“ alternatyvų yra while kilpa. Jei norite kartoti per masyvą, galite tai padaryti:

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

Kaip tradicinės kilpos, while kilpos palaikomos net seniausiose naršyklėse.

Taip pat atkreipkite dėmesį, kad tuo metu kilpa gali būti perrašyta kaip kilpa. Pavyzdžiui, per tam tikrą while kilpa elgiasi pirmiau, kaip for :

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

For...in ir for...of

Taip pat galite atlikti šį JavaScript:

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

Tačiau tai turėtų būti naudojama atsargiai, nes visais atvejais jis neveikia taip pat, kaip ir tradicinis ciklas, ir galimas šalutinis poveikis, kurį reikia apsvarstyti. Žr. Kodėl yra naudojamas „...“, kai „masyvo iteracija“ yra bloga idėja? Daugiau informacijos.

Arba, for...in , dabar taip pat for...of Toliau pateiktame pavyzdyje parodomas skirtumas tarp for...of kilpos ir for...in kilpos:

 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 } 

Be to, reikia atsižvelgti į tai, kad nereikia jokios „Internet Explorer“ palaikomosios versijos for...of (iš „ Edge 12+ “) ir for...in bent „Internet Explorer 10“.


Array.prototype.forEach()

Alternatyva yra „ Array.prototype.forEach() , kuri naudoja šią sintaksę:

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

Array.prototype.forEach() palaiko visos modernios naršyklės, taip pat Internet Explorer 9 ir vėlesnės Array.prototype.forEach() .


Bibliotekos

Galiausiai, daugelis komunalinių bibliotekų taip pat turi savo foreach pakeitimus. AFAIK, trys populiariausios:

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); }); 
52
29 февр. John Slegers atsakymas vasario 29 d 2016-02-29 21:56 '16 at 21:56 2016-02-29 21:56

Jei jums reikia trumpo įrašymo greito ciklo, ir jūs galite kartoti atvirkštine tvarka:

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

Tai turi pranašumą: ilgio spartinimas (panašus į for (var i=0, len=myArray.length; i<len; ++i) ir skirtingai for (var i=0; i<myArray.length; ++i) ), o simbolių skaičius yra mažesnis.

Yra net kelis kartus, kai reikia kartoti atvirkščiai, pvz., Kartojant gyvą „NodeList“ , kuriame planuojate pašalinti elementus iš DOM iteracijos metu.

35
04 июня '12 в 19:26 2012-06-04 19:26 atsakymą pateikė „ Phrogz “ birželio 4 d. 12 d. 19:26 2012-06-04 19:26

Kai kurie aplinkraščio iteracijos funkciniai programavimo būdai naudojant JavaScript:

1. Tiesiog prijunkite masyvą.

 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 }); 

Pastaba: „Array.prototype.forEach“ (), griežtai kalbant, nėra funkcinis būdas, nes funkcija, kurią ji naudoja kaip įvesties parametrą, neturėtų grąžinti vertės, kuri negali būti laikoma grynąja funkcija.

2. Patikrinkite, ar bet kuris matricos elementas praeina bandymą.

 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. Konvertuoti į naują masyvą

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

Pastaba Žemėlapio () metodas sukuria naują masyvą su kiekvienos skambinančiojo masyvo elemento skambinimo funkcija.

4. Apibendrinkite tam tikrą turtą ir apskaičiuokite jo vidurkį

 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. Sukurkite naują masyvą, pagrįstą originalu, bet nekeičiant jo.

 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. Apskaičiuokite kiekvienos kategorijos numerį.

 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. Gauti masyvo pogrupį pagal tam tikrus kriterijus.

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

Pastaba Filtras () metodas sukuria naują masyvą su visais elementais, kurie praeina testą, įgyvendinamą teikiamos funkcijos.

8. Rūšiuoti masyvą

 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); 

2019

23 февр. atsakymas pateikiamas Yuci 23 vasario mėn. 2018-02-23 14:29 '18, 14:29 pm, 2018-02-23 14:29

Yra būdas tai padaryti, kai jūsų linijoje yra labai mažai paslėptos apimties ir atsikratote papildomų kintamųjų.

 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. } 

Arba, jei tikrai norite gauti identifikatorių ir turėti klasikinę kilpą:

 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 } 

Šiuolaikinės naršyklės palaiko forEach , map , reduce , filter ir daugelį kitų metodų „ Array“ prototipe .

26
17 мая '11 в 1:52 2011-05-17 01:52 atsakymą Gabrielas pateikė gegužės 17 d. 11 val. 1:52 2011-05-17 01:52

Yra keletas būdų, kaip matuoti masyvą į javascript.

Bendras ciklas:

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

ES5 kiekvienam:

 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) }); 

Jei norite gauti išsamesnės informacijos, peržiūrėkite MDN kilpą naudodami „JavaScript“ masyvą ir jQuery patvirtinimą jQuery kiekvienam .

26
23 июля '14 в 15:59 2014-07-23 15:59 atsakymas pateikiamas RizN81 liepos 23 d., 14 val. 15:59 2014-07-23 15:59

Aš visiškai rekomenduoju naudoti „ underscore.js“ biblioteką. Jis suteikia jums įvairias funkcijas, kurias galite naudoti kartojant per masyvus / kolekcijas.

Pavyzdžiui:

 _.each([1, 2, 3], function(num){ alert(num); }); => alerts each number in turn... 
25
17 апр. Atsakyti Andrew Thomson balandžio 17 d 2012-04-17 02:33 '12 at 2:33 2012-04-17 02:33

Masyvo kontūras:

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

Objekto ciklas:

 for(var prop in obj){ var propValue = obj[prop]; console.log(propValue); } 
24
02 авг. atsakymas duotas bzim 02 rug . 2016-08-02 00:18 '16 at 0:18 2016-08-02 00:18

Taip, jūs galite padaryti tą patį ir „JavaScript“ naudodami kilpą, bet neapsiribojant ja, daug būdų, kaip „JavaScrip“ susieti masyvus, įsivaizduokite, kad turite šią masyvą žemiau, ir norite jį perjungti

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

Tai yra sprendimai:

1) ciklui

Jei naudojate kilpą, tai yra bendrasis „looping“ matricų „JavaScript“ būdas, tačiau jis nėra laikomas sparčiausiai didelių matricų sprendimu:

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

2) Bye ciklas

Nors kilpa laikoma sparčiausiai perkeliant ilgus matricus, bet dažniausiai mažiau naudojama „JavaScript“:

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

3) Во время
Делайте, делая то же самое, что и с некоторыми различиями синтаксиса, как показано ниже:

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