精华内容
下载资源
问答
  • 利用MTS815材料试验机和12 CHs PCI-2声发射信号采集系统,对砂岩在等幅循环加载和分级循环加载条件下损伤破坏全过程的声发射规律进行了研究,探讨了Kaiser效应与Felicity效应,以及Felicity效应声发射中"明显增多"的...
  • 循环加载二维码 保存页面 获得所有二维码图片
  • 循环加载”(circular dependency)指的是,a脚本的执行依赖b脚本,而b脚本的执行又依赖a脚本。 // a.js var b = require('b'); // b.js var a = require('a'); 通常,”循环加载”表示存在强耦合,如果处理不好...
  • 循环加载模块 假设你有两个文件,a.py和b.py,在这两个文件中互相加载对方,例如: 在a.py中: import b def f(): return b.x print f() 在b.py中: import a x = 1 def g(): print a.f() 首先,我们试着加载a.py...
  • 循环加载和分级加载条件下岩石损伤破坏全过程的声发射规律和频谱特性进行了研究。结果表明,声发射与载荷变化或岩体变形破裂密切相关。循环加载过程中当载荷超过前期最大值时声发射信号增强,卸载阶段声发射信号随...
  • 为了研究循环加载条件下岩石的变形演化规律,开展了红砂岩试件的等幅循环加载与分级等幅循环加载试验。采用CCD相机对试验过程中试件的变形图像进行采集,基于数字散斑相关方法分析了等幅循环加载过程中试件的非均匀...
  • es6 循环加载ES6模块

    2018-02-05 20:19:52
    循环加载ES6模块 “循环加载”(circular dependency)指的是,a脚本的执行依赖b脚本,而b脚本的执行又依赖a脚本。 // a.jsvar b = require('b');// b.jsvar a = require('a'); 通常,“循环加载”表示存在强...

    循环加载ES6模块

    “循环加载”(circular dependency)指的是,a脚本的执行依赖b脚本,而b脚本的执行又依赖a脚本。

    1. // a.js
    2. var b = require('b');
    3. // b.js
    4. var a = require('a');

    通常,“循环加载”表示存在强耦合,如果处理不好,还可能导致递归加载,使得程序无法执行,因此应该避免出现。

    但是实际上,这是很难避免的,尤其是依赖关系复杂的大项目,很容易出现a依赖bb依赖cc又依赖a这样的情况。这意味着,模块加载机制必须考虑“循环加载”的情况。

    对于 JavaScript 语言来说,目前最常见的两种模块格式 CommonJS 和 ES6,处理“循环加载”的方法是不一样的,返回的结果也不一样。

    CommonJS模块的加载原理

    介绍 ES6 如何处理“循环加载”之前,先介绍目前最流行的 CommonJS模块格式的加载原理。

    CommonJS 的一个模块,就是一个脚本文件。require命令第一次加载该脚本,就会执行整个脚本,然后在内存生成一个对象。

    1. {
    2. id: '...',
    3. exports: { ... },
    4. loaded: true,
    5. ...
    6. }

    上面代码就是 Node 内部加载模块后生成的一个对象。该对象的id属性是模块名,exports属性是模块输出的各个接口,loaded属性是一个布尔值,表示该模块的脚本是否执行完毕。其他还有很多属性,这里都省略了。

    以后需要用到这个模块的时候,就会到exports属性上面取值。即使再次执行require命令,也不会再次执行该模块,而是到缓存之中取值。也就是说,CommonJS模块无论加载多少次,都只会在第一次加载时运行一次,以后再加载,就返回第一次运行的结果,除非手动清除系统缓存。

    CommonJS模块的循环加载

    CommonJS模块的重要特性是加载时执行,即脚本代码在require的时候,就会全部执行。一旦出现某个模块被"循环加载",就只输出已经执行的部分,还未执行的部分不会输出。

    让我们来看,Node官方文档里面的例子。脚本文件a.js代码如下。

    1. exports.done = false;
    2. var b = require('./b.js');
    3. console.log('在 a.js 之中,b.done = %j', b.done);
    4. exports.done = true;
    5. console.log('a.js 执行完毕');

    上面代码之中,a.js脚本先输出一个done变量,然后加载另一个脚本文件b.js。注意,此时a.js代码就停在这里,等待b.js执行完毕,再往下执行。

    再看b.js的代码。

    1. exports.done = false;
    2. var a = require('./a.js');
    3. console.log('在 b.js 之中,a.done = %j', a.done);
    4. exports.done = true;
    5. console.log('b.js 执行完毕');

    上面代码之中,b.js执行到第二行,就会去加载a.js,这时,就发生了“循环加载”。系统会去a.js模块对应对象的exports属性取值,可是因为a.js还没有执行完,从exports属性只能取回已经执行的部分,而不是最后的值。

    a.js已经执行的部分,只有一行。

    1. exports.done = false;

    因此,对于b.js来说,它从a.js只输入一个变量done,值为false

    然后,b.js接着往下执行,等到全部执行完毕,再把执行权交还给a.js。于是,a.js接着往下执行,直到执行完毕。我们写一个脚本main.js,验证这个过程。

    1. var a = require('./a.js');
    2. var b = require('./b.js');
    3. console.log('在 main.js 之中, a.done=%j, b.done=%j', a.done, b.done);

    执行main.js,运行结果如下。

    1. $ node main.js
    2. b.js 之中,a.done = false
    3. b.js 执行完毕
    4. a.js 之中,b.done = true
    5. a.js 执行完毕
    6. main.js 之中, a.done=true, b.done=true

    上面的代码证明了两件事。一是,在b.js之中,a.js没有执行完毕,只执行了第一行。二是,main.js执行到第二行时,不会再次执行b.js,而是输出缓存的b.js的执行结果,即它的第四行。

    1. exports.done = true;

    总之,CommonJS 输入的是被输出值的拷贝,不是引用。

    另外,由于 CommonJS模块遇到循环加载时,返回的是当前已经执行的部分的值,而不是代码全部执行后的值,两者可能会有差异。所以,输入变量的时候,必须非常小心。

    1. var a = require('a'); // 安全的写法
    2. var foo = require('a').foo; // 危险的写法
    3. exports.good = function (arg) {
    4. return a.foo('good', arg); // 使用的是 a.foo 的最新值
    5. };
    6. exports.bad = function (arg) {
    7. return foo('bad', arg); // 使用的是一个部分加载时的值
    8. };

    上面代码中,如果发生循环加载,require('a').foo的值很可能后面会被改写,改用require('a')会更保险一点。

    ES6模块的循环加载

    ES6 处理“循环加载”与 CommonJS 有本质的不同。ES6模块是动态引用,如果使用import从一个模块加载变量(即import foo from 'foo'),那些变量不会被缓存,而是成为一个指向被加载模块的引用,需要开发者自己保证,真正取值的时候能够取到值。

    请看下面这个例子。

    1. // a.mjs
    2. import {bar} from './b';
    3. console.log('a.mjs');
    4. console.log(bar);
    5. export let foo = 'foo';
    6. // b.mjs
    7. import {foo} from './a';
    8. console.log('b.mjs');
    9. console.log(foo);
    10. export let bar = 'bar';

    上面代码中,a.mjs加载b.mjsb.mjs又加载a.mjs,构成循环加载。执行a.mjs,结果如下。

    1. $ node --experimental-modules a.mjs
    2. b.mjs
    3. ReferenceError: foo is not defined

    上面代码中,执行a.mjs以后会报错,foo变量未定义,这是为什么?

    让我们一行行来看,ES6 循环加载是怎么处理的。首先,执行a.mjs以后,引擎发现它加载了b.mjs,因此会优先执行b.mjs,然后再执行a.js。接着,执行b.mjs的时候,已知它从a.mjs输入了foo接口,这时不会去执行a.mjs,而是认为这个接口已经存在了,继续往下执行。执行到第三行console.log(foo)的时候,才发现这个接口根本没定义,因此报错。

    解决这个问题的方法,就是让b.mjs运行的时候,foo已经有定义了。这可以通过将foo写成函数来解决。

    1. // a.mjs
    2. import {bar} from './b';
    3. console.log('a.mjs');
    4. console.log(bar());
    5. function foo() { return 'foo' }
    6. export {foo};
    7. // b.mjs
    8. import {foo} from './a';
    9. console.log('b.mjs');
    10. console.log(foo());
    11. function bar() { return 'bar' }
    12. export {bar};

    这时再执行a.mjs就可以得到预期结果。

    1. $ node --experimental-modules a.mjs
    2. b.mjs
    3. foo
    4. a.mjs
    5. bar

    这是因为函数具有提升作用,在执行import {bar} from './b'时,函数foo就已经有定义了,所以b.mjs加载的时候不会报错。这也意味着,如果把函数foo改写成函数表达式,也会报错。

    1. // a.mjs
    2. import {bar} from './b';
    3. console.log('a.mjs');
    4. console.log(bar());
    5. const foo = () => 'foo';
    6. export {foo};

    上面代码的第四行,改成了函数表达式,就不具有提升作用,执行就会报错。

    我们再来看 ES6模块加载器SystemJS给出的一个例子。

    1. // even.js
    2. import { odd } from './odd'
    3. export var counter = 0;
    4. export function even(n) {
    5. counter++;
    6. return n === 0 || odd(n - 1);
    7. }
    8. // odd.js
    9. import { even } from './even';
    10. export function odd(n) {
    11. return n !== 0 && even(n - 1);
    12. }

    上面代码中,even.js里面的函数even有一个参数n,只要不等于 0,就会减去 1,传入加载的odd()odd.js也会做类似操作。

    运行上面这段代码,结果如下。

    1. $ babel-node
    2. > import * as m from './even.js';
    3. > m.even(10);
    4. true
    5. > m.counter
    6. 6
    7. > m.even(20)
    8. true
    9. > m.counter
    10. 17

    上面代码中,参数n从 10 变为 0 的过程中,even()一共会执行 6 次,所以变量counter等于 6。第二次调用even()时,参数n从 20 变为 0,even()一共会执行 11 次,加上前面的 6 次,所以变量counter等于 17。

    这个例子要是改写成 CommonJS,就根本无法执行,会报错。

    1. // even.js
    2. var odd = require('./odd');
    3. var counter = 0;
    4. exports.counter = counter;
    5. exports.even = function (n) {
    6. counter++;
    7. return n == 0 || odd(n - 1);
    8. }
    9. // odd.js
    10. var even = require('./even').even;
    11. module.exports = function (n) {
    12. return n != 0 && even(n - 1);
    13. }

    上面代码中,even.js加载odd.js,而odd.js又去加载even.js,形成“循环加载”。这时,执行引擎就会输出even.js已经执行的部分(不存在任何结果),所以在odd.js之中,变量even等于null,等到后面调用even(n-1)就会报错。

    1. $ node
    2. > var m = require('./even');
    3. > m.even(10)
    4. TypeError: even is not a function
    展开全文
  • 为了研究循环加载对煤能量聚集和释放的影响,对煤样进行单轴压缩循环加载实验,分析得出循环次数与弹性模量大致呈正相关关系;随着循环次数的增加,弹性应变能大致呈增加趋势,塑性应变能呈减少趋势。同时,随着循环次数的...
  • 为了研究循环加载条件下瓦斯对煤体破坏表面电位的影响,搭建了含瓦斯煤受载破坏表面电位实验系统,测试并分析了不同瓦斯压力条件下,煤体循环加载破坏产生表面电位信号的特征规律,探讨了有瓦斯参与情况下煤体受载破坏的...
  • 研究了循环加载条件下煤岩受载破坏过程的电磁辐射变化特征规律,并分析了其产生的机理。研究结果表明:煤岩单轴循环加载过程中,电磁辐射信号参量变化随着循环载荷的增加基本上呈线性增大;在加卸载过程中,电磁辐射信号...
  • "循环加载"(circular dependency)指的是,a脚本的执行依赖b脚本,而b脚本的执行又依赖a脚本。// a.jsvar b = require('b');// b.jsvar a = require('a');通常,"循环加载"表示存在强耦合,如果处理不好,还可能导致...

    "循环加载"(circular dependency)指的是,a脚本的执行依赖b脚本,而b脚本的执行又依赖a脚本。

    // a.js

    var b = require('b');

    // b.js

    var a = require('a');

    通常,"循环加载"表示存在强耦合,如果处理不好,还可能导致递归加载,使得程序无法执行,因此应该避免出现。

    但是实际上,这是很难避免的,尤其是依赖关系复杂的大项目,很容易出现a依赖b,b依赖c,c又依赖a这样的情况。这意味着,模块加载机制必须考虑"循环加载"的情况。

    本文介绍JavaScript语言如何处理"循环加载"。目前,最常见的两种模块格式CommonJS和ES6,处理方法是不一样的,返回的结果也不一样。

    一、CommonJS模块的加载原理

    介绍ES6如何处理"循环加载"之前,先介绍目前最流行的CommonJS模块格式的加载原理。

    CommonJS的一个模块,就是一个脚本文件。require命令第一次加载该脚本,就会执行整个脚本,然后在内存生成一个对象。

    {

    id: '...',

    exports: { ... },

    loaded: true,

    ...

    }

    上面代码中,该对象的id属性是模块名,exports属性是模块输出的各个接口,loaded属性是一个布尔值,表示该模块的脚本是否执行完毕。其他还有很多属性,这里都省略了。(详细介绍情参见《require() 源码解读》。)

    以后需要用到这个模块的时候,就会到exports属性上面取值。即使再次执行require命令,也不会再次执行该模块,而是到缓存之中取值。

    二、CommonJS模块的循环加载

    CommonJS模块的重要特性是加载时执行,即脚本代码在require的时候,就会全部执行。CommonJS的做法是,一旦出现某个模块被"循环加载",就只输出已经执行的部分,还未执行的部分不会输出。

    让我们来看,官方文档里面的例子。脚本文件a.js代码如下。

    exports.done = false;

    var b = require('./b.js');

    console.log('在 a.js 之中,b.done = %j', b.done);

    exports.done = true;

    console.log('a.js 执行完毕');

    上面代码之中,a.js脚本先输出一个done变量,然后加载另一个脚本文件b.js。注意,此时a.js代码就停在这里,等待b.js执行完毕,再往下执行。

    再看b.js的代码。

    exports.done = false;

    var a = require('./a.js');

    console.log('在 b.js 之中,a.done = %j', a.done);

    exports.done = true;

    console.log('b.js 执行完毕');

    上面代码之中,b.js执行到第二行,就会去加载a.js,这时,就发生了"循环加载"。系统会去a.js模块对应对象的exports属性取值,可是因为a.js还没有执行完,从exports属性只能取回已经执行的部分,而不是最后的值。

    a.js已经执行的部分,只有一行。

    exports.done = false;

    因此,对于b.js来说,它从a.js只输入一个变量done,值为false。

    然后,b.js接着往下执行,等到全部执行完毕,再把执行权交还给a.js。于是,a.js接着往下执行,直到执行完毕。我们写一个脚本main.js,验证这个过程。

    var a = require('./a.js');

    var b = require('./b.js');

    console.log('在 main.js 之中, a.done=%j, b.done=%j', a.done, b.done);

    执行main.js,运行结果如下。

    $ node main.js

    在 b.js 之中,a.done = false

    b.js 执行完毕

    在 a.js 之中,b.done = true

    a.js 执行完毕

    在 main.js 之中, a.done=true, b.done=true

    上面的代码证明了两件事。一是,在b.js之中,a.js没有执行完毕,只执行了第一行。二是,main.js执行到第二行时,不会再次执行b.js,而是输出缓存的b.js的执行结果,即它的第四行。

    exports.done = true;

    三、ES6模块的循环加载

    ES6模块的运行机制与CommonJS不一样,它遇到模块加载命令import时,不会去执行模块,而是只生成一个引用。等到真的需要用到时,再到模块里面去取值。

    因此,ES6模块是动态引用,不存在缓存值的问题,而且模块里面的变量,绑定其所在的模块。请看下面的例子。

    // m1.js

    export var foo = 'bar';

    setTimeout(() => foo = 'baz', 500);

    // m2.js

    import {foo} from './m1.js';

    console.log(foo);

    setTimeout(() => console.log(foo), 500);

    上面代码中,m1.js的变量foo,在刚加载时等于bar,过了500毫秒,又变为等于baz。

    让我们看看,m2.js能否正确读取这个变化。

    $ babel-node m2.js

    bar

    baz

    上面代码表明,ES6模块不会缓存运行结果,而是动态地去被加载的模块取值,以及变量总是绑定其所在的模块。

    这导致ES6处理"循环加载"与CommonJS有本质的不同。ES6根本不会关心是否发生了"循环加载",只是生成一个指向被加载模块的引用,需要开发者自己保证,真正取值的时候能够取到值。

    请看下面的例子(摘自 Dr. Axel Rauschmayer 的《Exploring ES6》)。

    // a.js

    import {bar} from './b.js';

    export function foo() {

    bar();

    console.log('执行完毕');

    }

    foo();

    // b.js

    import {foo} from './a.js';

    export function bar() {

    if (Math.random() > 0.5) {

    foo();

    }

    }

    按照CommonJS规范,上面的代码是没法执行的。a先加载b,然后b又加载a,这时a还没有任何执行结果,所以输出结果为null,即对于b.js来说,变量foo的值等于null,后面的foo()就会报错。

    但是,ES6可以执行上面的代码。

    $ babel-node a.js

    执行完毕

    a.js之所以能够执行,原因就在于ES6加载的变量,都是动态引用其所在的模块。只要引用是存在的,代码就能执行。

    我们再来看ES6模块加载器SystemJS给出的一个例子。

    // even.js

    import { odd } from './odd'

    export var counter = 0;

    export function even(n) {

    counter++;

    return n == 0 || odd(n - 1);

    }

    // odd.js

    import { even } from './even';

    export function odd(n) {

    return n != 0 && even(n - 1);

    }

    上面代码中,even.js里面的函数foo有一个参数n,只要不等于0,就会减去1,传入加载的odd()。odd.js也会做类似操作。

    运行上面这段代码,结果如下。

    $ babel-node

    > import * as m from './even.js';

    > m.even(10);

    true

    > m.counter

    6

    > m.even(20)

    true

    > m.counter

    17

    上面代码中,参数n从10变为0的过程中,foo()一共会执行6次,所以变量counter等于6。第二次调用even()时,参数n从20变为0,foo()一共会执行11次,加上前面的6次,所以变量counter等于17。

    这个例子要是改写成CommonJS,就根本无法执行,会报错。

    // even.js

    var odd = require('./odd');

    var counter = 0;

    exports.counter = counter;

    exports.even = function(n) {

    counter++;

    return n == 0 || odd(n - 1);

    }

    // odd.js

    var even = require('./even').even;

    module.exports = function(n) {

    return n != 0 && even(n - 1);

    }

    上面代码中,even.js加载odd.js,而odd.js又去加载even.js,形成"循环加载"。这时,执行引擎就会输出even.js已经执行的部分(不存在任何结果),所以在odd.js之中,变量even等于null,等到后面调用even(n-1)就会报错。

    $ node

    > var m = require('./even');

    > m.even(10)

    TypeError: even is not a function

    (完)

    展开全文
  • commonjs与ES6循环加载

    2019-09-26 20:08:22
    1.commonjs模块化定义 var odd = require('') ...一旦出现某个模块被"循环加载",就只输出已经执行的部分,还未执行的部分不会输出。 3.ES6模块化定义 import from export function add () {} 4.ES6模块化循...

    1.commonjs模块化定义

    var odd = require('')

    modules.exports = function () {}

    2.commonjs循环加载执行

    一旦出现某个模块被"循环加载",就只输出已经执行的部分,还未执行的部分不会输出。

    3.ES6模块化定义

    import from

    export function add () {}

    4.ES6模块化循环加载执行

    ES6模块是动态引用,不存在缓存值的问题

    转载于:https://www.cnblogs.com/tangyunluck/p/9886083.html

    展开全文
  • CommonJS模块规范使用require语句导入模块,module.exports导出模块,输出的是值的拷贝,模块导入的也是输出值的拷贝,也就是...那CommonJS和ES6模块规范针对模块的循环加载处理机制有什么不同呢? 循环加载指的是a脚
  • "循环加载"(circular dependency)指的是,a脚本的执行依赖b脚本,而b脚本的执行又依赖a脚本。 // a.js var b = require('b'); // b.js var a = require('a'); 通常,"循环加载"表示存在强耦合,如果处理...

    "循环加载"(circular dependency)指的是,a脚本的执行依赖b脚本,而b脚本的执行又依赖a脚本。

    
    // a.js
    var b = require('b');
    
    // b.js
    var a = require('a');
    

    通常,"循环加载"表示存在强耦合,如果处理不好,还可能导致递归加载,使得程序无法执行,因此应该避免出现。

    但是实际上,这是很难避免的,尤其是依赖关系复杂的大项目,很容易出现a依赖b,b依赖cc又依赖a这样的情况。这意味着,模块加载机制必须考虑"循环加载"的情况。

    本文介绍JavaScript语言如何处理"循环加载"。目前,最常见的两种模块格式CommonJS和ES6,处理方法是不一样的,返回的结果也不一样。

    一、CommonJS模块的加载原理

    介绍ES6如何处理"循环加载"之前,先介绍目前最流行的CommonJS模块格式的加载原理。

    CommonJS的一个模块,就是一个脚本文件。require命令第一次加载该脚本,就会执行整个脚本,然后在内存生成一个对象。

    
    {
      id: '...',
      exports: { ... },
      loaded: true,
      ...
    }
    

    上面代码中,该对象的id属性是模块名,exports属性是模块输出的各个接口,loaded属性是一个布尔值,表示该模块的脚本是否执行完毕。其他还有很多属性,这里都省略了。(详细介绍情参见《require() 源码解读》。)

    以后需要用到这个模块的时候,就会到exports属性上面取值。即使再次执行require命令,也不会再次执行该模块,而是到缓存之中取值。

    二、CommonJS模块的循环加载

    CommonJS模块的重要特性是加载时执行,即脚本代码在require的时候,就会全部执行。CommonJS的做法是,一旦出现某个模块被"循环加载",就只输出已经执行的部分,还未执行的部分不会输出。

    让我们来看,官方文档里面的例子。脚本文件a.js代码如下。

    
    exports.done = false;
    var b = require('./b.js');
    console.log('在 a.js 之中,b.done = %j', b.done);
    exports.done = true;
    console.log('a.js 执行完毕');
    

    上面代码之中,a.js脚本先输出一个done变量,然后加载另一个脚本文件b.js。注意,此时a.js代码就停在这里,等待b.js执行完毕,再往下执行。

    再看b.js的代码。

    
    exports.done = false;
    var a = require('./a.js');
    console.log('在 b.js 之中,a.done = %j', a.done);
    exports.done = true;
    console.log('b.js 执行完毕');
    

    上面代码之中,b.js执行到第二行,就会去加载a.js,这时,就发生了"循环加载"。系统会去a.js模块对应对象的exports属性取值,可是因为a.js还没有执行完,从exports属性只能取回已经执行的部分,而不是最后的值。

    a.js已经执行的部分,只有一行。

    
    exports.done = false;
    

    因此,对于b.js来说,它从a.js只输入一个变量done,值为false

    然后,b.js接着往下执行,等到全部执行完毕,再把执行权交还给a.js。于是,a.js接着往下执行,直到执行完毕。我们写一个脚本main.js,验证这个过程。

    
    var a = require('./a.js');
    var b = require('./b.js');
    console.log('在 main.js 之中, a.done=%j, b.done=%j', a.done, b.done);
    

    执行main.js,运行结果如下。

    
    $ node main.js
    
    在 b.js 之中,a.done = false
    b.js 执行完毕
    在 a.js 之中,b.done = true
    a.js 执行完毕
    在 main.js 之中, a.done=true, b.done=true
    

    上面的代码证明了两件事。一是,在b.js之中,a.js没有执行完毕,只执行了第一行。二是,main.js执行到第二行时,不会再次执行b.js,而是输出缓存的b.js的执行结果,即它的第四行。

    
    exports.done = true;
    

    三、ES6模块的循环加载

    ES6模块的运行机制与CommonJS不一样,它遇到模块加载命令import时,不会去执行模块,而是只生成一个引用。等到真的需要用到时,再到模块里面去取值。

    因此,ES6模块是动态引用,不存在缓存值的问题,而且模块里面的变量,绑定其所在的模块。请看下面的例子。

    
    // m1.js
    export var foo = 'bar';
    setTimeout(() => foo = 'baz', 500);
    
    // m2.js
    import {foo} from './m1.js';
    console.log(foo);
    setTimeout(() => console.log(foo), 500);
    

    上面代码中,m1.js的变量foo,在刚加载时等于bar,过了500毫秒,又变为等于baz

    让我们看看,m2.js能否正确读取这个变化。

    
    $ babel-node m2.js
    
    bar
    baz
    

    上面代码表明,ES6模块不会缓存运行结果,而是动态地去被加载的模块取值,以及变量总是绑定其所在的模块。

    这导致ES6处理"循环加载"与CommonJS有本质的不同。ES6根本不会关心是否发生了"循环加载",只是生成一个指向被加载模块的引用,需要开发者自己保证,真正取值的时候能够取到值。

    请看下面的例子(摘自 Dr. Axel Rauschmayer 的《Exploring ES6》)。

    
    // a.js
    import {bar} from './b.js';
    export function foo() {
      bar();  
      console.log('执行完毕');
    }
    foo();
    
    // b.js
    import {foo} from './a.js';
    export function bar() {  
      if (Math.random() > 0.5) {
        foo();
      }
    }
    

    按照CommonJS规范,上面的代码是没法执行的。a先加载b,然后b又加载a,这时a还没有任何执行结果,所以输出结果为null,即对于b.js来说,变量foo的值等于null,后面的foo()就会报错。

    但是,ES6可以执行上面的代码。

    
    $ babel-node a.js
    
    执行完毕
    

    a.js之所以能够执行,原因就在于ES6加载的变量,都是动态引用其所在的模块。只要引用是存在的,代码就能执行。

    我们再来看ES6模块加载器SystemJS给出的一个例子。

    
    // even.js
    import { odd } from './odd'
    export var counter = 0;
    export function even(n) {
      counter++;
      return n == 0 || odd(n - 1);
    }
    
    // odd.js
    import { even } from './even';
    export function odd(n) {
      return n != 0 && even(n - 1);
    }
    

    上面代码中,even.js里面的函数foo有一个参数n,只要不等于0,就会减去1,传入加载的odd()odd.js也会做类似操作。

    运行上面这段代码,结果如下。

    
    $ babel-node
    > import * as m from './even.js';
    > m.even(10);
    true
    > m.counter
    6
    > m.even(20)
    true
    > m.counter
    17
    

    上面代码中,参数n从10变为0的过程中,foo()一共会执行6次,所以变量counter等于6。第二次调用even()时,参数n从20变为0,foo()一共会执行11次,加上前面的6次,所以变量counter等于17。

    这个例子要是改写成CommonJS,就根本无法执行,会报错。

    
    // even.js
    var odd = require('./odd');
    var counter = 0;
    exports.counter = counter;
    exports.even = function(n) {
      counter++;
      return n == 0 || odd(n - 1);
    }
    
    // odd.js
    var even = require('./even').even;
    module.exports = function(n) {
      return n != 0 && even(n - 1);
    }
    

    上面代码中,even.js加载odd.js,而odd.js又去加载even.js,形成"循环加载"。这时,执行引擎就会输出even.js已经执行的部分(不存在任何结果),所以在odd.js之中,变量even等于null,等到后面调用even(n-1)就会报错。

     

     

     

    
    $ node
    > var m = require('./even');
    > m.even(10)
    TypeError: even is not a function
    展开全文
  • Q345B钢在大应变下的循环加载试验研究,吴旗,陈以一,本文对Q345B钢材在循环往复加载下的滞回性能进行了试验研究,考虑了循环拉伸、等幅升幅、等幅降幅和等幅交替四种不同的循环加载制�
  • 模块的循环加载问题

    2018-09-12 17:55:36
    有时候会出现一种就是a模块依赖于b模块,然而b模块又依赖于a模块,这样在模块加载的时候就出现了一种模块间的循环加载的问题   模块加载在CommonJS中会存在缓存问题:若出现模块加载的会,会先加载模块,然后等要...
  • 为研究强冲击倾向性煤在多级循环加载条件下的能量耗散特征及损伤演化过程,在实验室开展了陕西某矿煤样的多级循环加载试验,试验研究结果表明:在多级应力循环下煤样的耗散能先迅速降低,后缓慢增加,当循环上限应力达到...
  • foreach嵌套循环的多次循环加载问题 参考博客:(https://blog.csdn.net/weixin_38552343/article/details/79675620) 在开发过程中遇到这样一个问题,就是在我使用双层foreach循环去循环两个字符串类型数组的时候...
  • 循环加载对磁流变弹性体性能影响的研究,张玮,龚兴龙,磁流变弹性体是一种新型的功能材料和智能材料,其力学性能可以由外加磁场来控制。磁流变弹性体经常被用于各类振动器械中,受到循
  • 循环加载模块假设你有两个文件,a.py和b.py,在这两个文件中互相加载对方,例如:在a.py中:import bdef f():return b.xprint f()在b.py中:import ax = 1def g():print a.f()首先,我们试着加载a.py:>...
  • 今天小编就为大家分享一篇vue 循环加载数据并获取第一条记录的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 这个时候就在模块(模块方法)的加载机制上面就必须要考虑"循环加载"循环加载的情况了. 在这篇文章里面主要说ES6和CommonJS的模块加载 CommonJS模块的加载 CommonJS的一个模块,就是一个脚本文件。requi...
  • 通过webclient加载图片到bitmapimage中,循环加载,时不时会掉图片,掉哪一张不定,有时候掉好几张,有时候掉一张。 这是silverlight的BUG吗?谁能帮我解决这个问题啊?
  • 最近一段事件死磕Scroll View循环加载虽然也是站在巨人的肩膀上进行的研究,总算是有点成果,还有很多不足还请大佬指出
  • js循环加载数据列表

    2017-11-01 11:30:00
    js循环加载数据列表 //订单渲染 function buildShowInfoDiv(data){ for(i in data.data){ var bussNo = data.data[i].bussNo; var items='<div class="weui-cells" onclick="selec...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,463
精华内容 2,585
关键字:

循环加载