O que é esse Javascript "requer"?

Estou tentando fazer com que o Javascript leia / grave em um banco de dados PostgreSQL. Encontrei este projeto no github. Consegui obter o seguinte código de exemplo para executar no nó.

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

Em seguida, tentei fazê-lo rodar em uma página da web, mas nada parecia acontecer. Eu verifiquei no console Javascript e ele diz apenas "não requer definido".

Então, o que é isso "requer?" Por que funciona no nó, mas não em uma página da web?

Além disso, antes de fazê-lo funcionar no nó, eu tinha que fazer npm install pg. Sobre o que é isso? Procurei no diretório e não encontrei um arquivo pg. Onde o colocou e como o Javascript o encontra?

Então, o que é isso "requer?"

require()não faz parte da API JavaScript padrão. Mas no Node.js, é uma função interna com uma finalidade especial: carregar módulos .

Os módulos são uma maneira de dividir um aplicativo em arquivos separados, em vez de ter todo o seu aplicativo em um arquivo. Esse conceito também está presente em outros idiomas com pequenas diferenças de sintaxe e comportamento, como os C'sinclude , Python importe assim por diante.

Uma grande diferença entre os módulos Node.js. e o JavaScript do navegador é como o código de um script é acessado a partir do código de outro script.

• No JavaScript do navegador, os scripts são adicionados por meio do <script>elemento Quando executados, todos eles têm acesso direto ao escopo global, um "espaço compartilhado" entre todos os scripts. Qualquer script pode definir / modificar / remover / chamar livremente qualquer coisa no escopo global.

• No Node.js, cada módulo tem seu próprio escopo. Um módulo não pode acessar diretamente as coisas definidas em outro módulo, a menos que opte por expô-las. Para expor coisas de um módulo, elas devem ser atribuídas a exportsou module.exports. Para um módulo acessar outro módulo exportsou module.exports, ele deve ser usadorequire() .

No seu código, var pg = require('pg');carrega o pgmódulo, um cliente PostgreSQL para Node.js. Isso permite que seu código acesse a funcionalidade das APIs do cliente PostgreSQL viapg variável

Por que funciona no nó, mas não em uma página da web?

require(), module.exportsE exportssão APIs de um módulo do sistema que é específico para Node.js. Navegadores não implementam este sistema de módulos.

Além disso, antes de fazê-lo funcionar no nó, eu tinha que fazer npm install pg. Sobre o que é isso?

O NPM é um serviço de repositório de pacotes que hospeda módulos JavaScript publicados. npm installé um comando que permite baixar pacotes do repositório.

Onde o colocou e como o Javascript o encontra?

O npm cli coloca todos os módulos baixados em um node_modulesdiretório em que você executou npm install. O Node.js possui uma documentação muito detalhada sobre como os módulos encontram outros módulos, incluindo a localização de um node_modulesdiretório.

Tudo bem, então vamos começar fazendo a distinção entre Javascript em um navegador da Web e Javascript em um servidor (CommonJS e Node).

Javascript é uma linguagem tradicionalmente confinada a um navegador da Web com um contexto global limitado, definido principalmente pelo que ficou conhecido como DOM (Document Object Model) nível 0 (a API Javascript do Netscape Navigator).

O Javascript do servidor elimina essa restrição e permite que o Javascript chame em várias partes do código nativo (como a biblioteca do Postgres) e abra soquetes.

Agora require()é uma chamada de função especial definida como parte da especificação CommonJS. No nó, resolve bibliotecas e módulos no caminho de pesquisa do Nó, agora geralmente definido como node_modulesno mesmo diretório (ou no diretório do arquivo javascript chamado) ou no caminho de pesquisa em todo o sistema.

Para tentar responder ao restante da sua pergunta, precisamos usar um proxy entre o código em execução no navegador e no servidor de banco de dados.

Como estamos discutindo o Node e você já conhece como executar uma consulta a partir daí, faria sentido usar o Node como esse proxy.

Como exemplo simples, criaremos um URL que retorne alguns fatos sobre um Beatle, com um nome, como 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');

É usado para carregar módulos. Vamos usar um exemplo simples.

No arquivo 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;
    }
}

Podemos usar isso via require, como:

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

O require()método é usado para carregar e armazenar em cache módulos JavaScript. Portanto, se você deseja carregar um módulo JavaScript relativo local em um aplicativo Node.js., você pode simplesmente usar orequire() método

Exemplo:

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

Notei que, enquanto as outras respostas explicam o que é necessário e que é usado para carregar módulos no Nó, elas não deram uma resposta completa sobre como carregar os módulos do nó ao trabalhar no Navegador.

É bem simples de fazer. Instale seu módulo usando o npm como você descreve, e o próprio módulo estará localizado em uma pasta geralmente chamada node_modules.

Agora, a maneira mais simples de carregá-lo no seu aplicativo é referenciá-lo do seu html com uma tag de script que aponte para esse diretório. ou seja, se o diretório node_modules estiver na raiz do projeto no mesmo nível do seu index.html, você escreveria isso no seu index.html:

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

Todo esse script agora será carregado na página - para que você possa acessar suas variáveis ​​e métodos diretamente.

Existem outras abordagens que são mais amplamente usadas em projetos maiores, como um carregador de módulos como o require.js . Dos dois, eu não usei o Exigir a mim mesmo, mas acho que é considerado por muitas pessoas o caminho a seguir.

Você sabe como quando você executa o JavaScript no navegador, tem acesso a variáveis ​​como "window" ou Math? Você não precisa declarar essas variáveis, elas foram escritas para você usar quando quiser.

Bem, quando você está executando um arquivo no ambiente Node.js., há uma variável que você pode usar. É chamado de "módulo". É um objeto. Possui uma propriedade chamada "exportações". E funciona assim:

Em um arquivo que chamaremos de example.js, você escreve:

example.js

module.exports = "some code";

Agora, você deseja que essa sequência "algum código" em outro arquivo.

Vamos nomear o outro arquivo como otherFile.js

Neste arquivo, você escreve:

otherFile.js

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

Essa instrução require () vai para o arquivo que você coloca dentro dela, encontra os dados armazenados na propriedade module.exports. A parte let str = ... do seu código significa que o que quer que exija a declaração retorna é armazenado na variável str.

Portanto, neste exemplo, o resultado final é que, em otherFile.js, você agora tem isso:

deixe string = "algum código";

• ou -

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

Nota:

o nome do arquivo gravado dentro da instrução require: Se for um arquivo local, deverá ser o caminho do arquivo para example.js. Além disso, a extensão .js é adicionada por padrão, então não precisei escrevê-la.

Você faz algo semelhante ao exigir as bibliotecas node.js., como o Express. No arquivo express.js, há um objeto chamado 'module', com uma propriedade chamada 'export'.

Então, parece algo assim, sob o capô (eu sou um iniciante, alguns desses detalhes podem não ser precisos, mas é para mostrar o conceito:

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 você está exigindo um módulo, ele se parece com isso: const moduleName = require ("module-name");

Se você está exigindo um arquivo local, ele se parece com isso: const localFile = require ("./ path / to / local-file");

(observe o ./ no início do nome do arquivo)

Observe também que, por padrão, a exportação é um objeto. Por exemplo, module.exports = {} Portanto, você pode escrever module.exports.myfunction = () => {} antes de atribuir um valor ao module.exports. Mas você também pode substituir o objeto escrevendo module.exports = "Eu não sou mais um objeto."

Dois tipos de module.exports / exigem:

(veja aqui )

Arquivo de exportação do sabor 1 (misc.js):

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

outro arquivo:

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

Arquivo de exportação Sabor 2 (user.js):

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

outro arquivo:

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