Il ritorno arresta un ciclo?

Supponiamo che io abbia un ciclo come questo:

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

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

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

Domanda veloce: returninterrompe l'esecuzione del loop in sé e per sé?

Sì, returninterrompe l'esecuzione ed esce dalla funzione.return** sempre esce immediatamente dalla sua funzione, senza ulteriori esecuzioni se si trova all'interno di un ciclo for.

È facilmente verificabile per te:

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

alert(returnMe());
// 1

** Note: vedere questa altra risposta sul caso speciale di try/catch/finally e questa risposta su come ogni ciclo ha il suo ambito di funzione non uscirà dalla funzione di contenimento.

Nella maggior parte dei casi (incluso questo), returnuscirà immediatamente. Tuttavia, se il ritorno è in un tryblocco con un finallyblocco associato , finallyviene sempre eseguito e può "sovrascrivere" il file returnin 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' returnistruzione interrompe un ciclo solo se si trova all'interno della funzione. Altrimenti, otterrai questo errore:

Uncaught SyntaxError: Illegal return statement(…)

Questo codice uscirà dal ciclo dopo la prima iterazione in un for ofciclo:

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

il codice seguente salterà sulla condizione e continuerà su un for ofciclo:

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

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

Sì, una volta che il return eseguita istruzione, l'intera funzione viene abbandonata proprio in quel momento.

Immagina cosa succederebbe se non lo facesse e continuasse ad eseguire il ciclo e ad eseguire questa returnaffermazione ogni volta? Invaliderebbe il suo significato di restituire un valore quando ci pensi.

La risposta è sì, se si scrive l'istruzione return, i controlli tornano immediatamente al metodo del chiamante. Con l'eccezione di finally block, che viene eseguito dopo l'istruzione return.

e infine può anche sovrascrivere il valore che hai restituito, se ritorni all'interno del blocco finally. LINK: chiarimento Try-catch-finally-return

Definizione dell'istruzione di reso secondo:

Documenti Java:

un'istruzione return può essere utilizzata per derivare da un blocco del flusso di controllo ed uscire dal metodo

Documentazione MSDN:

L'istruzione return termina l'esecuzione di una funzione e restituisce il controllo alla funzione chiamante. L'esecuzione riprende nella funzione di chiamata nel punto immediatamente successivo alla chiamata.

Wikipedia:

Una dichiarazione di ritorno fa sì che l'esecuzione lasci la subroutine corrente e riprenda nel punto nel codice immediatamente dopo la chiamata della subroutine, noto come indirizzo di ritorno. L'indirizzo di ritorno viene salvato, generalmente nello stack di chiamate del processo, come parte dell'operazione di esecuzione della chiamata di subroutine. Le dichiarazioni di ritorno in molte lingue consentono a una funzione di specificare un valore di ritorno da restituire al codice che ha chiamato la funzione.

"return" esce dalla funzione ma se si desidera restituire grandi somme di dati, è possibile memorizzarlo in un array e quindi restituirlo invece di provare a restituire ogni pezzo di dati 1 per 1 nel ciclo.