NODO.JS– uno strumento software per l'esecuzione di js.
Nodejs = V8 + I/O + librerie
V8: veloce, moderno, economico
Vantaggi
- Javascript
- Codice comune su client e server
- Attività web di base
- Molte connessioni e attività allo stesso tempo
- Facile creare un prototipo funzionante
- Comodo gestore di pacchetti npm
- Comunità
Installazione
Durante l'installazione, nodejs si scrive nella variabile PATH (+ npm), [amministrazione - variabili di ambiente]; può essere controllato sulla riga di comando:
impostare il PERCORSO
Di norma i file vengono avviati sotto nodejs: scriviamo un semplice script ed eseguiamolo tramite riga di comando:
Lo script verrà eseguito e il risultato verrà visualizzato sulla riga di comando.
Documentazione di Nodejs
moduli nodejs
Per capire come funzionano i moduli nodejs integrati, è necessario scaricare l'archivio del codice sorgente dal sito web nodejs (codice sorgente). E vai alla directory lib. (comando dir: ottieni un elenco di file tramite la riga di comando; se devi elencare i file in tutte le sottocartelle, invece di "dir" usa "dir /s"). Se hai installato nodejs da un pacchetto, non troverai alcun file nella cartella lib.
Nodejs ha moduli con vari gradi di stabilità. (ad esempio, 0 – non deve essere utilizzato; 1, 2 – può essere utilizzato ma l'API del modulo potrebbe cambiare).
Le funzioni stanno crescendo (il progetto è in fase di sviluppo) e col tempo bisognerà spostare la funzione di costruzione USER in un file separato.
È qui che entrano in gioco i moduli.
I moduli sono un tipo di modo offerto da nodejs per organizzare un progetto.
I progetti tendono a crescere, il che porta al desiderio di dividere il progetto in più file: è qui che entrano in gioco i moduli.
richiedere
Per le pagine HTML, i tag script vengono utilizzati per includere script. Nodejs ha uno speciale comando require.
Var utente = require("./utente");
//richiede("./utente"); // Non è necessario specificare .js // in questo caso il file verrà eseguito, ma non ci sarà alcuna variabile USER // questa è la differenza principale rispetto ai tag script di nodejs // In node.js, le funzioni e le variabili di ciascun modulo sono globali // per questo file (il modulo stesso) e non diventano automaticamente // disponibili una volta connessi (require("./user")) // Ma come ottenere l'accesso? // Ogni modulo ha una variabile speciale exports: questo è un oggetto e ciò che // inserisco restituirà come risultato require var user = require("./user.js"); // risultato: utente = ( Utente: funzione )
La prima differenza tra il sistema modulare nodejs e gli script del browser: se nel browser sono presenti due tag di script, una funzione definita a livello globale in uno di essi è disponibile nell'altro, ma non in nodejs. In nodejs, le funzioni e le variabili sono globali per un dato file (non sono rese disponibili quando richiesto). Pertanto, nodejs ti consente di scrivere moduli veramente indipendenti. Ma affinché il modulo sia disponibile, viene utilizzato sistema di esportazione. Ogni modulo ha una variabile di esportazione speciale.
Directory del modulo DIR/indice
Colleghiamo direttamente la cartella var user = require("./user"); , che contiene il corrispondente index.js .
Per esempio
Funzione Utente(nome)( this.nome = nome; ) Utente.prototipo.ciao = funzione(chi)( console.log(frase.Ciao + ", " + chi.nome); ); esportazioni.Utente = Utente;
Ci colleghiamo e utilizziamo il costruttore User nel file ./server.js
//server.js var utente = require("./utente"); var vasya = nuovo utente.Utente("Vasya");
"./" - relativo alla cartella corrente
exports è un oggetto e ciò che viene inserito verrà restituito come risultato di require (exports.jpg). In questo modo il modulo può dichiarare le sue variabili/funzioni private ed esportare solo ciò che è necessario.
Per variabili globali, ecc. c'è un oggetto globale
Global.User = Utente;
In conclusione
- È richiesta la connessione
- Variabili: var (privata per moduli), esportazioni, globale (usata raramente)
- Tipi di moduli: js, node (con estensione .node), json (con estensione .json). I moduli JSON vengono utilizzati quando è necessario archiviare alcune semplici informazioni su un file.
- Directory del modulo DIR/indice
oggetto modulo
- oggetto modulo
- Modulo-funzione module.exports = funzione
- Caching dei moduli (il modulo non viene mai più letto)
- Disposizione dei moduli: ordine di ricerca
- Passaggio dei parametri: module-factory
L'oggetto modulo (l'oggetto fondamentale per i moduli) è una variabile che esiste in ogni modulo (file, puoi restituire console.log(module;);). . Contenuto: proprietà id – solitamente il percorso del file,
parent – collegamento al modulo genitore (module.parent – collegamento al modulo genitore che lo richiede),
bambini (module.children - quei moduli che sono collegati tramite require),
esporta proprietà e altri.
Modulo o applicazione? modulo.parent
Il modulo può essere avviato direttamente, ma in caso contrario, se la funzionalità è connessa a un altro modulo, lascia che esporti questa funzionalità. Questi due casi possono essere separati controllando:
If(modulo.parent) (exports.run = esegui;) else (esegui();)
ps: come si dice su stackoverflow.com Il genitore è il modulo che ha chiamato lo script per l'interpretazione
// $ nodo foo.js console.log(module.parent); // null // require("./foo") console.log(module.parent); // (...)
Uso corretto di module.exports
Nel contesto di un modulo:
module.exports = exports = this (questi costrutti sono equivalenti)
Se vuoi passare una funzione non in un oggetto, ma direttamente, usa la seguente sintassi:
Modulo.exports = Utente;
Caching del modulo
Quando Nodejs carica un modulo, crea completamente l'oggetto modulo corrispondente (tenendo conto parent , esportazioni e altre proprietà simili) e lo ricorda in sé (module.id (il percorso completo del file) serve come identificatore per la cache interna ) e la prossima volta che accediamo (ci connettiamo) a qualsiasi modulo (file), nodejs prende lo stesso oggetto dalla cache. Cioè, ad esempio, è sufficiente inizializzare il modulo una volta nel file, in futuro potrai semplicemente usarlo;
Nel nostro caso, for var db = require("../db");
e per var db = require("./db"); viene preso lo stesso oggetto. Pertanto, il principio è il seguente: la prima volta che si utilizza un modulo, viene inizializzato e in futuro ci limiteremo a collegarlo e utilizzarlo (ovvero, nel nostro caso non è necessario utilizzare db.connect() due volte, cioè in file diversi).
Disposizione dei moduli: l'ordine in cui i moduli si trovano in nodejs
Come fare in modo che il db si connetta sempre senza specificare un percorso specifico:
Var db = require("../db"); //o var db = require("./db");
e così:
Var db = require("db");
indipendentemente dal file a cui è connesso db.
Per fare ciò, è necessario comprendere l'ordine di ricerca dei moduli in nodejs (cosa succede quando viene chiamato require). Ci sono molti moduli integrati in nodejs, ad esempio require("fs"); , che si collegherà senza problemi. Se specifichi un percorso specifico in require, ad esempio, require("../db"); , quindi la ricerca sarà basata sul percorso specificato e il file verrà trovato, oppure nodejs proverà a ottenere questo file come directory (e cercherà index.js all'interno della categoria).
Se specifichi require("db"); e il modulo non è integrato, verrà cercata la directory node_modules rispetto alla posizione corrente (se trovata, proverà a prendere il modulo da essa). Se manca la directory node_modules, la directory node_modules verrà cercata sopra, ecc.
Oltre a specificare un percorso specifico per un modulo, nodejs può cercare moduli come questo:
Introduzione a npm: il gestore pacchetti per Node.JS
- creare un file di descrizione del pacchetto (package.json) che contenga informazioni sul modulo (nome, versione, ecc.). Sia manualmente che tramite comando
npm init
(chiederà le informazioni necessarie) - Per pubblicare un modulo è necessario:
- Aggiungi un utente utilizzando il comando npm adduser (devi inserire nome utente e password). Ora tutto il lavoro con npm verrà eseguito per conto di questo utente. L'utente può accedere a https://www.npmjs.com/~name_user e monitorare i propri moduli.
- Pubblicazione: npm pubblica
- Quindi qualcuno può utilizzare il tuo modulo aggiunto al database e l'utente stesso può apportare modifiche.
- Ottieni tutti i comandi npm utilizzando il comando npm help
- Cerca un modulo nel database: parole chiave npm o parole chiave di ricerca npm (ad esempio, npm s super module)
- Installa il modulo: npm install name_module o npm i name_module
- Quando si installano i moduli, nodejs cerca prima la cartella node_modules nella directory corrente (poi sempre più in alto, ecc.), oppure (se node_modules manca) cerca package.json (sempre andando verso l'alto; package.json di solito denota la radice di il progetto) e, di conseguenza, se trova package.json, crea una cartella node_modules nella directory corrispondente; se entrambe le opzioni falliscono, nodejs crea una cartella node_modules nella directory corrente. Se vuoi posizionare un modulo in una directory specifica, devi creare una cartella node_modules in quella directory.
- npm up update module (controllerà la presenza di moduli di aggiornamento che si trovano nella cartella node_modules)
- npm rimuovi nome_modulo (rimuovi modulo)
Uscita da npm:
npm init
add-user NMP
npm pubblica
parole chiave di ricerca npm
modulo di installazione npm
modulo di aggiornamento npm
npm rimuove il modulo
comando di aiuto npm
Struttura del pacchetto NPM
Installando la versione richiesta, ad esempio: npm i [e-mail protetta]
La versione più recente del modulo può essere ottenuta se il modulo è sviluppato utilizzando il sistema di versione git, ad esempio su github. È sufficiente ottenere Git Read-Only (url): https://github.com/strongloop/express.git e nella console:
npm su https://github.com/strongloop/express.git
dipendenze in package.json
le dipendenze puntano a quei moduli da cui dipende questo.
devDependencies
I moduli registrati in devDependencies non vengono installati se il modulo viene estratto come dipendenza. Vengono installati solo per lo sviluppo e possono essere installati se, ad esempio, vai al modulo nella cartella node_modules e inserisci npm i (o impostando il flag npm config).
il campo principale specifica il punto di ingresso nel pacchetto
Moduli globali
Qualsiasi modulo può essere installato globalmente se imposti il flag -g: npm -g module
Globale significa la directory di sistema.
Directory dei moduli globali per Windows:
C:\utenti\Nome_utente\AppData\Roaming\npm
I moduli globali vengono posizionati nella directory di sistema standard. Quei binari presenti in package.json verranno installati nel percorso di sistema (questo è l'uso principale dei moduli globali), ovvero in futuro potranno essere richiamati tramite la console.
Basato sui materiali dei corsi di I. Kantor
Ehi ragazzi, nell'articolo di oggi voglio parlare delle variabili globali in Node. Questo articolo è rivolto agli sviluppatori che hanno un livello di abilità da principiante a intermedio che lavora con Node. Se non avete mai sentito parlare di variabili globali o non avete mai lavorato con esse, no non devi preoccuparti. Questo articolo ti consentirà di essere operativo in pochissimo tempo con tutto ciò che devi sapere sulle variabili globali.
Cosa sono le variabili globali?
Le variabili globali sono molto simili, se non identiche, alle variabili regolari. Le variabili globali possono essere inizializzate con un valore, quel valore può essere modificato e possono anche essere cancellate come una variabile normale. La differenza tra una variabile regolare e una variabile globale dipende dal loro ambito. Quando crei una variabile in un file JavaScript, tale variabile esiste solo nell'ambito in cui è stata dichiarata. Ora cosa intendo con questo? Nel codice seguente puoi vedere un esempio di due diverse variabili con ambiti diversi.
// Scope.js let fileScope = "È possibile accedere ovunque nel file"; function doSomething() ( let localScope = "È possibile accedervi solo all'interno di questa funzione"; fileScope = "È possibile accedervi anche dalla funzione!"; ) // Ciò risulterà in un errore perché la variabile non esiste // al di fuori di funzione. localScope = "Prova a cambiarmi qui";
Nel frammento di codice sopra, possiamo vedere che ci sono due variabili, fileScope e localScope . La variabile fileScope può essere modificata o richiamata da qualsiasi punto all'interno di questo file, mentre la variabile localScope esiste solo all'interno della funzione doSomething() . Sono sicuro che a questo punto ti starai chiedendo cosa c'entra questo con le variabili globali. Quando parliamo di variabili globali, esistono per tutti i file in un programma, il che significa che hanno un ambito globale per il programma.
Il motivo per cui ciò è possibile è perché i programmi JavaScript condividono uno spazio dei nomi globale tra tutti i file nel programma. Per dirla in altro modo, immagina che il tuo programma sia un file o contenitore gigante che ha "importato" tutti gli altri file JavaScript. Quindi dichiari una variabile in questo file contenitore di grandi dimensioni, quella variabile ora ha ambito in tutto il programma. Se non sei sicuro di cosa sia uno spazio dei nomi o vuoi saperne di più su di essi, consulta questo articolo per saperne di più.
Come dichiarare e utilizzare una variabile globale
Ora che abbiamo una migliore comprensione di cosa sia una variabile globale in Node, parliamo di come impostiamo e utilizziamo effettivamente una variabile globale. Per impostare una variabile globale, dobbiamo crearla sull'oggetto globale. L'oggetto globale è ciò che ci dà l'ambito dell'intero progetto, piuttosto che solo il file (modulo) in cui è stata creata la variabile. Nel blocco di codice seguente, creiamo una variabile globale chiamata globalString e le diamo un valore Successivamente, cambiamo il valore di globalString e infine lo impostiamo su unfine.
// Global.js global.globalString = "È possibile accedervi ovunque!"; console.log(globalString); // Risultato: "È possibile accedervi ovunque!" globalString = "Guardami adesso"; console.log(globalString); // Risultato: "Dai un'occhiata adesso" globalString = undefinito; console.log(globalString); // Output: unfine // Esempio.js // Possiamo utilizzare il globale che abbiamo creato in Global.js anche in questo file //. console.log(globalString); // Risultato: unfine globalString = "Possiamo cambiarlo anche noi!"; console.log(globalString);
Ciò di cui non ho ancora parlato è un altro modo in cui puoi rendere globale una variabile. Il motivo per cui l'ho escluso è perché non è un modo corretto di impostare una variabile. Se dichiari una variabile in un file senza utilizzare la parola chiave var e quindi le assegni un valore, l'oggetto globale imposterà una proprietà per questa variabile. Questo processo lo trasforma essenzialmente in una variabile accessibile a livello globale. Sconsiglio vivamente di utilizzare questo metodo poiché non è il modo corretto per creare valori globali. È anche importante notare che se imposti la direttiva "use strict", Node disabiliterà i globali impliciti e probabilmente ti ritroverai con un errore in fase di runtime anziché con uno script funzionante.
Casi d'uso pratici per variabili globali
Ora, potresti pensare a te stesso che vuoi partire e creare variabili globali ora che ne sai di più. Metterò fortemente in guardia contro la creazione di variabili globali per alcuni motivi molto importanti.
Il primo motivo è che quando crei una variabile globale, questa esiste per tutta la durata dell'applicazione. Quando una variabile persiste per tutta la durata dell'app significa che è lì, in memoria, e occupa risorse mentre l'app è in esecuzione.
In secondo luogo, l’utilizzo tradizionale delle variabili globali può causare problemi di concorrenza. Se più thread possono accedere alla stessa variabile e non sono presenti modificatori di accesso o misure di sicurezza, ciò può portare a seri problemi se due thread tentano di accedere e utilizzare la stessa variabile. Tuttavia, mentre questo è il caso in altri linguaggi, non è necessariamente il caso di Node.js poiché è strettamente un ambiente a thread singolo. Mentre esso È possibile raggruppare i processi del nodo, non esiste un modo nativo per comunicare tra loro.
L'ultimo motivo di cui parlerò è che l'uso dei globali può causare un accoppiamento implicito tra file o variabili. L'accoppiamento non è una buona cosa quando si tratta di scrivere un ottimo codice. Quando scriviamo il codice, vogliamo assicurarci che sia il più modulare e riutilizzabile possibile, assicurandoci anche che sia facile da usare e comprendere. Accoppiare insieme pezzi del tuo codice può portare a grossi grattacapi in futuro quando stai tentando di eseguire il debug del motivo per cui qualcosa non funziona.
Se vuoi saperne di più sul motivo per cui le variabili globali non sono consigliate, puoi consultare questo fantastico articolo intitolato Le variabili globali sono dannose.
Se ti senti confuso riguardo allo scopo delle variabili globali, non temere. Daremo un'occhiata ad alcune delle variabili globali integrate in Node e proveremo a comprendere meglio perché sono globali e come vengono utilizzate. In effetti, probabilmente ne hai già utilizzati alcuni senza nemmeno renderti conto che sono oggetti globali!
// Globali del nodo console.log("Ciao mondo!"); processo.env.PORT = 3000; setInterval(( console.log("Sono passati 2 secondi."); 2000);
Se dai un'occhiata al blocco di codice sopra probabilmente vedrai almeno un'istanza che hai usato in precedenza, console.log() . Secondo la documentazione di Node, l'oggetto console è un oggetto globale che dispone di alcuni metodi che consentono agli sviluppatori di eseguire operazioni come stampare un registro o un errore. Scavando più a fondo nei documenti possiamo vedere che la console è in realtà un'istanza globale configurata per scrivere su process.stdout e process.stderr .
Questo ci porta all'istruzione successiva che vedi nel blocco di codice sopra, l'oggetto processo. Se hai creato una build di produzione di un'applicazione Node, probabilmente hai dovuto impostare la porta per la variabile di ambiente. La variabile d'ambiente env è una parte dell'oggetto processo che è un altro globale. Puoi accedere alle variabili sull'oggetto processo in qualsiasi file del tuo progetto perché è globale. Se questo oggetto non fosse globale, anche l'oggetto console non sarebbe accessibile da nessun file, ricorda che è davvero un oggetto che fa riferimento all'oggetto processo.
setInterval è un'altra funzione che potresti aver già visto se hai mai avuto motivo di ritardare un'operazione prima di eseguirla. setTimeout e setImmediate sono di natura simile a setInterval e sono entrambe funzioni globali. Queste tre funzioni fanno parte del modulo timer che espone un'API globale che ti consente di chiamare queste funzioni senza richiedere esplicitamente il timer nei tuoi file.
Tutti i casi d'uso sopra menzionati sono integrati in Node e sono globali per un motivo. L'oggetto processo è globale perché fornisce informazioni sul processo corrente del Nodo in esecuzione e pertanto dovrebbe essere disponibile da qualsiasi file senza doverlo richiedere. Lo stesso si può dire del modulo timer che contiene una serie di funzioni importanti e che dovrebbero essere accessibili ovunque senza doverlo richiedere. Se desideri saperne di più sugli oggetti globali esistenti integrati in Node, ti incoraggio a visitare la documentazione ufficiale su Globals.
Saperne di più
Vuoi saperne di più sui fondamenti di Node.js? Personalmente, consiglierei un corso online, come Wes Bos" Learn Node.js poiché i video sono molto più facili da seguire e potrai effettivamente creare un'applicazione nel mondo reale.
Conclusione
So che erano molte informazioni, quindi grazie per avermelo segnalato. Tutte le informazioni di cui sopra sono state trovate nella documentazione sul sito web di Node. Non esitate a porre domande e fornire commenti nella sezione commenti qui sotto. Alla prossima volta ragazzi!
JavaScript ha un oggetto speciale chiamato Oggetto Globale, a esso e a tutti i suoi attributi è possibile accedere ovunque nel programma, una variabile globale.
Un browser JavaScript è solitamente un oggetto finestra globale, un oggetto globale Node.js è un oggetto globale, tutte le variabili globali (eccetto il sé globale) sono di proprietà dell'oggetto globale.
In Node.js abbiamo accesso diretto alle proprietà globali, senza doverlo includere nell'applicazione.
Oggetti globali e variabili globali
Il ruolo globale più fondamentale è quello di variabile host globale. Secondo la definizione ECMAScript, le seguenti condizioni sono variabili globali:
- La variabile Esterna è definita;
- Proprietà globali dell'oggetto;
- La variabile è definita implicitamente (assegnazione diretta a variabili non definite).
Quando definisci una variabile globale, la variabile diventerà anche proprietà dell'oggetto globale e viceversa. Tieni presente che, in Node.js, non puoi definire variabili in un contesto esterno, poiché tutto il codice utente fa parte del modulo corrente e il modulo stesso non è un contesto esterno.
Nota: utilizzare sempre var per definire le variabili per evitare di introdurre una variabile globale, poiché le variabili globali inquineranno lo spazio dei nomi, aumentando il rischio di codice di comunicazione.
__nomefile
__filename specifica il nome del file dello script attualmente in esecuzione. Il percorso assoluto della posizione in cui si troverà il file di output, ma l'opzione della riga di comando e la specifica del nome del file non sono necessariamente la stessa cosa. Se in un modulo, il valore restituito è il percorso del file del modulo.
esempi
// Visualizza __filename in console.log(__filename);$ nodo main.js /web/com/w3big/nodejs/main.js
__nomedir
__dirname rappresenta la directory dello script attualmente posizionata.
esempi
Crea un file main.js, codice come questo:
// Cambia __dirname in console.log(__dirname);Il file eseguibile main.js, il codice è simile al seguente:
$ nodo main.js /web/com/w3big/nodejs
setTimeout(CB, ms)
setTimeout(C - Bi, ms): La funzione SetTimeout() viene specificata solo una volta.
Restituisce il valore dell'handle che rappresenta il timer.
esempi
Crea un file main.js, codice come questo:
Funzione stampaCiao())( console.log("Ciao, mondo!"); ) // setTimeout(stampaCiao, 2000);
Il file eseguibile main.js, il codice è simile al seguente:
$ nodo main.js Ciao mondo!
clearTimeout(t)
clearTimeout(t) viene utilizzato per interrompere la funzione globale prima di passare setTimeout() per creare il timer. Parametro Funzione T setTimeout() per creare una calcolatrice.
esempi
Crea un file main.js, codice come questo:
Funzione printCiao())( console.log("Ciao, mondo!"); ) // var t = setTimeout(printCiao, 2000); // 清除定时器 clearTimeout(t);
Il file eseguibile main.js, il codice è simile al seguente:
$ dominio nodo.js
setInterval(CB, ms)
setInterval(C - Bi, ms) La funzione globale esegue la funzione specificata dopo un numero specificato di millisecondi (ms) Numero (CB).
Restituisce il valore dell'handle che rappresenta il timer. È possibile utilizzare la funzione clearInterval(T) per cancellare il timer.
Il metodo setInterval() continuerà a chiamare la funzione finché non viene chiamato clearInterval() o finché la finestra non viene chiusa.
esempi
Crea un file main.js, codice come questo:
Funzione stampaCiao())( console.log("Ciao, mondo!"); ) // setInterval(stampaCiao, 2000);
Il file eseguibile main.js, il codice è simile al seguente:
$ nodo main.js Ciao mondo! Ciao mondo! Ciao mondo! Ciao mondo! Ciao mondo! ......
Il programma sopra emetterà "Hello, World!" una volta ogni due secondi e verrà eseguito continuamente finché non verrà premuto il pulsante CTRL+C.
consolle
Console La console per fornire l'output standard, che è la funzione di debug fornita dal motore JScript in Internet Explorer e in seguito diventata di fatto lo standard del browser.
Node.js segue questo standard, garantendo comportamenti e abitudini coerenti dell'oggetto console utilizzato nei caratteri di output del flusso di output standard (STDOUT) o del flusso di errore standard (STDERR).
metodo della consolle
Di seguito è riportato l'oggetto console:
| NO. | Metodo e descrizione |
|---|---|
| 1 | console.log([dati] [, ... ]) Per i caratteri stampabili standard del flusso di output e termina con un carattere di nuova riga. Questo metodo accetta diversi parametri, se è presente un solo parametro, l'output è una stringa di questo parametro. Se sono presenti più argomenti, posizionare ad esempio il formato di output del comando in C E(). |
| 2 | console.info([dati] [, ... ]) Il ruolo del comando restituisce un messaggio informativo, il comando console.log non fa molta differenza, oltre a Chrome, verrà emesso solo il testo, il resto mostrerà un punto esclamativo blu. |
| 3 | console.errore([dati] [, ... ]) Messaggio di errore in uscita. La console verrà visualizzata in rosso quando si verifica un errore di fork. |
| 4 | console.warn([dati] [, ... ]) Viene visualizzato un messaggio di avviso. La console viene visualizzata con un punto esclamativo giallo. |
| 5 | console.dir(OBJ[, opzioni]) Oggetto utilizzato per l'ispezione (ispezione) e formati di visualizzazione e stampa di facile lettura. |
| 6 | console.time (scorciatoia) Uscita temporale, ora di inizio. |
| 7 | console.timeEnd(scorciatoia) Ora di fine, che indica la fine del tempo. |
| 8 | console.trace(messaggio [, ...]) Il codice attualmente implementa il percorso della chiamata nello stack, l'esecuzione di questa funzione di test è utile, voglio solo testare la funzione a cui si unisce console.trace sulla riga. |
| 9 | console.assert(valore[, messaggio][, ...]) Per determinare se una variabile o un'espressione è vera, erano necessari due parametri, il primo parametro è un'espressione e il secondo argomento è una stringa. Solo quando il primo argomento è falso, l'output sarà il secondo argomento e non avrà risultati. |
console.log accetta più parametri, se è presente un solo parametro, la stringa di output di quel parametro. Se sono presenti più argomenti, posizionare ad esempio il formato di output del comando in C E().
Il primo parametro è una stringa, nessun parametro, stampa solo un carattere di nuova riga.
Console.log("Ciao mondo"); console.log("byvoid%diovyb"); console.log("byvoid%diovyb", 1991);
Ciao mondo byvoid%diovyb byvoid1991iovyb
- console.error(): con console.log() fa la stessa cosa, ma restituisce un errore standard.
- console.trace(): trasmette gli errori all'output standard dello stack di chiamate corrente.
Risultati operativi come segue:
Traccia: nell'oggetto.
esempi
Crea un file main.js, codice come questo:
Console.info("程序开始执行："); contatore var = 10; console.log("计数: %d", contatore); console.time("获取数据"); // // 执行一些代码 // console.timeEnd("获取数据"); console.info("程序执行完毕。")
Il file eseguibile main.js, il codice è simile al seguente:
$ node main.js Durata del file $ node main.js: 10 minuti di lunghezza: 0ms
processo
Un processo è una variabile globale, un attributo è un oggetto globale.
Viene utilizzato per descrivere lo stato del processo corrente di un oggetto Node.js e fornisce un'interfaccia semplice al sistema operativo. Di solito scrivi i tuoi programmi a riga di comando e finisci per occupartene. Di seguito verranno introdotti alcuni dei metodi più comunemente utilizzati per il processo di opposizione da parte dei membri.
| NO. | Eventi e descrizione |
|---|---|
| 1 | Uscita Si attiva quando il processo è pronto per essere terminato. |
| 2 | prima di uscire Questo evento viene generato quando il nodo ha un ciclo di eventi vuoto e nessun'altra azione. In generale, non esiste un processo per organizzare un nodo di uscita, ma i listener "beforeExit" possono essere chiamati in modo asincrono in modo che il nodo continui. |
| 3 | uncaughtException Quando un'eccezione viene riportata nel ciclo degli eventi, genera questo evento. Se si aggiunge un monitor a un'eccezione, l'azione predefinita (stampa in pila e uscita) non verrà eseguita. |
| 4 | Il segnale viene attivato quando evento quando il processo riceve un segnale. Esamina l'elenco dei nomi di segnali POSIX standard come SIGINT, SIGUSR1 e così via. |
esempi
Crea un file main.js, codice come questo:
Process.on("esci", funzione(codice) ( // setTimeout(funzione() ( console.log("该代码不会执行"); 0); console.log("退出码为:", codice) ;)); console.log("程序执行结束");
Il file eseguibile main.js, il codice è simile al seguente:
$ node main.js 程序执行结束退出码为: 0
Codici di stato delle uscite
| Codice di stato | Titolo e descrizione |
|---|---|
| 1 | Eccezione fatale non rilevata È presente un'eccezione non rilevata e non è stata gestita né il dominio del gestore uncaughtException. |
| 2 | inutilizzato ritenzione |
| 3 | Analisi degli errori interni JavaScript L'errore JavaScript durante l'analisi del codice sorgente viene richiamato all'avvio del processo Node. Molto raramente, solo quando Node. |
| 4 | Punteggio errori JavaScript interni Il processo JavaScript che esegue il nodo di origine restituisce un errore durante la valutazione della funzione. Molto raramente, solo quando Node. |
| 5 | Errore fatale V8 in un errore irreparabile con esito fatale. Di solito stampa Stderr, contenuto: errore fatale |
| 6 | Gestore eccezioni interne non funzione Eccezione non rilevata, il gestore delle eccezioni all'interno è in qualche modo impostato sulla funzione e inoltre non può essere chiamato. |
| 7 | Errore eccezione del gestore runtime interno Eccezione non rilevata e il gestore delle eccezioni per gestire la propria genera un'eccezione. Ad esempio, se process.on("uncaughtException") o domain.on("error") genera un'eccezione. |
| 8 | inutilizzato ritenzione |
| 9 | Argomento non valido Potrebbero trattarsi di parametri sconosciuti o di parametri da valorizzare. |
| 10 | Il runtime JavaScript interno non è riuscito Il codice sorgente JavaScript viene generato quando vengono attivati errori nel processo Node, molto raramente, solo quando è in corso lo sviluppo di Node. |
| 12 | Argomento di debug non valido L'opzione --debug è impostata e/o --debug-BRK, ma ha selezionato la porta sbagliata. |
| > 128 | Uscite di segnale Se un nodo riceve un segnale fatale, come SIGKILL o SIGHUP, il codice di ritorno è 128 più il codice del segnale. Questa è la pratica Unix standard, codice elevato sui segnali di uscita. |
attributi del processo
Il processo fornisce molte proprietà utili, facilità di interazione, che possiamo controllare meglio il sistema:
| Qtà. | Proprietà e descrizione |
|---|---|
| 1 | STDOUT Flusso di output standard. |
| 2 | STDERR Flusso di errori standard. |
| 3 | STDIN Flusso di input standard. |
| 4 | ARGV La proprietà ARGV restituisce una serie di varie opzioni per l'esecuzione di uno script da riga di comando durante la composizione. I primi membri sono sempre un nodo, il secondo membro è il nome del file di script e i restanti membri sono parametri del file di script. |
| 5 | execPath Restituisce il percorso assoluto del nodo binario di esecuzione dello script corrente. |
| 6 | execArgv Restituisce il membro dell'array situato sotto lo script della riga di comando eseguito tra i parametri della riga di comando eseguibile del nodo del file di script. |
| 7 | ENV Restituisce un oggetto, i membri della variabile d'ambiente shell corrente |
| 8 | Codice d'uscita Il codice di uscita per il processo, se il processo viene presentato con process.exit() exit, senza specificare un codice di uscita. |
| 9 | versione versione del nodo, come v0.10.18. |
| 10 | versioni Una proprietà che contiene le versioni di nodi e dipendenze. |
| 11 | config L'oggetto che contiene il nodo corrente viene utilizzato per compilare il file di configurazione delle opzioni javascript eseguibile. Questo è lo stesso script run./configure creato dal file "config.gypi". |
| 12 | PID- regolatore
Numero del processo corrente. |
| 13 | Nome Nome del processo, "nodo" predefinito, è possibile personalizzare il valore. |
| 14 | arco Architettura attuale della CPU: "arm", "ia32" o "64". |
| 15 | piattaforma Esegui il programma dove la piattaforma è "Darwin", "FreeBSD", "Linux", "SunOS" o "win32" |
| 16 | mainModule require.main metodi alternativi. Vari punti, se il modulo principale cambia in fase di esecuzione, require.main potrebbe continuare a ricadere sul vecchio modulo. Entrambi sono considerati appartenenti allo stesso modulo. |
esempi
Crea un file main.js, codice come questo:
// 输出到终端 process.stdout.write("Ciao mondo!" + "\n"); // Modifica process.argv.forEach(funzione(val, indice, array) ( console.log(indice + ": " + val); )); // Copia console.log(process.execPath); // Visualizza console.log(process.platform);
Il file eseguibile main.js, il codice è simile al seguente:
$ nodo main.js Ciao mondo! 0: nodo 1: /web/www/node/main.js /usr/local/node/0.10.36/bin/node darwin
Guida di riferimento del metodo
Il processo fornisce molti metodi utili per facilitare un controllo più efficiente del nostro sistema interattivo:
| NO. | Metodo e descrizione |
|---|---|
| 1 | interrompere() Ciò genererà l'evento di attivazione del nodo di interruzione. Ciò farà sì che il nodo esca e crei un file di dump. |
| 2 | ChDir (directory) Modificare la directory di lavoro corrente del processo se l'operazione non può essere interrotta. |
| 3 | ORECCHIO () Restituisce la directory di lavoro del processo corrente |
| 4 | uscita([codice]) Termina il processo con il codice specificato. Se questo parametro viene omesso, utilizzerà il codice 0. |
| 5 | impazzisci() Ottieni l'identificazione del gruppo di processi (vedi getgid(2)). Quando un gruppo è stato acquistato un ID digitale anziché un nome. |
| 6 | setgid(ID) Impostazione del processo di identificazione del gruppo (vedere setgid (2)). L'ID può assumere un nome numerico o di gruppo. Se specifichi un nome di gruppo, sarà consentito il blocco in attesa di un ID digitale. Nota: questa funzione può essere utilizzata solo (ad esempio non Windows e Android) su piattaforme POSIX. |
| 7 | getuid() Ottieni il processo di identificazione dell'utente (vedi getuid(2)). Si tratta di un ID utente numerico, non di un nome utente. Nota: questa funzione può essere utilizzata solo (ad esempio non Windows e Android) su piattaforme POSIX. |
| 8 | UIP (ID) ID utente impostazione processo (vedere UIP (2)). Recupero di un identificatore digitale o di una stringa di nome. Se specifichi un nome di gruppo, sarà consentito il blocco durante l'attesa di un ID digitale. Nota: questa funzione può essere utilizzata solo (ad esempio non Windows e Android) su piattaforme POSIX. |
| 9 | getgroups() Il processo di restituzione dell'array ID gruppo. Il sistema POSIX non garantisce che lo sia, ma Node.js è garantito che sia presente. Nota: questa funzione può essere utilizzata solo (ad esempio non Windows e Android) su piattaforme POSIX. |
| 10 | setgroups Imposta l'ID del gruppo di processi. È idoneo a funzionare, tutto ciò che serve è avere privilegi di superutente o avere la funzionalità CAP_SETGID. Nota: questa funzione può essere utilizzata solo (ad esempio non Windows e Android) su piattaforme POSIX. |
| 11 | initgroups(utente, extra_group) Leggere/ecc. /group e inizializza l'elenco di accesso del gruppo, vengono individuati tutti i membri del gruppo. È idoneo a funzionare, tutto ciò che serve è avere privilegi di superutente o avere la funzionalità CAP_SETGID. Nota: questa funzione può essere utilizzata solo (ad esempio non Windows e Android) su piattaforme POSIX. |
| 12 | uccidere (IDP [segnale]) Invia un segnale a un processo. L'ID è l'identificatore del processo e il segnale è una stringa che indica il segnale trasmesso. I nomi dei segnali sono stringhe come "SIGINT" o "" SIGHUP. Se questo parametro viene omesso, il segnale sarà "SIGTERM". |
| 13 | Utilizzo memoria() Restituisce un oggetto che descrive il processo utilizzato dai byte di stato della memoria del nodo. |
| 14 | nextTick(richiamata) Al termine del ciclo di eventi di callback della funzione corrente. |
| 15 | Umask ([maschera]) Imposta o leggi il file della maschera di processo. I processi figli ereditano questa maschera dal processo genitore. Se l'argomento della maschera è vero, restituisce la vecchia maschera. Altrimenti restituisce la maschera corrente. |
| 16 | Speso() Restituisce il numero di secondi in cui il nodo è già stato avviato. |
| 17 | ore() Risoluzione temporale del processo corrente, specificata come array [secondi] nanosecondi. Questo è relativo a qualsiasi evento passato. Questo valore non ha nulla a che fare con la data, quindi non influisce sulla deriva dell'orologio. Lo scopo principale è misurare la performance del programma in un preciso periodo di tempo. Prima che il risultato possa essere passato all'attuale process.hrtime(), restituirà la differenza di tempo tra loro, per la misurazione del riferimento e dell'intervallo di tempo. |
esempi
Crea un file main.js, codice come questo:
// Copia console.log("immagine: " + process.cwd()); // Modifica console.log("当前版本: " + process.version); // Copia console.log(process.memoryUsage());In un nodo è possibile impostare variabili globali utilizzando l'oggetto "global" o "GLOBAL":
GLOBAL._ = require("underscore"); // ma "non dovresti" farlo! (vedi nota sotto)
o più utile...
GLOBAL.finestra = GLOBALE; // come nel browser
Dal nodo puoi vedere che sono cuciti insieme:
Node-v0.6.6/src/node.js:28:global = questo; 128: globale.GLOBALE = globale;
Nel codice precedente, "questo" è il contesto globale. Con il modulo commonJS (utilizzato dal nodo), questo "oggetto" all'interno del modulo (ovvero "il tuo codice") NON è il contesto globale. Per prova di ciò, vedi sotto dove ho emesso "questo" oggetto e poi l'oggetto gigante "GLOBAL".
Console.log("\nQUESTO:"); console.log(questo); console.log("\nGLOBALE:"); console.log(globale); /* emette... QUESTO: {} GLOBALE: ( ArrayBuffer: , Int8Array: ( BYTES_PER_ELEMENT: 1 ), Uint8Array: ( BYTES_PER_ELEMENT: 1 ), Int16Array: ( BYTES_PER_ELEMENT: 2 ), Uint16Array: ( BYTES_PER_ELEMENT: 2 ), Int32Array: ( BYTES_PER_ELEMENT: 4 ), Uint32Array: ( BYTES_ PER_ELEMENT: 4 ), Float32Array: ( BYTES_PER_ELEMENT: 4 ), Float64Array: ( BYTES_PER_ELEMENT: 8 ), DataView: , globale: , processo: ( EventEmitter: , titolo: "node", assert: , versione: "v0.6.5", _tickCallback: " NativeModule fs", "Associazione fs", "Associazione costanti", "Stream NativeModule", "Console NativeModule", "Associazione tty_wrap", "NativeModule tty", "NativeModule net", "Timer NativeModule", "Associazione timer_wrap", " NativeModule _linklist" ], versioni: ( node: "0.6.5", v8: "3.6.6.11", ares: "1.7.5-DEV", uv: "0.6", openssl: "0.9.8n" ), nextTick : , stdout: , arch: "x64", stderr: , piattaforma: "darwin", argv: [ "node", "/workspace/zd/zgap/darwin-js/index.js" ], stdin: , env: ( TERM_PROGRAM: "iTerm.app", "COM_GOOGLE_CHROME_FRAMEWORK_SERVICE_PROCESS/USERS/DDOPSON/LIBRARY/APPLICATION_SUPPORT/GOOGLE/CHROME_SOCKET": "/tmp/launch-nNl1vo/ServiceProcessSocket", TERM: "xterm", SHELL: "/bin/bash" , TMPDIR: "/var/folders/2h/2hQmtmXlFT4yVGtr5DBpdl9LAiQ/-Tmp-/", Apple_PubSub_Socket_Render: "/tmp/launch-9Ga0PT/Render", UTENTE: "ddopson", COMMAND_MODE: "unix2003", SSH_AUTH_SOCK: "/tmp/ launch -sD905b/Listeners", __CF_USER_TEXT_ENCODING: "0x12D732E7:0:0", PERCORSO: "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:~/bin:/usr/ X11 /bin", PWD: "/workspace/zd/zgap/darwin-js", LANG: "en_US.UTF-8", ITERM_PROFILE: "Default", SHLVL: "1", COLORFGBG: "7;0", HOME: "/Users/ddopson", ITERM_SESSION_ID: "w0t0p0", LOGNAME: "ddopson", DISPLAY: "/tmp/launch-l9RQXI/org.x:0", OLDPWD: "/workspace/zd/zgap/darwin- js /external", _: "./index.js"), openStdin: , exit: , pid: 10321, caratteristiche: ( debug: false, uv: true, ipv6: true, tls_npn: false, tls_sni: true, tls : true ), kill: , execPath: "/usr/local/bin/node", addListener: , _needTickCallback: , on: , rimuoviListener: , ReallyExit: , chdir: , debug: , error: , cwd: , watchFile: , umask:, getuid:, unwatchFile:, mixin:, setuid:, setgid:, createChildProcess:, getgid:, inherits:, _kill:, _byteLength:, mainModule: ( id: ". ", esportazioni: (), genitore: null, nome file: "/workspace/zd/zgap/darwin-js/index.js", caricato: false, uscito: false, figli: , percorsi: ), _debugProcess: , dlopen: , uptime: , memoryUsage: , uvCounters: , associazione: ), GLOBAL: , root: , Buffer: ( poolSize: 8192, isBuffer: , byteLength: , _charsWritten: 8 ), setTimeout: , setInterval: , clearTimeout: , clearInterval: , console: , finestra: , navigatore: () ) */
**Nota: per quanto riguarda l'impostazione "GLOBAL._", in generale dovresti semplicemente fare var _ = require("underscore"); . Sì, lo fai in ogni file che utilizza il carattere di sottolineatura, proprio come in Java import com.foo.bar; . Ciò rende più semplice determinare cosa sta facendo il tuo codice perché i collegamenti tra i file sono "espliciti". Leggermente fastidioso, ma buono. Questo è un sermone.
C'è un'eccezione a ogni regola. Avevo esattamente un'istanza in cui dovevo impostare "GLOBAL._". Stavo creando un sistema per definire file "config" che erano principalmente JSON, ma erano "scritti in JS" per aggiungere un po' più di flessibilità. Non c'erano istruzioni "require" in tali file di configurazione, ma volevo che avessero accesso al carattere di sottolineatura (L'INTERO sistema era basato su caratteri di sottolineatura e caratteri di sottolineatura), quindi impostavo "GLOBAL._" prima di valutare "config". Quindi sì, per ogni regola c’è un’eccezione da qualche parte. Ma hai una buona ragione, non solo "sono stanco di scrivere", quindi voglio rompere l'accordo."