Objets globaux de Node.js
En JavaScript, il existe un objet spécial appelé l'Objet global. Lui et toutes ses propriétés sont accessibles n'importe où dans le programme, c'est-à-dire les variables globales.
En JavaScript côté navigateur, window est généralement l'objet global, tandis que dans Node.js l'objet global est global. Toutes les variables globales (sauf global lui-même) sont des propriétés de l'objet global.
Dans Node.js, nous pouvons accéder directement aux propriétés de global sans avoir besoin de l'inclure dans l'application.
Objets globaux et variables globales
Le rôle le plus fondamental de global est de servir d'hôte aux variables globales. Selon la définition d'ECMAScript, les variables qui remplissent les conditions suivantes sont des variables globales :
- Variables définies au niveau le plus externe ;
- Propriétés de l'objet global ;
- Variables définies implicitement (variables affectées directement sans définition).
Lorsque vous définissez une variable globale, cette variable devient également une propriété de l'objet global, et vice versa. Il convient de noter que dans Node.js, vous ne pouvez pas définir de variables au niveau le plus externe, car tout le code utilisateur appartient au module courant, et le module lui-même n'est pas le contexte le plus externe.
Remarque :Il est préférable de ne pas utiliser var pour définir des variables afin d'éviter d'introduire des variables globales, car les variables globales polluent l'espace de noms et augmentent le risque de couplage du code.
__filename
__filenameReprésente le nom de fichier du script en cours d'exécution. Il affichera le chemin absolu de l'emplacement du fichier, et il peut ne pas être identique au nom de fichier spécifié par les arguments de ligne de commande. Si dans un module, la valeur renvoyée est le chemin du fichier du module.
Exemple
Créez un fichier main.js avec le code suivant :
// 输出全局变量 __filename 的值 console.log( __filename );
Exécutez le fichier main.js, le code est le suivant :
$ node main.js /web/com/example/nodejs/main.js
__dirname
__dirnameReprésente le répertoire où se trouve le script en cours d'exécution.
Exemple
Créez un fichier main.js avec le code suivant :
// 输出全局变量 __dirname 的值 console.log( __dirname );
Exécutez le fichier main.js, le code est le suivant :
$ node main.js /web/com/example/nodejs
setTimeout(cb, ms)
setTimeout(cb, ms)La fonction globale exécute la fonction spécifiée (cb) après le nombre spécifié de millisecondes (ms). setTimeout() n'exécute la fonction spécifiée qu'une seule fois.
Renvoie une valeur de handle représentant le minuteur.
Exemple
Créez un fichier main.js avec le code suivant :
function printHello(){
console.log( "Hello, World!");
}
// 两秒后执行以上函数
setTimeout(printHello, 2000);
Exécutez le fichier main.js, le code est le suivant :
$ node main.js Hello, World!
clearTimeout(t)
clearTimeout( t )La fonction globale est utilisée pour arrêter un minuteur précédemment créé par setTimeout(). Le paramètretest le minuteur créé par la fonction setTimeout().
Exemple
Créez un fichier main.js avec le code suivant :
function printHello(){
console.log( "Hello, World!");
}
// 两秒后执行以上函数
var t = setTimeout(printHello, 2000);
// 清除定时器
clearTimeout(t);
Exécutez le fichier main.js, le code est le suivant :
$ node main.js
setInterval(cb, ms)
setInterval(cb, ms)La fonction globale exécute la fonction spécifiée (cb) après le nombre spécifié de millisecondes (ms).
Renvoie une valeur de handle représentant le minuteur. Vous pouvez utiliserclearInterval(t)la fonction pour effacer le minuteur.
La méthode setInterval() appelle continuellement la fonction jusqu'à ce que clearInterval() soit appelée ou que la fenêtre soit fermée.
Exemple
Créez un fichier main.js avec le code suivant :
function printHello(){
console.log( "Hello, World!");
}
// 两秒后执行以上函数
setInterval(printHello, 2000);
Exécutez le fichier main.js, le code est le suivant :
$ node main.jsHello, World! Hello, World! Hello, World! Hello, World! Hello, World! ……
Le programme ci-dessus affichera "Hello, World!" toutes les deux secondes, et continuera à s'exécuter indéfiniment jusqu'à ce que vous appuyiez surctrl + cle bouton.
console
console est utilisé pour fournir une sortie console standard. C'est un outil de débogage fourni par le moteur JScript d'Internet Explorer, et il est ensuite progressivement devenu la norme d'implémentation pour les navigateurs.
Node.js suit cette norme et fournit un objet console cohérent avec le comportement habituel, utilisé pour afficher des caractères vers le flux de sortie standard (stdout) ou le flux d'erreur standard (stderr).
Méthodes de console
Voici les méthodes de l'objet console :
| Non. | Metode & Deskripsi |
|---|---|
| 1 | console.log([data][, ...]) Affiche des caractères vers le flux de sortie standard et se termine par un saut de ligne. Cette méthode accepte plusieurs paramètres. S'il n'y a qu'un seul paramètre, elle affiche la représentation sous forme de chaîne de ce paramètre. S'il y a plusieurs paramètres, elle affiche dans un format similaire à la commande printf() du langage C. |
| 2 | console.info([data][, ...]) Cette commande est utilisée pour renvoyer un message d'information. Cette commande n'est pas très différente de console.log, sauf que dans Chrome elle n'affiche que du texte, tandis que dans d'autres elle affiche un point d'exclamation bleu. |
| 3 | console.error([data][, ...]) Affiche des messages d'erreur. Lorsqu'une erreur se produit, la console affiche une croix rouge. |
| 4 | console.warn([data][, ...]) Affiche des messages d'avertissement. La console affiche un point d'exclamation jaune. |
| 5 | console.dir(obj[, options]) Utilisé pour inspecter un objet et l'afficher dans un format facile à lire et imprimable. |
| 6 | console.time(label) Affiche le temps, indiquant le début du chronométrage. |
| 7 | console.timeEnd(label) Termine le temps, indiquant la fin du chronométrage. |
| 8 | console.trace(message[, ...]) Le chemin d'appel du code en cours d'exécution dans la pile. C'est très utile pour tester l'exécution d'une fonction ; ajoutez simplement console.trace à l'intérieur de la fonction que vous voulez tester. |
| 9 | console.assert(value[, message][, ...]) Sert à déterminer si une expression ou une variable est vraie. Il accepte deux paramètres : le premier est une expression, et le second est une chaîne. Ce n'est que lorsque le premier paramètre est faux qu'il affiche le second paramètre ; sinon, il n'y aura aucun résultat. |
console.log accepte plusieurs paramètres. S'il n'y a qu'un seul paramètre, il affiche ce paramètre sous forme de chaîne. S'il y a plusieurs paramètres, il effectue l'affichage dans un format similaire à la commande printf() du langage C.
Le premier paramètre est une chaîne. S'il n'y a aucun paramètre, il affiche uniquement un caractère de nouvelle ligne.
console.log('Hello world');
console.log('byvoid%diovyb');
console.log('byvoid%diovyb', 1991);
Le résultat d'exécution est :
Hello world byvoid%diovyb byvoid1991iovyb
- console.error() : Même utilisation que console.log(), sauf qu'il affiche sur le flux d'erreur standard.
- console.trace() : Affiche la pile d'appels actuelle sur le flux d'erreur standard.
console.trace();
Le résultat d'exécution est :
Trace: at Object.<anonymous> (/home/byvoid/consoletrace.js:1:71) at Module._compile (module.js:441:26) at Object..js (module.js:459:10) at Module.load (module.js:348:31) at Function._load (module.js:308:12) at Array.0 (module.js:479:10) at EventEmitter._tickCallback (node.js:192:40)
Exemple
Créez un fichier main.js avec le code suivant :
console.info("程序开始执行：");
var counter = 10;
console.log("计数: %d", counter);
console.time("获取数据");
//
// 执行一些代码
//
console.timeEnd('获取数据');
console.info("程序执行完毕。")
Exécutez le fichier main.js, le code est le suivant :
$ node main.js 程序开始执行： 计数: 10 获取数据: 0ms 程序执行完毕
process
process est une variable globale, c'est-à-dire une propriété de l'objet global.
Il s'agit d'un objet utilisé pour décrire l'état actuel du processus Node.js, fournissant une interface simple avec le système d'exploitation. Habituellement, lorsque vous écrivez des programmes en ligne de commande locaux, vous devez inévitablement interagir avec lui. Ce qui suit présentera quelques-unes des méthodes membres les plus couramment utilisées de l'objet process.
| Non. | Événement & Description |
|---|---|
| 1 | exit Déclenché lorsque le processus est sur le point de se terminer. |
| 2 | beforeExit Cet événement est déclenché lorsque Node vide la boucle d'événements et n'a plus d'autres tâches planifiées. Généralement, Node quitte lorsqu'il n'y a plus de tâches planifiées, mais les écouteurs 'beforeExit' peuvent être appelés de manière asynchrone, donc Node continuera à s'exécuter. |
| 3 | uncaughtException Déclenché lorsqu'une exception remonte jusqu'à la boucle d'événements. Si un écouteur est ajouté pour l'exception, l'opération par défaut (afficher la trace de la pile et quitter) ne se produira pas. |
| 4 | Événement de signal Déclenché lorsque le processus reçoit un signal. Pour la liste des signaux, voir les noms de signaux POSIX standard, tels que SIGINT, SIGUSR1, etc. |
Exemple
Créez un fichier main.js avec le code suivant :
process.on('exit', function(code) {
// 以下代码永远不会执行
setTimeout(function() {
console.log("该代码不会执行");
}, 0);
console.log('退出码为:', code);
});
console.log("程序执行结束");
Exécutez le fichier main.js, le code est le suivant :
$ node main.js 程序执行结束 退出码为: 0
Codes de statut de sortie
| Code d'état | Nom et description |
|---|---|
| 1 | Exception fatale non interceptée Il y a une exception non interceptée, et elle n'a pas été gérée par un domaine ou un gestionnaire uncaughtException. |
| 2 | Inutilisé Réservé, réservé par Bash pour une mauvaise utilisation des commandes intégrées. |
| 3 | Erreur d'analyse JavaScript interne Une erreur d'analyse causée lors du démarrage du processus Node avec du code source JavaScript. Très rare, ne se produit que lors du développement de Node. |
| 4 | Échec d'évaluation JavaScript interne Un échec de retour d'une fonction lors de l'évaluation du code source JavaScript pour démarrer le processus Node. Très rare, ne se produit que lors du développement de Node. |
| 5 | Erreur fatale Une erreur fatale et irrécupérable dans V8. Généralement imprimée sur stderr, avec le contenu : FATAL ERROR. |
| 6 | Gestionnaire d'exceptions interne non-fonction Exception non interceptée, et pour une raison quelconque, la fonction de gestionnaire d'exceptions interne est définie comme non-fonction et ne peut pas être appelée. |
| 7 | Échec d'exécution du gestionnaire d'exceptions interne Exception non interceptée, et le gestionnaire d'exceptions a lui-même levé une exception pendant qu'il la traitait. Par exemple, si process.on('uncaughtException') ou domain.on('error') a levé une exception. |
| 8 | Inutilisé Réservé. Dans les versions précédentes de Node.js, le code de sortie 8 indiquait parfois une exception non interceptée. |
| 9 | Argument non valide Un argument inconnu a peut-être été fourni, ou l'argument fourni n'avait aucune valeur. |
| 10 | Défaillance interne de l'exécution JavaScript Une erreur levée lorsque la source JavaScript démarre le processus Node ; très rare, et ne se produit que lors du développement de Node lui-même. |
| 12 | Argument de débogage non valide L'option --debug et/ou --debug-brk a été définie, mais un port incorrect a été choisi. |
| 128 | Sorties par signal Si Node reçoit un signal fatal, tel que SIGKILL ou SIGHUP, le code de sortie est 128 plus le code du signal. C'est une pratique Unix standard, qui place le code du signal de sortie dans les bits de poids fort. |
Propriétés du processus
Le processus fournit de nombreuses propriétés utiles pour nous aider à mieux contrôler l'interaction avec le système :
| Non. | Propriété & Description |
|---|---|
| 1 | stdout Flux de sortie standard. |
| 2 | stderr Flux d'erreur standard. |
| 3 | stdin Flux d'entrée standard. |
| 4 | argv La propriété argv renvoie un tableau composé des différents arguments lorsque le script est exécuté depuis la ligne de commande. Son premier membre est toujours node, le deuxième membre est le nom du fichier de script, et les membres restants sont les arguments du fichier de script. |
| 5 | execPath Renvoie le chemin absolu du fichier binaire Node exécutant le script actuel. |
| 6 | execArgv Renvoie un tableau dont les membres sont les arguments de ligne de commande entre le fichier exécutable Node et le fichier de script lorsque le script est exécuté depuis la ligne de commande. |
| 7 | env Renvoie un objet dont les membres sont les variables d'environnement du shell actuel. |
| 8 | exitCode Le code de sortie lorsque le processus se termine. Si le processus se termine via process.exit(), il n'est pas nécessaire de spécifier un code de sortie. |
| 9 | version La version de Node, telle que v0.10.18. |
| 10 | versions Une propriété qui contient la version de Node et ses dépendances. |
| 11 | config Un objet contenant les options de configuration JavaScript utilisées pour compiler l'exécutable Node actuel. Il est identique au fichier "config.gypi" généré en exécutant le script ./configure. |
| 12 | pid L'ID du processus actuel. |
| 13 | title Le nom du processus, avec une valeur par défaut de "node" ; cette valeur peut être personnalisée. |
| 14 | arch L'architecture CPU actuelle : 'arm', 'ia32' ou 'x64'. |
| 15 | plateforme Le système de plateforme sur lequel le programme s'exécute : 'darwin', 'freebsd', 'linux', 'sunos' ou 'win32'. |
| 16 | mainModule Une alternative à require.main. La différence est que si le module principal change au moment de l'exécution, require.main peut continuer à renvoyer l'ancien module. On peut considérer que les deux font référence au même module. |
Exemple
Créez un fichier nommé main.js avec le code suivant :
// 输出到终端
process.stdout.write("Hello World!" + "\n");
// 通过参数读取
process.argv.forEach(function(val, index, array) {
console.log(index + ': ' + val);
});
// 获取执行路径
console.log(process.execPath);
// 平台信息
console.log(process.platform);
Exécutez le fichier main.js avec le code suivant :
$ node main.js Hello World! 0: node 1: /web/www/node/main.js /usr/local/node/0.10.36/bin/node darwin
Référence des méthodes
Process fournit de nombreuses méthodes utiles pour nous aider à mieux contrôler l'interaction avec le système :
| Non. | Metode & Deskripsi |
|---|---|
| 1 | abort() Cela amènera Node à déclencher l'événement abort. Cela amènera Node à quitter et à générer un fichier core. |
| 2 | chdir(directory) Change le répertoire du processus de travail actuel ; lève une exception si l'opération échoue. |
| 3 | cwd() Retourne le répertoire de travail du processus actuel. |
| 4 | exit([code]) Termine le processus avec le code spécifié. S'il est omis, le code 0 sera utilisé. |
| 5 | getgid() Obtient l'identité de groupe du processus (voir getgid(2)). L'identifiant numérique de groupe est obtenu, pas le nom. Remarque : cette fonction n'est disponible que sur les plateformes POSIX (par exemple, non-Windows et non-Android). |
| 6 | setgid(id) Définit l'identité de groupe du processus (voir setgid(2)). Il peut accepter un ID numérique ou un nom de groupe. Si un nom de groupe est spécifié, il bloque en attendant de le résoudre en un ID numérique. Remarque : cette fonction n'est disponible que sur les plateformes POSIX (par exemple, non-Windows et non-Android). |
| 7 | getuid() Obtient l'identité utilisateur du processus (voir getuid(2)). Il s'agit de l'ID utilisateur numérique, pas du nom d'utilisateur. Remarque : cette fonction n'est disponible que sur les plateformes POSIX (par exemple, non-Windows et non-Android). |
| 8 | setuid(id) Définit l'identité utilisateur du processus (voir setuid(2)). Il accepte un ID numérique ou un nom sous forme de chaîne. Si un nom de groupe est spécifié, il bloque en attendant de le résoudre en un ID numérique. Remarque : cette fonction n'est disponible que sur les plateformes POSIX (par exemple, non-Windows et non-Android). |
| 9 | getgroups() Renvoie un tableau des ID de groupe du processus. Les systèmes POSIX ne garantissent pas leur présence, mais node.js le garantit. Remarque : cette fonction n'est disponible que sur les plateformes POSIX (par exemple, non-Windows et non-Android). |
| 10 | setgroups(groups) Définit les ID de groupe du processus. Il s'agit d'une opération privilégiée, vous avez donc besoin des privilèges root ou de la capacité CAP_SETGID. Remarque : cette fonction n'est disponible que sur les plateformes POSIX (par exemple, non-Windows et non-Android). |
| 11 | initgroups(user, extra_group) Lit /etc/group et initialise la liste d'accès des groupes, en utilisant tous les groupes auxquels le membre appartient. Il s'agit d'une opération privilégiée, vous avez donc besoin des privilèges root ou de la capacité CAP_SETGID. Remarque : cette fonction n'est disponible que sur les plateformes POSIX (par exemple, non-Windows et non-Android). |
| 12 | kill(pid[, signal]) Envoie un signal au processus. pid est l'identifiant du processus, et signal est la description sous forme de chaîne du signal envoyé. Les noms de signaux sont des chaînes, telles que 'SIGINT' ou 'SIGHUP'. S'ils sont omis, le signal sera 'SIGTERM'. |
| 13 | memoryUsage() Renvoie un objet décrivant l'utilisation de la mémoire du processus Node, en octets. |
| 14 | nextTick(callback) Appelle la fonction de rappel une fois que la boucle d'événements actuelle se termine. |
| 15 | umask([mask]) Définit ou lit le masque de fichier du processus (umask). Les processus enfants héritent du masque du processus parent. Si l'argument mask est valide, l'ancien masque est renvoyé. Sinon, le masque actuel est renvoyé. |
| 16 | uptime() Renvoie le nombre de secondes depuis que Node est en cours d'exécution. |
| 17 | hrtime() Renvoie le temps haute résolution du processus actuel sous forme d'un tableau de [secondes, nanosecondes]. Il est relatif à un événement arbitraire dans le passé. Cette valeur n'a aucun rapport avec la date, elle n'est donc pas affectée par la dérive de l'horloge. Son objectif principal est de mesurer les performances d'un programme au moyen d'intervalles de temps précis. Vous pouvez passer le résultat précédent à la méthode process.hrtime() actuelle, qui renverra la différence de temps entre les deux, pour l'analyse comparative et la mesure d'intervalles de temps. |
Exemple
Créez un fichier nommé main.js avec le code suivant :
// 输出当前目录
console.log('当前目录: ' + process.cwd());
// 输出当前版本
console.log('当前版本: ' + process.version);
// 输出内存使用情况
console.log(process.memoryUsage());
Exécutez le fichier main.js avec le code suivant :
$ node main.js
当前目录: /web/com/example/nodejs
当前版本: v0.10.36
{ rss: 12541952, heapTotal: 4083456, heapUsed: 2157056 } Autres extensions