export,,export default,import || export,module.exports,require

參考地址 http://www.lxweimin.com/p/be2d4eab3878

module.exports

Node應(yīng)用由模塊組成,采用CommonJS模塊規(guī)范。根據(jù)這個規(guī)范,每個文件就是一個模塊,有自己的作用域。在這些文件里面定義的變量、函數(shù)、類,都是私有的,對外不可見,因此規(guī)避掉了作用域污染。

根據(jù)CommonJS規(guī)定,每個模塊內(nèi)部,module變量代表當前模塊,這個變量是一個對象,它的exports屬性(即module.exports)是對外的接口。加載某個模塊,其實就是加載該模塊的exports屬性。

舉例:通過module.exports輸出變量 age 和 sayHelloTo 函數(shù)。

//./MyModule.js
    var age = 7; 
    var sayHelloTo= function (name) { 
        return "hello " + name;
    }; 
    module.exports.age = age; 
    module.exports.sayHelloTo=sayHelloTo;

require:用于加載模塊

var temp = require('./MyModule.js');  
//這里也可以使用 import temp from './MyModule.js'
console.log(temp.age); // 7 
console.log(temp.sayHelloTo("Steve")); // hello 

exports 與 module.exports

為了方便,node為每個模塊提供了一個exports變量,指向module.exports。這等同于在每個模塊頭部,有這么一行代碼:

var exports = module.exports;

因此,我們可以直接在exports對象上添加方法(等同于在 module.exports 添加一樣)

//./MyModule.js
    var age = 7; 
    var sayHelloTo= function (name) { 
        return "hello " + name;
    }; 
    exports.age = age;  //等效于:  module.exports.age = age;
    exports.sayHelloTo=sayHelloTo;  //等效于: module.exports.sayHelloTo=sayHelloTo;

P.S.不能直接將exports指向一個值,這會切斷 exports 與 module.exports 的聯(lián)系(但是可以用module.exports來指向一個值)

//./MyModule.js
    var age = 7; 
    var sayHelloTo= function (name) { 
        return "hello " + name;
    }; 
    exports = age;  //不要這么干。這么做會切斷exports與module.exports的聯(lián)系, require該文件會得到一個空對象
    module.exports = age; //這樣寫沒有問題,require該文件會得到一個值7

不同于CommonJS,ES6使用 export 和 import 來導(dǎo)入、導(dǎo)出模塊

用 export 導(dǎo)出的模塊,需要用 import 來進行導(dǎo)入,而不能用 require。
P.S.:export 命令規(guī)定的是對外的接口,必須與模塊內(nèi)部的變量建立一一對應(yīng)的關(guān)系

const utils = {
    showSth : function(){
        console.log("showSth");
    },
    saySth : function(){
        console.log("saySth");
    }
}
//導(dǎo)出的3種方式
// 方式1,這種方式在引用的時候需要這樣: import {m} from './utils.js';
export var m = utils; 
// 方式2,用大括號來導(dǎo)出變量,如果導(dǎo)出的變量有多個,則{變量1,變量2,變量3...,變量N}。
//這種方式在引用的時候需要這樣: import {utils} from './utils.js';
export {utils}; 
// 方式3,這種方式在引用的時候需要這樣: import {myUtils} from './utils.js';
//在引用的地方,也可以直接指定別名,如:import {myUtils as utils} from './utils.js';
export {utils as myUtils}; 

export 和 export default

  1. export 和export default 均可用于導(dǎo)出(常量 | 函數(shù) | 文件 | 模塊)等。
  2. 可以在其他文件中通過 import+(常量 | 函數(shù) | 文件 | 模塊)名的方式,將其導(dǎo)入,以便能夠進行使用。
  3. 在一個文件或者模塊中,export、import 可以有多個,但 export default 僅有一個。
const utils = {
    showSth : function(){
        console.log("showSth");
    },
    saySth : function(){
        console.log("saySth");
    }
}
const name = "my name is Artech";
export {name}; //命名導(dǎo)出
export {utils};

//對于命名方式導(dǎo)出的,在導(dǎo)入的時候必須使用相應(yīng)對象的相同名稱
//引用的時候:
import {utils,name as myName} from './utils.js';
  1. 通過 export 方式導(dǎo)出,在導(dǎo)入時要用花括號{ };而通過 export default 方式導(dǎo)出的,則不需要:
//如通過 export default 導(dǎo)出
  export default utils;  
//則在使用的時候不用加花括號,且導(dǎo)入時的名字可以自定義,如:
  import myUtils from './utils.js';  //對于默認方式導(dǎo)出的,則導(dǎo)入的時候,名稱可以隨便取

//默認導(dǎo)出:不能使用 let,var 或 const 作為默認導(dǎo)出

import *

將一個js文件中定義的方法,模塊,對象等,全部導(dǎo)出,一般結(jié)合別名使用,如:

//myModule.js
   export const fun1 = ()=>{}
   export const objInfo = {...};
//demo.js:引用mymODULE。JS
    import * as myAlias from './myModule';
    //fun1()和objInfo都是定義在myModule中的方法和對象
    myAlias.fun1();
    myAlias.objInfo;

補充:

1. 如果用export default導(dǎo)出,然后用import * 引入
//myModule.js
   export default {
    fun1: ()=>{},
    objInfo: {
      aaa: 'sss1'
    },
  }
//demo.js:引用myModule.js
    import * as myAlias from './myModule';
    //fun1()和objInfo都是定義在myModule中的default的方法和對象
    myAlias.default.fun1();
    myAlias.default.objInfo;

本質(zhì)上,export default就是輸出一個叫做default的變量或方法,然后系統(tǒng)允許你為它取任意名字。所以,下面的寫法是有效的。

//demo.js:引用myModule.js
    import { default as myAlias } from './myModule';
    myAlias.fun1();
    myAlias.objInfo;

正是因為export default命令其實只是輸出一個叫做default的變量,所以它后面不能跟變量聲明語句

// 正確
export var a = 1;

// 正確
var a = 1;
export default a;

// 錯誤
export default var a = 1;

上面代碼中,export default a的含義是將變量a的值賦給變量default。所以,最后一種寫法會報錯。

同樣地,因為export default命令的本質(zhì)是將后面的值,賦給default變量,所以可以直接將一個值寫在export default之后。

// 正確
export default 42;

// 報錯
export 42;

2. export語句輸出的接口,與其對應(yīng)的值是動態(tài)綁定關(guān)系,即通過該接口,可以取到模塊內(nèi)部實時的值。
//myModule.js
export var foo = 'bar';
setTimeout(() => foo = 'baz', 500);
//demo.js:引用myModule.js
  import * as myAlias from './myModule';
  console.log(myAlias.foo); //bar
  setTimeout(() => {
    console.log(myAlias.foo); //baz
  },1000);

這一點與 CommonJS 規(guī)范完全不同。CommonJS 模塊輸出的是值的緩存,不存在動態(tài)更新


3. export 和 import 命令可以出現(xiàn)在模塊的任何位置,只要處于模塊頂層就可以。如果處于塊級作用域內(nèi),就會報錯,這是因為處于條件代碼塊之中,就沒法做靜態(tài)優(yōu)化了,違背了 ES6 模塊的設(shè)計初衷。
function foo() {
  export default 'bar' // SyntaxError
}
foo()

上面代碼中,export語句放在函數(shù)之中,結(jié)果報錯。


4. import命令輸入的變量都是只讀的,因為它的本質(zhì)是輸入接口。也就是說,不允許在加載模塊的腳本里面,改寫接口。
import {a} from './xxx.js'

a = {}; // Syntax Error : 'a' is read-only;

上面代碼中,腳本加載了變量a,對其重新賦值就會報錯,因為a是一個只讀的接口。但是,如果a是一個對象,改寫a的屬性是允許的。

import {a} from './xxx.js'

a.foo = 'hello'; // 合法操作

上面代碼中,a的屬性可以成功改寫,并且其他模塊也可以讀到改寫后的值。不過,這種寫法很難查錯,建議凡是輸入的變量,都當作完全只讀,輕易不要改變它的屬性。


5. import命令具有提升效果,會提升到整個模塊的頭部,首先執(zhí)行。
foo();

import { foo } from 'my_module';

上面的代碼不會報錯,因為import的執(zhí)行早于foo的調(diào)用。這種行為的本質(zhì)是,import命令是編譯階段執(zhí)行的,在代碼運行之前。


6. 由于import是靜態(tài)執(zhí)行,所以不能使用表達式和變量,這些只有在運行時才能得到結(jié)果的語法結(jié)構(gòu)。
// 報錯
import { 'f' + 'oo' } from 'my_module';

// 報錯
let module = 'my_module';
import { foo } from module;

// 報錯
if (x === 1) {
  import { foo } from 'module1';
} else {
  import { foo } from 'module2';
}

上面三種寫法都會報錯,因為它們用到了表達式、變量和if結(jié)構(gòu)。在靜態(tài)分析階段,這些語法都是沒法得到值的。


7.import語句會執(zhí)行所加載的模塊,因此可以有下面的寫法。
import 'lodash';

上面代碼僅僅執(zhí)行lodash模塊,但是不輸入任何值。
如果多次重復(fù)執(zhí)行同一句import語句,那么只會執(zhí)行一次,而不會執(zhí)行多次。

import 'lodash';
import 'lodash';

上面代碼加載了兩次lodash,但是只會執(zhí)行一次。

import { foo } from 'my_module';
import { bar } from 'my_module';

// 等同于
import { foo, bar } from 'my_module';

上面代碼中,雖然foobar在兩個語句中加載,但是它們對應(yīng)的是同一個my_module實例。也就是說,import語句是 Singleton 模式。


8.目前階段,通過 Babel 轉(zhuǎn)碼,CommonJS 模塊的require命令和 ES6 模塊的import命令,可以寫在同一個模塊里面,但是最好不要這樣做。因為import在靜態(tài)解析階段執(zhí)行,所以它是一個模塊之中最早執(zhí)行的。下面的代碼可能不會得到預(yù)期結(jié)果。
require('core-js/modules/es6.symbol');
require('core-js/modules/es6.promise');
import React from 'React';

9. 如果想在一條import語句中,同時輸入默認方法和其他接口,可以寫成下面這樣。
import _, { each, forEach } from 'lodash';

對應(yīng)上面代碼的export語句如下。

export default function (obj) {}
export function each(obj, iterator, context) { }
export function forEach () { }

10. export default也可以用來輸出類。
// MyClass.js
export default class { ... }

// main.js
import MyClass from 'MyClass';
let o = new MyClass();

11. export 與 import 的復(fù)合寫法

如果在一個模塊之中,先輸入后輸出同一個模塊,import語句可以與export語句寫在一起。

export { foo, bar } from 'my_module';

// 可以簡單理解為
import { foo, bar } from 'my_module';
export { foo, bar };

上面代碼中,exportimport語句可以結(jié)合在一起,寫成一行。但需要注意的是,寫成一行以后,foobar實際上并沒有被導(dǎo)入當前模塊,只是相當于對外轉(zhuǎn)發(fā)了這兩個接口,導(dǎo)致當前模塊不能直接使用foobar


未總結(jié)的:

模塊的繼承
跨模塊常量

如果要使用的常量非常多,可以建一個專門的constants目錄,將各種常量寫在不同的文件里面,保存在該目錄下。然后,將這些文件輸出的常量,合并在index.js里面。

import() - 提案

importexport命令只能在模塊的頂層,不能在代碼塊之中(比如,在if代碼塊之中,或在函數(shù)之中)。

這樣的設(shè)計,固然有利于編譯器提高效率,但也導(dǎo)致無法在運行時加載模塊。在語法上,條件加載就不可能實現(xiàn)。如果import命令要取代 Node 的require方法,這就形成了一個障礙。因為require是運行時加載模塊,import命令無法取代require的動態(tài)加載功能。

const path = './' + fileName;
const myModual = require(path);

上面的語句就是動態(tài)加載,require到底加載哪一個模塊,只有運行時才知道。import命令做不到這一點。

因此,有一個提案,建議引入import()函數(shù),完成動態(tài)加載。
.....

最后編輯于
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明:文章內(nèi)容(如有圖片或視頻亦包括在內(nèi))由作者上傳并發(fā)布,文章內(nèi)容僅代表作者本人觀點,簡書系信息發(fā)布平臺,僅提供信息存儲服務(wù)。