Question

我正在尝试使用Javascript来读取/写入PostgreSQL数据库。我在github上找到了这个project。我能够获得以下示例代码以在节点中运行。

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

接下来我尝试让它在网页上运行，但似乎没有任何事情发生。我检查了Javascript控制台，它只是说“要求没有定义。”

那么“需要什么？”为什么它在节点中工作而在网页中不起作用？

此外，在我让它在节点中工作之前，我必须做npm install pg。那是什么意思？我查看了目录，但没找到文件pg。它把它放在哪里，Javascript如何找到它？

Answer 1

那么“需要什么？”

require()不是标准JavaScript API的一部分。但是在Node.js中，它是一个具有特殊用途的内置函数：to load modules。

模块是一种将应用程序拆分为单独文件的方法，而不是将所有应用程序放在一个文件中。这个概念也存在于其他语言中，在语法和行为方面存在细微差别，例如C include，PHP use，Python import等等。

Node.js模块和浏览器JavaScript之间的一个重要区别是如何从另一个脚本的代码访问一个脚本的代码。

在浏览器JavaScript中，脚本通过<script>元素添加。当它们执行时，它们都可以直接访问全局范围，即所有脚本中的“共享空间”。任何脚本都可以在全局范围内自由定义/修改/删除/调用任何内容。
在Node.js中，每个模块都有自己的范围。模块不能直接访问另一个模块中定义的内容，除非它选择公开它们。要从模块中公开内容，必须将它们分配到exports或module.exports。要使模块访问其他模块的exports或module.exports，，必须使用require() 。

在您的代码中，var pg = require('pg');加载pg模块，Node.js的PostgreSQL客户端。这允许您的代码通过pg变量访问PostgreSQL客户端API的功能。

为什么它在节点中有效但在网页中却无效？

require()，module.exports和exports是特定于Node.js的模块系统的API。浏览器不实现此模块系统。

另外，在我让它在节点中工作之前，我不得不做npm install pg。那是什么意思？

NPM是一个包存储JavaScript模块的包存储库服务。 npm install是一个允许您从其存储库下载包的命令。

它把它放在哪里，以及Javascript如何找到它？

Node.js有关于how modules find other modules的非常详细的文档。但在一个要点中，它将所有下载的模块放在node_modules的{{1}}目录中。{/ p>

Answer 2

好吧，让我们首先区分Web浏览器中的Javascript 和服务器上的Javascript （CommonJS和Node）。

Javascript是一种传统上局限于Web浏览器的语言，它具有有限的全局上下文，主要由所谓的文档对象模型（DOM）级别0（Netscape Navigator Javascript API）定义。

服务器端Javascript消除了这种限制，允许Javascript调用各种本机代码（如Postgres库）并打开套接字。

现在require()是一个特殊的函数调用，被定义为CommonJS规范的一部分。在节点中，它解析节点搜索路径中的库和模块，现在通常在同一目录（或调用的javascript文件的目录）或系统范围的搜索路径中定义为node_modules。

要尝试回答您的其余问题，我们需要在浏览器中运行的代码与数据库服务器之间使用代理。

由于我们正在讨论Node，并且您已经熟悉如何从那里运行查询，因此将Node用作该代理是有意义的。

作为一个简单的例子，我们将创建一个URL，该URL返回一些关于披头士的事实，给定一个名称，作为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');

Answer 3

它用于加载模块。让我们用一个简单的例子。

在档案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;
    }
}

我们可以通过require使用此功能，例如：

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

require()方法用于加载和缓存JavaScript模块。因此，如果要将本地相对JavaScript模块加载到Node.js应用程序中，只需使用require()方法即可。

示例：

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

Answer 4

我注意到，虽然其他答案解释了需求是什么，并且它用于在Node中加载模块，但他们没有给出关于如何在浏览器中工作时加载节点模块的完整答复。

这很简单。如您所述，使用npm安装模块，模块本身将位于通常称为node_modules的文件夹中。

现在将其加载到您的应用中的最简单方法是使用指向此目录的脚本标记从您的html引用它。即如果你的node_modules目录位于与index.html相同级别的项目根目录中，你可以在index.html中写这个：

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

现在整个脚本将被加载到页面中 - 因此您可以直接访问其变量和方法。

在大型项目中还有其他更广泛使用的方法，例如像require.js这样的模块加载器。在这两个中，我没有使用过需要自己，但我认为很多人都认为这样做了。

Answer 5

不断创新。
恕我直言，现有的答案有很多不足之处。

非常简单：
Require只是一个（非标准）函数defined at global scope。
（浏览器中的窗口，NodeJS中的全局窗口）。

现在，要回答“需要什么”这个问题，我们“仅”需要知道此功能的作用。
最好用代码解释一下。

这是simple implementation by Michele Nasti，您可以找到on his github page的代码。

基本上，我们将我们的minimalisc需求函数称为myRequire：

function myRequire(name) 
{
    console.log(`Evaluating file ${name}`);
    if (!(name in myRequire.cache)) {
        console.log(`${name} is not in cache; reading from disk`);
        let code = fs.readFileSync(name, 'utf8');
        let module = { exports: {} };
        myRequire.cache[name] = module;
        let wrapper = Function("require, exports, module", code);
        wrapper(myRequire, module.exports, module);
    }
    console.log(`${name} is in cache. Returning it...`);
    return myRequire.cache[name].exports;
}
myRequire.cache = Object.create(null);
window.require = myRequire;
const stuff = window.require('./main.js');
console.log(stuff);

现在您注意到，这里使用了对象“ fs”。
为了简单起见，Michele刚刚导入了NodeJS fs模块：

const fs = require('fs');

不需要。
因此，在浏览器中，您可以使用SYNCHRONOUS XmlHttpRequest来实现require的简单实现：

const fs = {
    file: `
    // module.exports = \"Hello World\";
        
    module.exports = function(){ return 5*3;};
    
    `
    , getFile(fileName: string, encoding: string): string
    {
        // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Synchronous_and_Asynchronous_Requests
        let client = new XMLHttpRequest();
        // client.setRequestHeader("Content-Type", "text/plain;charset=UTF-8");

        // open(method, url, async)
        client.open("GET", fileName, false);
        client.send();
        if (client.status === 200)
            return client.responseText;

        return null;
    }


    , readFileSync: function (fileName: string, encoding: string): string
    {
        // this.getFile(fileName, encoding);
        return this.file; // Example, getFile would fetch this file 
    }
};

因此，基本上要做的是下载一个JavaScript文件，并将其评估为具有全局参数“ require”，“ exports”和“ module”的匿名命名空间（aka Function），并返回导出，即对象的公共功能和属性。

请注意，此评估是递归的：您需要文件，而文件本身也可能需要文件。

这样，模块中使用的所有“全局”变量都是require-wrapper-function命名空间中的变量，并且不会用不需要的变量来污染全局范围。

此外，通过这种方式，您可以重复使用代码而无需依赖名称空间，因此可以在JavaScript中获得“模块化”。用引号括起来的“模块化”，因为这并不完全正确，因为您仍然可以编写window.bla，因此仍然污染了全局范围... 公共职能，公共职能是出口。

现在不用说了

module.exports = function(){ return 5*3;};

您也可以说：

function privateSomething()
{
    return 42:
}


function privateSomething2()
{
    return 21:
}


module.exports = {
      getRandomNumber: privateSomething
     ,getHalfRandomNumber: privateSomething2
};

并返回一个对象。

此外，因为您的模块在带有参数的函数中求值 “ require”，“ exports”和“ module”，您的模块可以使用未声明的变量“ require”，“ exports”和“ module”，这些变量一开始可能会令人吃惊。当然，require参数有一个ByVal指针，该指针指向保存到变量中的require函数。
酷吧？
这样看来，要求放松其魔力，并变得简单。
现在，真正的require函数将进行更多的检查和怪癖，但这就是其本质。

此外，在2020年，您应该使用ECMA实现，而不是要求：

import defaultExport from "module-name";
import * as name from "module-name";
import { export1 } from "module-name";
import { export1 as alias1 } from "module-name";
import { export1 , export2 } from "module-name";
import { foo , bar } from "module-name/path/to/specific/un-exported/file";
import { export1 , export2 as alias2 , [...] } from "module-name";
import defaultExport, { export1 [ , [...] ] } from "module-name";
import defaultExport, * as name from "module-name";
import "module-name";

如果您需要动态非静态导入（例如，基于浏览器类型加载polyfill），则可以使用ECMA导入功能/关键字：

var promise = import("module-name");

请注意，导入不像require那样是同步的。
相反，导入是一种承诺，所以

var something = require("something");

成为

var something = await import("something");

因为导入返回一个承诺（异步）。

因此，基本上，与要求不同，导入将fs.readFileSync替换为fs.readFileAsync。

async readFileAsync(fileName, encoding) 
{
    const textDecoder = new TextDecoder(encoding);
    // textDecoder.ignoreBOM = true;
    const response = await fetch(fileName);
    console.log(response.ok);
    console.log(response.status);
    console.log(response.statusText);
    // let json = await response.json();
    // let txt = await response.text();
    // let blo:Blob = response.blob();
    // let ab:ArrayBuffer = await response.arrayBuffer();
    // let fd = await response.formData()
    // Read file almost by line
    // https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader/read#Example_2_-_handling_text_line_by_line
    let buffer = await response.arrayBuffer();
    let file = textDecoder.decode(buffer);
    return file;
} // End Function readFileAsync

这当然也要求导入功能也要异步。

"use strict";
async function myRequireAsync(name) {
    console.log(`Evaluating file ${name}`);
    if (!(name in myRequireAsync.cache)) {
        console.log(`${name} is not in cache; reading from disk`);
        let code = await fs.readFileAsync(name, 'utf8');
        let module = { exports: {} };
        myRequireAsync.cache[name] = module;
        let wrapper = Function("asyncRequire, exports, module", code);
        await wrapper(myRequireAsync, module.exports, module);
    }
    console.log(`${name} is in cache. Returning it...`);
    return myRequireAsync.cache[name].exports;
}
myRequireAsync.cache = Object.create(null);
window.asyncRequire = myRequireAsync;
async () => {
    const asyncStuff = await window.asyncRequire('./main.js');
    console.log(asyncStuff);
};

更好，对吧？
是的，除了没有ECMA方式可以动态地同步导入（无承诺）。

现在，要了解其影响，如果您不知道那是什么，您绝对可以read up on promises/async-await here。

但是很简单，如果一个函数返回一个promise，它可以被“等待”：

function sleep (fn, par) 
{
  return new Promise((resolve) => {
    // wait 3s before calling fn(par)
    setTimeout(() => resolve(fn(par)), 3000)
  })
}


var fileList = await sleep(listFiles, nextPageToken)

这是使异步代码看起来同步的好方法。
请注意，如果要在函数中使用异步等待，则必须将该函数声明为异步。

async function doSomethingAsync()
{
    var fileList = await sleep(listFiles, nextPageToken)
}

另外请注意，在JavaScript中，无法从同步函数（您知道的函数）调用（阻塞地）调用异步函数。因此，如果您要使用await（也称为ECMA导入），则所有代码都需要异步，如果所有内容还不是异步的，则很可能是个问题...

这种简化的require实现失败的例子是，当您需要一个无效JavaScript的文件时，例如当您需要CSS，HTML，TXT，SVG和图像或其他二进制文件时。
而且很容易明白为什么：
如果您例如将HTML放入JavaScript函数体中，您当然可以正确地得到

SyntaxError: Unexpected token '<'

因为Function("bla", "<doctype...")

现在，如果您想将其扩展到例如包括非模块，则只需使用code.indexOf("module.exports") == -1检查下载的文件内容，然后例如。 eval（“ jquery content”）代替Func（只要您在浏览器中就可以正常工作）。由于使用Fetch / XmlHttpRequests进行的下载遵循相同的原产地策略，并且SSL / TLS确保了完整性，因此，在将JS文件添加到站点之前检查了它们的情况下，在此处使用eval是相当无害的，但是很多应该是标准操作程序。

请注意，有几种类似需求的功能的实现：

the CommonJS (CJS) format使用require函数和module.exports定义依赖项和模块。 npm生态系统基于此格式构建。（这是上面实现的）
the Asynchronous Module Definition (AMD) format使用define函数定义模块。
the ES Module (ESM) format。从ES6（ES2015）开始，JavaScript支持本机模块格式。它使用export关键字导出模块的公共API，并使用import关键字导入模块。
the System.register format，旨在支持ES5中的ES6模块。
the Universal Module Definition (UMD) format，与在浏览器和Node.js中使用的所有上述格式兼容。如果您编写可在NodeJS和浏览器中使用的模块，则特别有用。

Answer 6

您知道在浏览器中运行JavaScript时，您可以访问“window”或Math等变量吗？您无需声明这些变量，它们已经编写，您可以随时使用。

好吧，当您在Node.js环境中运行文件时，您可以使用一个变量。它被称为“模块”它是一个对象。它有一个叫做“出口”的房产。它的工作原理如下：

在我们将命名为example.js的文件中，您写道：

example.js

module.exports = "some code";

现在，您希望在另一个文件中使用此字符串“some code”。

我们将其他文件命名为otherFile.js

在此文件中，您写道：

otherFile.js

let str = require('example.js')

require（）语句转到你放在其中的文件，找到存储在module.exports属性上的任何数据。 let str = ...代码的一部分表示无论require索引返回的是什么，都存储在str变量中。

所以，在这个例子中，最终结果是在otherFile.js中你现在有了这个：

让string =“some code”;

或 -

让str =（'。/ example.js'）。module.exports

注意：

在require语句中写入的文件名：如果是本地文件，则它应该是example.js的文件路径。此外，默认情况下会添加.js扩展名，因此我不必编写它。

在需要node.js库（例如Express）时，您会执行类似的操作。在express.js文件中，有一个名为“module”的对象，其属性名为“exports”。

所以，它看起来就像沿着这些线，在引擎盖下（我有点像初学者，所以这些细节可能不准确，但它是为了展示这个概念：

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

如果您需要模块，它看起来像这样： const moduleName = require（“module-name”）;

如果您需要本地文件，它看起来像这样： const localFile = require（“./ local-file”）;

（注意文件名开头的./）

Answer 7

module.exports的两种样式/要求：

（请参阅here）

风味1
导出文件（misc.js）：

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

其他文件：

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

风味2
导出文件（user.js）：

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

其他文件：

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

这个Javascript“需要”是什么？

7 个答案: