Le retour arrête-t-il une boucle?

Supposons que j'ai une boucle comme celle-ci:

for (var i = 0; i < SomeArrayOfObject.length; i++) {

  if (SomeArray[i].SomeValue === SomeCondition) {

     var SomeVar = SomeArray[i].SomeProperty;
     return SomeVar;
  }
}

Question rapide: l' returnarrêt de l'exécution de la boucle en soi?

Oui, returnarrête l'exécution et quitte la fonction. returnalways ** quitte sa fonction immédiatement, sans autre exécution si elle se trouve dans une boucle for.

Il se vérifie facilement par vous-même:

function returnMe() {
  for (var i=0; i<2; i++) {
    if (i === 1) return i;
  }
}

alert(returnMe());
// 1

** Notes: Voir cette autre réponse sur le cas particulier de try/catch/finally et cette réponse sur la façon dont les boucles forEach ont sa propre portée de fonction ne sortira pas de la fonction contenant.

Dans la plupart des cas (y compris celui-ci), se returnterminera immédiatement. Cependant, si le retour est dans un trybloc avec un finallybloc qui l' accompagne , le finallys'exécute toujours et peut "écraser" le returndans le try.

function foo() {
    try {
        for (var i = 0; i < 10; i++) {
            if (i % 3 == 0) {
                return i; // This executes once
            }
        }
    } finally {
        return 42; // But this still executes
    }
}

console.log(foo()); // Prints 42

L' returninstruction arrête une boucle uniquement si elle se trouve à l'intérieur de la fonction. Sinon, vous obtiendrez cette erreur:

Uncaught SyntaxError: Illegal return statement(…)

Ce code quittera la boucle après la première itération d'une for ofboucle:

const objc = [{ name: 1 }, { name: 2 }, { name: 3 }];
for (const iterator of objc) {
  if (iterator.name == 2) {
    return;
  }
  console.log(iterator.name);// 1
}

le code ci-dessous sautera sur la condition et continuera sur une for ofboucle:

const objc = [{ name: 1 }, { name: 2 }, { name: 3 }];

for (const iterator of objc) {
  if (iterator.name == 2) {
    continue;
  }
  console.log(iterator.name); // 1  , 3
}

Oui, une fois l' returninstruction exécutée, la fonction entière est quittée à ce point précis.

Imaginez ce qui se passerait si ce n'était pas le cas et continuait à boucler et à exécuter cette returninstruction à chaque fois? Cela invaliderait son sens de renvoyer une valeur lorsque vous y réfléchissez.

La réponse est oui, si vous écrivez une instruction return, les contrôles reviennent immédiatement à la méthode appelante. À l'exception du bloc finally, qui est exécuté après l'instruction return.

et enfin peut également remplacer la valeur que vous avez retournée, si vous retournez à l'intérieur du bloc finally. LIEN: clarification Try-catch-finally-return

Définition de la déclaration de retour selon:

Documents Java:

une instruction return peut être utilisée pour sortir d'un bloc de flux de contrôle et quitter la méthode

Documentation MSDN:

L'instruction return met fin à l'exécution d'une fonction et retourne le contrôle à la fonction appelante. L'exécution reprend dans la fonction appelante au point suivant immédiatement l'appel.

Wikipédia:

Une instruction return provoque l'exécution de quitter le sous-programme en cours et de reprendre au point dans le code immédiatement après où le sous-programme a été appelé, connu comme son adresse de retour. L'adresse de retour est enregistrée, généralement sur la pile d'appels du processus, dans le cadre de l'opération d'appel de sous-programme. Les instructions de retour dans de nombreux langages permettent à une fonction de spécifier une valeur de retour à renvoyer au code qui a appelé la fonction.

"return" quitte la fonction mais si vous voulez renvoyer de grandes sommes de données, vous pouvez les stocker dans un tableau puis les renvoyer au lieu d'essayer de renvoyer chaque élément de données 1 par 1 dans la boucle.