Node.js Handledning
Komma igång med Node.js

Anmärkningar

versioner

Hej World HTTP-server

Installera först Node.js för din plattform.

I det här exemplet skapar vi en HTTP-server som lyssnar på port 1337, som skickar Hello, World! till webbläsaren. Observera att istället för att använda port 1337 kan du använda valfritt portnummer som du för närvarande inte använder någon annan tjänst.

http modulen är en Node.js- kärnmodul (en modul som ingår i Node.js källa, som inte kräver installation av ytterligare resurser). http modulen tillhandahåller funktionaliteten för att skapa en HTTP-server med hjälp av http.createServer() . Skapa en fil genom att skapa en fil som innehåller följande JavaScript-kod.

const http = require('http'); // Loads the http module

http.createServer((request, response) => {

    // 1. Tell the browser everything is OK (Status code 200), and the data is in plain text
    response.writeHead(200, {
        'Content-Type': 'text/plain'
    });

    // 2. Write the announced text to the body of the page
    response.write('Hello, World!\n');

    // 3. Tell the server that all of the response headers and body have been sent
    response.end();

}).listen(1337); // 4. Tells the server what port to be on

Spara filen med vilket filnamn som helst. I det här fallet, om vi hello.js det hello.js vi köra applikationen genom att gå till den katalog filen finns i och använda följande kommando:

node hello.js

Den skapade servern kan sedan nås med webbadressen http: // localhost: 1337 eller http://127.0.0.1:1337 i webbläsaren.

En enkel webbsida visas med "Hej, världen!" text längst upp, som visas på skärmdumpen nedan.

Redigerbart online-exempel.

Hello World kommandorad

Node.js kan också användas för att skapa kommandoradsverktyg. Exemplet nedan läser det första argumentet från kommandoraden och skriver ut ett Hello-meddelande.

Så här kör du koden på ett Unix-system:

1. Skapa en ny fil och klistra in koden nedan. Filnamnet är inte relevant.
2. Gör den här filen körbar med chmod 700 FILE_NAME
3. Kör appen med ./APP_NAME David

På Windows gör du steg 1 och kör det med node APP_NAME David

#!/usr/bin/env node

'use strict';

/*
    The command line arguments are stored in the `process.argv` array, 
    which has the following structure:
    [0] The path of the executable that started the Node.js process
    [1] The path to this application
    [2-n] the command line arguments

    Example: [ '/bin/node', '/path/to/yourscript', 'arg1', 'arg2', ... ]
    src: https://nodejs.org/api/process.html#process_process_argv
 */

// Store the first argument as username.
var username = process.argv[2];

// Check if the username hasn't been provided.
if (!username) {

    // Extract the filename
    var appName = process.argv[1].split(require('path').sep).pop();

    //  Give the user an example on how to use the app.
    console.error('Missing argument! Example: %s YOUR_NAME', appName);

    // Exit the app (success: 0, error: 1). 
    // An error will stop the execution chain. For example:
    //   ./app.js && ls       -> won't execute ls
    //   ./app.js David && ls -> will execute ls
    process.exit(1);
}

// Print the message to the console.
console.log('Hello %s!', username);

Installera och köra Node.js

För att börja installerar du Node.js på din utvecklingsdator.

Windows: Navigera till nedladdningssidan och ladda ner / köra installationsprogrammet.

Mac: Navigera till nedladdningssidan och ladda ner / köra installationsprogrammet. Alternativt kan du installera Node via Homebrew med hjälp av brew install node . Homebrew är en kommandoradspaketmanager för Macintosh, och mer information om det finns på Homebrews webbplats .

Linux: Följ instruktionerna för din distro på installationssidan för kommandoraden .

Kör ett nodprogram

För att köra ett Node.js-program kör du bara node app.js eller nodejs app.js , där app.js är filnamnet på din nod-källkod. Du behöver inte inkludera .js suffixet för Node för att hitta skriptet du vill köra.

Alternativt under UNIX-baserade operativsystem kan ett Node-program köras som ett terminalskript. För att göra det måste det börja med en shebang som pekar på Node-tolkaren, till exempel #!/usr/bin/env node . Filen måste också ställas in som körbar, vilket kan göras med chmod . Nu kan skriptet köras direkt från kommandoraden.

Distribuera din ansökan online

När du distribuerar din app till en (Node.js-specifik) PORT erbjuder den här miljön vanligtvis en PORT miljövariabel som du kan använda för att köra din server på. Ändra portnummer till process.env.PORT ger dig tillgång till applikationen.

Till exempel,

http.createServer(function(request, response) {
   // your server code
}).listen(process.env.PORT);

Om du vill komma åt detta offline när du felsöker kan du använda det här:

http.createServer(function(request, response) {
  // your server code
}).listen(process.env.PORT || 3000);

där 3000 är offline-portnumret.

Felsöka ditt NodeJS-program

Du kan använda nodinspektören. Kör det här kommandot för att installera det via npm:

npm install -g node-inspector

Sedan kan du felsöka din ansökan med

node-debug app.js

Github-förvaret kan hittas här: https://github.com/node-inspector/node-inspector

Debugging natively

Du kan också felsöka node.js naturligt genom att starta det så här:

node debug your-script.js

För att bryta din felsökare exakt i en kodrad du vill använda:

debugger;

För mer information se här .

Använd följande kommando i node.js 8:

node --inspect-brk your-script.js

Öppna sedan about://inspect i en ny version av Google Chrome och välj ditt Node-skript för att få felsökningsupplevelsen i Chrome: s DevTools.

Hej värld med Express

Följande exempel använder Express för att skapa en HTTP-server som lyssnar på port 3000, som svarar med "Hej, världen!". Express är ett vanligt använt webbramverk som är användbart för att skapa HTTP API: er.

myApp en ny mapp, t.ex. myApp . Gå in i myApp och skapa en ny JavaScript-fil som innehåller följande kod (låt oss namnge det till exempel hello.js ). Installera sedan npm install --save express med npm install --save express från kommandoraden. Se den här dokumentationen för mer information om hur du installerar paket .

// Import the top-level function of express
const express = require('express');

// Creates an Express application using the top-level function
const app = express();

// Define port number as 3000
const port = 3000;

// Routes HTTP GET requests to the specified path "/" with the specified callback function
app.get('/', function(request, response) {
  response.send('Hello, World!');
});

// Make the app listen on port 3000
app.listen(port, function() {
  console.log('Server listening on http://localhost:' + port);
});

Kör följande kommando från kommandoraden:

node hello.js

Öppna din webbläsare och navigera till http://localhost:3000 eller http://127.0.0.1:3000 att se svaret.

För mer information om Express-ramverket kan du kontrollera avsnittet Web Apps With Express

Hej världs grundläggande dirigering

När du först har förstått hur du skapar en HTTP-server med nod är det viktigt att förstå hur man gör det till att "göra" saker baserat på den sökväg som en användare har navigerat till. Detta fenomen kallas "routing".

Det mest grundläggande exemplet på detta är att kontrollera if (request.url === 'some/path/here') och sedan ringa en funktion som svarar med en ny fil.

Ett exempel på detta kan ses här:

const http = require('http');

function index (request, response) {
    response.writeHead(200);
    response.end('Hello, World!');
}

http.createServer(function (request, response) {
    
    if (request.url === '/') {
        return index(request, response);
    }

    response.writeHead(404);
    response.end(http.STATUS_CODES[404]);

}).listen(1337);

Om du fortsätter att definiera dina "rutter" så här, kommer du dock att sluta med en massiv återuppringningsfunktion, och vi vill inte ha en gigantisk röra så, så låt oss se om vi kan rensa detta.

Först, låt oss lagra alla våra rutter i ett objekt:

var routes = {
    '/': function index (request, response) {
        response.writeHead(200);
        response.end('Hello, World!');
    },
    '/foo': function foo (request, response) {
        response.writeHead(200);
        response.end('You are now viewing "foo"');
    }
}

Nu när vi har lagrat två rutter i ett objekt kan vi nu leta efter dem i vår huvuduppringning:

http.createServer(function (request, response) {
    
    if (request.url in routes) {
        return routes[request.url](request, response);
    }

    response.writeHead(404);
    response.end(http.STATUS_CODES[404]);

}).listen(1337);

Nu varje gång du försöker navigera på din webbplats kommer den att kontrollera om det finns en sökväg på dina rutter och den kommer att ringa respektive funktion. Om ingen rutt hittas kommer servern att svara med en 404 (Not Found).

Och där har du det - dirigering med HTTP Server API är väldigt enkelt.

TLS Socket: server och klient

De enda stora skillnaderna mellan denna och en vanlig TCP-anslutning är den privata nyckeln och det offentliga certifikatet som du måste ange till ett alternativobjekt.

Hur man skapar en nyckel och certifikat

Det första steget i denna säkerhetsprocess är skapandet av en privat nyckel. Och vad är den här privata nyckeln? I grund och botten är det en uppsättning slumpmässigt brus som används för att kryptera information. I teorin kan du skapa en nyckel och använda den för att kryptera vad du vill. Men det är bäst att ha olika nycklar för specifika saker. För om någon stjäl din privata nyckel liknar det att låta någon stjäla dina husnycklar. Föreställ dig om du använde samma nyckel för att låsa din bil, garage, kontor etc.

openssl genrsa -out private-key.pem 1024

När vi har fått vår privata nyckel kan vi skapa en CSR (certifikatsigneringsbegäran), som är vår begäran om att få den privata nyckeln signerad av en fin myndighet. Det är därför du måste ange information relaterad till ditt företag. Denna information kommer att ses av signeringsmyndigheten och användas för att verifiera dig. I vårt fall spelar det ingen roll vad du skriver, eftersom vi i nästa steg kommer att underteckna vårt certifikat själva.

openssl req -new -key private-key.pem -out csr.pem

Nu när vi har fyllt i vårt pappersarbete är det dags att låtsas att vi är en cool signeringsmyndighet.

openssl x509 -req -in csr.pem -signkey private-key.pem -out public-cert.pem

Nu när du har den privata nyckeln och det offentliga certifikatet kan du upprätta en säker anslutning mellan två NodeJS-appar. Och som du ser i exemplskoden är det en mycket enkel process.

Viktig!

Eftersom vi själva skapade allmänheten certifikatet, i all ärlighet, är vårt certifikat värdelöst eftersom vi är nobodies. NodeJS-servern litar inte på ett sådant certifikat som standard, och det är därför vi måste säga den att faktiskt lita på vårt cert med följande alternativ avstänga godkänt: falsk. Mycket viktigt : ställ aldrig in denna variabel till sann i en produktionsmiljö.

TLS Socket Server

'use strict';

var tls = require('tls');
var fs = require('fs');

const PORT = 1337;
const HOST = '127.0.0.1'

var options = {
    key: fs.readFileSync('private-key.pem'),
    cert: fs.readFileSync('public-cert.pem')
};

var server = tls.createServer(options, function(socket) {

    // Send a friendly message
    socket.write("I am the server sending you a message.");

    // Print the data that we received
    socket.on('data', function(data) {

        console.log('Received: %s [it is %d bytes long]',
            data.toString().replace(/(\n)/gm,""),
            data.length);

    });

    // Let us know when the transmission is over
    socket.on('end', function() {

        console.log('EOT (End Of Transmission)');

    });

});

// Start listening on a specific port and address
server.listen(PORT, HOST, function() {

    console.log("I'm listening at %s, on port %s", HOST, PORT);

});

// When an error occurs, show it.
server.on('error', function(error) {

    console.error(error);

    // Close the connection after the error occurred.
    server.destroy();

});

TLS Socket Client

'use strict';

var tls = require('tls');
var fs = require('fs');

const PORT = 1337;
const HOST = '127.0.0.1'

// Pass the certs to the server and let it know to process even unauthorized certs.
var options = {
    key: fs.readFileSync('private-key.pem'),
    cert: fs.readFileSync('public-cert.pem'),
    rejectUnauthorized: false
};

var client = tls.connect(PORT, HOST, options, function() {

    // Check if the authorization worked
    if (client.authorized) {
        console.log("Connection authorized by a Certificate Authority.");
    } else {
        console.log("Connection not authorized: " + client.authorizationError)
    }

    // Send a friendly message
    client.write("I am the client sending you a message.");

});

client.on("data", function(data) {

    console.log('Received: %s [it is %d bytes long]',
        data.toString().replace(/(\n)/gm,""),
        data.length);

    // Close the connection after receiving the message
    client.end();

});

client.on('close', function() {

    console.log("Connection closed");

});

// When an error ocoures, show it.
client.on('error', function(error) {

    console.error(error);

    // Close the connection after the error occurred.
    client.destroy();

});

Hej värld i REPL

När det anropas utan argument startar Node.js en REPL (Read-Eval-Print-Loop) även känd som " Node shell ".

Skriv en node vid en kommandoprompt.

$ node
>

Vid noden skalprompten > typ "Hello World!"

$ node
> "Hello World!"
'Hello World!'

Kärnmoduler

Node.js är en Javascript-motor (Googles V8-motor för Chrome, skriven i C ++) som gör det möjligt att köra Javascript utanför webbläsaren. Medan många bibliotek finns tillgängliga för att utöka Nodes funktionaliteter, kommer motorn med en uppsättning kärnmoduler som implementerar grundläggande funktioner.

Det finns för närvarande 34 kärnmoduler i Node:

[ 'assert',
  'buffer',
  'c/c++_addons',
  'child_process',
  'cluster',
  'console',
  'crypto',
  'deprecated_apis',
  'dns',
  'domain',
  'Events',
  'fs',
  'http',
  'https',
  'module',
  'net',
  'os',
  'path',
  'punycode',
  'querystring',
  'readline',
  'repl',
  'stream',
  'string_decoder',
  'timers',
  'tls_(ssl)',
  'tracing',
  'tty',
  'dgram',
  'url',
  'util',
  'v8',
  'vm',
  'zlib' ]

Denna lista erhölls från Node-dokumentation API https://nodejs.org/api/all.html (JSON-fil: https://nodejs.org/api/all.json ).

Alla kärnmoduler snabbt

hävda

assert tillhandahåller en enkel uppsättning påståttest som kan användas för att testa invarianter.

buffert

Före introduktionen av TypedArray i ECMAScript 2015 (ES6) hade JavaScript-språket ingen mekanism för att läsa eller manipulera strömmar av binär data. Buffer introducerades som en del av Node.js API för att göra det möjligt att interagera med oktettströmmar i samband med saker som TCP-strömmar och filsystemoperationer.

Nu när TypedArray har lagts i ES6 de Buffer klass implementerar Uin t8Array API på ett sätt som är mer optimerat och lämpar sig för Node.js' användningsfall.

C / C ++ _ addons

Node.js-tillägg är dynamiskt länkade delade objekt, skrivna i C eller C ++, som kan laddas i Node.js med funktionen require() och användas precis som om de är en vanlig Node.js-modul. De används främst för att tillhandahålla ett gränssnitt mellan JavaScript som körs i Node.js och C / C ++ -bibliotek.

child_process

Modulen child_process ger möjlighet att leka barnprocesser på ett sätt som liknar men inte identiskt med popen (3).

klunga

En enda instans av Node.js körs i en enda tråd. För att dra fördel av flerkärniga system kommer användaren ibland att vilja starta ett kluster av Node.js-processer för att hantera belastningen. Med klustermodulen kan du enkelt skapa barnprocesser som alla delar serverportar.

trösta

Den console modulen ger en enkel felsökning konsol som liknar konsolmekanism JavaScript tillhandahålls av webbläsare.

crypto

crypto tillhandahåller kryptografisk funktionalitet som inkluderar en uppsättning omslag för OpenSSL: s hash, HMAC, chiffer, dechiffrering, signering och verifiering.

deprecated_apis

Node.js kan avskriva API: er när antingen: (a) användning av API anses vara osäker, (b) ett förbättrat alternativt API har gjorts tillgängligt, eller (c) brytande ändringar av API förväntas i en framtida större utgåva .

dns

dns modulen innehåller funktioner som hör till två olika kategorier:

1. Funktioner som använder de underliggande operativsystemfaciliteterna för att utföra namnupplösning och som inte nödvändigtvis utför någon nätverkskommunikation. Denna kategori innehåller bara en funktion: dns.lookup() .
2. Funktioner som ansluter till en faktisk DNS-server för att utföra namnupplösning och som alltid använder nätverket för att utföra DNS-frågor. Denna kategori innehåller alla funktioner i dns modulen utom dns.lookup() .

domän

Denna modul väntar på avskrivning . När ett ersättnings-API har slutförts kommer denna modul att avskrivas helt. De flesta slutanvändare bör inte ha anledning att använda den här modulen. Användare som absolut måste ha den funktionalitet som domänerna tillhandahåller kan förlita sig på den för närvarande men kan förvänta sig att behöva migrera till en annan lösning i framtiden.

evenemang

Mycket av Node.js kärn-API bygger kring en idiomatisk asynkron händelsestyrd arkitektur där vissa typer av objekt (kallad "emitters") regelbundet avger namngivna händelser som får funktionsobjekt ("lyssnare") att kallas.

fs

File I / O tillhandahålls av enkla omslag runt standard POSIX-funktioner. För att använda den här modulen require('fs') . Alla metoder har asynkrona och synkrona former.

http

HTTP-gränssnitten i Node.js är utformade för att stödja många funktioner i protokollet som traditionellt har varit svåra att använda. I synnerhet stora, möjligen chunk-kodade meddelanden. Gränssnittet är noga med att aldrig buffra hela förfrågningar eller svar - användaren kan strömma data.

https

HTTPS är HTTP-protokollet över TLS / SSL. I Node.js implementeras detta som en separat modul.

modul

Node.js har ett enkelt modulbelastningssystem. I Node.js finns filer och moduler i en-till-en-korrespondens (varje fil behandlas som en separat modul).

netto

net ger dig en asynkron nätverksomslag. Den innehåller funktioner för att skapa både servrar och klienter (kallas strömmar). Du kan inkludera den här modulen med require('net'); .

os

os modulen tillhandahåller ett antal operativsystemrelaterade verktygsmetoder.

väg

Den path modulen ger verktyg för att arbeta med filer och katalogvägar.

punycode

Versionen av punycode-modulen som ingår i Node.js skrivs ut .

frågesträng

Modulen querystring ger verktyg för att analysera och formatera URL-frågesträngar.

readline

readline modulen tillhandahåller ett gränssnitt för att läsa data från en läsbar ström (som process.stdin ) en rad åt gången.

repl

repl modulen tillhandahåller en Read-Eval-Print-Loop (REPL) -implementering som är tillgänglig både som ett fristående program eller som inkluderas i andra applikationer.

ström

En ström är ett abstrakt gränssnitt för att arbeta med strömningsdata i Node.js. Den stream modulen ger en bas API som gör det enkelt att bygga objekt som implementerar strömmen gränssnittet.

Det finns många strömobjekt som tillhandahålls av Node.js. Till exempel är en begäran till en HTTP-server och process.stdout båda process.stdout .

string_decoder

Modulen string_decoder tillhandahåller ett API för att avkoda Buffer till strängar på ett sätt som bevarar kodade multi-byte UTF-8 och UTF-16-tecken.

timers

timer visar ett globalt API för schemaläggningsfunktioner som ska anropas under en framtida tidsperiod. Eftersom timerfunktionerna är globala, finns det inget behov att ringa require('timers') att använda API: n.

Timerfunktionerna i Node.js implementerar ett liknande API som timerns API som tillhandahålls av webbläsare men använder en annan intern implementering som är byggd runt Node.js Event Loop .

tls_ (ssl)

Modulen tls ger en implementering av protokollet Transport Layer Security (TLS) och Secure Socket Layer (SSL) som är byggt ovanpå OpenSSL.

spårande

Trace Event tillhandahåller en mekanism för att centralisera spårningsinformation genererad av V8, Node core och userpace code.

Spårning kan aktiveras genom att passera --trace-events-enabled när du startar ett Node.js-program.

tty

tty modulen ger tty.ReadStream och tty.WriteStream . I de flesta fall kommer det inte att vara nödvändigt eller möjligt att använda den här modulen direkt.

dgram

dgram ger en implementering av UDP Datagram-uttag.

url

url modulen tillhandahåller verktyg för URL-upplösning och analysering.

util

util är främst utformad för att stödja behoven i Node.js egna interna API: er. Många av verktygen är dock användbara för applikations- och modulutvecklare också.

v8

Modulen v8 visar API: er som är specifika för den version av V8 som är inbyggd i binär Node.js.

Obs : API: erna och implementeringen kan ändras när som helst.

vm

vm modulen tillhandahåller API: er för att sammanställa och köra kod inom V8 Virtual Machine-sammanhang. JavaScript-kod kan sammanställas och köras omedelbart eller sammanställas, sparas och köras senare.

Obs! Vm-modulen är inte en säkerhetsmekanism. Använd inte den för att köra otillförlitlig kod .

zlib

zlib modulen tillhandahåller komprimeringsfunktionalitet implementerad med Gzip och Deflate / Inflate.

Hur man startar en grundläggande HTTPS-webbserver!

När du har installerat node.js på ditt system kan du bara följa proceduren nedan för att få en grundläggande webbserver med stöd för både HTTP och HTTPS!

Steg 1: Bygg en certifikatutfärdare

1. skapa mappen där du vill lagra ditt nyckel & certifikat:

   mkdir conf

2. gå till den katalogen:

   cd conf

3. ta denna ca.cnf fil för att använda som en genväg för konfigurering:

   wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/ca.cnf

4. skapa en ny certifikatutfärdare med hjälp av denna konfiguration:

   openssl req -new -x509 -days 9999 -config ca.cnf -keyout ca-key.pem -out ca-cert.pem

5. nu när vi har vår certifikatutfärdare i ca-key.pem och ca-cert.pem , låt oss skapa en privat nyckel för servern:

   openssl genrsa -out key.pem 4096

6. ta denna server.cnf fil för att använda som en genväg för konfigurering:

   wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/server.cnf

7. generera certifikatsigneringsbegäran med denna konfiguration:

   openssl req -new -config server.cnf -key key.pem -out csr.pem

8. underteckna begäran:

   openssl x509 -req -extfile server.cnf -days 999 -passin "pass:password" -in csr.pem -CA ca-cert.pem -CAkey ca-key.pem -CAcreateserial -out cert.pem

Steg 2: Installera ditt certifikat som ett rotcertifikat

1. kopiera ditt certifikat till mappen rotcertifikat:

   sudo cp ca-crt.pem /usr/local/share/ca-certificates/ca-crt.pem

2. uppdatera CA-butiken:

   sudo update-ca-certificates

Steg 3: Starta din nodserver

Först vill du skapa en server.js fil som innehåller din faktiska serverkod.

Den minimala inställningen för en HTTPS-server i Node.js skulle vara något liknande:

var https = require('https');
var fs = require('fs');

var httpsOptions = {
    key: fs.readFileSync('path/to/server-key.pem'),
    cert: fs.readFileSync('path/to/server-crt.pem')
};

var app = function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}

https.createServer(httpsOptions, app).listen(4433);

Om du också vill stödja http-förfrågningar måste du göra just den här lilla modifieringen:

var http = require('http');
var https = require('https');
var fs = require('fs');

var httpsOptions = {
    key: fs.readFileSync('path/to/server-key.pem'),
    cert: fs.readFileSync('path/to/server-crt.pem')
};

var app = function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}

http.createServer(app).listen(8888);
https.createServer(httpsOptions, app).listen(4433);

1. gå till katalogen där din server.js finns:

   cd /path/to

2. kör server.js :

   node server.js