nod memerlukan apa maksudnya

memerlukan dalam nod ialah fungsi yang menerima parameter, parameter formal dinamakan id, dan jenisnya ialah String fungsi boleh mengimport modul, fail JSON dan modul boleh diakses daripada; Dieksport daripada "node_modules", "modul tempatan" atau "fail JSON", laluannya adalah untuk pembolehubah "__dirname" atau direktori kerja semasa.

Persekitaran pengendalian tutorial ini: sistem Windows 7, nodejs versi 18.4.0, komputer Dell G3.

Apakah maksud nod memerlukan?

Penggunaan khusus fungsi memerlukan dalam Nodejs

Arahan

Artikel ini merujuk kepada pegawai Node versi dokumen laman web v11.12.0.

Artikel ini terutamanya menganalisis hasil yang diperoleh apabila memerlukan import fail JSON dan js dalam Nodejs Ia juga menyentuh secara ringkas tentang penggunaan modul eksport modul.eksport dan eksport dalam Nodejs.

Pengenalan

Semasa membaca kod sumber webpack, saya melihat baris kod berikut:

const version = require("../package.json").version

Ini membawa kepada kajian keperluan dalam Nodejs.

Pengenalan kepada memerlukan

Dalam dokumentasi Node.js, dokumentasi yang berkaitan untuk memerlukan berada dalam direktori Modul dan kepunyaan bahagian modul Nodejs sistem.

require ialah fungsi. Kesimpulan ini boleh disahkan melalui typeof atau Object.prototype.toString.call():

console.log(require) // 输出：Function
console.log(Object.prototype.toString.call(require) // 输出：[object Function]

Dengan mencetak memerlukan secara langsung, anda boleh mendapati terdapat beberapa sifat statik yang dipasang di bawah fungsi memerlukan ini juga Arahan yang berkaitan boleh didapati terus dalam dokumentasi rasmi Nodejs:

{ [Function: require]
 resolve: { [Function: resolve] paths: [Function: paths] },
 main:
  Module {
   id: '.',
   exports: {},
   parent: null,
   filename: '/Users/bjhl/Documents/webpackSource/index.js',
   loaded: false,
   children: [],
   paths:
   [ '/Users/bjhl/Documents/webpackSource/node_modules',
    '/Users/bjhl/Documents/node_modules',
    '/Users/bjhl/node_modules',
    '/Users/node_modules',
    '/node_modules' ] },
 extensions:
  [Object: null prototype] { '.js': [Function], '.json': [Function], '.node': [Function] },
 cache:
  [Object: null prototype] {
   '/Users/bjhl/Documents/webpackSource/index.js':
   Module {
    id: '.',
    exports: {},
    parent: null,
    filename: '/Users/bjhl/Documents/webpackSource/index.js',
    loaded: false,
    children: [],
    paths: [Array] } } }

memerlukan atribut statik fungsi

akan ditambah secara terperinci kemudian.

memerlukan menggunakan

Anda boleh melihat arahan berikut tentang memerlukan dalam dokumentasi tapak web rasmi:

require(id)# Added in: v0.1.13 nama modul id atau laluan Pengembalian: kandungan modul yang dieksport Digunakan untuk mengimport modul, JSON dan fail tempatan Modul boleh diimport daripada modul tempatan dan fail JSON boleh diimport menggunakan laluan relatif (cth. ./, ./foo, ./bar/baz, ../foo) yang akan diselesaikan terhadap direktori yang dinamakan oleh __dirname (jika ditakrifkan) atau direktori kerja semasa

Pada masa yang sama, tiga kaedah penggunaan memerlukan diberikan:

// Importing a local module:
const myLocalModule = require('./path/myLocalModule');

// Importing a JSON file:
const jsonData = require('./path/filename.json');

// Importing a module from node_modules or Node.js built-in module:
const crypto = require('crypto');

Daripada dokumen di atas, maklumat berikut boleh diambil:

• require menerima satu Parameter, parameter formal dinamakan id dan jenisnya ialah String.

• Fungsi require mengembalikan kandungan di mana-mana dalam modul, dan jenisnya adalah sewenang-wenangnya.

• memerlukan fungsi boleh mengimport modul, fail JSON dan fail setempat. Modul boleh dieksport daripada node_modules, modul tempatan, fail JSON melalui laluan relatif terhadap pembolehubah __dirname (jika ditakrifkan) atau direktori kerja semasa.

memerlukan latihan

Di sini kita akan membincangkan kesimpulan praktikal keperluan dalam kategori.

memerlukan import JSON

JSON ialah sintaks untuk mensiri objek, tatasusunan, nombor, rentetan, boolean dan null .

Pada permulaan artikel, telah disebutkan bahawa atribut versi dalam fail package.json dibaca melalui fail require("./package.json"). Di sini kami akan cuba mengimport fail info.json dan melihat maklumat berkaitan.

Direktori struktur fail adalah seperti berikut:

.
├── index.js
└── info.json

Ubah suai kandungan fail info.json kepada:

{
  "name": "myInfo",
  "hasFriend": true,
  "salary": null,
  "version": "v1.0.0",
  "author": {
    "nickname": "Hello Kitty",
    "age": 20,
    "friends": [
      {
        "nickname": "snowy",
        "age": 999
      }
    ]
  }
}

Dalam info.json, ia mengandungi rentetan, boolean, nol, nombor, objek dan tatasusunan.

Ubah suai kandungan index.js seperti berikut dan jalankan nod arahan index.js dalam terminal semasa dan dapatkan keputusan berikut:

const info = require("./info.json")
console.log(Object.prototype.toString.call(info)) // [object Object]
console.log(info.version) // v1.0.0
console.log(info.hasFriend) // true
console.log(info.salary) // null
console.log(info.author.nickname) // Hello Kitty
console.log(info.author.friends) // [ { nickname: 'snowy', age: 999 } ]

Seperti yang anda lihat, apabila memerlukan mengimport fail JSON, Objek dikembalikan dan Nodejs boleh mengakses terus semua sifat dalam objek ini, termasuk String, Boolean, Number, Null, Object dan Array. Tekaan peribadi saya ialah kaedah yang serupa dengan JSON.parse() boleh digunakan di sini.

Melalui kesimpulan ini, kami juga mendapat idea, iaitu menghantar dalam fail JSON melalui kaedah memerlukan untuk membaca nilai tertentu Contohnya, pada permulaan artikel, webpack memperoleh nilai versi dengan membaca fail package.json .

memerlukan import fail js tempatan

Direktori struktur fail adalah seperti berikut:

.
├── index.js
├── module_a.js
└── module_b.js

fail index.js, importnya dalam urutan Modul_a dan module_b diberikan dan diberi nilai, dan kemudian kedua-dua pembolehubah dicetak adalah seperti berikut:

console.log("*** index.js开始执行 ***")
const module_a = require("./module_a")
const module_b = require("./module_b")
console.log(module_a, "*** 打印module_a ***")
console.log(module_b, "*** 打印module_b ***")
console.log("*** index.js结束执行 ***")

Dalam fail module_a, module.exports atau exports tidak dinyatakan, tetapi satu. set pernyataan pelaksanaan tak segerakMasa tamat ditambah, kandungannya adalah seperti berikut :

console.log("** module_a开始执行 **")
let name = "I'm module_a"
setTimeout(() => {
  console.log(name, "** setTimeout打印a的名字 **")
}, 0)
console.log("** module_a结束执行 **")

Dalam fail module_b, module.exports ditentukan (ia juga boleh digantikan dengan exports.name, tetapi eksport tidak boleh digunakan terus ke sama dengan objek, kerana eksport dan module.exports sebenarnya menghala ke alamat , merujuk objek yang sama, jika eksport adalah sama dengan jenis rujukan lain, ia tidak akan menghala ke module.exports lagi dan kandungan dalam module.exports tidak boleh diubah ), kandungannya adalah seperti berikut:

console.log("** module_b开始执行 **")
let name = "I'm module_b"
console.log(name, "** 打印b的名字 **")
module.exports = {
  name
}
console.log("** module_b结束执行 **")

dalam terminal direktori semasa Jalankan node index.js dan dapatkan output berikut:

*** index.js开始执行 ***
** module_a开始执行 **
** module_a结束执行 **
** module_b开始执行 **
I am module_b ** 打印b的名字 **
** module_b结束执行 **
{} '*** 打印module_a ***'
{ name: 'I am module_b' } '*** 打印module_b ***'
*** index.js结束执行 ***
I am module_a ** setTimeout打印a的名字 **

通过以上执行结果可以得出结论：

• require某个js文件时，如果未通过exports或者module.exports指定导出内容，则require返回的结果是一个空对象；反之可以通过module.export或者给exports属性赋值来导出指定内容。

• require某个js文件时，该文件会立即sync执行。

require导入模块

我们先选择一个npm包——cors。 进入文件夹，运行一下命令：

npm init -y // 初始化
echo -e "let cors = require(\"cors\")\nconsole.log(cors)" > index.js // 生成index.js文件
npm install cors --save // 安装cors包

文件结构如下(...处省略了其他的模块):

.
├── index.js
├── node_modules
│  ├── cors
│  │  ├── CONTRIBUTING.md
│  │  ├── HISTORY.md
│  │  ├── LICENSE
│  │  ├── README.md
│  │  ├── lib
│  │  │  └── index.js
│  │  └── package.json
│  │  ...
├── package-lock.json
└── package.json

index.js中的内容如下：

let cors = require("cors")
console.log(cors)

运行 node index.js ，得出以下结果：

[Function: middlewareWrapper]

找到node_modules下的cors模块文件夹，观察cros模块中的package.json文件，找到main字段： "main": "./lib/index.js" ，找到main字段指向的文件，发现这是一个IIFE，在IIFE中的代码中添加，console.log("hello cors")，模拟代码结构如下：

(function () {
  'use strict';
  console.log("hello cors"); // 这是手动添加的代码
  ...
  function middlewareWrapper(o) {
    ...
  }
  module.exports = middlewareWrapper;
})()

再次运行 node index.js ，得出以下结果：

hello cors
[Function: middlewareWrapper]

为什么会打印出 hello cors 呢？因为require模块的时候，引入的是该模块package.json文件中main字段指向的文件。而这个js文件会自动执行，跟require引用本地js文件是相同的。

packjson文档

在npm的官方网站中可以找到关于package.json中的main字段定义。

main   The main field is a module ID that is the primary entry point to your program. That is, if your package is named foo, and a user installs it, and then does require("foo"), then your main module's exports object will be returned.   This should be a module ID relative to the root of your package folder   For most modules, it makes the most sense to have a main script and often not much else.

在以上说明中可以得出以下结论：

• main字段是一个模块ID，是程序的主入口。

• 当使用require("xxx")的时候，导入的是main字段对应的js文件里的module.exports。

所以require导入模块的时候，是运行的对应模块package.json中main字段指定的文件。

推荐学习：《node视频教程》

Atas ialah kandungan terperinci nod memerlukan apa maksudnya. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!