web-dev-qa-db-fra.com

Qu'est-ce que ce Javascript "nécessite"?

J'essaie d'obtenir du Javascript pour lire/écrire dans une base de données PostgreSQL. J'ai trouvé ceci projet sur github. J'ai pu obtenir l'exemple de code suivant pour qu'il s'exécute dans node.

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 passer. J'ai vérifié sur la console Javascript et il a juste dit "nécessite pas défini."

Alors, quelle est cette "nécessite?" Pourquoi cela fonctionne-t-il dans les nœuds mais pas dans les pages Web?

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

javascriptdatabasepostgresqlnode.js
427
neuromancer

Alors, quelle est cette "nécessite?"

require() ne fait pas partie de l'API JavaScript standard. Mais dans Node.js, il s’agit d’une fonction intégrée ayant un objectif particulier: charger des modules .

Les modules permettent de scinder une application en plusieurs fichiers au lieu de regrouper 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 include de C, import de Python, etc.

Une grande différence entre les modules Node.js et le JavaScript du navigateur réside dans le fait que le code d'un script est accessible à partir du code d'un autre script.

  • Dans le navigateur JavaScript, les scripts sont ajoutés via l'élément _<script>_. Quand ils s'exécutent, ils ont tous un accès direct à la portée globale, un "espace partagé" entre tous les scripts. N'importe quel script peut définir/modifier/supprimer/appeler librement tout élément de 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 s'il ne choisit pas de les exposer. Pour exposer des éléments d’un module, ils doivent être attribués à exports ou _module.exports_. Pour qu'un module puisse accéder à exports ou _module.exports_ d'un autre module, , il doit utiliser require().

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

Pourquoi cela fonctionne-t-il dans les nœuds mais pas dans les pages Web?

require(), _module.exports_ et exports sont des API d'un système de module spécifique à Node.js. Les navigateurs n'implémentent pas ce système de module.

De plus, avant de pouvoir utiliser le nœud, je devais faire _npm install pg_. Ça parles de quoi?

NPM est un service de référentiel de paquets qui héberge les modules JavaScript publiés. npm install est 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?

Npm cli place tous les modules téléchargés dans un répertoire _node_modules_ dans lequel vous avez exécuté _npm install_. Node.js a une documentation très détaillée sur comment les modules trouvent d’autres modules qui inclut la recherche d’un répertoire _node_modules_.

742
Joseph

Bon, commençons 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 appelle désormais le DOM (Document Object Model) 0 (l’API Javascript de Netscape Navigator).

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

Maintenant, require() est un appel de fonction spécial défini dans le cadre de la spécification CommonJS. Dans node, il résout les bibliothèques et les modules dans le chemin de recherche Node, généralement défini comme node_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.

Puisque 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, en lui donnant un nom, au format 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');
99
Timothy Meade

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

Dans le fichier 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 utiliser ceci 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 méthode require() est utilisée pour charger et mettre en cache les modules JavaScript. Ainsi, si vous souhaitez charger un module JavaScript local et relatif dans une application Node.js, vous pouvez simplement utiliser la méthode require().

Exemple:

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

J'ai remarqué que, tandis que les autres réponses expliquaient ce qui était requis et qu'il était utilisé pour charger des modules dans Node, elles ne donnaient pas de réponse complète sur la procédure de chargement des modules de nœud lorsque vous travailliez 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 code HTML avec une balise script qui pointe vers ce répertoire. Si votre répertoire node_modules se trouve à 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 va maintenant être 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 projets plus importants, telles qu'un chargeur de module tel que require.js . Des deux, je n'ai pas utilisé Require moi-même, mais je pense qu'il est considéré par beaucoup de gens comme la voie à suivre.

20
Sam Redway

Vous savez comment, lorsque vous utilisez JavaScript dans le navigateur, vous avez accès à des variables telles que "window" ou Math? Vous n'êtes pas obligé de 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, vous pouvez utiliser une variable. Cela s'appelle "module". C'est un objet. Il a une propriété appelée "exportations". Et ça marche comme ça:

Dans un fichier nommé exemple.js, vous écrivez:

exemple.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 avez mis dedans, trouve toutes les données stockées dans la propriété module.exports. La lettre let str = ... de votre code signifie que tout ce qui nécessite une instruction est retourné dans la variable str.

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

let string = "du code";

  • ou -

let 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 du fichier exemple.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 que Express. Dans le fichier express.js, il y a un objet nommé 'module', avec une propriété nommée 'exports'.

Donc, cela ressemble à cela, sous le capot (je suis un peu débutant, alors 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, cela ressemble à ceci: const moduleName = require ("nom-module");

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

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

5
Maiya