Kısa devre dizisi. Her çağrı çağrısı gibi

[1,2,3].forEach(function(el) {
    if(el === 1) break;
});

forEachJavaScript'teki yeni yöntemi kullanarak bunu nasıl yapabilirim ? Denedim return;, return false;ve break. breakçöküyor ve returnyinelemeye devam etmekten başka bir şey yapmıyor.

Hiçbir Orada yerleşik oluyor yeteneğini breakde forEach. Yürütmeyi durdurmak için bir tür istisna atmanız gerekir. Örneğin.

var BreakException = {};

try {
  [1, 2, 3].forEach(function(el) {
    console.log(el);
    if (el === 2) throw BreakException;
  });
} catch (e) {
  if (e !== BreakException) throw e;
}

JavaScript istisnaları çok hoş değil. İçine forgerçekten ihtiyacınız varsa, geleneksel bir döngü daha uygun olabilir break.

kullanım Array#some

Bunun yerine şunu kullanın Array#some:

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

Geri kalanı yürütme kısa devre, dizi sırayla yürütülür, herhangi bir geri aramalar, en kısa sürede somedöner true, çünkü çalışır true.

some, bunun tersi every( a'da duracaktır return false) ve eksik oldukları tarayıcılara forEacheklenmesi gereken ECMAScript Fifth Edition yöntemleridir Array.prototype.

ECMAScript2015'te (aka ES6) bunu yeni for döngüsü kullanarak yapmanın daha iyi bir yolu var . Örneğin, bu kod dizi öğelerini 5 rakamından sonra yazdırmaz:

let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
for (let el of arr) {
  console.log(el);
  if (el === 5) {
    break;
  }
}

Dokümanlardan:

Hem için ... lütfen ve for ... tabloların bir şey yüzünden yineleme. Aralarındaki temel fark, tekrar ettikleri şeydir. İçin ... lütfen ifadesi orijinal kampanya siparişinde bir nesnenin enumerable özelliklerini üzerinde dolaşır. Son zamanlarda ... ifadesi verileri üzerinde dolaşır iterable nesne tanımlar iterated edilecek söyledi.

Yinelemede dizine mi ihtiyacınız var? Şunları kullanabilirsiniz Array.entries():

for (const [index, el] of arr.entries()) {
  if ( index === 5 ) break;
}

Her yöntemi kullanabilirsiniz :

[1,2,3].every(function(el) {
    return !(el === 1);
});

ES6

[1,2,3].every( el => el !== 1 )

eski tarayıcı desteği kullanımı için:

if (!Array.prototype.every)
{
  Array.prototype.every = function(fun /*, thisp*/)
  {
    var len = this.length;
    if (typeof fun != "function")
      throw new TypeError();

    var thisp = arguments[1];
    for (var i = 0; i < len; i++)
    {
      if (i in this &&
          !fun.call(thisp, this[i], i, this))
        return false;
    }

    return true;
  };
}

daha fazla ayrıntı burada .

MDN belgelerindenArray.prototype.forEach() alıntı :

Orada durdurmak veya kırmak için hiçbir şekilde bir forEach()istisna atarak dışındaki döngü. Böyle bir davranışa ihtiyacınız varsa, .forEach()yöntem yanlış araçtır , bunun yerine düz bir döngü kullanın. Dizi öğelerini bir yüklem için test ediyorsanız ve bir boole dönüş değerine ihtiyacınız varsa, every()veya öğesini kullanabilirsiniz some().

@Bobince tarafından önerildiği gibi kodunuzda (soruda) Array.prototype.some()kullanın. Kullanıcınıza çok uygundur.

Array.prototype.some()geri çağrının bir doğruluk değeri (a dönüştürüldüğünde doğru olan bir değer) döndürdüğü yerde bulana kadar dizide bulunan her öğe için geri arama işlevini bir kez yürütür Boolean. Böyle bir eleman bulunursa, some()hemen true değerini döndürür. Aksi takdirde some()false değerini döndürür. geri arama yalnızca atanmış değerleri olan dizinin dizinleri için çağrılır; silinmiş veya hiç değer atanmamış dizinler için çağrılmaz.

Ne yazık ki bu durumda kullanmamanız daha iyi olacaktır forEach. Bunun yerine normal bir fordöngü kullanın ve şimdi tam olarak beklediğiniz gibi çalışacaktır.

var array = [1, 2, 3];
for (var i = 0; i < array.length; i++) {
  if (array[i] === 1){
    break;
  }
}

Geri arama işlevi içinde false döndürmeyi sağladığı için jquery' eachyöntemini kullanmayı düşünün :

$.each(function(e, i) { 
   if (i % 2) return false;
   console.log(e)
})

Lodash kütüphaneleri aynı zamanda takeWhileharita / azalt / katla vb. İle zincirlenebilen bir yöntem sağlar :

var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true }
];

_.takeWhile(users, function(o) { return !o.active; });
// => objects for ['barney', 'fred']

// The `_.matches` iteratee shorthand.
_.takeWhile(users, { 'user': 'barney', 'active': false });
// => objects for ['barney']

// The `_.matchesProperty` iteratee shorthand.
_.takeWhile(users, ['active', false]);
// => objects for ['barney', 'fred']

// The `_.property` iteratee shorthand.
_.takeWhile(users, 'active');
// => []

Kod örneğinizden, Array.prototype.findaradığınız şeye benziyor : Array.prototype.find () ve Array.prototype.findIndex ()

[1, 2, 3].find(function(el) {
    return el === 2;
}); // returns 2

Dean Edward'ın önerisini kullanmak ve hatayı yakalamak zorunda kalmadan döngüden çıkmak için StopIteration hatasını atmak isterseniz, aşağıdaki işlevi kullanabilirsiniz ( başlangıçta buradan ):

// Use a closure to prevent the global namespace from be polluted.
(function() {
  // Define StopIteration as part of the global scope if it
  // isn't already defined.
  if(typeof StopIteration == "undefined") {
    StopIteration = new Error("StopIteration");
  }

  // The original version of Array.prototype.forEach.
  var oldForEach = Array.prototype.forEach;

  // If forEach actually exists, define forEach so you can
  // break out of it by throwing StopIteration.  Allow
  // other errors will be thrown as normal.
  if(oldForEach) {
    Array.prototype.forEach = function() {
      try {
        oldForEach.apply(this, [].slice.call(arguments, 0));
      }
      catch(e) {
        if(e !== StopIteration) {
          throw e;
        }
      }
    };
  }
})();

Yukarıdaki kod, kendi try-catch cümlelerinizi yapmak zorunda kalmadan aşağıdakiler gibi kodu çalıştırma yeteneğini verecektir:

// Show the contents until you get to "2".
[0,1,2,3,4].forEach(function(val) {
  if(val == 2)
    throw StopIteration;
  alert(val);
});

Unutulmaması gereken önemli bir nokta, bunun Array.prototype.forEach işlevini zaten varsa güncellemesi. Zaten mevcut değilse, onu değiştirmez.

Kısa cevap: bunun için kullanın for...breakveya kırılmasını önlemek için kodunuzu değiştirin forEach. Taklit etmek için .some()veya kullanmayın . Döngüyü önlemek için kodunuzu yeniden yazın veya kullanın . Bu yöntemleri alternatif Tanrı olarak her kullandığınızda yavru kedi öldürür..every()for...breakfor...breakfor...breakfor...break

Uzun cevap:

.some()ve .every()her ikisi de geri dönüş booleandeğeri, .some()döner trueherhangi bir elemanı işlevi getiriler aktarılırsa true, her döner falseherhangi bir elemanı işlevi getiriler aktarılırsa false. Fonksiyonların anlamı budur. Ne anlama gelmedikleri için işlevleri kullanmak, CSS yerine mizanpaj için tabloları kullanmaktan daha kötüdür, çünkü kodunuzu okuyan herkesi hayal kırıklığına uğratır.

Ayrıca, bu yöntemleri for...breakalternatif olarak kullanmanın tek yolu yan etkiler yapmak ( .some()geri arama işlevinin dışındaki bazı değişkenleri değiştirmek ) ve bu çok farklı değildir for...break.

Yani, döngü alternatifi olarak .some()veya .every()olarak kullanmak for...breakyan etkilerden arınmış değildir for...break, o zaman bu çok daha temiz değildir , bu sinir bozucudur, bu yüzden daha iyi değildir.

Kodunuzu her zaman yeniden yazabilirsiniz, böylece for...break . Diziyi kullanarak filtreleyebilir .filter(), diziyi .slice()vb. Kullanarak bölebilir , sonra dizinin o kısmı için .forEach()veya kullanabilirsiniz .map().

Bu sadece sorunu çözmek için bulduğum bir şey ... Orijinal askerin sahip olduğu sorunu çözdüğünden eminim:

Array.prototype.each = function(callback){
    if(!callback) return false;
    for(var i=0; i<this.length; i++){
        if(callback(this[i], i) == false) break;
    }
};

Ve sonra şunu kullanarak çağırırsınız:

var myarray = [1,2,3];
myarray.each(function(item, index){
    // do something with the item
    // if(item != somecondition) return false; 
});

Geri arama işlevi içinde false döndürülmesi bir kesintiye neden olur. Bu gerçekten işe yaramıyorsa bana bildirin.

Geldiğim başka bir konsept:

function forEach(array, cb) {
  var shouldBreak;
  function _break() { shouldBreak = true; }
  for (var i = 0, bound = array.length; i < bound; ++i) {
    if (shouldBreak) { break; }
    cb(array[i], i, array, _break);
  }
}

// Usage

forEach(['a','b','c','d','e','f'], function (char, i, array, _break) {
  console.log(i, char);
  if (i === 2) { _break(); }
});

Bu çözümü başka bir sitede buldu. ForEach'ı bir deneme / yakalama senaryosuna sarabilirsiniz.

if(typeof StopIteration == "undefined") {
 StopIteration = new Error("StopIteration");
}

try {
  [1,2,3].forEach(function(el){
    alert(el);
    if(el === 1) throw StopIteration;
  });
} catch(error) { if(error != StopIteration) throw error; }

Daha fazla ayrıntı burada: http://dean.edwards.name/weblog/2006/07/enum/

var array = [1,2,3,4];

for(var item of array){
    console.log(item);
    if(item == 2){
       break;
    }
}

Yinelemeden sonra dizinize erişmeniz gerekmiyorsa, dizinin uzunluğunu 0 olarak ayarlayarak kefaletle serbest bırakabilirsiniz.

[1,3,4,5,6,7,8,244,3,5,2].forEach(function (item, index, arr) {
  if (index === 3) arr.length = 0;
});

Veya bir klonla:

var x = [1,3,4,5,6,7,8,244,3,5,2];

x.slice().forEach(function (item, index, arr) {
  if (index === 3) arr.length = 0;
});

Bu da kodunuza rastgele hatalar atmaktan çok daha iyi bir çözümdür.

Bu bir for döngüsüdür, ancak forEach () gibi döngüdeki nesne referansını korur, ancak ayrılabilirsiniz.

var arr = [1,2,3];
for (var i = 0, el; el = arr[i]; i++) {
    if(el === 1) break;
}

Daha önce de belirtildiği gibi, kırılamazsın .forEach() .

İşte ES6 Yineleyicileri ile bir foreach yapmanın biraz daha modern bir yolu. Yineleme sırasında index/ işlemine doğrudan erişmenizi sağlar value.

const array = ['one', 'two', 'three'];

for (const [index, val] of array.entries()) {
  console.log('item:', { index, val });
  if (index === 1) {
    console.log('break!');
    break;
  }
}

Çıktı:

item: { index: 0, val: 'one' }
item: { index: 1, val: 'two' }
break!

Bağlantılar

• Array.prototype.entries()
• Yineleyiciler ve jeneratörler
• Yıkıcı ödev

Yine başka bir yaklaşım

        var wageType = types.filter(function(element){
            if(e.params.data.text == element.name){ 
                return element;
            }
        });
        console.dir(wageType);

Ben bu amaçla nullhack kullanın null, bu bir hata olan özelliğine erişmek için çalışır :

try {
  [1,2,3,4,5]
  .forEach(
    function ( val, idx, arr ) {
      if ( val == 3 ) null.NULLBREAK;
    }
  );
} catch (e) {
  // e <=> TypeError: null has no properties
}
//

Eğer tutmak istiyorsan forEachSözdiziminizi , bu onu verimli tutmanın bir yoludur (döngü için normal kadar iyi olmasa da). Döngüden çıkmak isteyip istemediğinizi bilen bir değişkeni hemen kontrol edin.

Bu örnek, çevresinde tamamlanmış bilgileri depolamanız gereken bir işlev kapsamı oluşturmak için anonim bir işlev kullanır .forEach

(function(){
    var element = document.getElementById('printed-result');
    var done = false;
    [1,2,3,4].forEach(function(item){
        if(done){ return; }
        var text = document.createTextNode(item);
        element.appendChild(text);
        if (item === 2){
          done = true;
          return;
        }
    });
})();

<div id="printed-result"></div>

Benim görüşüm.

Doğru yoldan olmadığını biliyorum. Döngüyü kırmaz. Bu bir Jugad

let result = true;
[1, 2, 3].forEach(function(el) {
    if(result){
      console.log(el);
      if (el === 2){
        result = false;
      }
    }
});

array.prototype.everyDöngüyü kırmak için size yardımcı olan işlevi kullanın . Buradaki örneğe bakın Mozilla geliştirici ağındaki Javascript belgeleri

@Bobince, kabul edildi.

Ayrıca, FYI:

Prototype.js bu amaçla bir şey var:

<script type="text/javascript">
  $$('a').each(function(el, idx) {
    if ( /* break condition */ ) throw $break;
    // do something
  });
</script>

$break Prototype.js tarafından dahili olarak yakalanacak ve işlenecek, "her" döngüsünü kıracak, ancak harici hatalar üretmeyecektir.

Ayrıntılar için Prototype.JS API'sine bakın.

jQuery ayrıca bir yolu vardır, sadece döngüyü erken kırmak için işleyicide false döndürür:

<script type="text/javascript">
  jQuery('a').each( function(idx) {
    if ( /* break condition */ ) return false;
    // do something

  });
</script>

Ayrıntılar için jQuery API'sine bakın.

Bu hala en etkili değil, çünkü hala tüm unsurları devir ediyorsunuz, ancak çok basit düşünmeye değer olabileceğini düşündüm:

let keepGoing = true;
things.forEach( (thing) => {
  if (noMore) keepGoing = false;
  if (keepGoing) {
     // do things with thing
  }
});

benim için çalışan aşağıdaki kodu takip edebilirsiniz:

 var     loopStop = false;
YOUR_ARRAY.forEach(function loop(){
    if(loopStop){ return; }
    if(condition){ loopStop = true; }
});

Kullanmayı tercih ederim for in

var words = ['a', 'b', 'c'];
var text = '';
for (x in words) {
    if (words[x] == 'b') continue;
    text += words[x];
}
console.log(text);

for inçok benzer çalışır forEachve içindeki çıkış işlevine dönüş ekleyebilirsiniz. Daha iyi performans.

Durumunuzdaki gibi zaten dizinizde bulunan öğelerin değerine dayalı olarak kesmeniz gerekiyorsa (örneğin, kesme koşulu, dizinin öğe değerleri atandıktan sonra değişebilen çalışma zamanı değişkenine bağlı değilse) bir arada da kullanabilirsiniz. bir dilim () ve indexOf () olarak takip eder.

ForEach 'Apple' a ulaştığında kırılmanız gerekiyorsa,

var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var fruitsToLoop = fruits.slice(0, fruits.indexOf("Apple"));
// fruitsToLoop = Banana,Orange,Lemon

fruitsToLoop.forEach(function(el) {
    // no need to break
});

W3Schools.com'da belirtildiği gibi , slice () yöntemi bir dizideki seçili öğeleri yeni bir dizi nesnesi olarak döndürür. Orijinal dizi değiştirilmez.

JSFiddle'da görün

Umarım birine yardımcı olur.

Seni bir varyantını oluşturabilir forEachbunun için izin verir break, continue, returnve hatta async/ await: (örnek daktilo yazılmış)

export type LoopControlOp = "break" | "continue" | ["return", any];
export type LoopFunc<T> = (value: T, index: number, array: T[])=>LoopControlOp;

Array.prototype.ForEach = function ForEach<T>(this: T[], func: LoopFunc<T>) {
    for (let i = 0; i < this.length; i++) {
        const controlOp = func(this[i], i, this);
        if (controlOp == "break") break;
        if (controlOp == "continue") continue;
        if (controlOp instanceof Array) return controlOp[1];
    }
};

// this variant lets you use async/await in the loop-func, with the loop "awaiting" for each entry
Array.prototype.ForEachAsync = async function ForEachAsync<T>(this: T[], func: LoopFunc<T>) {
    for (let i = 0; i < this.length; i++) {
        const controlOp = await func(this[i], i, this);
        if (controlOp == "break") break;
        if (controlOp == "continue") continue;
        if (controlOp instanceof Array) return controlOp[1];
    }
};

Kullanımı:

function GetCoffee() {
    const cancelReason = peopleOnStreet.ForEach((person, index)=> {
        if (index == 0) return "continue";
        if (person.type == "friend") return "break";
        if (person.type == "boss") return ["return", "nevermind"];
    });
    if (cancelReason) console.log("Coffee canceled because: " + cancelReason);
}

"find" ile deneyin:

var myCategories = [
 {category: "start", name: "Start", color: "#AC193D"},
 {category: "action", name: "Action", color: "#8C0095"},
 {category: "exit", name: "Exit", color: "#008A00"}
];

function findCategory(category) {
  return myCategories.find(function(element) {
    return element.category === category;
  });
}

console.log(findCategory("start"));
// output: { category: "start", name: "Start", color: "#AC193D" }

Evet, bir forEach döngüsüne devam etmek ve çıkmak mümkündür.

Devam etmek için return'i kullanabilirsiniz, döngü devam eder, ancak geçerli işlev sona erer.

Döngüden çıkmak için üçüncü parametreyi 0 uzunluğuna, boş diziye ayarlayabilirsiniz. Döngü devam etmeyecek, geçerli işlev devam edecek, böylece döngü için normal bir çıkış gibi bitirmek için "return" kullanabilirsiniz ...

Bu:

[1,2,3,4,5,6,7,8,9,10].forEach((a,b,c) => {
    console.log(a);
    if(b == 2){return;}
    if(b == 4){c.length = 0;return;}
    console.log("next...",b);
});

bunu yazdıracak:

1
next... 0
2
next... 1
3
4
next... 3
5

Daha önce, kodum aşağıda

 this.state.itemsDataSource.forEach((item: any) => {
                if (!item.isByPass && (item.invoiceDate == null || item.invoiceNumber == 0)) {

                    return false;
                }
            });

Aşağıya değiştirdim, düzeltildi.

 for (var i = 0; i < this.state.itemsDataSource.length; i++) {
                var item = this.state.itemsDataSource[i];
                if (!item.isByPass && (item.invoiceDate == null || item.invoiceNumber == 0)) {

                    return false;
                }
            }