Che cos'è questo Javascript "richiesto"?

Sto cercando di ottenere Javascript per leggere / scrivere in un database PostgreSQL. Ho trovato questo progetto su github. Sono stato in grado di ottenere il seguente codice di esempio per l'esecuzione nel nodo.

var pg = require('pg'); //native libpq bindings = `var pg = require('pg').native`
var conString = "tcp://postgres:1234@localhost/postgres";

var client = new pg.Client(conString);
client.connect();

//queries are queued and executed one after another once the connection becomes available
client.query("CREATE TEMP TABLE beatles(name varchar(10), height integer, birthday timestamptz)");
client.query("INSERT INTO beatles(name, height, birthday) values($1, $2, $3)", ['Ringo', 67, new Date(1945, 11, 2)]);
client.query("INSERT INTO beatles(name, height, birthday) values($1, $2, $3)", ['John', 68, new Date(1944, 10, 13)]);

//queries can be executed either via text/parameter values passed as individual arguments
//or by passing an options object containing text, (optional) parameter values, and (optional) query name
client.query({
  name: 'insert beatle',
  text: "INSERT INTO beatles(name, height, birthday) values($1, $2, $3)",
  values: ['George', 70, new Date(1946, 02, 14)]
});

//subsequent queries with the same name will be executed without re-parsing the query plan by postgres
client.query({
  name: 'insert beatle',
  values: ['Paul', 63, new Date(1945, 04, 03)]
});
var query = client.query("SELECT * FROM beatles WHERE name = $1", ['John']);

//can stream row results back 1 at a time
query.on('row', function(row) {
  console.log(row);
  console.log("Beatle name: %s", row.name); //Beatle name: John
  console.log("Beatle birth year: %d", row.birthday.getYear()); //dates are returned as javascript dates
  console.log("Beatle height: %d' %d\"", Math.floor(row.height/12), row.height%12); //integers are returned as javascript ints
});

//fired after last row is emitted
query.on('end', function() { 
  client.end();
});

Successivamente ho provato a farlo funzionare su una pagina web, ma sembrava non succedere nulla. Ho controllato sulla console Javascript e mi dice solo "richiede non definito".

Quindi cos'è questo "requisito?" Perché funziona nel nodo ma non in una pagina Web?

Inoltre, prima di farlo funzionare nel nodo, dovevo farlo npm install pg. Di cosa si tratta? Ho cercato nella directory e non ho trovato un file pag. Dove lo ha inserito e come lo trova Javascript?

Quindi cos'è questo "requisito?"

require()non fa parte dell'API JavaScript standard. Ma in Node.js, è una funzione integrata con uno scopo speciale: caricare i moduli .

I moduli sono un modo per dividere un'applicazione in file separati invece di avere tutta l'applicazione in un unico file. Questo concetto è presente anche in altre lingue con lievi differenze nella sintassi e nel comportamento, come C include, Python importe così via.

Una grande differenza tra i moduli Node.js e JavaScript del browser è come si accede al codice di uno script dal codice di un altro script.

• Nel browser JavaScript, gli script vengono aggiunti tramite l' <script>elemento. Quando vengono eseguiti, hanno tutti accesso diretto all'ambito globale, uno "spazio condiviso" tra tutti gli script. Qualsiasi script può definire / modificare / rimuovere / chiamare liberamente qualsiasi cosa nell'ambito globale.

• In Node.js, ogni modulo ha il suo ambito. Un modulo non può accedere direttamente alle cose definite in un altro modulo a meno che non scelga di esporle. Per esporre oggetti da un modulo, devono essere assegnati a exportso module.exports. Perché un modulo possa accedere a un altro modulo exportso module.exports, deve utilizzarerequire() .

Nel tuo codice, var pg = require('pg');carica il pgmodulo, un client PostgreSQL per Node.js. Ciò consente al codice di accedere alla funzionalità delle API del client PostgreSQL tramite la pgvariabile.

Perché funziona nel nodo ma non in una pagina Web?

require(), module.exportsE exportssono API di un sistema modulare che è specifico per Node.js. I browser non implementano questo sistema di moduli.

Inoltre, prima di farlo funzionare nel nodo, dovevo farlo npm install pg. Di cosa si tratta?

NPM è un servizio di repository di pacchetti che ospita moduli JavaScript pubblicati. npm installè un comando che ti consente di scaricare i pacchetti dal loro repository.

Dove lo ha inserito e come lo trova Javascript?

Npm cli mette tutti i moduli scaricati in una node_modulesdirectory in cui è stato eseguito npm install. Node.js ha una documentazione molto dettagliata su come i moduli trovano altri moduli che include la ricerca di una node_modulesdirectory.

Bene, quindi cominciamo prima a fare la distinzione tra Javascript in un browser Web e Javascript su un server (CommonJS e Node).

Javascript è un linguaggio tradizionalmente confinato a un browser Web con un contesto globale limitato definito principalmente da quello che è diventato noto come Document Object Model (DOM) livello 0 (l'API Javascript di Netscape Navigator).

Il Javascript lato server elimina tale restrizione e consente a Javascript di richiamare varie parti di codice nativo (come la libreria Postgres) e aprire socket.

Ora require()è una chiamata di funzione speciale definita come parte delle specifiche CommonJS. Nel nodo, risolve le librerie e i moduli nel percorso di ricerca del nodo, ora generalmente definito come node_modulesnella stessa directory (o nella directory del file javascript invocato) o nel percorso di ricerca dell'intero sistema.

Per provare a rispondere al resto della tua domanda, dobbiamo usare un proxy tra il codice in esecuzione nel browser e il server di database.

Dal momento che stiamo discutendo di Node e hai già familiarità con come eseguire una query da lì, avrebbe senso usare Node come proxy.

Come semplice esempio, creeremo un URL che restituisce alcuni fatti su un Beatle, a cui viene dato un nome, come JSON.

/* your connection code */

var express = require('express');
var app = express.createServer();
app.get('/beatles/:name', function(req, res) {
    var name = req.params.name || '';
    name = name.replace(/[^a-zA_Z]/, '');
    if (!name.length) {
        res.send({});
    } else {
        var query = client.query('SELECT * FROM BEATLES WHERE name =\''+name+'\' LIMIT 1');
        var data = {};
        query.on('row', function(row) {
            data = row;
            res.send(data);
        });
    };
});
app.listen(80, '127.0.0.1');

È usato per caricare i moduli. Facciamo un semplice esempio.

Nel file circle_object.js:

var Circle = function (radius) {
    this.radius = radius
}
Circle.PI = 3.14

Circle.prototype = {
    area: function () {
        return Circle.PI * this.radius * this.radius;
    }
}

Possiamo usarlo tramite require, come:

node> require('circle_object')
{}
node> Circle
{ [Function] PI: 3.14 }
node> var c = new Circle(3)
{ radius: 3 }
node> c.area()

Il require()metodo viene utilizzato per caricare e memorizzare nella cache i moduli JavaScript. Pertanto, se si desidera caricare un modulo JavaScript locale relativo in un'applicazione Node.js, è possibile utilizzare semplicemente il require()metodo

Esempio:

var yourModule = require( "your_module_name" ); //.js file extension is optional

Ho notato che mentre le altre risposte hanno spiegato che cosa è richiesto e che viene utilizzato per caricare i moduli in Nodo, non hanno dato una risposta completa su come caricare i moduli di nodo quando si lavora nel browser.

È abbastanza semplice da fare. Installa il tuo modulo usando npm come descritto e il modulo stesso si troverà in una cartella solitamente chiamata node_modules.

Ora il modo più semplice per caricarlo nella tua app è fare riferimento a esso dal tuo html con un tag di script che punta a questa directory. vale a dire se la directory node_modules si trova nella radice del progetto allo stesso livello di index.html, la scriverebbe in index.html:

<script src="node_modules/ng"></script>

L'intero script verrà ora caricato nella pagina, in modo da poter accedere direttamente alle sue variabili e ai suoi metodi.

Esistono altri approcci che sono più ampiamente utilizzati in progetti più grandi, come un caricatore di moduli come require.js . Dei due, non ho usato Require me stesso, ma penso che sia considerato da molte persone la strada da percorrere.

Sai come quando esegui JavaScript nel browser, hai accesso a variabili come "finestra" o matematica? Non è necessario dichiarare queste variabili, sono state scritte per essere utilizzate quando si desidera.

Bene, quando stai eseguendo un file nell'ambiente Node.js, c'è una variabile che puoi usare. Si chiama "modulo" È un oggetto. Ha una proprietà chiamata "export". E funziona così:

In un file che chiameremo example.js, scrivi:

example.js

module.exports = "some code";

Ora, vuoi questa stringa "un po 'di codice" in un altro file.

Chiameremo l'altro file otherFile.js

In questo file scrivi:

otherFile.js

let str = require('./example.js')

Quell'istruzione request () va al file che hai inserito al suo interno, trova tutti i dati memorizzati nella proprietà module.exports. La parte let str = ... del tuo codice indica che qualunque cosa richieda l'istruzione return viene memorizzata nella variabile str.

Quindi, in questo esempio, il risultato finale è che in otherFile.js ora hai questo:

let string = "some code";

• o -

let str = ('./example.js').module.exports

Nota:

il nome file che è scritto all'interno dell'istruzione request: se si tratta di un file locale, dovrebbe essere il percorso del file di esempio.js. Inoltre, l'estensione .js viene aggiunta per impostazione predefinita, quindi non ho dovuto scriverla.

Fai qualcosa di simile quando richiedi le librerie node.js, come Express. Nel file express.js c'è un oggetto chiamato 'module', con una proprietà chiamata 'exports'.

Quindi, sembra qualcosa del genere, sotto il cofano (sono un po 'un principiante, quindi alcuni di questi dettagli potrebbero non essere esatti, ma è per mostrare il concetto:

express.js

module.exports = function() {
    //It returns an object with all of the server methods
    return {
        listen: function(port){},
        get: function(route, function(req, res){}){}
     }
}

Se si richiede un modulo, è simile al seguente: const moduleName = require ("nome-modulo");

Se si richiede un file locale, è simile al seguente: const localFile = require ("./ percorso / to / local-file");

(notare il ./ all'inizio del nome del file)

Inoltre, per impostazione predefinita, l'esportazione è un oggetto .. ad esempio module.exports = {} Quindi, puoi scrivere module.exports.myfunction = () => {} prima di assegnare un valore a module.exports. Ma puoi anche sostituire l'oggetto scrivendo module.exports = "Non sono più un oggetto."

Due versioni di module.exports / richiedono:

(vedi qui )

File di esportazione sapore 1 (misc.js):

var x = 5;
var addX = function(value) {
  return value + x;
};
module.exports.x = x;
module.exports.addX = addX;

altro file:

var misc = require('./misc');
console.log("Adding %d to 10 gives us %d", misc.x, misc.addX(10));

File di esportazione sapore 2 (user.js):

var User = function(name, email) {
  this.name = name;
  this.email = email;
};
module.exports = User;

altro file:

var user = require('./user');
var u = new user();