it-swarm-eu.dev

Pro-každý přes pole v JavaScriptu?

Jak mohu procházet všechny položky v poli pomocí JavaScriptu?

Myslel jsem, že to bylo něco takového:

forEach(instance in theArray)

Kde theArray je mé pole, ale toto se zdá být nesprávné.

4056
Dante1986

Edit: Tato odpověď je beznadějně zastaralá. Pro modernější přístup, podívejte se na metody dostupné na poli . Zajímavé metody mohou být:

  • pro každého
  • mapa
  • filtr
  • Zip
  • snížit
  • každý
  • nějaký

Standardní způsob, jak iterovat pole v JavaScriptu je Vanilla for- loop:

var length = arr.length,
    element = null;
for (var i = 0; i < length; i++) {
  element = arr[i];
  // Do something with element
}

Všimněte si však, že tento přístup je dobrý pouze v případě, že máte husté pole a každý index je obsazen prvkem. Pokud je pole řídké, můžete s tímto přístupem narazit na problémy s výkonem, protože budete iterovat přes mnoho indexů, které v poli neexistují opravdu. V tomto případě může být lepší for .. in- loop. Nicméně, musíte použít odpovídající zabezpečení, abyste zajistili, že se budou jednat pouze o požadované vlastnosti pole (tj. Prvky pole), protože for..in- smyčka bude také vyčíslena v starších prohlížečích nebo pokud další vlastnosti jsou definovány jako enumerable.

V ECMAScript 5 bude na prototypu pole metoda forEach, ale není podporována v starších prohlížečích. Abyste je mohli používat konzistentně, musíte mít buď prostředí, které je podporuje (například Node.js pro server JavaScript na straně serveru), nebo použít "Polyfill". Polyfill pro tuto funkcionalitu je však triviální a protože to usnadňuje čtení kódu, je to dobrý polyfill.

473
PatrikAkerstrand

Pokud používáte knihovnu jQuery , můžete použít jQuery.each :

$.each(yourArray, function(index, value) {
  // do your stuff here
});

UPRAVIT : 

Na otázku, uživatel chce kód v JavaScriptu místo jquery, takže editace je

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

Některé C - jazyky stylu používají foreach ke smyčce přes enumerations. V JavaScriptu se to děje pomocí for..in struktury smyček :

var index,
    value;
for (index in obj) {
    value = obj[index];
}

Tam je úlovek. for..in bude procházet každým z výčtových členů objektu a členy na jeho prototypu. Chcete-li se vyhnout čtení hodnot, které jsou zděděny prostřednictvím prototypu objektu, jednoduše zkontrolujte, zda vlastnost patří objektu:

for (i in obj) {
    if (obj.hasOwnProperty(i)) {
        //do stuff
    }
}

Navíc - ECMAScript 5 přidal forEach metodu k Array.prototype, která může být použita k výčtu přes pole pomocí calbacku (polyfill je v dokumentech, takže ho můžete použít i pro starší prohlížeče):

arr.forEach(function (val, index, theArray) {
    //do stuff
});

Je důležité si uvědomit, že Array.prototype.forEach se nerozbije, když zpětné volání vrátí false. jQuery a Underscore.js poskytují své vlastní variace na each pro poskytování smyček, které mohou být zkratovány.

75
zzzzBov

Pokud chcete smyčku přes pole, použijte standardní třídílné smyčky for.

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

Některá optimalizace výkonu můžete získat pomocí ukládání do mezipaměti myArray.length nebo iterací nad ním.

34
Quentin

Pokud vám to nevadí vyprázdnit pole:

var x;

while(x = y.pop()){ 

    alert(x); //do something 

}

x bude obsahovat poslední hodnotu y a bude odstraněna z pole. Můžete také použít shift(), který dá a odstraní první položku z y.

27
gaby de wilde

Implementace forEach ( viz jsFiddle ):

function forEach(list,callback) {
  var length = list.length;
  for (var n = 0; n < length; n++) {
    callback.call(list[n]);
  }
}

var myArray = ['hello','world'];

forEach(
  myArray,
  function(){
    alert(this); // do something
  }
);
27
nmoliveira

Snadné řešení by bylo použít knihovnu underscore.js . Poskytuje mnoho užitečných nástrojů, například each a automaticky deleguje úlohu na nativní forEach, pokud je k dispozici.

Příklad CodePen jak to funguje:

var arr = ["elemA", "elemB", "elemC"];
_.each(arr, function(elem, index, ar)
{
...
});

Viz také

24
Micka

Existují tři implementace foreach v jQuery následovně.

var a = [3,2];

$(a).each(function(){console.log(this.valueOf())}); //Method 1
$.each(a, function(){console.log(this.valueOf())}); //Method 2
$.each($(a), function(){console.log(this.valueOf())}); //Method 3
24
Rajesh Paul

Pravděpodobně není smyčka for(i = 0; i < array.length; i++) tou nejlepší volbou. Proč? Pokud máte toto:

var array = new Array();
array[1] = "Hello";
array[7] = "World";
array[11] = "!";

Metoda zavolá z array[0] do array[2]. Za prvé, to bude první referenční proměnné, které ještě nemáte, za druhé byste neměli proměnné v poli, a třetí to bude dělat tučnější kód. Podívej se tady, to je to, co používám:

for(var i in array){
    var el = array[i];
    //If you want 'i' to be INT just put parseInt(i)
    //Do something with el
}

A pokud chcete, aby to byla funkce, můžete to udělat:

function foreach(array, call){
    for(var i in array){
        call(array[i]);
    }
}

Pokud se chcete rozbít, trochu logičtěji:

function foreach(array, call){
    for(var i in array){
        if(call(array[i]) == false){
            break;
        }
    }
}

Příklad:

foreach(array, function(el){
    if(el != "!"){
        console.log(el);
    } else {
        console.log(el+"!!");
    }
});

Vrací:

//Hello
//World
//!!!
22
Federico Piragua

Od ES6:

list = [0, 1, 2, 3]
for (let obj of list) {
    console.log(obj)
}

Kde of se vyhne zvláštnostem spojeným s in a dělá to pracovat jako for smyčka nějakého jiného jazyka a let se váže i uvnitř smyčky jak protichůdný k uvnitř funkce.

Šířky ({}) lze vynechat, pokud existuje pouze jeden příkaz (např. V příkladu výše).

21
Zaz

Toto je iterátor pro NON-sparse seznam, kde index začíná na 0, což je typický scénář při práci s document.getElementsByTagName nebo document.querySelectorAll)

function each( fn, data ) {

    if(typeof fn == 'string')
        eval('fn = function(data, i){' + fn + '}');

    for(var i=0, L=this.length; i < L; i++) 
        fn.call( this[i], data, i );   

    return this;
}

Array.prototype.each = each;  

Příklady použití:

Příklad č. 1

var arr = [];
[1, 2, 3].each( function(a){ a.Push( this * this}, arr);
arr = [1, 4, 9]

Příklad č. 2

each.call(document.getElementsByTagName('p'), "this.className = data;",'blue');

Každá značka p získá class="blue"

Příklad č. 3

each.call(document.getElementsByTagName('p'), 
    "if( i % 2 == 0) this.className = data;",
    'red'
);

Každá další značka p získá class="red">

Příklad č. 4

each.call(document.querySelectorAll('p.blue'), 
    function(newClass, i) {
        if( i < 20 )
            this.className = newClass;
    }, 'green'
);

A konečně prvních 20 modrých p tagů se změní na zelenou

Upozornění při použití řetězce jako funkce: funkce je vytvořena mimo kontext a měla by být použita pouze tam, kde jste si jisti proměnlivým rozsahem. V opačném případě je lepší předávat funkce, které jsou intuitivnější.

17
Tim

V nativním JavaScript neexistuje žádná smyčka for each. Tuto funkci můžete použít buď pomocí knihoven (doporučuji Underscore.js ), použít jednoduchou for ve smyčce.

for (var instance in objects) {
   ...
}

Všimněte si však, že mohou existovat důvody pro použití ještě jednodušší smyčky for (viz otázka Přetečení zásobníku PROČ JE POUŽIT&IACUTE; &BDQUO;FOR&HELLIP; IN&LDQUO; S ITERAC&IACUTE; POLE TAK &SCARON;PATN&YACUTE; N&AACUTE;PAD?)

var instance;
for (var i=0; i < objects.length; i++) {
    var instance = objects[i];
    ...
}
17
joidegn

Tam je nemnoho způsobů k smyčce přes pole v JavaScriptu, jak dole:\t

for - je to nejběžnější. Plný blok kódu pro looping

var languages = ["Java", "JavaScript", "C#", "Python"];
var i, len, text;
for (i = 0, len = languages.length, text = ""; i < len; i++) {
    text += languages[i] + "<br>";
}
document.getElementById("example").innerHTML = text;
<p id="example"></p>

while - smyčka při průchodu podmínkou. Zdá se, že je to nejrychlejší smyčka

var text = "";
var i = 0;
while (i < 10) {
    text +=  i + ") something<br>";
    i++;
}
document.getElementById("example").innerHTML = text;
<p id="example"></p>

do/while - také smyčka přes blok kódu, zatímco podmínka je true, bude probíhat alespoň jednou

var text = ""
var i = 0;
do {
    text += i + ") something <br>";
    i++;
}
while (i < 10);
document.getElementById("example").innerHTML = text;
<p id="example"></p>

Funkční smyčky - forEach, map, filter, také reduce (procházejí funkcí, ale používají se, pokud potřebujete něco udělat s polem atd.).

// For example, in this case we loop through the number and double them up using the map function
var numbers = [65, 44, 12, 4];
document.getElementById("example").innerHTML = numbers.map(function(num){return num * 2});
<p id="example"></p>

Další informace a příklady týkající se funkčního programování na polích naleznete v příspěvku blogu Funkční programování v JavaScriptu: mapování, filtrování a zmenšování.

16
Alireza

ECMAScript5 (verze na Javascript) pro práci s poli.

forEach - Iteruje každou položku v poli a dělá s každou položkou vše, co potřebujete.

['C', 'D', 'E'].forEach(function(element, index) {
  console.log(element + " is the #" + (index+1) + " in musical scale");
});

// Output
// C is the #1 in musical scale
// D is the #2 in musical scale
// E is the #3 in musical scale

V případě, že se více zajímají o provoz na poli pomocí nějaké vestavěné funkce.

map - Vytvoří nové pole s výsledkem funkce zpětného volání. Tuto metodu je vhodné použít, když potřebujete formátovat prvky pole.

// Let's upper case the items in the array
['bob', 'joe', 'jen'].map(function(elem) {
  return elem.toUpperCase();
});

// Output: ['BOB', 'JOE', 'JEN']

Redukovat - Jak název říká, že snižuje pole na jednu hodnotu voláním dané funkce předané v prvku currenct a výsledku předchozího provedení.

[1,2,3,4].reduce(function(previous, current) {
  return previous + current;
});
// Output: 10
// 1st iteration: previous=1, current=2 => result=3
// 2nd iteration: previous=3, current=3 => result=6
// 3rd iteration: previous=6, current=4 => result=10

každý - Vrací hodnotu true nebo false, pokud všechny prvky v poli projdou testem funkce zpětného volání.

// Check if everybody has 18 years old of more.
var ages = [30, 43, 18, 5];  
ages.every(function(elem) {  
  return elem >= 18;
});

// Output: false

filter - Velmi podobný každému kromě toho, že filtr vrací pole s prvky, které se vrací dané funkci.

// Finding the even numbers
[1,2,3,4,5,6].filter(function(elem){
  return (elem % 2 == 0)
});

// Output: [2,4,6]

Doufám, že to bude užitečné.

14
Anil Kumar Arya

V souboru forEach není žádná schopnost vložit. Pro přerušení provádění použijte následující Array#some:

[1,2,3].some(function(number) {
    return number === 1;
});

To funguje, protože some vrátí hodnotu true, jakmile některá z zpětných volání provedená v pořadí polí vrátí hodnotu true, zkratující provedení zbytku. Původní odpověď Viz prototyp pole pro některé

14

Také bych rád přidal toto jako složení reverzní smyčky a odpověď na někoho, kdo by rád tuto syntaxi taky.

var foo = [object,object,object];
for (var i = foo.length, item; item = foo[--i];) {
    console.log(item);
}

Klady:

Přínos pro to: Máte odkaz již v první, která nebude muset být deklarována později s jiným řádkem. To je užitečné, když smyčka přes pole objektů.

Nevýhody:

Toto bude přerušeno vždy, když je odkaz false - falsey (undefined atd.). Lze ji však využít jako výhodu. Bylo by to však o něco těžší číst. A také v závislosti na prohlížeči to může být "ne" optimalizován pracovat rychleji než původní.

jQuery způsobem pomocí $.map:

var data = [1, 2, 3, 4, 5, 6, 7];

var newData = $.map(data, function(element) {
    if (element % 2 == 0) {
        return element;
    }
});

// newData = [2, 4, 6];
10
DanFromGermany

Způsob, který je nejblíže vaší myšlence, je použít Array.forEach(), která přijímá funkci clojure, která bude provedena pro každý prvek pole.

myArray.forEach(
  (item) => {
    // do something 
    console.log(item);
  }
);

Dalším možným způsobem by bylo použití Array.map(), které funguje stejným způsobem, ale také mutates každý prvek a vrátí jej jako:

var myArray = [1, 2, 3];
myArray = myArray.map(
  (item) => {
    return item + 1;
  }
);

console.log(myArray); // [2, 3, 4]
6

Použití smyček s ES6 destrukturace a operátor rozprostření

Destrukturace a použití operátorů šíření se ukázaly jako velmi užitečné pro nováčky do ES6 jako více lidsky čitelné/estetické, i když někteří veteráni javascriptu to mohou považovat za chaotický, junioři nebo jiní lidé by to mohli považovat za užitečné.

Následující příklady budou používat metodu for...of příkaz a .forEach .

Příklady 6, 7 a 8 mohou být použity s libovolnými funkčními smyčkami jako .map, .filter, .reduce, .sort, .every, .some, pro více informací o těchto metodách se podívejte na Array Object .

Příklad 1: Normální for...of smyčka - žádné triky zde.

let arrSimple = ['a', 'b', 'c'];

for (let letter of arrSimple) {
  console.log(letter);
}

Příklad 2: Rozdělit slova na znaky

let arrFruits = ['Apple', 'orange', 'banana'];

for (let [firstLetter, ...restOfTheWord] of arrFruits) {
  // Create a shallow copy using the spread operator
  let [lastLetter] = [...restOfTheWord].reverse();
  console.log(firstLetter, lastLetter, restOfTheWord);

}

Příklad 3: Opakování s key a value 

// let arrSimple = ['a', 'b', 'c'];

// Instead of keeping an index in `i` as per example `for(let i = 0 ; i<arrSimple.length;i++)`
// this example will use a multi-dimensional array of the following format type: 
// `arrWithIndex: [number, string][]`

let arrWithIndex = [
  [0, 'a'],
  [1, 'b'],
  [2, 'c'],
];

// Same thing can be achieved using `.map` method
// let arrWithIndex = arrSimple.map((i, idx) => [idx, i]);

// Same thing can be achieved using `Object.entries`
// NOTE: `Object.entries` method doesn't work on internet Explorer unless it's polyfilled
// let arrWithIndex = Object.entries(arrSimple);

for (let [key, value] of arrWithIndex) {
  console.log(key, value);
}

Příklad 4: Získání vlastností objektu inline

let arrWithObjects = [{
    name: 'Jon',
    age: 32
  },
  {
    name: 'Elise',
    age: 33
  }
];

for (let { name, age: aliasForAge } of arrWithObjects) {
  console.log(name, aliasForAge);
}

Příklad 5: Získejte vlastnosti hlubokého objektu toho, co potřebujete

let arrWithObjectsWithArr = [{
    name: 'Jon',
    age: 32,
    tags: ['driver', 'chef', 'jogger']
  },
  {
    name: 'Elise',
    age: 33,
    tags: ['best chef', 'singer', 'dancer']
  }
];

for (let { name, tags: [firstItemFromTags, ...restOfTags] } of arrWithObjectsWithArr) {
  console.log(name, firstItemFromTags, restOfTags);
}

Příklad 6: Je použito Příklad 3 s .forEach

let arrWithIndex = [
  [0, 'a'],
  [1, 'b'],
  [2, 'c'],
];

// Not to be confused here, `forEachIndex` is the real index
// `mappedIndex` was created by "another user", so you can't really trust it

arrWithIndex.forEach(([mappedIndex, item], forEachIndex) => {
  console.log(forEachIndex, mappedIndex, item);
});

Příklad 7: Je použito Příklad 4 s .forEach

let arrWithObjects = [{
    name: 'Jon',
    age: 32
  },
  {
    name: 'Elise',
    age: 33
  }
];
// NOTE: Destructuring objects while using shorthand functions 
// are required to be surrounded by parenthesis
arrWithObjects.forEach( ({ name, age: aliasForAge }) => {
  console.log(name, aliasForAge)
});

Příklad 8: Je Příklad 5 použito s .forEach

let arrWithObjectsWithArr = [{
    name: 'Jon',
    age: 32,
    tags: ['driver', 'chef', 'jogger']
  },
  {
    name: 'Elise',
    age: 33,
    tags: ['best chef', 'singer', 'dancer']
  }
];

arrWithObjectsWithArr.forEach(({
  name,
  tags: [firstItemFromTags, ...restOfTags]
}) => {
  console.log(name, firstItemFromTags, restOfTags);
});

6
darklightcode

Syntaxe lambda obvykle nefunguje v IE 10 nebo nižších.

Obvykle používám

[].forEach.call(arrayName,function(value,index){
    console.log("value of the looped element" + value);
    console.log("index of the looped element" + index);
});


If you are a jQuery Fan and already have a jQuery file running, you should reverse the positions of the index and value parameters

$("#ul>li").each(function(**index,value**){
    console.log("value of the looped element" + value);
    console.log("index of the looped element" + index);
});
5
Murtuza Husain

Můžete volat forEach Like this:

let Array = [1,3,2];

theArray.forEach((element)=>{ 
  // use the element of the array
  console.log(element) 
}

element bude mít hodnotu každého indexu od 0 do délky pole.

Výstup:

1    
3    
2

Vysvětlení:

forEach je ve třídě prototypů. můžete to také nazvatArray.prototype.forEach (...);

prototyp: https://hackernoon.com/prototypes-in-javascript-5bba2990e04b

Můžete také změnit toto pole:

for(let i=0;i<theArray.length;i++){
  console.log(i); //i will have the value of each index
}
4
Nouman Dilshad

chcete-li smyčku přes pole objektů s funkcí šipky:

let arr=[{name:'john',age:50},{name:'clark',age:19},{name:'mohan',age:26}];

arr.forEach((person)=>{
  console.log('i am '+person.name+' and i am '+person.age+ ' old');
})
3
subhashish negi

Souhrn:

Když iterujeme po poli, často chceme dosáhnout jednoho z následujících cílů:

  1. Chceme iterovat přes pole a vytvořit nové pole:

    Array.prototype.map 

  2. Chceme iterovat přes pole a nevytvářet nové pole:

    Array.prototype.forEach 

    for..ofloop

V JS existuje mnoho způsobů, jak splnit oba tyto cíle. Nicméně, někteří jsou více conventient než jiní. Níže najdete některé běžně používané metody (nejvhodnější imo) pro dosažení iterace pole v javascriptu.

Vytvoření nového pole: Map

map() je funkce umístěná na Array.prototype, která může transformovat každý prvek pole a poté vrátí pole new. map() bere jako argument funkci zpětného volání a funguje následujícím způsobem:

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

let newArr = arr.map((element, index, array) => {
  return element * 2;
})

console.log(arr);
console.log(newArr);

Zpětné volání, které jsme předali do parametru map() jako argument, se provede pro každý prvek. Pak se vrátí pole, které má stejnou délku jako původní pole. V tomto novém elementu pole je transformována funkce zpětného volání předaná jako argument map().

Odlišný rozdíl mezi map a jiným mechanismem smyčky, jako je forEach a smyčka for..of, je to, že map se vrací jako nové pole a ponechává staré pole neporušené (s výjimkou případů, kdy s ním explicity manipulujete s myšlenkami jako splice). 

Všimněte si také, že zpětné volání funkce map poskytuje jako druhý argument číslo indexu aktuální iterace. Dále třetí argument poskytuje pole, na kterém bylo voláno map. Někdy tyto vlastnosti mohou být velmi užitečné.

Smyčka pomocí forEach

forEach je funkce, která je umístěna na Array.prototype, která jako argument používá funkci zpětného volání. Potom provede tuto funkci zpětného volání pro každý prvek v poli. Na rozdíl od funkce map() funkce forEach vrací nic (undefined). Například:

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

arr.forEach((element, index, array) => {

  console.log(element * 2);

  if (index === 4) {
    console.log(array)
  }
  // index, and oldArray are provided as 2nd and 3th argument by the callback

})

console.log(arr);

Podobně jako funkce map, zpětné volání forEach poskytuje jako druhý argument číslo indexu aktuální iterace. Také třetí argument poskytuje pole, na kterém bylo voláno forEach

Smyčka přes prvky pomocí for..of

Smyčka for..of prochází každým prvkem pole (nebo jiným iterovatelným objektem). Funguje následujícím způsobem:

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

for(let element of arr) {
  console.log(element * 2);
}

Ve výše uvedeném příkladu element znamená prvek pole a arr je pole, které chceme smyčku. Není to tak, že jméno element je libovolné a mohli bychom si vybrat jiné jméno jako 'el' nebo něco více deklarativního, když je to použitelné. 

Nezaměňujte smyčku for..in se smyčkou for..of. for..in bude procházet všemi výčtovými vlastnostmi pole, zatímco smyčka for..of bude procházet pouze prvky pole. Například:

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

arr.foo = 'foo';

for(let element of arr) {
  console.log(element);
}

for(let element in arr) {
  console.log(element);
}

2

Pokud máte masivní pole, měli byste použít iterators pro získání nějaké účinnosti. Iterátory jsou majetkem určitých sbírek JavaScriptu (jako Map , Set , String , Array ). Dokonce, for..of uses iterator pod kapotou.

Iterátoři zlepšují efektivitu tím, že nechávají konzumovat položky v seznamu po jednom, jako kdyby to byl proud. Co dělá iterátor zvláštní je jak to projde sbírkou. Jiné smyčky potřebují načíst celou sbírku dopředu, aby ji mohly iterovat, zatímco iterátor potřebuje znát pouze aktuální pozici ve sbírce. 

K aktuální položce přistupujete voláním metody next iterátoru. Další metoda vrátí value aktuální položky a boolean, aby indikovala, kdy jste dosáhli konce kolekce. Následuje příklad vytvoření iterátoru z pole. 

Transformujte své běžné pole na iterátor pomocí values() metody takto: 

    const myArr = [2,3,4]

let it = myArr.values();

console.log(it.next());
console.log(it.next());
console.log(it.next());
console.log(it.next());

Pravidelné pole můžete také převést na iterátor pomocí Symbol.iterator takto: 

const myArr = [2,3,4]

let it = myArr[Symbol.iterator]();

console.log(it.next());
console.log(it.next());
console.log(it.next());
console.log(it.next());

Pravidelnou array můžete také transformovat na iterator takto: 

let myArr = [8, 10, 12];

function makeIterator(array) {
    var nextIndex = 0;
    
    return {
       next: function() {
           return nextIndex < array.length ?
               {value: array[nextIndex++], done: false} :
               {done: true};
       }
    };
};

var it = makeIterator(myArr);

console.log(it.next().value);   // {value: 8, done: false}
console.log(it.next().value);   // {value: 10, done: false}
console.log(it.next().value);   // {value: 12, done: false}
console.log(it.next().value);   // {value: undefined, done: true}

POZN&AACUTE;MKA

  • Iterátory jsou v přírodě vyčerpatelné. 
  • Objekty nejsou ve výchozím nastavení iterable. Použijte for..in v tomto případě, protože místo hodnot pracuje s klávesami.

Více o iteration protocolzde

1
BlackBeard
var a = ["car", "bus", "truck"]
a.forEach(function(item, index) {
    console.log("Index" + index);
    console.log("Element" + item);
})
1
John

// Looping through arrays using foreach  ES6 way

var data = new Array(1,2,3,4,5);
data.forEach((val,index) => {
    console.log("index :",index); // index
	console.log("value :", val); // value
});

0
arul prince

Můžete použít API forEach () (poskytované Javascriptem), které přijímá funkci zpětného volání a spouští jednou pro každý prvek přítomný v poli.

https://fullstackgeek.blogspot.com/2019/01/arrays-in-javascript-part-2.html

0
Ayush Jain

Pocházím z pythonu a zjistil jsem, že je to mnohem jasnější.
Aray je pole, instancí je prvek pole

for(let instance of theArray)
{
    console.log("The instance",instance);
}

nebo

for( instance in theArray)
{
  console.log("The instance",instance);
}

porovnat s:

theArray.forEach(function(instance) {
    console.log(instance);
});

ale na konci dne oba dělají totéž

0
Peko Chan

Chcete-li kód udržet funkčním způsobem, použijte mapu:

theArray.map(instance => do_something);

Tímto způsobem budete generovat nové pole do budoucího provozu a vynecháte žádný nežádoucí vedlejší efekt.

0
alejoko

Pokud chcete použít forEach(), bude to vypadat takto: 

theArray.forEach ( element => {
    console.log(element);
});

Pokud chcete použít for(), bude to vypadat takto: 

for(let idx = 0; idx < theArray.length; idx++){
    let element = theArray[idx];
    console.log(element);
}
0
Harunur Rashid