Qu'est-ce que ce Javascript «requiert»?

J'essaie d'obtenir Javascript pour lire / écrire dans une base de données PostgreSQL. J'ai trouvé ce projet sur github. J'ai pu obtenir l'exemple de code suivant à exécuter dans le nœud.

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();
});

Ensuite, j'ai essayé de le faire fonctionner sur une page Web, mais rien ne semblait se produire. J'ai vérifié sur la console Javascript et il dit juste "pas besoin de définir".

Alors, qu'est-ce que c'est "exiger?" Pourquoi cela fonctionne-t-il dans le nœud mais pas dans une page Web?

De plus, avant de le faire fonctionner en nœud, je devais le faire npm install pg. Ça parles de quoi? J'ai regardé dans le répertoire et je n'ai pas trouvé de fichier pg. Où l'a-t-il mis et comment Javascript le trouve-t-il?

Alors, qu'est-ce que c'est "exiger?"

require()ne fait pas partie de l'API JavaScript standard. Mais dans Node.js, c'est une fonction intégrée avec un but spécial: charger des modules .

Les modules sont un moyen de diviser une application en fichiers séparés au lieu d'avoir toute votre application dans un seul fichier. Ce concept est également présent dans d'autres langages avec des différences mineures de syntaxe et de comportement, comme les C include, Python import, etc.

Une grande différence entre les modules Node.js et le navigateur JavaScript est la façon dont le code d'un script est accessible à partir du code d'un autre script.

• Dans le navigateur JavaScript, les scripts sont ajoutés via le <script> élément. Lorsqu'ils s'exécutent, ils ont tous un accès direct à la portée globale, un "espace partagé" entre tous les scripts. Tout script peut librement définir / modifier / supprimer / appeler n'importe quoi sur la portée globale.

• Dans Node.js, chaque module a sa propre portée. Un module ne peut pas accéder directement aux éléments définis dans un autre module à moins qu'il ne choisisse de les exposer. Pour exposer des éléments d'un module, ils doivent être affectés à exportsou module.exports. Pour qu'un module accède à un autre module exportsou module.exports, il doit utiliserrequire() .

Dans votre code, var pg = require('pg');charge lepg module, un client PostgreSQL pour Node.js. Cela permet à votre code d'accéder aux fonctionnalités des API du client PostgreSQL via la pgvariable.

Pourquoi cela fonctionne-t-il dans le nœud mais pas dans une page Web?

require(), module.exportsetexports sont des API d'un système de module qui est spécifique à Node.js. Les navigateurs n'implémentent pas ce système de modules.

De plus, avant de le faire fonctionner en nœud, je devais faire npm install pg . Ça parles de quoi?

NPM est un service de référentiel de packages qui héberge des modules JavaScript publiés.npm installest une commande qui vous permet de télécharger des packages à partir de leur référentiel.

Où l'a-t-il mis et comment Javascript le trouve-t-il?

Le cli npm place tous les modules téléchargés dans un node_modulesrépertoire où vous avez exécuté npm install. Node.js a une documentation très détaillée sur la façon dont les modules trouvent d'autres modules, ce qui inclut la recherche d'un node_modulesrépertoire.

Très bien, commençons donc par faire la distinction entre Javascript dans un navigateur Web et Javascript sur un serveur (CommonJS et Node).

Javascript est un langage traditionnellement confiné à un navigateur Web avec un contexte global limité défini principalement par ce que l'on a appelé le DOM (Document Object Model) niveau 0 (l'API Javascript Netscape Navigator).

Le Javascript côté serveur élimine cette restriction et permet à Javascript d'appeler dans différents morceaux de code natif (comme la bibliothèque Postgres) et d'ouvrir des sockets.

Maintenant, require()un appel de fonction spéciale est défini dans le cadre de la spécification CommonJS. Dans le nœud, il résout les bibliothèques et les modules dans le chemin de recherche du nœud, désormais généralement défini commenode_modules dans le même répertoire (ou le répertoire du fichier javascript appelé) ou le chemin de recherche à l'échelle du système.

Pour essayer de répondre au reste de votre question, nous devons utiliser un proxy entre le code exécuté dans le navigateur et le serveur de base de données.

Étant donné que nous discutons de Node et que vous savez déjà comment exécuter une requête à partir de là, il serait logique d'utiliser Node comme proxy.

À titre d'exemple simple, nous allons créer une URL qui renvoie quelques faits sur un Beatle, sous un nom, sous la forme 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');

Il est utilisé pour charger des modules. Prenons un exemple simple.

En dossier 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;
    }
}

Nous pouvons l'utiliser via require, comme:

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

La require()méthode est utilisée pour charger et mettre en cache des modules JavaScript. Donc, si vous souhaitez charger un module JavaScript relatif local dans une application Node.js, vous pouvez simplement utiliser lerequire() méthode.

Exemple:

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

J'ai remarqué que tandis que les autres réponses expliquaient ce qu'est le besoin et qu'il est utilisé pour charger des modules dans Node, ils n'ont pas donné de réponse complète sur la façon de charger les modules de noeud lors du travail dans le navigateur.

C'est assez simple à faire. Installez votre module en utilisant npm comme vous le décrivez, et le module lui-même sera situé dans un dossier généralement appelé node_modules.

Maintenant, le moyen le plus simple de le charger dans votre application est de le référencer à partir de votre html avec une balise de script qui pointe vers ce répertoire. c'est-à-dire que si votre répertoire node_modules est à la racine du projet au même niveau que votre index.html vous écrirez ceci dans votre index.html:

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

Tout ce script sera maintenant chargé dans la page - vous pouvez donc accéder directement à ses variables et méthodes.

Il existe d'autres approches qui sont plus largement utilisées dans les grands projets, comme un chargeur de module comme require.js . Des deux, je n'ai pas utilisé Require moi-même, mais je pense qu'il est considéré par beaucoup comme la voie à suivre.

Vous savez comment lorsque vous exécutez JavaScript dans le navigateur, vous avez accès à des variables comme "fenêtre" ou Math? Vous n'avez pas à déclarer ces variables, elles ont été écrites pour que vous puissiez les utiliser quand vous le souhaitez.

Eh bien, lorsque vous exécutez un fichier dans l'environnement Node.js, il existe une variable que vous pouvez utiliser. On l'appelle "module". C'est un objet. Il possède une propriété appelée «exportations». Et cela fonctionne comme ceci:

Dans un fichier que nous nommerons example.js, vous écrivez:

example.js

module.exports = "some code";

Maintenant, vous voulez cette chaîne "du code" dans un autre fichier.

Nous nommerons l'autre fichier otherFile.js

Dans ce fichier, vous écrivez:

otherFile.js

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

Cette instruction require () va dans le fichier que vous placez à l'intérieur, trouve toutes les données stockées dans la propriété module.exports. La partie let str = ... de votre code signifie que tout ce qui nécessite des retours d'instructions est stocké dans la variable str.

Donc, dans cet exemple, le résultat final est que dans otherFile.js, vous avez maintenant ceci:

let string = "some code";

• ou -

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

Remarque:

le nom de fichier qui est écrit à l'intérieur de l'instruction require: s'il s'agit d'un fichier local, il doit s'agir du chemin d'accès au fichier example.js. De plus, l'extension .js est ajoutée par défaut, je n'ai donc pas eu à l'écrire.

Vous faites quelque chose de similaire lorsque vous avez besoin de bibliothèques node.js, telles qu'Express. Dans le fichier express.js, il y a un objet nommé 'module', avec une propriété nommée 'exports'.

Donc, cela ressemble à quelque chose comme ça, sous le capot (je suis un peu débutant, donc certains de ces détails peuvent ne pas être exacts, mais c'est pour montrer le concept:

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){}){}
     }
}

Si vous avez besoin d'un module, il ressemble à ceci: const moduleName = require ("module-name");

Si vous avez besoin d'un fichier local, il ressemble à ceci: const localFile = require ("./ path / to / local-file");

(notez le ./ au début du nom du fichier)

Notez également que par défaut, l'exportation est un objet. Par exemple module.exports = {} Vous pouvez donc écrire module.exports.myfunction = () => {} avant d'assigner une valeur à module.exports. Mais vous pouvez également remplacer l'objet en écrivant module.exports = "Je ne suis plus un objet."

Deux versions de module.exports / require:

(voir ici )

Fichier d'exportation Flavour 1 (misc.js):

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

autre fichier:

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

Fichier d'exportation Flavour 2 (user.js):

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

autre fichier:

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