Come terminare lo script in JavaScript?

Question

Come posso uscire dallo script JavaScript in modo molto simile a quello di PHP exit O die?So che non è la migliore pratica di programmazione, ma ne ho bisogno.

Answer 1

equivalente JavaScript per PHP die . BTW solo chiama exit() (grazie splattne):

function exit( status ) {
    // http://kevin.vanzonneveld.net
    // +   original by: Brett Zamir (http://brettz9.blogspot.com)
    // +      input by: Paul
    // +   bugfixed by: Hyam Singer (http://www.impact-computing.com/)
    // +   improved by: Philip Peterson
    // +   bugfixed by: Brett Zamir (http://brettz9.blogspot.com)
    // %        note 1: Should be considered expirimental. Please comment on this function.
    // *     example 1: exit();
    // *     returns 1: null

    var i;

    if (typeof status === 'string') {
        alert(status);
    }

    window.addEventListener('error', function (e) {e.preventDefault();e.stopPropagation();}, false);

    var handlers = [
        'copy', 'cut', 'paste',
        'beforeunload', 'blur', 'change', 'click', 'contextmenu', 'dblclick', 'focus', 'keydown', 'keypress', 'keyup', 'mousedown', 'mousemove', 'mouseout', 'mouseover', 'mouseup', 'resize', 'scroll',
        'DOMNodeInserted', 'DOMNodeRemoved', 'DOMNodeRemovedFromDocument', 'DOMNodeInsertedIntoDocument', 'DOMAttrModified', 'DOMCharacterDataModified', 'DOMElementNameChanged', 'DOMAttributeNameChanged', 'DOMActivate', 'DOMFocusIn', 'DOMFocusOut', 'online', 'offline', 'textInput',
        'abort', 'close', 'dragdrop', 'load', 'paint', 'reset', 'select', 'submit', 'unload'
    ];

    function stopPropagation (e) {
        e.stopPropagation();
        // e.preventDefault(); // Stop for the form controls, etc., too?
    }
    for (i=0; i < handlers.length; i++) {
        window.addEventListener(handlers[i], function (e) {stopPropagation(e);}, true);
    }

    if (window.stop) {
        window.stop();
    }

    throw '';
}

Answer 2

funzioni "uscita" di solito chiudere il programma o lo script insieme a un messaggio di errore come paramete. Per esempio die (...) in php

die("sorry my fault, didn't mean to but now I am in byte nirvana")

L'equivalente in JS è per segnalare un errore con il gettare parola chiave in questo modo:

throw new Error();

Si può facilmente verificare questa:

var m = 100;
throw '';
var x = 100;

x
>>>undefined
m
>>>100

Answer 3

Anche in semplici programmi senza maniglie, gli eventi e tale, è meglio mettere il codice in una funzione "principale", anche quando è l'unica procedura:

<script> 
function main()
{
//code

}
main();
</script>

In questo modo, quando si desidera interrompere il programma è possibile utilizzare "ritorno".

Answer 4

Ci sono molti modi per uscire da un JS o uno script Nodo . Ecco le più rilevanti:

// This will never exit!
setInterval((function() {  
    return;
}), 5000);

// This will exit after 5 seconds, with signal 1
setTimeout((function() {  
    return process.exit(1);
}), 5000);

// This will also exit after 5 seconds, and print its (killed) PID
setTimeout((function() {  
    return process.kill(process.pid);
}), 5000);

// This will also exit after 5 seconds and create a core dump.
setTimeout((function() {  
    return process.abort();
}), 5000);

Se siete in REPL (vale a dire dopo l'esecuzione node sulla riga di comando), è possibile digitare .exit per uscire.

Answer 5

Se non si cura che si tratta di un errore solo scrivere:

fail;

che si fermerà il codice principale (globale) di procedere. Utile per alcuni aspetti di debugging / testing.

Answer 6

Mettere la parola chiave debugger; nel codice JavaScript in cui si desidera interrompere l'esecuzione. Quindi aprire strumenti di sviluppo del tuo browser preferito e ricaricare la pagina. Ora dovrebbe mettere in pausa automaticamente. Aprire le Fonti dei vostri strumenti:. La parola debugger; è evidenziato e si ha la possibilità di riprendere l'esecuzione dello script

Spero che aiuta.

Maggiori informazioni su:

• https://developer.mozilla.org/de/docs/ Strumenti / Debugger

• http://www.w3schools.com/js/js_debugging.asp

Answer 7

Nel mio caso ho usato il window.stop API che è come fare clic sul pulsante X del browser:

window.stop();

Answer 8

Questa risposta fornisce dettagli che dimostrano un framework aggiuntivo che aiuterà a risolvere questa e altre esigenze di uscita anticipata, eccezioni, controllo dei processi e gestione delle funzioni sequenziali nei javascript modulari.La soluzione fornisce esempi di chiusura.Questa risposta presuppone che l'utente desideri che altri script sulla pagina continuino a essere eseguiti dopo la chiusura dello script in questione.

Esempio dal vivo di soluzione semplice qui: https://jsfiddle.net/alignedfibers/cpe1o1yy/66/

<script>
    var safetyRun = (function(){
      var curExecution = null;
      var exceptionHandlers = {
        cleanup:function(){
          /*do exit cleanup*/
          console.log("Cleanup could set straglers to {}");
          return;
        }
      }
      var exitErr = function(errcode){
        curExecution.exNames.push("cleanup");
        throw new Error("EarlyExit");
      }
        var run = function(fun){
          curExecution = this;
          curExecution.exNames = [];
          fun(exitErr);
          for ( x in exNames){
            exceptionHandlers[x]();
          }
          return;
        }
        return run;
    })();
    var exitThisScript = function(exit){
      //write some modular code
      console.log("before exit");
      exit();
      console.log("after exit");
      return;
    }
    safetyRun(exitThisScript);
</script>

Sopra c'è un "CallRunner" che fornisce un modo molto semplice per uscire gratuitamente semplicemente passando la tua funzione al corridore.

I nomi delle variabili nel violino potrebbero creare confusione, la funzione denominata "fun" è il nome utilizzato in safetyRun per fare riferimento alla funzione da cui stiamo tentando di uscire e exitErr è il nome utilizzato per fare riferimento alla funzione che eseguiamo per completare effettivamente l'uscita.Inoltre un po' di confusione è:una volta completato exitErr, lo stack frame non viene ancora rilasciato dal thread di controllo che ha chiamato la funzione da cui siamo usciti.Poiché abbiamo ancora il thread di controllo, possiamo utilizzare funzioni o codici di errore inseriti in un array nella funzione exitErr e chiamarli in modo iterativo prima di tornare per consentire l'esecuzione di qualsiasi altra funzione.Ciò ci consente di modificare qualsiasi peso, apportare correzioni o impostare qualsiasi stato necessario che possiamo utilizzare per avvisare quali stati di correzione degli errori richiedono attenzione, inviare un rapporto di registro o persino completare una pulizia impegnativa e correggere autonomamente la funzione in background e chiamare iterativamente exitErr finché non completa un ritorno invece di un lancio consentendo così il completamento anticipato della funzione da cui stiamo tentando di uscire (suggeriamo di farlo fuori dal thread principale).Questo "wrapper/harness" potrebbe essere un buon modo per verificare le versioni del browser e altro all'inizio di una funzione, potresti anche eseguire un'importazione statica o dinamica qui se gestisci le tue librerie o qualunque cosa tu possa davvero pensare.L'uscita è solo una funzione fondamentale che può essere resa disponibile per la tua funzione racchiudendola in questo modo.

Il codice nel violino è un po' sporco e non carino, i nuovi costrutti es6 possono renderlo più carino.Inoltre ti consiglio di chiamare un generatore di cablaggio nella parte superiore di questa funzione e di assegnarne il risultato a una var locale in modo che la funzione da cui vuoi uscire possa assomigliare di più al codice seguente.Per mantenere il thread di controllo senza rilasciare lo stack, sarà comunque necessario disporre di un cablaggio.run(funzione(imbracatura){/MyVanillaFunc/}) per completare la tua funzione Vanilla, altrimenti in teoria dovrebbe funzionare quanto segue.Il wrapper è esattamente quello che ho fatto nel codice exitEarly sopra.

var rockStarFunction = new function (){
var harness = reducePublicStrapOnFromCache()._url(location);
return function(){ /*wrapper would wrap these internals*/
        harness.scriptContextChangeEvent();
        harness.imInteligentFunction("{slib_err-15346 : 'Cannot handle request, ::suggest(mesh//abc) exit back to pool'}");
        harness.exit();
        console.log("You should never get this far");
        return true;
    };
}

La soluzione che ho fornito qui è quella che consiglio se la tua intenzione è quella di creare un contenitore runner JavaScript con funzionalità come exit, assert, mock e simili integrate.Penso che questo sia il modo migliore per costruire questa nave portacontainer e rendere trasmissibili le mie funzioni.

Answer 9

Se siete alla ricerca di un modo per interrompere forzatamente esecuzione di tutte Javascript in una pagina, io non sono sicuro che ci sia un modo ufficialmente sanzionato per farlo - sembra che il tipo di cosa che potrebbe essere un rischio per la sicurezza (anche se ad essere onesti, non riesco a pensare a come sarebbe la parte superiore della mia testa). Normalmente in JavaScript quando si desidera che il codice per smettere di correre, basta return da qualsiasi funzione è in esecuzione. (La dichiarazione return è facoltativo se è l'ultima cosa che nella funzione e la funzione non deve restituire un valore) Se c'è qualche motivo di ritorno non è abbastanza buono per voi, probabilmente si dovrebbe modificare più in dettaglio la questione del perché si pensa che è necessario e forse qualcuno in grado di offrire una soluzione alternativa.

Si noti che, in pratica, la maggior parte dei browser interpreti JavaScript semplicemente fermare l'esecuzione dello script corrente se incontrano un errore. Così si può fare qualcosa di simile l'accesso a un attributo di una variabile unset:

function exit() {
    p.blah();
}

e sarà probabilmente annullare lo script. Ma non si dovrebbe contare su questo, perché non è affatto normale, e sembra davvero come una pratica terribile.

Modifica : OK, forse non è stata una buona risposta così alla luce di Ólafur di. Anche se la funzione die() ha collegato alla implementa praticamente il mio secondo comma, vale a dire solo genera un errore.

Answer 10

UPDATE: Questo funziona fino a quando non si è catch

throw window.location.assign('dead.html');

Answer 11

Questa piccola funzione è molto vicino a mimare l'uscita di PHP (). Come per le altre soluzioni, non aggiungere altro.

function exit(Msg)
    {
    Msg=Msg?'*** '+Msg:'';
    if (Msg) alert(Msg);
    throw new Error();
    } // exit

Answer 12

È sufficiente creare una condizione BOOL, Non c'è bisogno di complicato codice qui ..

Se anche una volta che si accende a true / o più volte, vi sia dare una linea di soluzione / non più - fondamentalmente semplice.

Answer 13

tiro "";

È un uso improprio del concetto, ma probabilmente l'unica opzione. E, sì, sarà necessario ripristinare tutti i listener di eventi, proprio come la risposta accettata menziona. Si potrebbe anche bisogno di un unico punto di ingresso se ho ragione.

Sulla cima di esso: Si desidera una pagina che riporta a voi via e-mail non appena getta - è possibile utilizzare per esempio Raven / Sentry per questo. Ma questo significa, si producono da soli falsi positivi. In tal caso, è anche necessario aggiornare il gestore predefinito per filtrare tali eventi fuori o impostare tali eventi sulla ignorare sul cruscotto di Sentry.

window.stop ();

Questo non funziona durante il caricamento della pagina. Si ferma la decodifica della pagina pure. Così non si può davvero usare per offrire all'utente una variante priva di javascript della pagina.

debugger;

interrompe l'esecuzione solo con debugger aperto. Funziona alla grande, ma non un risultato finale.

Answer 14

Credo che questa domanda è stato risposto, fare clic su qui maggiori informazioni. Qui di seguito è la risposta breve è pubblicato.

throw new Error("Stop script");

È anche possibile utilizzare il browser per aggiungere punti di rottura, tutti i browser è simile, controllare le informazioni qui di seguito per il browser.

Per Chrome palle break info clicca qui
Per Firefox punti di rottura info clicca qui
Per Explorer punti info cliccare
Per Safari punti di rottura info clicca qui

Answer 15

Se si utilizza una qualsiasi funzione definita nello script, allora lo script si fermerà a causa di "ReferenceError Uncaught". Ho provato dalla seguente codice ed prime due righe eseguite.

Credo che, questo è il modo migliore per fermare lo script. Se c'è qualche altro modo, allora vi prego di lasciare un commento. Voglio anche conoscere un altro modo migliore e più semplice. BTW, non ho avuto uscita o morire funzione intrinseca in Javascript come PHP per terminare lo script. Se qualcuno sa, allora per favore fatemelo sapere.

alert('Hello');

document.write('Hello User!!!');

die();  //Uncaught ReferenceError: die is not defined

alert('bye');

document.write('Bye User!!!');

Answer 16

Questo è un esempio, che, se una condizione esiste, quindi terminare lo script. Io uso questo nel mio SSE lato client javascript, se la

<script src="sse-clint.js" host="https://sse.host" query='["q1,"q2"]' ></script>

canot essere analizzato direttamente dalla JSON parse ...

if( ! SSE_HOST  ) throw new Error(['[!] SSE.js: ERR_NOHOST - finished !']);

... comunque l'idea generale è:

if( error==true) throw new Error([ 'You have This error' ,  'At this file', 'At this line'  ]);

questo terminerà / die lo script javasript