for - jquery each class

Anidado jQuery.each()-continuar/romper

Question

Considera el siguiente código:

 var sentences = [
''Lorem ipsum dolor sit amet, consectetur adipiscing elit.'',
''Vivamus aliquet nisl quis velit ornare tempor.'',
''Cras sit amet neque ante, eu ultrices est.'',
''Integer id lectus id nunc venenatis gravida nec eget dolor.'',
''Suspendisse imperdiet turpis ut justo ultricies a aliquet tortor ultrices.''
];
var words = [''ipsum'', ''amet'', ''elit''];
$(sentences).each(function() {
var s = this;
alert(s);
$(words).each(function(i) {
if (s.indexOf(this) > -1)
{
alert(''found '' + this);
return false;
}
});
});

La parte interesante son los bucles jQuery.each () anidados. Según la documentación , devolver falso saldrá del bucle (interrumpir la ejecución del bucle, similar a una instrucción de interrupción de JavaScript normal) y devolver no-falso detendrá la iteración actual y continuará con la siguiente iteración (similar a una repetición normal). Declaración de JavaScript continue).

Puedo romper o continuar un jQuery.each () por sí mismo, pero con jQuery.each anidado, me ha resultado difícil salir del bucle padre desde el bucle secundario. Podría usar un valor booleano y actualizarlo en cada iteración hija, pero me preguntaba si habría una manera más fácil.

He creado un ejemplo en jsFiddle si quieres perder el tiempo con él. Simplemente haga clic en el botón "Probar" para ejecutar el ejemplo que se muestra arriba.

TLDR: ¿hay algo parecido a una etiqueta de continuar o romper en el contexto de jQuery?

Answer 1

Deberías hacer esto sin jQuery, puede que no sea tan "bonito", pero hay menos problemas y es más fácil hacer exactamente lo que quieres, como este:

var sentences = [
''Lorem ipsum dolor sit amet, consectetur adipiscing elit.'',
''Vivamus aliquet nisl quis velit ornare tempor.'',
''Cras sit amet neque ante, eu ultrices est.'',
''Integer id lectus id nunc venenatis gravida nec eget dolor.'',
''Suspendisse imperdiet turpis ut justo ultricies a aliquet tortor ultrices.''
];
var words = [''ipsum'', ''amet'', ''elit''];
for(var s=0; s<sentences.length; s++) {
alert(sentences[s]);
for(var w=0; w<words.length; w++) {
if(sentences[s].indexOf(words[w]) > -1) {
alert(''found '' + words[w]);
return;
}
}
}

Puedes probarlo aquí . No estoy seguro de si este es el comportamiento exacto que buscas, pero ahora no estás en un cierre dentro de un cierre creado por el double .each() y puedes return o break cuando quieras en este caso.

Answer 2

El problema aquí es que si bien puede devolver falso desde dentro de .each devolución de llamada, la función .each devuelve el objeto jQuery. Entonces debe devolver un falso en ambos niveles para detener la iteración del ciclo. Además, dado que no hay manera de saber si el .each interno encontró una coincidencia o no, tendremos que usar una variable compartida utilizando un cierre que se actualice.

Cada iteración interna de words refiere a la misma variable notFound , por lo que solo debemos actualizarla cuando se encuentre una coincidencia, y luego devolverla. El cierre exterior ya tiene una referencia, por lo que puede salir cuando sea necesario.

$(sentences).each(function() {
var s = this;
var notFound = true;
$(words).each(function() {
return (notFound = (s.indexOf(this) == -1));
});
return notFound;
});

Puedes probar tu ejemplo aquí .

Answer 3

Lamentablemente no. El problema aquí es que la iteración ocurre dentro de las funciones, por lo que no son como los bucles normales. La única manera en que puede "romperse" una función es regresar o lanzar una excepción. Entonces, sí, usar una bandera booleana parece ser la única forma razonable de "romper" el "bucle" externo.

Answer 4

No hay una manera clara de hacer esto y, como @Nick mencionado anteriormente, podría ser más fácil usar la forma de bucles de la vieja escuela, ya que entonces puedes controlar esto. Pero si quieres mantenerte con lo que tienes, hay una forma de que puedas manejar esto. Estoy seguro de que conseguiré algo de calor para este. Pero...

Una forma de hacer lo que quiere sin una instrucción if es generar un error y envolver su ciclo con un bloque try / catch:

try{
$(sentences).each(function() {
var s = this;
alert(s);
$(words).each(function(i) {
if (s.indexOf(this) > -1)
{
alert(''found '' + this);
throw "Exit Error";
}
});
});
}
catch (e)
{
alert(e)
}

Ok, deja que empiece la paliza.

Answer 5

devolver verdadero no funciona

devolver falso trabajo

found = false;
query = "foo";
$(''.items'').each(function()
{
if($(this).text() == query)
{
found = true;
return false;
}
});

Answer 6

Rotura etiquetada

outerloop:
$(sentences).each(function()
{
$(words).each(function(i)
{
break; /* breaks inner loop */
}
$(words).each(function(i)
{
break outerloop; /* breaks outer loop */
}
}

Answer 7

Como se indica en la documentación de jQuery http://api.jquery.com/jQuery.each/ a return true; es lo mismo que continue; en un bucle y un return false; es lo mismo que un break;

Answer 8

Hay muchas respuestas aquí. Y es viejo, pero esto es para cualquiera que venga aquí a través de google. En jQuery cada función

return false; es como un break .

sólo

return; es como continue

Estos emularán el comportamiento de break y continuarán.

Answer 9

Confirme en la documentación de API http://api.jquery.com/jQuery.each/ decir:

Podemos romper el bucle $ .each () en una iteración particular haciendo que la función de devolución de llamada devuelva falso. La devolución de no falso es lo mismo que una instrucción continuar en un ciclo for; saltará de inmediato a la próxima iteración.

y este es mi ejemplo http://jsfiddle.net/r6jqP/

(function($){
$(''#go'').on(''click'',function(){
var i=0,
all=0;
$(''li'').each(function(){
all++;
if($(''#mytext'').val()==''continue'')return true;
i++;
if($(''#mytext'').val()==$(this).html()){
return false;
}
});
alert(''Iterazione : ''+i+'' to ''+all);
});
}(jQuery));

Answer 10

He usado un patrón de "ruptura" para esto:

$(sentences).each(function() {
var breakout;
var s = this;
alert(s);
$(words).each(function(i) {
if (s.indexOf(this) > -1)
{
alert(''found '' + this);
return breakout = false;
}
});
return breakout;
});

Esto funciona muy bien con cualquier profundidad de anidación. breakout es una bandera simple. Permanecerá undefined menos y hasta que lo establezca en false (como lo hago en mi declaración de devolución como se ilustra arriba). Todo lo que tienes que hacer es:

1. declararlo en su cierre más externo: var breakout;
2. agréguela a su return false (s) de return breakout = false : return breakout = false
3. regrese la ruptura en su (s) cierre (s) externo (s).

No muy poco elegante, ¿verdad? ... funciona para mí de todos modos.