Mi az a Node.js? Kezdő bevezető a JavaScript futtatókörnyezetébe

A Node.js egy nyílt forráskódú, többplatformos, JavaScript-futási környezet, amely JavaScript-kódot hajt végre a webböngészőn kívül. A Node.js egy népszerű, könnyű webes keretrendszer kezdőknek, és számos nagy cég használja, például a Netflix és az Uber.

Amikor általában a JavaScriptre gondolunk, hajlamos a webfejlesztésre járni az eszünk. A Node.js megjelenéséig nem igazán lehetett JavaScriptet böngészőn kívül futtatni. Amikor háttérkiszolgálót és adatbázist írunk, a Node.js népszerű választás, mert a kódunkat önálló alkalmazásként futtathatjuk, nem pedig olyan, amelyet csak böngésző környezetben lehet kiértékelni.

A Node.js fontos eszköz, amelyet minden JavaScript-fejlesztő megérthet. Tehát ma bemutatjuk Önnek a Node.js-t, és megmutatjuk, hogyan kezdjen hozzá egy projekthez.

Ma a következőkkel foglalkozunk:

• Mi az a Node.js?
• A Node.js alapjai
• Node.js eseményhurok
• Kezdje el egy projektet
• Mit kell tanulni ezután

Mi az a Node.js?

A Node.js egy nyílt forráskódú, többplatformos JavaScript-futási környezet, amelyet JavaScript-kód webböngészőn kívüli futtatására használnak.

A Node.js egy nagyszerű webes keretrendszer kezdőknek, mert remekül működik az adatigényes alkalmazásoknál, mint például a streaming és a valós idejű alkalmazások, a Node.js pedig megkönnyíti a hátlap felépítését. -véget.

A Node.js lehetővé teszi számunkra, hogy bárhol használjuk a JavaScriptet és bármilyen böngészőben, beleértve a macOS-t, a Linuxot és a Windows-t is. Amikor azt mondjuk, hogy mindenhol, akkor az elülső részt, a köztes szoftvert és a hátsó részt értjük. A Node.js ezért része néhány nagyon népszerű webfejlesztési veremnek, például a MERN veremnek, a MEVN veremnek és a MEAN veremnek.

A Node.js-t számos jellemző teszi azzá, ami:

• Google Chrome V8 JavaScript motor: Ez a futásidejű környezet a Google Chrome V8 JavaScript futásidejű motorjára épül. Ugyanígy a Java Virtual Machine lefordítja a bájtkódot, a Chrome V8 JavaScript motor pedig átveszi a JavaScriptet, és olvashatóvá teszi azt.
• Modulok/csomagok: A Node.js rendelkezik npm csomóponti csomagkezelővel, több mint 350 000 csomagból álló könyvtárral, amely segít a projektek vagy alkalmazások hatékony és egyszerű elindítása érdekében. .
• Eseményvezérelt, egyszálú I/O-modell: A JavaScript futtatása felhasználói interakciókra vagy eseményekre támaszkodik. A legtöbb esetben a kód szinkronban fut. A kiszolgálókérések és más hasonló aszinkron feladatok az ígéretek rendszerére vagy aszinkron/várakozó függvényekre támaszkodnak ezen bemenetek és kimenetek kezeléséhez.

A Node.js alapjai

Most, hogy tudjuk, mi az a Node.js, nézzük meg ennek az eszköznek az alapjait.

Konzol

A konzol a Node.js által biztosított modul, amely hasonló a böngésző JavaScript-konzoljához, amikor Ön egy weboldalt vizsgál. A konzolnak vannak olyan metódusai, amelyeket hibakeresési célokra használhatunk.

• console.log(): Gyakran használják valamilyen kimenet naplózására.
• console.warn(): Kifejezetten figyelmeztetést küld a konzolnak.
• console.error(): Kifejezetten hibaüzenetet küld a konzolnak. A hibát karakterláncként vagy objektumként naplózhatja. Ha új Error() néven van bejelentkezve, a visszakövetés az üzenet részeként fog szerepelni.
• console.trace(): Nyomon követést naplóz, ha hiba történik a kódban. Megadja annak a fájlnak a sorszámát és oszlopszámát, amelyben a hiba valószínűleg előfordult.

Puffer

Lényegében a Node.js pufferosztálya egy ideiglenes tárolási megoldás fájlrendszerekhez. Alacsony szintű jellege miatt webfejlesztőként ritkán használjuk közvetlenül a Buffer osztályt. Ennek az osztálynak a fő célja a memória lefoglalása.

Vessen egy pillantást az alábbiakban a puffer osztály által biztosított néhány módszerre.

const buf1 = Buffer.alloc(10);
console.log(buf1);

const buf2 = Buffer.alloc(5, 15);
console.log(buf2);

const buf3 = Buffer.allocUnsafe(10);
console.log(buf3);

buf3.fill(1);
console.log(buf3);

buf2.write("abcedf");
console.log(buf2);

const buf4 = Buffer.from([265, 6.5, -255, '7']);
console.log(buf4);

const buf5 = Buffer.from('Hello world');
console.log(buf5);

console.log(buf5.toString());

Fájlrendszer

A fájlrendszer (fs) modul lehetővé teszi számunkra, hogy a Node.js fájlokkal kommunikáljunk. Léteznek szinkron és aszinkron metódusok, amelyek segítségével az fs modul segítségével fájlokat olvashat vagy írhat. Ellentétben a konzol vagy a puffer osztály használatával, az fs modult be kell importálnunk abba a fájlba, amelyet használni szeretnénk, hogy működjön.

Az alábbi kódpélda bemutatja, hogyan működik a readFile, egy aszinkron metódus. Figyeljük meg, hogy a metódus utolsó argumentuma egy visszahívási függvény, amelynek első argumentuma hiba. A definíció szerint ez a visszahívás mindig az adatok előtti hibaüzenetben történik.

Aszinkron példa:

A readFile metódus aszinkron jellege nem akadályozza meg más funkciók vagy kódsorok futását.

A szinkron metódus, a readFileSync, azonban blokkolja más kódsorok futtatását, amíg a fájl be nem olvassa.

Íme egy példa:

const fs = require('fs')
 
fs.readFile('data.txt', 'utf-8', (err, data) => {
 if (err) {
   console.error(err)
   return
 }
 let array = data.split('\n')

 //props are id, first_name, last_name, email, gender and ip_address

 let mapped = array.map(person => {
   let new_person = person.split(',');
   return new Object({
     id: new_person[0],
     first_name: new_person[1],
     last_name: new_person[2],
     email: new_person[3],
     gender: new_person[4],
     ip: new_person[5]

   })
 });
  console.log(mapped)

});
 
console.log("Hit!")

Szinkron példa:

const fs = require('fs')

try {
  const data = fs.readFileSync('data.txt', 'utf-8')
  let array = data.split('\n')
 //props are id, first_name, last_name, email, gender and ip_address
 let mapped = array.map(person => {
   let new_person = person.split(',');
   return new Object({
     id: new_person[0],
     first_name: new_person[1],
     last_name: new_person[2],
     email: new_person[3],
     gender: new_person[4],
     ip: new_person[5]
   })
 });
  console.log(mapped)
} catch (err) {
  console.error(err)
}
console.log("Hit!")

data.txt:

1,Annabell,Cicconetti,[email protected],Female,219.207.16.2
2,Silvana,Glasman,[email protected],Female,233.214.135.18
3,Rebeka,Redmile,[email protected],Female,121.106.165.14
4,Veriee,Jovis,[email protected],Female,43.217.63.173
5,Melitta,Hanburry,[email protected],Female,42.204.168.27
6,Alethea,Webben,[email protected],Female,189.126.43.49
7,Saxe,Leary,[email protected],Male,95.156.25.21
8,Ario,Brabyn,[email protected],Male,220.226.164.176
9,Marybeth,Ughelli,[email protected],Female,251.234.218.207
10,Gothart,Tassell,[email protected],Male,247.146.121.230
11,Fairlie,Beevis,[email protected],Male,161.219.190.148
12,Skippie,Station,[email protected],Male,178.184.167.113
13,Ashla,Tett,[email protected],Female,209.125.39.161
14,Belinda,Olin,[email protected],Female,222.234.181.134
15,Laurianne,Ledgerton,[email protected],Female,184.56.226.2
16,Angele,Rhodus,[email protected],Female,112.66.128.23
17,Meridith,Pena,[email protected],Female,163.227.38.120
18,Romola,Erbe,[email protected],Female,184.50.183.25
19,Damien,Cominotti,[email protected],Male,122.62.139.51
20,Lou,Clemerson,[email protected],Female,176.117.18.82
21,Donall,Lorence,[email protected],Male,153.209.179.90
22,Maribeth,Sloam,[email protected],Female,177.119.164.156
23,Fowler,Pethybridge,[email protected],Male,58.228.162.249
24,Jarred,Haxley,[email protected],Male,26.74.46.200
25,Natalie,Outright,[email protected],Female,181.218.16.217
26,Cloe,Devitt,[email protected],Female,109.68.184.211
27,Shane,Farmer,[email protected],Male,198.230.29.69
28,Iorgo,Thrower,[email protected],Male,103.213.212.70
29,Letty,Dakhno,[email protected],Female,32.245.196.9
30,Woodrow,Flageul,[email protected],Male,105.129.139.220
31,Franchot,Large,[email protected],Male,219.98.60.51
32,Anna-diana,Callam,[email protected],Female,59.121.52.69
33,Benoit,Scallon,[email protected],Male,227.53.63.103
34,Lavinie,Lovelady,[email protected],Female,227.20.131.192
35,Timoteo,Laurentino,[email protected],Male,149.251.44.30
36,Robers,Cassella,[email protected],Male,179.219.60.199
37,Arnoldo,Eakly,[email protected],Male,189.110.238.26
38,Janis,Didball,[email protected],Female,105.74.199.165

Próbáljon meg egy console.log(“Hit!”) jelet elhelyezni a függvény után, hogy megtudja, mikor van ténylegesen naplózva a konzol. Van különbség a két funkció között? Mi az?

A readFile függvény elindítja a függvényt, majd azonnal áttér a kód többi részére, mielőtt a függvény befejezné és kinyomtatná a tömbünk tartalmát. Tehát valami ilyesmit kellene látnod:

Hit!
 
[
 {
   id: '1',
   first_name: 'Annabell',
   last_name: 'Cicconetti',
   email: '[email protected]',
   gender: 'Female',
   ip: '219.207.16.2'
 },
 etc…
]

Ezzel szemben a console.log(“Hit!”) csak a readFileSync függvény befejezése után fog futni:

[...{
   id: '37',
   first_name: 'Arnoldo',
   last_name: 'Eakly',
   email: '[email protected]',
   gender: 'Male',
   ip: '189.110.238.26'
 },
 {
   id: '38',
   first_name: 'Janis',
   last_name: 'Didball',
   email: '[email protected]',
   gender: 'Female',
   ip: '105.74.199.165'
 }
]
Hit!

A fájlba írás nagyon hasonló módon történik, de a függvények neve writeFile() és writeFileSync().

Eseményhurok

A Node.js nagy része eseményvezérelt. Amikor a felhasználó rákattint egy felületre vagy beír egy űrlapot, egy esemény aktiválódik, és ennek eredményeként történik valami. Egy függvény vagy függvénykészlet egy adott eseményhez való csatolása esemény kibocsátását jelenti.

Ezek az eseményfigyelőknek nevezett funkciók az eseményhuroknak nevezett átfogó utazás részét képezik. Vegyük ezt a példát:

const EventEmitter = require('events');

const emitter = new EventEmitter();
const handleEvent = (str) => {
 console.log(`================ ${str}`);
 console.log("handleEvent fired! An event has happened!");
 console.log("end of event")
}
emitter.on('load event', () => handleEvent("load"));
emitter.on('hello event', () => handleEvent("hello"));
emitter.emit('load event');
emitter.emit('hello event')

Ebben a kódpéldában az események modult importáljuk. Ezután létrehozunk egy új EventEmitter értéket, és hozzárendeljük az emitter változóhoz. Ebben a konkrét példában létrehoztunk egy handleEvent függvényt, amely visszahívási funkcióként fog szolgálni, és bizonyos dolgokat console.logol.

A EventEmitter osztálynak számos metódusa van, amelyet használhatunk. Egy esemény kibocsátásakor lefutott módszer a EventEmitter.on() függvény.

Ez az adott módszer akkor indul el, amikor egy esemény kibocsátásra kerül. A függvénybe átadott első argumentum az esemény neve, a második pedig a visszahívási függvény, amely megmondja, hogyan kezeljük az eseményt.

Ebben a konkrét példában két eseményt bocsátunk ki. A fenti kód futtatásakor a következőket kell kapnunk:

================ load
handleEvent fired! An event has happened!
end of event
================ hello
handleEvent fired! An event has happened!
end of event
true

Az emit metódus elindítja az on metódust, amely ezután meghívja a handleEvent visszahívási függvényt.

Globálisok

A globális objektumok minden modulban elérhetők, így egy adott modul importálása nélkül is használhatók. A Buffer osztály például globálisként van definiálva a Node.js-ben. Néhány más gyakori globális objektum:

• A console objektumot a stdout és stderr címekre való nyomtatáshoz használják.
• Az időzítők, például a setImmediate, setInterval és setTimeout szintén globálisak.
• A process objektum is globális.

A böngészőben a legfelső szintű hatókör a globális hatókör. De a Node.js-ben a legfelső szintű hatókör nem a globális hatókör.

A Node.js-ben a globális objektum használható a globális hatókörben rendelkezésre álló elemek megtekintéséhez. Példa megtekintéséhez nézze meg az alábbi kódot.

console.log(global)
//output:

Object [global] {
  global: [Circular],
  process:
   process {
     title: 'node',
     version: 'v10.17.0',
     versions:
      { http_parser: '2.8.0',
        node: '10.17.0',
        v8: '6.8.275.32-node.54',
        uv: '1.28.0',
        zlib: '1.2.11',
        brotli: '1.0.7',
        ares: '1.15.0',
        modules: '64',
        nghttp2: '1.39.2',
        napi: '5',
        openssl: '1.1.1d',
        icu: '64.2',
        unicode: '12.1',
        cldr: '35.1',
        tz: '2019a' },
     arch: 'x64',
     platform: 'linux',
     release:
      { name: 'node',
        lts: 'Dubnium',
        sourceUrl:
         'https://nodejs.org/download/release/v10.17.0/node-v10.17.0.tar.gz',
        headersUrl:
         'https://nodejs.org/download/release/v10.17.0/node-v10.17.0-headers.tar.gz' },
     argv: [ '/usr/local/bin/node', '/usercode/index.js' ],
     execArgv: [],
     env:
      { HOSTNAME: '3f1f59adaf77',
        HOME: '/root',
        OLDPWD: '/',
        PATH:
         '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
        LANG: 'C.UTF-8',
        NODE_PATH: '/usr/local/lib/node_modules/',
        PWD: '/usercode' },
     pid: 10,
     features:
      { debug: false,
        uv: true,
        ipv6: true,
        tls_alpn: true,
        tls_sni: true,
        tls_ocsp: true,
        tls: true },
     ppid: 9,
     execPath: '/usr/local/bin/node',
     debugPort: 9229,
     _debugProcess: [Function: _debugProcess],
     _debugEnd: [Function: _debugEnd],
     _startProfilerIdleNotifier: [Function: _startProfilerIdleNotifier],
     _stopProfilerIdleNotifier: [Function: _stopProfilerIdleNotifier],
     abort: [Function: abort],
     chdir: [Function: chdir],
     umask: [Function: umask],
     _getActiveRequests: [Function: _getActiveRequests],
     _getActiveHandles: [Function: _getActiveHandles],
     _kill: [Function: _kill],
     cwd: [Function: cwd],
     dlopen: [Function: dlopen],
     reallyExit: [Function: reallyExit],
     uptime: [Function: uptime],
     getuid: [Function: getuid],
     geteuid: [Function: geteuid],
     getgid: [Function: getgid],
     getegid: [Function: getegid],
     getgroups: [Function: getgroups],
     _rawDebug: [Function],
     moduleLoadList:
      [ 'Internal Binding module_wrap',
        'Binding contextify',
        'Internal Binding worker',
        'NativeModule events',
        'NativeModule internal/async_hooks',
        'NativeModule internal/errors',
        'Binding uv',
        'Binding buffer',
        'Binding async_wrap',
        'Internal Binding async_wrap',
        'Binding config',
        'Binding icu',
        'NativeModule util',
        'NativeModule internal/util/inspect',
        'Binding util',
        'NativeModule internal/util',
        'Binding constants',
        'Internal Binding types',
        'NativeModule internal/util/types',
        'NativeModule internal/validators',
        'NativeModule internal/encoding',
        'Internal Binding icu',
        'NativeModule buffer',
        'NativeModule internal/buffer',
        'NativeModule internal/process/per_thread',
        'NativeModule internal/process/main_thread_only',
        'NativeModule internal/process/stdio',
        'NativeModule assert',
        'NativeModule internal/assert',
        'NativeModule fs',
        'NativeModule path',
        'NativeModule internal/constants',
        'Binding fs',
        'NativeModule internal/fs/streams',
        'NativeModule internal/fs/utils',
        'NativeModule stream',
        'NativeModule internal/streams/pipeline',
        'NativeModule internal/streams/end-of-stream',
        'NativeModule internal/streams/legacy',
        'NativeModule _stream_readable',
        'NativeModule internal/streams/buffer_list',
        'NativeModule internal/streams/destroy',
        'NativeModule internal/streams/state',
        'NativeModule _stream_writable',
        'NativeModule _stream_duplex',
        'NativeModule _stream_transform',
        'NativeModule _stream_passthrough',
        'NativeModule internal/url',
        'NativeModule internal/querystring',
        'Binding url',
        'NativeModule internal/process/warning',
        'NativeModule internal/process/next_tick',
        'NativeModule internal/process/promises',
        'Internal Binding util',
        'NativeModule internal/fixed_queue',
        'Binding performance',
        'Binding trace_events',
        'NativeModule internal/inspector_async_hook',
        'Binding inspector',
        'NativeModule internal/options',
        'Internal Binding options',
        'NativeModule timers',
        'Binding timer_wrap',
        'NativeModule internal/linkedlist',
        'NativeModule internal/timers',
        'NativeModule console',
        'Binding tty_wrap',
        'Internal Binding tty_wrap',
        'NativeModule internal/fs/sync_write_stream',
        'NativeModule internal/modules/cjs/loader',
        'NativeModule vm',
        'NativeModule internal/modules/cjs/helpers',
        'NativeModule url',
        'NativeModule internal/safe_globals',
        'Internal Binding contextify' ],
     binding: [Function: binding],
     _linkedBinding: [Function: _linkedBinding],
     _events:
      [Object: null prototype] {
        newListener: [Function],
        removeListener: [Function],
        warning: [Function] },
     _eventsCount: 3,
     _maxListeners: undefined,
     _fatalException: [Function],
     domain: null,
     _exiting: false,
     assert: [Function: deprecated],
     config: { target_defaults: [Object], variables: [Object] },
     setUncaughtExceptionCaptureCallback: [Function],
     hasUncaughtExceptionCaptureCallback: [Function],
     emitWarning: [Function],
     nextTick: [Function: nextTick],
     _tickCallback: [Function: _tickCallback],
     stdout: [Getter],
     stderr: [Getter],
     stdin: [Getter],
     openStdin: [Function],
     initgroups: [Function: initgroups],
     setegid: [Function: setegid],
     seteuid: [Function: seteuid],
     setgid: [Function: setgid],
     setuid: [Function: setuid],
     setgroups: [Function: setgroups],
     hrtime: { [Function: hrtime] bigint: [Function] },
     cpuUsage: [Function: cpuUsage],
     memoryUsage: [Function: memoryUsage],
     exit: [Function],
     kill: [Function],
     argv0: 'node',
     allowedNodeEnvironmentFlags: [Getter/Setter],
     mainModule:
      Module {
        id: '.',
        exports: {},
        parent: null,
        filename: '/usercode/index.js',
        loaded: false,
        children: [],
        paths: [Array] } },
  Buffer:
   { [Function: Buffer]
     poolSize: 8192,
     from: [Function: from],
     of: [Function: of],
     alloc: [Function: alloc],
     allocUnsafe: [Function: allocUnsafe],
     allocUnsafeSlow: [Function: allocUnsafeSlow],
     isBuffer: [Function: isBuffer],
     compare: [Function: compare],
     isEncoding: [Function: isEncoding],
     concat: [Function: concat],
     byteLength: [Function: byteLength],
     [Symbol(kIsEncodingSymbol)]: [Function: isEncoding] },
  clearImmediate: [Function: clearImmediate],
  clearInterval: [Function: clearInterval],
  clearTimeout: [Function: clearTimeout],
  setImmediate:
   { [Function: setImmediate] [Symbol(util.promisify.custom)]: [Function] },
  setInterval: [Function: setInterval],
  setTimeout:
   { [Function: setTimeout] [Symbol(util.promisify.custom)]: [Function] } }

Hogyan készítsünk egy alap Node.js projektet

Tanuljuk meg, hogyan kezdjük el a Node.js-t egy egyszerű Node.js fájl létrehozásával. Ebben a példában a számítógépünket úgy állítjuk be, hogy szerverként működjön!

Ha szeretné megtanulni, hogyan kell Node.js alkalmazást létrehozni, nézze meg ezt az "Educative kezdő tanfolyamát".

Telepítse a Node.js-t és az NPM-et

Először is fel kell lépnie a Node.js webhely webhelyre, és le kell töltenie a fájlokat.

Kövesse a telepítési utasításokat, és indítsa újra a gépet a legjobb eredmény érdekében.

A Node.js telepítésének másik módja a csomagkezelő használata.

Ezután ellenőrizze, hogy működik-e a verzió kinyomtatásával a következő paranccsal:

> node -v

Az npm-et úgy is tesztelni kell, hogy kinyomtatja a verziót a következő paranccsal:

> npm -v

Hozzon létre egy fájlt

Miután megfelelően telepítette a Node.js fájlt, hozzon létre egy Node.js fájlt. Ebben a példában „first.js”-nek neveztük el. Ezután hozzáadjuk a következő kódot, és elmentjük a fájlt a számítógépére, így: C:\Users\Your Name\first.js

var http = require('http');

http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/html'});
  res.end('Hello World!');
}).listen(8080);

Ez a kód lényegében arra utasítja a számítógépet, hogy nyomtassa ki a „Hello World!” feliratot. amikor a 8080-as porton éri el.

Parancssori interfész

A Node.js fájlokat a számítógép „Command Line Interface” programjában kell elindítani. Keresse meg a „first.js” fájlt tartalmazó mappát.

C:\Users\Your Name>_

Indítsa el a fájlt

Ezt a fájlt a Node.js-nek kell kezdeményeznie. Ehhez indítsa el a parancssori felületet, írja be a node first.js parancsot, és kattintson az Enter gombra:

C:\Users\Your Name>node myfirst.js

Fantasztikus! Most a számítógépe kiszolgálóként van beállítva, így amikor a 8080-as porton éri el a számítógépet, megjelenik a „Hello World!” az üzenet kinyomtatásra kerül.

Ennek valós idejű megtekintéséhez nyissa meg a böngészőt, és írja be: http://localhost:8080

Mit kell tanulni ezután

Gratula! Ismeri a Node.js alapjait, alapvető eszközeit és a Node.js fájl elindítását. A következő lépések a Node.js modulok, a HTTP-modulok, a fájlrendszer és az NPM-függőségek elsajátítása.

Egy jó következő lépés a Node.js következő fogalmainak elsajátítása:

• Node.js és operációs rendszer
• Node.js REPL
• Csomagok
• Hogyan kell közzétenni egy csomagot
• Hogyan készítsünk működő alkalmazást
• Node.js és MySQL

Ezekkel a haladó témákkal való kezdéshez tekintse meg az Educative „Learn Node.js: The Complete Course for Beginners” című tanfolyamát, amely mindezeket a témákat és még többet is lefedi. Felfedezhet olyan fejlett fogalmakat, mint a modulok, események és csomagok. A tanfolyam végén elsajátíthatja a Node.js-t, és elkészítheti saját ételszállítási webalkalmazását.

Kellemes tanulást!

Olvasson tovább a Node.js-ről és a JavaScriptről az Educative webhelyen

• Node.js vs React.js: melyiket válassza webalkalmazás-projektjéhez
• „Bevált módszerek a Node.js-alkalmazások védelméhez”
• „Tanulja meg a JavaScript OOP-t: A webfejlesztés alapozója”

Indítson vitát

Mi a kedvenc node.js felhasználása a professzionális világban? Hasznos volt ez a cikk? Tudassa velünk az alábbi megjegyzésekben!