come interrompere la funzione _.each in underscore.js

Sto cercando un modo per interrompere le iterazioni del _.each()metodo underscore.js , ma non riesco a trovare la soluzione. jQuery .each()può rompersi se lo fai return false.

C'è un modo per smettere di sottolineare ciascuna ()?

_([1,2,3]).each(function(v){
    if (v==2) return /*what?*/;
})

Non puoi interrompere il eachmetodo: emula il forEachcomportamento del metodo nativo e il nativo forEachnon provvede a sfuggire al ciclo (oltre a generare un'eccezione).

Tuttavia, ogni speranza non è persa! Puoi usare ilArray.every metodo :)

Da quel link:

everyesegue callbackuna volta la funzione fornita per ciascun elemento presente nella matrice fino a quando non ne trova una in cui callbackrestituisce un valore falso. Se viene trovato un tale elemento, il everymetodo restituisce immediatamente falso.

In altre parole, potresti fare qualcosa di contorto come questo ( link a JSFiddle ):

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

Questo avviserà 1attraverso 3, e poi "rompere" fuori dal giro.

Stai usando underscore.js, in modo da sarete contenti di sapere che essa non fornisce un everymetodo-lo chiamano every, ma come quel link menziona, ma anche fornire un alias chiamato all.

Aggiornare:

_.find sarebbe meglio in quanto esce dal ciclo quando viene trovato l'elemento:

var searchArr = [{id:1,text:"foo"},{id:2,text:"bar"}];
var count = 0;
var filteredEl = _.find(searchArr,function(arrEl){ 
              count = count +1;
              if(arrEl.id === 1 ){
                  return arrEl;
              }
            });

console.log(filteredEl);
//since we are searching the first element in the array, the count will be one
console.log(count);
//output: filteredEl : {id:1,text:"foo"} , count: 1

** Vecchio **

Se vuoi uscire condizionatamente da un ciclo, usa _.filter api invece di _.each. Ecco uno snippet di codice

var searchArr = [{id:1,text:"foo"},{id:2,text:"bar"}];
var filteredEl = _.filter(searchArr,function(arrEl){ 
                  if(arrEl.id === 1 ){
                      return arrEl;
                  }
                });
console.log(filteredEl);
//output: {id:1,text:"foo"}

Puoi dare un'occhiata a _.someinvece di _.each. _.somesmette di attraversare l'elenco una volta che un predicato è vero. I risultati possono essere memorizzati in una variabile esterna.

_.some([1, 2, 3], function(v) {
    if (v == 2) return true;
})

Vedi http://underscorejs.org/#some

_([1,2,3]).find(function(v){
    return v if (v==2);
})

Forse vuoi Underscore's any () o find (), che interromperà l'elaborazione quando viene soddisfatta una condizione.

Come le altre risposte, è impossibile. Ecco il commento su breaker nel trattino di sottolineatura numero 21

Non è possibile rompere un carattere forEachdi sottolineatura in, poiché emula il comportamento nativo di EcmaScript 5.

Credo che se il tuo array fosse effettivamente un oggetto che potresti restituire usando un oggetto vuoto.

_.({1,2,3,4,5}).each(function(v){  
  if(v===3) return {}; 
});

È anche bene notare che non è possibile interrompere un loop per - per interrompere, utilizzare invece _.find.

http://underscorejs.org/#each

Aggiornare:

Puoi effettivamente "rompere" lanciando un errore all'interno e catturandolo all'esterno: qualcosa del genere:

try{
  _([1,2,3]).each(function(v){
    if (v==2) throw new Error('break');
  });
}catch(e){
  if(e.message === 'break'){
    //break successful
  }
}

Questo ovviamente ha alcune implicazioni per quanto riguarda eventuali altre eccezioni che il tuo codice attiva nel ciclo, quindi usa con cautela!

ha funzionato nel mio caso

var arr2 = _.filter(arr, function(item){
    if ( item == 3 ) return item;
});