Saída antecipada da função?

Eu tenho uma função:

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

Existe algo como exit()em JavaScript?

Você pode apenas usar return.

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

Isso enviará um valor de retorno undefinedpara o que for chamado de função.

var x = myfunction();

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

Obviamente, você pode especificar um valor de retorno diferente. Qualquer valor retornado será registrado no console usando o exemplo acima.

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

Aparentemente, você pode fazer isso:

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

Veja os escopos de bloco através do uso de um rótulo: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label

Ainda não vejo nenhuma desvantagem. Mas isso não parece um uso comum.

Derivada esta resposta: JavaScript equivalente ao dado do PHP

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

return false; é muito melhor do que apenas return;

Este:

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

Usando uma abordagem um pouco diferente, você pode usar try catch, com a declaração throw.

function name() {
    try {
        ...

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

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

se você estiver procurando por um script para evitar o envio de formulários quando forem encontrados alguns erros, esse método funcionará

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

altere o tipo de botão Enviar para "botão"

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

Espero que isso ajude.

Usar a returninterromperá a função e retornará undefinedou o valor que você especificar com o comando return.

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

Não gosto de responder coisas que não são uma solução real ...

... mas quando encontrei esse mesmo problema, fiz a seguinte solução alternativa:

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)
  }
}

Espero que possa ser útil para qualquer pessoa.

Eu acho que lançar um novo erro é uma boa abordagem para interromper a execução, em vez de apenas retornar ou retornar falso. Por ex. Estou validando vários arquivos que permitem apenas cinco arquivos para upload em função separada.

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);
}

Mas estou chamando essa função da função de fluxo principal como

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

No exemplo acima, não consigo parar a execução, a menos que eu lance um novo Error.Just return or return false, só funciona se você estiver na principal função de execução, caso contrário, não funcionará.

Saída(); pode ser usado para a próxima validação.

Se você estiver usando jquery. Isso deve impedir que a função borbulhe até que a função pai que chama isso também deve parar.

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

digite qualquer comando aleatório que gera um erro, por exemplo:

exit

ou

die:-)