Uscita anticipata dalla funzione?

Ho una funzione:

function myfunction() {
  if (a == 'stop')  // How can I stop the function here?
}

C'è qualcosa come exit()in JavaScript?

Puoi semplicemente usare return.

function myfunction() {
     if(a == 'stop') 
         return;
}

Questo invierà un valore di ritorno undefineda qualunque cosa abbia chiamato la funzione.

var x = myfunction();

console.log( x );  // console shows undefined

Ovviamente, puoi specificare un valore di ritorno diverso. Qualunque valore venga restituito verrà registrato nella console usando l'esempio sopra.

return false;
return true;
return "some string";
return 12345;

Apparentemente puoi farlo:

function myFunction() {myFunction:{
    console.log('i get executed');
    break myFunction;
    console.log('i do not get executed');
}}

Vedi gli ambiti di blocco tramite l'uso di un'etichetta: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label

Non riesco ancora a vedere alcun aspetto negativo. Ma non sembra un uso comune.

Deriva questa risposta: equivalente JavaScript del dado di PHP

function myfunction() {
     if(a == 'stop') 
         return false;
}

return false; è molto meglio di solo return;

Questo:

function myfunction()
{
     if (a == 'stop')  // How can I stop working of function here?
     {
         return;
     }
}

Utilizzando un approccio leggermente diverso, è possibile utilizzare try catch, con istruzione throw.

function name() {
    try {
        ...

        //get out of here
        if (a == 'stop')
            throw "exit";

        ...
    } catch (e) {
        // TODO: handle exception
    }
}

se stai cercando uno script per evitare di inviare il modulo quando vengono rilevati alcuni errori, questo metodo dovrebbe funzionare

function verifyData(){
     if (document.MyForm.FormInput.value.length == "") {
          alert("Write something!");
     }
     else {
          document.MyForm.submit();
     }
}

cambia il tipo di pulsante Invia in "pulsante"

<input value="Save" type="button" onClick="verifyData()">

spero che questo aiuto.

L'uso di a returninterromperà la funzione e restituirà undefined, o il valore specificato con il comando return.

function myfunction(){
    if(a=="stop"){
        //return undefined;
        return; /** Or return "Hello" or any other value */
    }
}

Non mi piace rispondere a cose che non sono una vera soluzione ...

... ma quando ho riscontrato questo stesso problema, ho fatto una soluzione alternativa di seguito:

function doThis() {
  var err=0
  if (cond1) { alert('ret1'); err=1; }
  if (cond2) { alert('ret2'); err=1; }
  if (cond3) { alert('ret3'); err=1; }
  if (err < 1) {
    // do the rest (or have it skipped)
  }
}

Spero che possa essere utile per chiunque.

Penso che lanciare un nuovo errore sia un buon approccio per fermare l'esecuzione piuttosto che semplicemente restituire o restituire false. Per es. Sto convalidando un numero di file che consento solo un massimo di cinque file per il caricamento in funzione separata.

validateMaxNumber: function(length) {
   if (5 >= length) {
        // Continue execution
   }
   // Flash error message and stop execution
   // Can't stop execution by return or return false statement; 
   let message = "No more than " + this.maxNumber + " File is allowed";
   throw new Error(message);
}

Ma sto chiamando questa funzione dalla funzione di flusso principale come

  handleFilesUpload() {
      let files =  document.getElementById("myFile").files;
      this.validateMaxNumber(files.length);
}

Nell'esempio sopra non riesco a fermare l'esecuzione a meno che non lanci un nuovo errore. Solo return o return false funziona solo se si è nella funzione principale dell'esecuzione, altrimenti non funziona.

Uscita(); può essere usato per andare alla prossima validazione.

Se stai usando jquery. Questo dovrebbe impedire alla funzione di gorgogliare, quindi anche la funzione genitore che chiama questo dovrebbe arrestarsi.

  function myfunction(e)
  {
       e.stopImmediatePropagation();
       ................
  }

digitare qualsiasi comando casuale che genera un errore, ad esempio:

exit

o

die:-)