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';

上面代碼中，雖然foo和bar在兩個語句中加載，但是它們對應(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 };

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

未總結(jié)的：

模塊的繼承
跨模塊常量

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

import() - 提案

import和export命令只能在模塊的頂層，不能在代碼塊之中（比如，在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ù)。