O que é esse JavaScript “require”?

Eu estou tentando obter JavaScript para ler / escrever em um database PostgreSQL. Eu encontrei este projeto no github. Consegui obter o seguinte código de exemplo para ser executado 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 executá-lo em uma página da Web, mas nada pareceu acontecer. Eu verifiquei no console de JavaScript e apenas diz “requer não 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 eu começar a trabalhar no nó, eu tive que fazer o npm install pg . Sobre o que é isso? Eu olhei no diretório e não encontrei um arquivo pg. Onde foi colocado e como o JavaScript o encontra?

require() não faz parte do seu JavaScript padrão. No contexto da sua pergunta e tags, require() é incorporado ao Node.js para carregar os módulos . O conceito é semelhante ao C / Java / Python / [insira mais idiomas aqui] importações ou inclusões.

O conceito de módulos é semelhante a apenas adicionar pequenos pedaços de código JavaScript por meio de tags . Ao contrário de adicionar uma tag , ela não vaza o arquivo para o escopo global. O arquivo tem seu próprio escopo, essencialmente interceptando tudo o que você define nesse arquivo, a menos que você decida expor a funcionalidade. require retorna um valor, dependendo do que o módulo expõe usando exports ou module.exports . Outro post explica como require() funciona em conjunto com as exports .

No seu código, ele carrega o módulo pg , que eu acho que é um driver do PostgreSQL para o NodeJS. A parte onde você faz o npm install pg download do módulo pg do npm (um repository de pacotes para os módulos do NodeJS) e o disponibiliza para o seu projeto via require('pg'); .


Apenas no caso de você estar se perguntando por que eu mencionei "no contexto da sua pergunta", existem bibliotecas de terceiros que também usam uma function chamada require para fazer alguma coisa. É útil identificar qual é qual.

  • RequireJS expõe uma function chamada require , juntamente com define para carregar dependencies antes de executar o código fornecido. A syntax está no formato AMD.

  • O Neuter , que concatena os arquivos js, também expõe uma function chamada require . Este age muito mais perto da import do PHP.

  • Browserify usa require no navegador, permitindo que scripts no navegador sejam gravados no estilo NodeJS (syntax do módulo CommonJS).

Tudo bem, então vamos primeiro começar a fazer 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 veio a ser conhecido como o nível 0 (DOM) do Document Object Model (a API Javascript do Netscape Navigator).

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

Agora require() é uma chamada de function especial definida como parte da especificação CommonJS. No nó, ele resolve bibliotecas e módulos no caminho de pesquisa do Nó, agora geralmente definido como node_modules no mesmo diretório (ou no diretório do arquivo chamado javascript) ou no caminho de pesquisa do 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 database.

Como estamos discutindo o Node e você já está familiarizado com a execução de uma consulta a partir dele, faria sentido usar o Node como proxy.

Como um exemplo simples, vamos criar um URL que retorne alguns fatos sobre um Beatle, dado 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 método require() é usado para carregar e armazenar em cache os módulos JavaScript. Portanto, se você quiser carregar um módulo JavaScript local relativo em um aplicativo Node.js, basta usar o método require() .

Exemplo:

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

Notei que enquanto as outras respostas explicaram o que é require e que ele é usado para carregar módulos no Node, elas não deram uma resposta completa sobre como carregar os módulos do nó ao trabalhar no Browser.

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

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

  

Todo esse script agora será carregado na página – para que você possa acessar suas variables ​​e methods 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 Exigir-me, mas acho que é considerado por muitas pessoas o caminho a percorrer.

Você sabe como quando você está executando JavaScript no navegador, você tem access a variables ​​como “janela” ou matemática? Você não precisa declarar essas variables, elas foram escritas para você usar sempre que 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 object. Tem uma propriedade chamada “exportações”. E funciona assim:

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

example.js

 module.exports = "some code"; 

Agora, você quer esta string “algum código” em outro arquivo.

Vamos nomear o outro arquivo 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, localiza todos os dados que estão armazenados na propriedade module.exports. O let str = … parte do seu código significa que tudo o que requer declaração retorna é armazenado na variável str.

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

deixe string = “algum código”;

Nota:

o nome do arquivo que está escrito dentro da instrução require: Se for um arquivo local, deve 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 bibliotecas node.js, como o Express. No arquivo express.js, existe um object chamado ‘module’, com uma propriedade chamada ‘exports’.

Então, parece algo como essas linhas, sob o capô (eu sou um tanto iniciante, então alguns desses detalhes podem não ser exatos, 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){}){} } }