Come eseguire il debug del codice JavaScript angolare


104

Sto lavorando a una prova di concetto utilizzando JavaScript angolare.

Come eseguire il debug del codice JavaScript angolare in diversi browser (Firefox e Chrome)?


13
uh angularjs avvolge molto del codice del modello e lo esegue in modo dinamico ... la fonte dell'errore è sempre "angular.js" quindi trovare la fonte di un errore è quasi impossibile.
user3338098

Risposte:


64

1. Chrome

Per eseguire il debug di AngularJS in Chrome puoi utilizzare AngularJS Batarang . (Dalle recensioni recenti sul plugin sembra che AngularJS Batarang non sia più mantenuto. Testato in varie versioni di Chrome non funziona)

Ecco il link per la descrizione e la demo:

Introduzione di Angular JS Batarang

Scarica il plugin Chrome da qui: plugin Chrome per il debug di AngularJS

Puoi anche fare riferimento a questo link: ng-book: Debugging AngularJS

Puoi anche usare ng-inspect per il debug di angular.

2. Firefox

Per Firefox con l'aiuto di Firebug puoi eseguire il debug del codice.

Usa anche questi componenti aggiuntivi per Firefox : AngScope: componenti aggiuntivi per Firefox (estensione non ufficiale del team di AngularJS)

3. Debug di AngularJS : controlla il collegamento: Debug di AngularJS


1
peccato che non funzioni davvero. Vorrei che il ragazzo iniziasse a mantenere la cosa perché è una grande idea e ha molto potenziale
Tules

5
@AskQuestion Sembra che Batarang non sia più supportato. Questa risposta dovrebbe essere rimossa
Aakil Fernandes

Il team di Angular (principalmente @btford) supporta ancora Batarang, ma non sembra essere una priorità nella loro lista, dal momento che sono tutti in testa alla prossima versione di AngularJS 2.0. Guardare nel ng-inspectcaso Batarang ti dà mal di testa.
demisx

supponendo che batarang funzioni correttamente, nessun contesto aggiuntivo viene aggiunto agli errori angular.js nella console e la scheda "AngularJS" non aiuta neanche.
user3338098

1
@SazzadTusharKhan: ok. Prova questo -> sulla versione per Mac hai un menu Sviluppatore ("Sviluppo"), sul Mac questo menu viene mostrato tramite le preferenze> Avanzate> Mostra menu Sviluppo, e lì puoi visualizzare elementi come "Avvia debug javascript". Per riferimento: youtube.com/watch?v=BUvsnDhFL2w
Vaibhav Jain

35

IMHO, l'esperienza più frustrante deriva dall'ottenere / impostare un valore di uno scopo specifico correlato a un elemento visivo. Ho creato molti punti di interruzione non solo nel mio codice, ma anche in angular.js stesso, ma a volte semplicemente non è il modo più efficace. Sebbene i metodi seguenti siano molto potenti, sono sicuramente considerati una cattiva pratica se effettivamente utilizzati nel codice di produzione, quindi usali con saggezza!

Ottieni un riferimento nella console da un elemento visivo

In molti browser non IE, è possibile selezionare un elemento facendo clic con il pulsante destro del mouse su un elemento e facendo clic su "Ispeziona elemento". In alternativa puoi anche fare clic su qualsiasi elemento nella scheda Elementi in Chrome, ad esempio. L'ultimo elemento selezionato verrà memorizzato nella variabile $0nella console.

Ottieni un ambito collegato a un elemento

A seconda che esista una direttiva che crea un ambito isolato, è possibile recuperare l'ambito con angular.element($0).scope()o angular.element($0).isolateScope()(utilizzare $($0).scope()se $ è abilitato). Questo è esattamente ciò che ottieni quando utilizzi l'ultima versione di Batarang. Se stai modificando direttamente il valore, ricordati di utilizzare scope.$digest()per riflettere le modifiche sull'interfaccia utente.

$ eval è il male

Non necessariamente per il debug. scope.$eval(expression)è molto utile quando si desidera controllare rapidamente se un'espressione ha il valore atteso.

I membri del prototipo mancanti dell'ambito

La differenza tra scope.blae scope.$eval('bla')è il primo non considera i valori ereditati dal prototipo. Usa lo snippet qui sotto per ottenere l'intera immagine (non puoi modificare direttamente il valore, ma puoi usarlo $evalcomunque!)

scopeCopy = function (scope) {
    var a = {}; 
    for (x in scope){ 
        if (scope.hasOwnProperty(x) && 
            x.substring(0,1) !== '$' && 
            x !== 'this') {
            a[x] = angular.copy(scope[x])
        }
    }
    return a
};

scopeEval = function (scope) {
    if (scope.$parent === null) {
        return hoho(scope)
    } else {
        return angular.extend({}, haha(scope.$parent), hoho(scope))
    }
};

Usalo con scopeEval($($0).scope()).

Dov'è il mio controller?

A volte potresti voler monitorare i valori ngModelquando scrivi una direttiva. Usa $($0).controller('ngModel')e si arriva a controllare il $formatters, $parsers, $modelValue, $viewValue $rendere tutto.


13

c'è anche $ log che puoi usare! fa uso della tua console in un modo in cui vuoi che funzioni!

mostrando l'errore / avviso / informazioni nel modo in cui la tua console ti mostra normalmente!

usa questo> Documento


Il collegamento è interrotto.
Ripristina Monica - notmaynard il



7

Sfortunatamente la maggior parte dei componenti aggiuntivi e delle estensioni del browser ti mostrano solo i valori ma non ti consentono di modificare le variabili di ambito o eseguire funzioni angolari. Se vuoi cambiare le variabili $ scope nella console del browser (in tutti i browser), puoi usare jquery. Se carichi jQuery prima di AngularJS, angular.element può essere passato a un selettore jQuery. Quindi potresti ispezionare l'ambito di un controller con

angular.element('[ng-controller="name of your controller"]').scope()

Esempio: è necessario modificare il valore della variabile $ scope e vedere il risultato nel browser, quindi digitare nella console del browser:

angular.element('[ng-controller="mycontroller"]').scope().var1 = "New Value";
angular.element('[ng-controller="mycontroller"]').scope().$apply();

Puoi vedere immediatamente le modifiche nel tuo browser. Il motivo per cui abbiamo usato $ apply () è: qualsiasi variabile di ambito aggiornata dall'esterno del contesto angolare non la aggiornerà vincolante, è necessario eseguire il ciclo digest dopo aver aggiornato i valori dell'ambito utilizzando scope.$apply().

Per osservare un valore di variabile $ scope, è sufficiente chiamare quella variabile.

Esempio: vuoi vedere il valore di $ scope.var1 nella console web in Chrome o Firefox digita semplicemente:

angular.element('[ng-controller="mycontroller"]').scope().var1;

Il risultato verrà mostrato immediatamente nella console.


5

Aggiungi la chiamata a debuggerdove intendi usarla.

someFunction(){
  debugger;
}

Nella consolescheda degli strumenti per sviluppatori web del tuo browser, issueangular.reloadWithDebugInfo();

Visita o ricarica la pagina di cui intendi eseguire il debug e visualizza il debugger nel tuo browser.


Questo non sembra funzionare all'interno dei componenti per qualche motivo. La console sembra individuare il punto di interruzione nel punto in cui viene creato il componente, ma non visualizzerà il codice effettivamente in esecuzione. Almeno non per me. sebbene sia possibile visualizzare il valore delle variabili che sono ambito. Se qualcuno sa come fare in modo che il debugger visualizzi il codice effettivo che viene esaminato, un consiglio sarebbe apprezzato.
user1023110

3
var rootEle = document.querySelector("html");
var ele = angular.element(rootEle); 

scope () Possiamo recuperare $ scope dall'elemento (o dal suo genitore) usando il metodo scope () sull'elemento:

var scope = ele.scope();

iniettore()

var injector = ele.injector();

Con questo iniettore, possiamo quindi istanziare qualsiasi oggetto angolare all'interno della nostra app, come servizi, altri controller o qualsiasi altro oggetto


Grazie. Proprio quello di cui avevo bisogno!
marlar

2

Puoi aggiungere "debugger" nel tuo codice e ricaricare l'app, che mette lì il punto di interruzione e puoi "scavalcare" o eseguire.

var service = {
user_id: null,
getCurrentUser: function() {
  debugger; // Set the debugger inside 
            // this function
  return service.user_id;
}

2

Puoi eseguire il debug utilizzando i browser integrati negli strumenti per sviluppatori.

  1. apri gli strumenti per sviluppatori nel browser e vai alla scheda sorgente.

  2. apri il file di cui vuoi eseguire il debug usando Ctrl + P e cerca il nome del file

  3. aggiungere un punto di interruzione su una riga facendo clic sul lato sinistro del codice.

  4. ricarica la pagina.

Sono disponibili molti plug-in per il debug a cui puoi fare riferimento per l'utilizzo del plug-in di Chrome Debug dell'Applicazione angolare utilizzando il plug-in "Debugger per Chrome"


1

Per Visual Studio Code (non Visual Studio) fare Ctrl+ Shift+P

Digita Debugger per Chrome nella barra di ricerca, installalo e abilitalo.

Nel tuo launch.jsonfile aggiungi questa configurazione:

{
    "version": "0.1.0",
    "configurations": [
        {
            "name": "Launch localhost with sourcemaps",
            "type": "chrome",
            "request": "launch",
            "url": "http://localhost/mypage.html",
            "webRoot": "${workspaceRoot}/app/files",
            "sourceMaps": true
        },
        {
            "name": "Launch index.html (without sourcemaps)",
            "type": "chrome",
            "request": "launch",
            "file": "${workspaceRoot}/index.html"
        },
    ]
}

È necessario avviare Chrome con il debug remoto abilitato affinché l'estensione possa collegarsi ad esso.

  • finestre

Fai clic con il pulsante destro del mouse sul collegamento Chrome e seleziona proprietà Nel campo "target", aggiungi --remote-debugging-port = 9222 Oppure in un prompt dei comandi, esegui /chrome.exe --remote-debugging-port = 9222

  • OS X

In un terminale, esegui / Applications / Google \ Chrome.app/Contents/MacOS/Google \ Chrome --remote-debugging-port = 9222

  • Linux

In un terminale, avvia google-chrome --remote-debugging-port = 9222

Scopri di più ===>


0

Poiché i componenti aggiuntivi non funzionano più, il set di strumenti più utile che ho trovato è l'utilizzo di Visual Studio / IE perché puoi impostare punti di interruzione nel tuo JS e ispezionare i tuoi dati in questo modo. Ovviamente Chrome e Firefox hanno strumenti di sviluppo molto migliori in generale. Inoltre, il buon vecchio 'console.log () è stato di grande aiuto!


Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.