Menyelam mendalam ke dalam modul VM dalam Node.js

Modul VM ialah modul teras dalam NodeJS, menyokong kaedah yang diperlukan dan mekanisme pengendalian NodeJS Kadangkala kami juga boleh menggunakan templat VM untuk melakukan beberapa perkara istimewa. Artikel ini akan memberi anda pemahaman terperinci tentang modul VM dalam Node saya harap ia akan membantu anda!

Rujukan vm mesin maya | >

Dalam artikel sebelum ini, kami menyebut masalah.

Bagaimanakah rentetan boleh ditukar menjadi JS untuk pelaksanaan?

Kami memperkenalkan dua kaedah secara terperinci, iaitu fungsi eval dan

Fungsi baharu

. Di sini kita perlu menekankan sekali lagi bahawa fungsi yang dicipta oleh pembina tidak membuat penutupan persekitaran semasa Ia sentiasa dicipta dalam persekitaran global, jadi mereka hanya boleh mengakses persekitaran global pada masa jalan. Pembolehubah dan pembolehubah tempatannya sendiri tidak boleh mengakses pembolehubah dalam skop di mana ia dicipta oleh pembina . Ini berbeza daripada menggunakan

Function untuk melaksanakan kod yang mencipta fungsi. Functioneval boleh memperoleh pembolehubah global, jadi ia mungkin masih mempunyai pencemaran berubah-ubah.

ialah prinsip pelaksanaan

global.a = 100; // 挂在到全局对象global上
var b = 200; // this !== global
new Function("console.log(a)")() // 100
new Function("console.log(b)")() // b is not defined

enjin modul

saya akan menerbitkan artikel untuk menerangkannya secara berasingan pada masa hadapan. FunctionFunctionTerdapat penyelesaian lain, yang tidak kami kembangkan secara terperinci dalam artikel lepas, dan itu ialah modul

.

vmmodul vm

Dalam teks di atas, saya telah menekankan satu konsep, iaitu pencemaran pembolehubah.

Ciri VM ialah ia tidak dipengaruhi oleh persekitaran Ia juga boleh dikatakan bahawa ia adalah persekitaran kotak pasir

(Mod kotak pasir menyediakan persekitaran untuk modul dijalankan. tanpa menjejaskan modul lain dan kotak pasir peribadi mereka)

. Kami ingin menekankan di sini bahawa kerana pembolehubah global dalam

Node.js

const vm = require('vm')
global.a = 100;
// 运行在当前环境中[当前作用域]
vm.runInThisContext('console.log(a)'); // 100
// 运行在新的环境中[其他作用域]
vm.runInNewContext('console.log(a)'); // a is not defined

dikongsi di bawah berbilang modul, jadi cuba jangan mentakrifkan atribut dalam global .

Takrifan dalam Demo adalah untuk memudahkan pemahaman. Andaikan kita mempunyai fail 1.js dalam direktori yang sama, dengan

ditakrifkan di dalamnya. Sekarang setelah kami memperkenalkan fail ini

kami dapati bahawa kami tidak mentakrifkan pembolehubah a dalam fail semasa, kami hanya mengaitkan dua fail modul bersama-sama. Inilah yang saya nyatakan di atas, pembolehubah global dalam global.a = 100;Nod dikongsi antara berbilang modul.

requrie(./1);
console.log(a); // 100

Sebabnya ialah dalam persekitaran Nod, terdapat konteks pelaksanaan secara global.

Jadi, boleh mengakses pembolehubah global pada

, tetapi tidak boleh mengakses pembolehubah tersuai. Walau bagaimanapun,

// 模拟一下Node的全局环境
// vm.runInThisContext在当前全局环境执行，但不会产生新函数
- function(exports, module, require, __dirname, __filename){ // ... }
- vm.runInThisContext ...
// vm.runInNewContext在全局环境之外执行
vm.runInNewContext ...

tidak boleh mengakses

dan juga tidak boleh mengakses pembolehubah tersuai Ia wujud dalam konteks pelaksanaan yang baharu. vm.runInThisContextglobalDan kami vm.runInNewContext mencapainya melalui global.

Pelaksanaan require boleh dibahagikan kepada empat langkah berikut. vm.runInThisContext

requireBaca fail yang perlu diimport.

• Selepas membaca fail, masukkan kod ke dalam fungsi.

• tukarkannya kepada sintaks JS melalui

  .

• vm.runInThisContextKod panggilan.

• Andaikan kita kini mempunyai dua fail berikut. Ia adalah

  a.js
dan

b.js

Kita boleh menganalisis logik pelaksanaan import dan eksport melalui empat langkah di atas.

// 文件a通过module.exports导出一个变量，在文件b中使用require进行接收。
// a.js
module.exports = "a"
// b.js
let a = require('./a');
console.log(a); // a

Baca fail.

• Perkenalkan kandungan fail yang perlu diimport ke dalam fail yang perlu diterima, dan ia akan kelihatan seperti ini

  Tetapi dalam bentuk ini, Node tidak boleh menghuraikannya sama sekali, jadi kami Anda perlu meneruskan ke langkah kedua.

  let a = module.exports = "a";

  Ekapsulkan fail baca ke dalam fungsi.

• let a = (function(exports, module, require, __dirname, __filename){
    module.exports = "a";
    return module.exports
  })(...args) // exports, module, require, __dirname, __filename 将五个参数传入

  封装成函数的原因，我们可以参考下面这个例子。

  假设我们现在传入的不是字符串，而是一个函数。

  // a.js
  var a = 100;
  module.exports = function(){}

  这样我们在解析的时候，就会被解析成下面这种格式

  let a = (function(exports, module, require, __dirname, __filename){
    var a = 100;
    module.exports = function(){};
    return module.exports
  })(...args) // exports, module, require, __dirname, __filename 将五个参数传入

  我们导出的是 module.exports，所以在模块文件中定义的变量a，也只属于当前这个执行上下文。

  在解析的时候，变量a 会被放到函数中。真正的实现了 作用域分离。

• vm.runInThisContext 解析成可执行的Js代码

  我们处理过的代码会以字符串的形式存在，所以我们需要通过vm.runInThisContext将字符串进行解析。

• 进行代码调用

  在此之前，我们其实还需要对代码进行调试。

更多node相关知识，请访问：nodejs 教程！！

Atas ialah kandungan terperinci Menyelam mendalam ke dalam modul VM dalam Node.js. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!