NODE.JS– softwarový nástroj pro spouštění js.
Nodejs = V8 + I/O + knihovny
V8: rychlý, moderní, ekonomický
Výhody
- Javascript
- Společný kód na klientovi a serveru
- Základní webové úkoly
- Mnoho spojení a úkolů zároveň
- Snadné vytvoření funkčního prototypu
- Pohodlný správce balíčků npm
- Společenství
Instalace
Při instalaci se nodejs zapisuje do proměnné PATH (+ npm), [administrace - proměnné prostředí]; lze zkontrolovat na příkazovém řádku:
nastavit PATH
Soubory se zpravidla spouštějí pod nodejs: napíšeme jednoduchý skript a spustíme jej přes příkazový řádek:
Skript se spustí a výsledek se zobrazí na příkazovém řádku.
Dokumentace Nodejs
moduly nodejs
Abyste pochopili, jak fungují vestavěné moduly nodejs, musíte si stáhnout archiv zdrojového kódu z webu nodejs (zdrojový kód). A přejděte do adresáře lib. (příkaz dir - získat seznam souborů přes příkazový řádek; Pokud potřebujete vypsat soubory ve všech podsložkách, pak místo "dir" použijte "dir /s"). Pokud jste nodejs nainstalovali z balíčku, ve složce lib nenajdete žádné soubory.
Nodejs má moduly s různým stupněm stabilita. (například 0 – nemělo by se používat; 1, 2 – lze použít, ale modul API se může změnit).
Funkce přibývají (projekt se vyvíjí) a postupem času budeme muset přesunout funkci konstruktoru USER do samostatného souboru. Zde vstupují do hry moduly.
Moduly jsou druhem způsobu, který nodejs nabízí k organizaci projektu.
Projekty mají tendenci narůstat, což vede k touze rozdělit projekt do několika souborů – zde vstupují do hry moduly.
vyžadovat
U stránek HTML se k zahrnutí skriptů používají značky skriptu. Nodejs má speciální příkaz require.
Var uživatel = vyžadovat("./uživatel");
V našem příkladu přistupujeme k souboru (user.js) ve stejném adresáři (přípona (.js) je volitelná).
//vyžadovat("./uživatel"); // .js není nutné zadávat // v tomto případě bude soubor spuštěn, ale nebude zde žádná proměnná USER // to je hlavní rozdíl od značek skriptu z nodejs // V node.js jsou funkce a proměnné každého modulu jsou globální // pro tento soubor (samotný modul) a nejsou automaticky // dostupné po připojení (require(./user)) // Jak ale získat přístup? // Každý modul má speciální exporty proměnných - to je objekt a to, co // tam dám, se vrátí jako výsledek require var user = require("./user.js"); // výsledek: uživatel = ( Uživatel: funkce )
První rozdíl mezi modulárním systémem nodejs a skripty prohlížeče: pokud jsou v prohlížeči dvě značky skriptu, pak funkce, která je definována na globální úrovni v jedné z nich, je dostupná v druhé, ale ne v nodejs. V nodejs jsou funkce a proměnné pro daný soubor globální (nejsou k dispozici, když jsou vyžadovány). Nodejs vám tedy umožňuje psát skutečně nezávislé moduly. Ale aby byl modul k dispozici, používá se exportní systém. Každý modul má speciální exportní proměnnou.
Modul-adresář DIR/index
Složku připojíme přímo var user = require("./user"); , který obsahuje odpovídající index.js .
Například
Function User(name)( this.name = name; ) User.prototype.hello = function(who)( console.log(phrases.Hello + ", " + who.name); ); exports.User = Uživatel;
Připojíme a použijeme konstruktor User v souboru ./server.js
//server.js var user = require("./user"); var vasya = nový uživatel.Uživatel("Vasya");
"./" - vzhledem k aktuální složce
exports je objekt a to, co se tam vloží, se vrátí jako výsledek požadavku (exports.jpg). Tímto způsobem může modul deklarovat své soukromé proměnné/funkce a exportovat pouze to, co je potřeba.
Pro globální proměnné atd. existuje globální objekt
Global.User = Uživatel;
Sečteno a podtrženo
- Vyžaduje připojení
- Proměnné: var (soukromé pro moduly), exporty, globální (zřídka používané)
- Typy modulů: js, node (s příponou .node), json (s příponou .json). Moduly Json se používají, když potřebujete uložit nějaké jednoduché informace do souboru.
- Modul-adresář DIR/index
modulový objekt
- modulový objekt
- Modul-funkce modul.export = funkce
- Ukládání modulů do mezipaměti (modul se již nikdy znovu nečte)
- Uspořádání modulů: pořadí vyhledávání
- Předání parametrů: modul-továrna
Objekt modulu (základní objekt pro moduly) je proměnná, která existuje v každém modulu (soubor, můžete výstupem console.log(module;);). . Obsah: vlastnost id – obvykle cesta k souboru,
parent – odkaz na nadřazený modul (module.parent – odkaz na nadřazený modul, který to vyžaduje),
děti (module.children - ty moduly, které jsou připojeny přes vyžadují),
export nemovitosti a další.
Modul nebo aplikace? modul.rodič
Modul lze spustit přímo, ale pokud ne, pokud je funkcionalita připojena k jinému modulu, nechte jej exportovat tuto funkcionalitu. Tyto dva případy lze oddělit kontrolou:
If(module.parent) ( exports.run = run; ) else ( run(); )
ps: jak se říká na stackoverflow.com Rodič je modul, který zavolal skript pro interpretaci
// $ node foo.js console.log(module.parent); // null // require("./foo") console.log(module.parent); // (...)
Správné používání modulu.exports
V kontextu modulu:
module.exports = exports = this (tyto konstrukce jsou ekvivalentní)
Pokud chcete předat funkci ne v objektu, ale přímo, použijte následující syntaxi:
Module.exports = Uživatel;
Modul Caching
Když Nodejs načte modul, zcela vytvoří odpovídající objekt modulu (s přihlédnutím k parent , exportům a dalším podobným vlastnostem) a pamatuje si jej sám o sobě (module.id (úplná cesta k souboru) slouží jako identifikátor pro interní mezipaměť ) a až příště znovu přistoupíme (připojíme se) k jakémukoli modulu (souboru), nodejs vezme stejný objekt z mezipaměti. To znamená, že například modul stačí inicializovat jednou v souboru, v budoucnu jej můžete jednoduše použít.
V našem případě pro var db = require("../db");
a pro var db = require("./db"); vezme se stejný objekt. Princip je tedy následující: při prvním použití se modul inicializuje a v budoucnu jej pouze připojíme a použijeme (tedy v našem případě nemusíme používat db.connect() dvakrát, to znamená v různých souborech).
Uspořádání modulů: pořadí, ve kterém se moduly nacházejí v nodejs
Jak zajistit, aby se db vždy připojoval bez zadání konkrétní cesty:
Var db = vyžadovat("../db"); //nebo var db = require("./db");
a takhle:
Var db = vyžadovat("db");
bez ohledu na soubor, ve kterém je db připojen.
Chcete-li to provést, musíte porozumět pořadí vyhledávání modulů v nodejs (co se stane, když je zavoláno require). V nodejs je mnoho vestavěných modulů, například require("fs"); , který bude bez problémů připojen. Pokud zadáte konkrétní cestu v require, například require("../db"); , pak bude hledání založeno na dané cestě a soubor bude nalezen, nebo se nodejs pokusí získat tento soubor jako adresář (a bude hledat index.js uvnitř kategorie).
Pokud zadáte require("db"); a modul není vestavěný, pak bude prohledán adresář node_modules vzhledem k aktuální pozici (pokud je nalezen, pokusí se z něj modul vzít). Pokud adresář node_modules chybí, bude se hledat adresář node_modules výše atd.
Kromě zadání konkrétní cesty pro modul může nodejs hledat moduly, jako je tento:
Úvod do npm – správce balíčků pro Node.JS
- vytvořte soubor s popisem balíčku (package.json), který obsahuje informace o modulu (název, verze atd.). Buď ručně nebo pomocí příkazu
npm init
(vyžádá si potřebné informace) - Chcete-li publikovat modul, musíte:
- Přidejte uživatele pomocí příkazu npm adduser (musíte zadat uživatelské jméno a heslo). Nyní bude veškerá práce s npm prováděna jménem tohoto uživatele. Uživatel se může přihlásit na https://www.npmjs.com/~name_user a sledovat své moduly.
- Vydavatelství: npm publish
- Pak může někdo použít váš modul přidaný do databáze a uživatel sám může provádět změny.
- Získejte všechny příkazy npm pomocí příkazu nápovědy npm
- Vyhledejte modul v databázi: klíčová slova npm s nebo klíčová slova vyhledávání npm (například npm s super modul)
- Nainstalujte modul: npm install name_module nebo npm i name_module
- Při instalaci modulů nodejs nejprve hledá složku node_modules v aktuálním adresáři (pak vyšší a vyšší atd.), nebo (pokud node_modules chybí) hledá package.json (také jde nahoru; package.json obvykle označuje kořen projekt) a podle toho, pokud najde package.json, vytvoří složku node_modules v odpovídajícím adresáři; pokud obě možnosti selžou, pak nodejs vytvoří složku node_modules v aktuálním adresáři. Pokud chcete umístit modul do konkrétního adresáře, musíte v tomto adresáři vytvořit složku node_modules.
- npm up aktualizační modul (zkontroluje aktualizační moduly, které jsou ve složce node_modules)
- npm odebrat název modulu (odebrat modul)
Výstup z npm:
npm init
nmp adduser
npm zveřejnit
klíčová slova pro vyhledávání npm
Instalační modul npm
aktualizační modul npm
npm odstranit modul
příkaz nápovědy npm
Struktura balíčku NPM
Instalace požadované verze, například: npm i [e-mail chráněný]
Nejnovější verzi modulu lze získat, pokud je modul vyvíjen pomocí verzovacího systému git, například na githubu. Stačí získat Git Read-Only (url): https://github.com/strongloop/express.git a v konzoli:
npm i https://github.com/strongloop/express.git
závislosti v package.json
závislosti ukazuje na ty moduly, na kterých tento závisí.
devDependencies
Moduly registrované v devDependencies se nenainstalují, pokud je modul vytažen jako závislost. Instalují se pouze pro vývoj a lze je nainstalovat, pokud například přejdete do modulu ve složce node_modules a zadáte npm i (nebo nastavením příznaku npm config).
hlavní pole určuje vstupní bod do balíčku
Globální moduly
Jakýkoli modul lze nainstalovat globálně, pokud nastavíte parametr -g: npm -g module
Globální znamená do systémového adresáře.
Adresář globálních modulů pro Windows:
C:\users\Jméno_uživatele\AppData\Roaming\npm
Globální moduly jsou umístěny ve standardním systémovém adresáři. Ty binární soubory, které jsou v package.json, budou nainstalovány do systémové cesty (toto je hlavní použití globálních modulů), to znamená, že v budoucnu je lze volat přes konzolu.
Na základě materiálů z kurzů I. Kantora
Ahoj lidi, v dnešním článku chci mluvit o globálních proměnných v Node. Tento článek je zaměřen na vývojáře, kteří pracují s Node na úrovni začátečníků až středně pokročilých. Pokud jste o globálních proměnných nikdy neslyšeli nebo jste s nimi nepracovali, ne v tomto článku se dozvíte vše, co potřebujete vědět o globálních proměnných, během okamžiku.
Co jsou globální proměnné?
Globální proměnné jsou velmi podobné, ne-li totožné, s regulárními proměnnými. Globální proměnné lze inicializovat hodnotou, tuto hodnotu lze změnit a dokonce je lze vymazat jako běžnou proměnnou. Rozdíl mezi regulární proměnnou a globální proměnnou spočívá v jejich rozsahu. Když vytvoříte proměnnou v souboru JavaScript, tyto proměnné existují pouze v rozsahu, ve kterém byly deklarovány. Co tím chci říct? V níže uvedeném kódu můžete vidět příklad dvou různých proměnných s různými rozsahy.
// Scope.js let fileScope = "Lze přistupovat kdekoli v souboru"; function doSomething() ( let localScope = "Lze přistupovat pouze uvnitř této funkce"; fileScope = "Lze přistupovat i ve funkci!"; ) // To bude mít za následek chybu, protože proměnná neexistuje // mimo funkce. localScope = "Zkuste mě změnit zde";
Ve úryvku kódu výše vidíme, že existují dvě proměnné, fileScope a localScope . Proměnnou fileScope lze změnit nebo volat odkudkoli v tomto souboru, zatímco proměnná localScope existuje pouze uvnitř funkce doSomething() . Jsem si jistý, že v tomto bodě vás zajímá, co to má společného s globálními proměnnými. Když mluvíme o globálních proměnných, existují pro všechny soubory v programu, což znamená, že mají pro program globální rozsah.
Důvodem je to, že programy JavaScript sdílejí globální jmenný prostor mezi všemi soubory v programu. Jinak řečeno, představte si, že váš program je obrovský soubor nebo kontejner, který „importoval“ všechny ostatní soubory JavaScriptu. Poté deklarujete proměnnou v tomto velkém kontejnerovém souboru, tato proměnná má nyní rozsah v celém programu. Pokud si nejste jisti, co to jmenný prostor je, nebo se o nich chcete dozvědět více, přečtěte si tento článek, kde se dozvíte více.
Jak deklarovat a používat globální proměnnou
Nyní, když lépe rozumíme tomu, co je globální proměnná v Node, pojďme si promluvit o tom, jak vlastně globální proměnnou nastavujeme a používáme. Chcete-li nastavit globální proměnnou, musíme ji vytvořit na globálním objektu. globální objekt je to, co nám dává rozsah celého projektu, spíše než jen soubor (modul), ve kterém byla proměnná vytvořena. V bloku kódu níže vytvoříme globální proměnnou nazvanou globalString a přiřadíme jí hodnotu. změnit hodnotu globalString a nakonec ji nastavíme na undefined.
// Global.js global.globalString = "Toto je přístupné odkudkoli!"; console.log(globalString); // Výstup: "Toto je přístupné odkudkoli!" globalString = "Odhlásit se hned"; console.log(globalString); // Výstup: "Odhlásit se hned" globalString = undefined; console.log(globalString); // Výstup: undefined // Example.js // I v tomto souboru // můžeme použít global, který jsme vytvořili v Global.js. console.log(globalString); // Výstup: undefined globalString = „Můžeme to také změnit!“; console.log(globalString); // Výstup: „Můžeme to také změnit!“
O čem jsem ještě nemluvil, je další způsob, jak můžete vytvořit proměnnou globální. Důvod, proč jsem to vyloučil, je ten, že to není správný způsob nastavení proměnné. Pokud deklarujete proměnnou v souboru bez použití klíčového slova var a poté k ní přiřadíte hodnotu, globální objekt pro tuto proměnnou nastaví vlastnost. Tento proces ji v podstatě promění v globálně dostupnou proměnnou. Důrazně nedoporučuji tuto metodu používat, protože to není správný způsob, jak vytvořit globaly. Je také důležité poznamenat, že pokud nastavíte direktivu "use strict", Node zakáže implicitní globals a pravděpodobně skončíte s chybou za běhu spíše než s funkčním skriptem.
Praktické příklady použití pro globální proměnné
Nyní si možná říkáte, že chcete začít vytvářet globální proměnné, když o nich víte více. Budu důrazně varovat před vytvářením globálních proměnných z několika velmi důležitých důvodů.
Prvním důvodem je, že když vytvoříte globální proměnnou, existuje po celou dobu životnosti aplikace. Když proměnná přetrvává po celou dobu životnosti aplikace, znamená to, že se nachází v paměti a zabírá zdroje, když je aplikace spuštěna.
Za druhé, tradiční používání globálních proměnných může způsobit problémy se souběžností. Pokud může ke stejné proměnné přistupovat více vláken a neexistují žádné modifikátory přístupu nebo zabezpečení proti selhání, může to vést k vážným problémům dvou vláken pokoušejících se o přístup a použití stejné proměnné. nicméně, zatímco v jiných jazycích tomu tak je, u Node.js tomu tak nutně není, protože se jedná výhradně o jednovláknové prostředí. Zatímco to je Je možné shlukovat procesy uzlů, neexistuje žádný nativní způsob komunikace mezi nimi.
Poslední důvod, o kterém budu mluvit, je ten, že použití globals může způsobit implicitní propojení mezi soubory nebo proměnnými. Coupling není dobrá věc, pokud jde o psaní skvělého kódu. Při psaní kódu se chceme ujistit, že je co nejvíce modulární a opakovaně použitelný, a zároveň zajistit, aby byl snadno použitelný a srozumitelný. Spojení částí kódu dohromady může vést k velkým bolestem hlavy, když se snažíte ladit, proč něco nefunguje.
Pokud se chcete dozvědět více o tom, proč se globální proměnné nedoporučují, můžete se podívat na tento skvělý článek s názvem Globální proměnné jsou špatné.
Pokud se cítíte zmateni, pokud jde o účel globálních proměnných, nebojte se. Podíváme se na několik globálních proměnných, které jsou zabudovány do Node, a pokusíme se lépe porozumět tomu, proč jsou globální a jak se používají. Ve skutečnosti jste pravděpodobně několik z nich již použili, aniž byste si uvědomili, že jde o globální objekty!
// Node Globals console.log("Ahoj světe!"); process.env.PORT = 3000; setInterval(( console.log("uplynuly 2 sekundy."); 2000);
Pokud se podíváte na výše uvedený blok kódu, pravděpodobně uvidíte alespoň jednu instanci, kterou jste použili dříve, console.log() . Podle dokumentace Node je objekt konzoly globální, který má několik metod umožňujících vývojářům dělat věci, jako je tisk protokolu nebo chyba. Když se ponoříme hlouběji do dokumentů, uvidíme, že konzole je skutečně globální instance, která je nakonfigurována pro zápis do process.stdout a process.stderr.
To nás přivádí k dalšímu příkazu, který vidíte v bloku kódu výše, objektu procesu. Pokud jste vytvořili produkční sestavení aplikace Node, pravděpodobně jste museli nastavit port pro proměnnou prostředí. Proměnná prostředí env je součástí objektu procesu, který je dalším globálním. K proměnným na objektu procesu můžete přistupovat v libovolném souboru ve vašem projektu, protože je globální. Pokud by tento objekt nebyl globální, objekt konzoly by také nebyl přístupný z žádného souboru, pamatujte, že je to skutečně objekt, který odkazuje zpět na objekt procesu.
setInterval je další funkce, kterou jste již mohli vidět, pokud jste někdy měli důvod odložit operaci před jejím provedením. setTimeout a setImmediate mají podobnou povahu jako setInterval a obě jsou také globálními funkcemi. Tyto tři funkce jsou součástí modulu časovače, který odhaluje globální API, které vám umožňuje volat tyto funkce, aniž byste ve svých souborech explicitně vyžadovali časovač.
Všechny výše uvedené případy použití jsou zabudovány do Node a z nějakého důvodu jsou globální. Objekt procesu je globální, protože poskytuje informace o aktuálně běžícím procesu Node, a proto by měl být dostupný z libovolného souboru, aniž byste jej museli vyžadovat. Totéž lze říci o modulu časovače, který obsahuje řadu funkcí, které jsou důležité a měly by být dostupné kdekoli, aniž by to bylo nutné. Pokud byste se chtěli dozvědět více o existujících globálních objektech zabudovaných do Node, doporučuji vám navštívit oficiální dokumentaci na Globals.
Další informace
Chcete se dozvědět více o základech Node.js? Osobně bych doporučil online kurz, jako je Wes Bos" Learn Node.js, protože videa jsou mnohem snazší sledovat a ve skutečnosti si vytvoříte aplikaci v reálném světě.
Závěr
Vím, že to bylo docela málo informací, takže děkuji, že jste je uvedl. Všechny výše uvedené informace byly nalezeny v dokumentaci na webu Node. Prosím, ptejte se a pište komentáře v sekci komentářů níže. Až příště, přátelé!
JavaScript má speciální objekt zvaný globální objekt, k němu a všem jeho atributům lze přistupovat kdekoli v programu, globální proměnná.
Prohlížeč JavaScript je obvykle globální objekt okna, globální objekt Node.js je globální objekt, všechny globální proměnné (kromě globálního self) jsou vlastněny globálním objektem.
V Node.js máme přímý přístup ke globálním vlastnostem, aniž bychom je museli zahrnout do aplikace.
Globální objekty a globální proměnné
Nejzákladnější globální role je jako globální hostitelská proměnná. Podle definice ECMAScript jsou následující podmínky globální proměnné:
- Je definována proměnná External;
- Globální vlastnosti objektu;
- Proměnná je implicitně definována (přímé přiřazení k nedefinovaným proměnným).
Když definujete globální proměnnou, proměnná se také stane vlastností globálního objektu a naopak. Všimněte si, že v Node.js nemůžete definovat proměnné v externím kontextu, protože veškerý uživatelský kód je součástí aktuálního modulu a modul samotný není externí kontext.
Poznámka: vždy používejte var k definování proměnných, abyste se vyhnuli zavedení globální proměnné, protože globální proměnné znečišťují jmenný prostor a zvyšují riziko komunikačního kódu.
__název souboru
__filename určuje název souboru aktuálně spuštěného skriptu. Absolutní cesta k umístění, kde bude výstupní soubor, ale možnost příkazového řádku a zadání názvu souboru nemusí být nutně stejné. Pokud je v modulu, vrácená hodnota je cesta k souboru modulu.
příklady
// 输出全局变量 __filename 的值 console.log(__filename);$ node main.js /web/com/w3big/nodejs/main.js
__dirname
__dirname představuje aktuálně umístěný adresář skriptu.
příklady
Vytvořte soubor main.js, kód takto:
// 输出全局变量 __dirname 的值 console.log(__dirname);Spustitelný soubor main.js, kód vypadá takto:
$ node main.js /web/com/w3big/nodejs
setTimeout(CB, ms)
setTimeout(C - bi, ms): Funkce SetTimeout() je určena pouze jednou.
Vrací hodnotu popisovače představujícího časovač.
příklady
Vytvořte soubor main.js, kód takto:
Funkce printHello())( console.log("Ahoj světe!"); ) // setTimeout(printHello, 2000);
Spustitelný soubor main.js, kód vypadá takto:
$ node main.js Dobrý den, světe!
clearTimeout(t)
clearTimeout(t) se používá k zastavení globální funkce před předáním setTimeout() k vytvoření časovače. Parametr T funkce setTimeout() pro vytvoření kalkulačky.
příklady
Vytvořte soubor main.js, kód takto:
Funkce printHello())( console.log("Ahoj světe!"); ) // var t = setTimeout(printHello, 2000); // 清除定时器 clearTimeout(t);
Spustitelný soubor main.js, kód vypadá takto:
$nodemain.js
setInterval(CB, ms)
setInterval(C - bi, ms) Globální funkce provede zadanou funkci po zadaném počtu milisekund (ms) Number (CB).
Vrací hodnotu popisovače představujícího časovač. Funkci můžete použít clearInterval(T) pro vymazání časovače.
Metoda setInterval() bude pokračovat ve volání funkce, dokud nebude volána metoda clearInterval() nebo dokud se okno nezavře.
příklady
Vytvořte soubor main.js, kód takto:
Funkce printHello())( console.log("Ahoj, světe!"); ) // setInterval(printHello, 2000);
Spustitelný soubor main.js, kód vypadá takto:
$ node main.js Dobrý den, světe! Ahoj světe! Ahoj světe! Ahoj světe! Ahoj světe! ......
Výše uvedený program vydá „Hello, World!“ jednou za dvě sekundy a bude se nepřetržitě provádět, dokud nestisknete tlačítko CTRL + C.
řídicí panel
Konzole Konzole pro poskytování standardního výstupu, což je ladicí zařízení poskytované jádrem JScript v Internet Exploreru a později se stalo de facto standardním prohlížečem.
Node.js se řídí tímto standardem a zajišťuje konzistentní chování a návyky objektu konzoly používaného ve výstupních znacích standardního výstupního proudu (STDOUT) nebo standardního chybového proudu (STDERR).
konzolová metoda
Níže je objekt konzoly:
| Ne. | Metoda a popis |
|---|---|
| 1 | console.log([data] [, ... ]) Pro standardní tisknutelné výstupní proudové znaky a končí znakem nového řádku. Tato metoda přijímá několik parametrů, pokud existuje pouze jeden parametr, je výstupem řetězec tohoto parametru. Pokud existuje více argumentů, umístěte například výstupní formát příkazu do C E(). |
| 2 | console.info([data] [, ... ]) P role příkazu vrací informační zprávu, příkaz console.log nic moc nemění, kromě chrome se vypíše pouze text, zbytek bude ukazovat modrý vykřičník. |
| 3 | console.error([data] [, ... ]) Chybová zpráva výstupu. Pokud dojde k chybě vidlice, konzola se zobrazí červeně. |
| 4 | console.warn([data] [, ... ]) Zobrazí se varovná zpráva. Na konzole se zobrazí žlutý vykřičník. |
| 5 | console.dir(OBJ[, možnosti]) Objekt používaný pro kontrolu (kontrolu) a snadno čitelné formáty zobrazení a tisku. |
| 6 | console.time (zkratka) Časový výstup, čas zahájení. |
| 7 | console.timeEnd(zkratka) Čas konce, který označuje konec času. |
| 8 | console.trace(zpráva [, ...]) Kód aktuálně implementuje cestu volání na zásobníku, spuštění této testovací funkce je užitečné, jen chcete otestovat funkci, ke které se připojuje console.trace na řádku. |
| 9 | console.assert(hodnota[, zpráva][, ...]) K určení, zda je proměnná nebo výraz pravdivý, byly vyžadovány dva parametry, první parametr je výraz a druhý argument je řetězec. Pouze když je první argument nepravdivý, bude výstupem druhý argument; nebude mít žádné výsledky. |
console.log přijímá více parametrů, pokud existuje pouze jeden parametr, výstupní řetězec tohoto parametru. Pokud existuje více argumentů, umístěte například výstupní formát příkazu do C E().
První parametr je řetězec, žádné parametry, stačí vytisknout znak nového řádku.
Console.log("Ahoj světe"); console.log("byvoid%diovyb"); console.log("byvoid%diovyb", 1991);
Ahoj světe byvoid%diovyb byvoid1991iovyb
- console.error(): S console.log() dělá to samé, ale zobrazuje standardní chybu.
- console.trace(): Streamování chyb na standardní výstup aktuálního zásobníku volání.
Provozní výsledky jsou následující:
Stopa: u objektu.
příklady
Vytvořte soubor main.js, kód takto:
Console.info("程序开始执行："); var counter = 10; console.log("计数: %d", čítač); console.time("获取数据"); // // 执行一些代码 // console.timeEnd("获取数据"); console.info("程序执行完毕。")
Spustitelný soubor main.js, kód vypadá takto:
$ node main.js 程序开始执行： 计数: 10 获取数据: 0 ms 程序执行完毕
proces
Proces je globální proměnná, atribut je globální objekt.
Používá se k popisu aktuálního stavu procesu objektu Node.js a poskytuje jednoduché rozhraní pro operační systém. Obvykle si píšete vlastní programy příkazového řádku a nakonec se s tím vypořádáte. Níže představíme některé z nejběžněji používaných metod procesu námitek členy.
| Ne. | Události a popis |
|---|---|
| 1 | výstup Spustí se, když je proces připraven k ukončení. |
| 2 | předVýjezdem Tato událost se spustí, když má uzel prázdnou smyčku událostí a neprovede se žádná další akce. Obecně neexistuje žádný proces pro organizaci výstupního uzlu, ale posluchače „před Exit“ lze volat asynchronně, takže uzel bude pokračovat. |
| 3 | nezachycená výjimka Když se výjimka vrátí zpět do smyčky událostí, aktivujte tuto událost. Pokud k výjimce přidáte monitor, výchozí akce (tisk zásobníku a ukončení) nenastane. |
| 4 | Signál se spustí, když událost když proces přijme signál. Prohlédněte si seznam standardních názvů signálů POSIX, jako je SIGINT, SIGUSR1 a tak dále. |
příklady
Vytvořte soubor main.js, kód takto:
Process.on("exit", function(code) ( // setTimeout(function() ( console.log("该代码不会执行"); 0); console.log("退出码为:", kód) ;)); console.log("程序执行结束");
Spustitelný soubor main.js, kód vypadá takto:
$ node main.js 程序执行结束退出码为: 0
Výstupní stavové kódy
| Stavový kód | Název a popis |
|---|---|
| 1 | Nezachycená fatální výjimka Existuje nezachycená výjimka a nebyla zpracována nebo doména obslužné rutiny uncaughtException. |
| 2 | nepoužitý retence |
| 3 | Analýza interních chyb JavaScriptu Chyba JavaScriptu při analýze zdrojového kódu je volána při spuštění procesu Node. Velmi zřídka, pouze když Node. |
| 4 | Skóre interní chyby JavaScriptu Proces JavaScript spouštějící zdrojový uzel vrátí chybu při vyhodnocování funkce. Velmi zřídka, pouze když Node. |
| 5 | Fatální chyba V8 v neopravitelné chybě s fatálním výsledkem. Obvykle tiskněte Stderr, obsah: fatální chyba |
| 6 | Nefunkční obsluha vnitřních výjimek Nezachycená výjimka, obsluha výjimky uvnitř je nějakým způsobem nastavena na funkci a také nemůže být volána. |
| 7 | Selhání výjimky interní obslužné rutiny run-time Nezachycená výjimka a obslužná rutina výjimky, která zpracuje vlastní, vyvolá výjimku. Pokud například process.on("uncaughtException") nebo domain.on("error") vyvolá výjimku. |
| 8 | nepoužitý retence |
| 9 | Neplatný argument Mohou to být neznámé parametry nebo parametr k hodnotě. |
| 10 | Interní běh JavaScriptu se nezdařil Zdrojový kód JavaScriptu je generován, když jsou v procesu Node spuštěny chyby, velmi zřídka, pouze při vývoji Node. |
| 12 | Neplatný argument ladění --debug nastavena volba a/nebo --debug-BRK, ale vybrali jste špatný port. |
| > 128 | Signální výstupy Pokud uzel přijme fatální signál, jako je SIGKILL nebo SIGHUP, pak návratový kód je 128 plus kód signálu. Toto je standardní unixová praxe, vysoký kód na výstupních signálech. |
atributy procesu
Proces poskytuje mnoho užitečných vlastností, snadnost interakce, díky kterým můžeme systém lépe ovládat:
| množství | Vlastnost a popis |
|---|---|
| 1 | STDOUT Standardní výstupní proud. |
| 2 | STDERR Standardní proud chyb. |
| 3 | STDIN Standardní vstupní proud. |
| 4 | ARGV Vlastnost ARGV vrací pole různých voleb pro provádění skriptu příkazového řádku při skládání. Jeho prvními členy jsou vždy uzel, jeho druhým členem je název souboru skriptu a zbývajícími členy jsou parametry souboru skriptu. |
| 5 | execPath Vrátí absolutní cestu binárního uzlu aktuálního provádění skriptu. |
| 6 | execArgv Vrátí člen pole umístěný pod skriptem příkazového řádku spuštěným mezi parametry spustitelného příkazového řádku uzlu souboru skriptu. |
| 7 | ENV Vrátí objekt, členy aktuální proměnné prostředí shellu |
| 8 | Výstupní kód Kód ukončení pro proces, pokud je proces prezentován s process.exit() exit, bez zadání kódu ukončení. |
| 9 | verze verze uzlu, například v0.10.18. |
| 10 | verze Vlastnost, která obsahuje verze uzlů a závislostí. |
| 11 | config Objekt, který obsahuje aktuální uzel, se používá ke kompilaci spustitelného konfiguračního souboru voleb javascriptu. Toto je stejný skript run./configure vytvořený souborem "config.gypi". |
| 12 | PID - regulátor
Aktuální číslo procesu. |
| 13 | název Název procesu, výchozí "uzel", hodnotu můžete přizpůsobit. |
| 14 | oblouk Aktuální architektura CPU: "arm", "ia32" nebo "64". |
| 15 | plošina Spusťte program, jehož platforma je "Darwin", "FreeBSD", "Linux", "SunOS" nebo "win32" |
| 16 | mainModule vyžadují.hlavní alternativní metody. Různé body, pokud se hlavní modul změní za běhu, require.main se může stále vracet ke starému modulu. Oba se považují za součást stejného modulu. |
příklady
Vytvořte soubor main.js, kód takto:
// 输出到终端 process.stdout.write("Ahoj světe!" + "\n"); // 通过参数读取 process.argv.forEach(function(val, index, array) ( console.log(index + ": " + val); )); // 获取执行路局 console.log(process.execPath); // 平台信息 console.log(process.platform);
Spustitelný soubor main.js, kód vypadá takto:
$ node main.js Ahoj světe! 0: uzel 1: /web/www/node/main.js /usr/local/node/0.10.36/bin/node darwin
Referenční příručka metod
Tento proces poskytuje mnoho užitečných metod pro usnadnění efektivnějšího ovládání našeho interaktivního systému:
| Ne. | Metoda a popis |
|---|---|
| 1 | přerušit() To vyvolá událost spouštěcího uzlu přerušení. To způsobí ukončení uzlu a vytvoření souboru výpisu. |
| 2 | ChDir (adresář) Pokud operaci nelze ukončit, změňte aktuální pracovní adresář procesu. |
| 3 | EAR () Vrátí pracovní adresář aktuálního procesu |
| 4 | exit([kód]) Ukončí proces se zadaným kódem. Pokud je tento parametr vynechán, použije se kód 0. |
| 5 | getgid() Získejte identifikaci skupiny procesů (viz getgid(2)). Když byla skupina zakoupena digitální ID, nikoli jméno. |
| 6 | setgid(ID) Nastavení procesu identifikace skupiny (viz setgid (2)). ID může mít číselný název nebo název skupiny. Pokud zadáte název skupiny, bude blokování povoleno během čekání na digitální ID. Poznámka: Tuto funkci lze použít pouze (např. mimo Windows a Android) na platformách POSIX. |
| 7 | getuid() Získejte proces identifikace uživatele (viz getuid(2)). Toto je číselné ID uživatele, nikoli uživatelské jméno. Poznámka: Tuto funkci lze použít pouze (např. mimo Windows a Android) na platformách POSIX. |
| 8 | UIP (ID) ID uživatele nastavení procesu (viz UIP (2)). Načtení digitálního identifikátoru nebo řetězce názvu. Pokud zadáte název skupiny, bude blokování povoleno během čekání na digitální ID. Poznámka: Tuto funkci lze použít pouze (např. mimo Windows a Android) na platformách POSIX. |
| 9 | getgroups() Proces vrácení pole ID skupiny. Systém POSIX nezaručuje, že tomu tak je, ale Node.js tam zaručeně je. Poznámka: Tuto funkci lze použít pouze (např. mimo Windows a Android) na platformách POSIX. |
| 10 | setgroups Nastavte ID skupiny procesů. Je způsobilý pracovat, vše, co potřebujete, je mít oprávnění superuživatele nebo mít schopnost CAP_SETGID. Poznámka: Tuto funkci lze použít pouze (např. mimo Windows a Android) na platformách POSIX. |
| 11 | initgroups(user, extra_group) Čtení / atd. /group a inicializuje přístupový seznam skupiny, jsou umístěni všichni členové skupiny. Je způsobilý pracovat, vše, co potřebujete, je mít oprávnění superuživatele nebo mít schopnost CAP_SETGID. Poznámka: Tuto funkci lze použít pouze (např. mimo Windows a Android) na platformách POSIX. |
| 12 | zabít (IDP [signál]) Vyšle signál do procesu. ID je identifikátor procesu a signál je řetězec označující přenášený signál. Názvy signálů jsou řetězce jako "SIGINT" nebo "" SIGHUP. Pokud je tento parametr vynechán, signál bude "SIGTERM". |
| 13 | Využití paměti() Vrací objekt, který popisuje proces používaný stavovými bajty paměti uzlu. |
| 14 | nextTick (zpětné volání) Po ukončení smyčky zpětného volání aktuální funkce. |
| 15 | umask ([maska]) Nastavit nebo přečíst soubor masky procesu. Podřízené procesy dědí tuto masku z nadřazeného procesu. Pokud je argument maska pravdivý, vrátí starou masku. V opačném případě vrátí aktuální masku. |
| 16 | Utraceno() Vrátí počet sekund, po které byl Uzel již spuštěn. |
| 17 | hrtime() Časové rozlišení aktuálního procesu, zadané jako [sekundy] nanosekundy pole. To je relativní k jakékoli minulé události. Tato hodnota nemá nic společného s datem, takže neovlivňuje posun hodin. Hlavním účelem je po přesné časové období měřit výkon programu. Než může být výsledek předán aktuální process.hrtime(), vrátí časový rozdíl mezi nimi pro referenční měření a měření časového intervalu. |
příklady
Vytvořte soubor main.js, kód takto:
// 输出当前目录 console.log("当前目录: " + process.cwd()); // 输出当前版本 console.log("当前版本: " + proces.verze); // 输出内存使用情况 console.log(process.memoryUsage());V uzlu můžete nastavit globální proměnné pomocí objektu "global" nebo "GLOBAL":
GLOBAL._ = require("podtržítko"); // ale "neměli byste" to udělat! (viz poznámka níže)
nebo užitečnější...
GLOBAL.window = GLOBAL; // jako v prohlížeči
Z uzlu můžete vidět, že jsou sešité:
Node-v0.6.6/src/node.js:28:global = this; 128: global.GLOBAL = global;
Ve výše uvedeném kódu je „toto“ globální kontext. U modulu commonJS (který uzel používá) NENÍ tento „objekt“ uvnitř modulu (tj. „váš kód“) globálním kontextem. Důkaz toho viz níže, kde jsem vyplivl „tento“ objekt a poté obří „GLOBÁLNÍ“ objekt.
Console.log("\nTHIS:"); console.log(toto); console.log("\nGLOBAL:"); console.log(global); /* výstupy... TENTO: {} GLOBÁLNÍ: ( ArrayBuffer: , Int8Array: ( BYTES_PER_ELEMENT: 1 ), Uint8Array: ( BYTES_PER_ELEMENT: 1 ), Int16Array: ( BYTES_PER_ELEMENT: 2 ), Uint16Array: ( BYTES_PER_ELEMENT: 2 ), ( BYTES_PER_ELEMENT: 2 ), Int4Array: 2Array: Int4Array_ELEMENT: 2 BYTES_PER _ELEMENT: 4 ), Float32Array: ( BYTES_PER_ELEMENT: 4 ), Float64Array: ( BYTES_PER_ELEMENT: 8 ), DataView: , globální: , proces: ( EventEmitter: , title: "node", claim: , verze: "v0.6.5", _tickCallback: , moduleLoadList: [ "Hodnoty vazby", "Vazba domorodců", "Události NativeModule", "Vyrovnávací paměť NativeModule", "Vyrovnávací paměť vazby", "Uplatnění NativeModule", "Nástroj NativeModule", "cesta NativeModule", "modul NativeModule", " NativeModule fs", "Binding fs", "Binding konstanty", "NativeModule stream", "NativeModule console", "Binding tty_wrap", "NativeModule tty", "NativeModule net", "NativeModule timers", "Binding timer_wrap", " NativeModule _linklist" ], verze: ( uzel: "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: , platforma: "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: "shxterm", SHELL , TMPDIR: "/var/folders/2h/2hQmtmXlFT4yVGtr5DBpdl9LAiQ/-Tmp-/", Apple_PubSub_Socket_Render: "/tmp/launch-9Ga0PT/Render", USER: "ddopson", COMMAND_SH_03: "mpTHunix_AUSO03" spustit -sD905b/Listeners", __CF_USER_TEXT_ENCODING: "0x12D732E7:0:0", PATH: "/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: "Výchozí", SHLVL: "1", COLORFGBG: "7;0", DOMŮ: "/Users/ddopson", ITERM_SESSION_ID: "w0t0p0", LOGNAME: "ddopson", ZOBRAZENÍ: "/tmp/launch-l9RQXI/org.x:0", OLDPWD: "/workspace/zd/zgap/darwin- js /external", _: "./index.js"), openStdin: , exit: , pid: 10321, features: ( ladění: false, uv: true, ipv6: true, tls_npn: false, tls_sni: true, tls : true ), kill: , execPath: "/usr/local/bin/node", addListener: , _needTickCallback: , on: , removeListener: , reallyExit: , chdir: , debug: , error: , cwd: , watchFile: , umask : , getuid: , unwatchFile: , mixin: , setuid: , setgid: , createChildProcess: , getgid: , dědí: , _kill: , _byteLength: , mainModule: ( id: ". ", exportuje: (), rodič: null, název souboru: "/workspace/zd/zgap/darwin-js/index.js", načteno: false, ukončeno: false, děti: , cesty: ), _debugProcess: , dlopen: , uptime: , memoryUsage: , uvCounters: , vazba: ), GLOBAL: , root: , Buffer: ( poolSize: 8192, isBuffer: , byteLength: , _charsWritten: 8 ), setTimeout: , setInterval: , clearTimeout: , clearInterval: , clearInterval konzole: , okno: , navigátor: () ) */
**Poznámka: Pokud jde o nastavení "GLOBAL._", obecně byste měli udělat pouze var _ = require("underscore"); . Ano, uděláte to v každém souboru, který používá podtržítko, stejně jako v Javě importujete com.foo.bar; . To usnadňuje určení, co váš kód dělá, protože odkazy mezi soubory jsou „explicitní“. Mírně otravné, ale dobré. Toto je kázání.
Z každého pravidla existuje výjimka. Měl jsem přesně jeden případ, kdy jsem potřeboval nastavit "GLOBAL._". Vytvářel jsem systém pro definování "konfiguračních" souborů, které byly většinou JSON, ale byly "napsány v JS", aby se přidala trochu větší flexibilita. V takových konfiguračních souborech nebyly žádné příkazy "require", ale chtěl jsem, aby měly přístup k podtržení (CELÝ systém byl založen na vzorech podtržení a podtržení), takže bych před vyhodnocením "config" nastavil "GLOBAL._". Takže ano, pro každé pravidlo existuje někde výjimka. Ale máte dobrý důvod, nejen "Už mě nebaví psát", takže chci porušit dohodu."