In der Urzeit des Internets wurden Websites hauptsächlich mit HTML und CSS entwickelt. Wenn JavaScript in eine Seite geladen wird, erfolgt dies normalerweise in Form kleiner Snippets, um Effekte und Interaktionen bereitzustellen. Normalerweise wird der gesamte JavaScript-Code in eine Datei geschrieben und in ein script
-Tag geladen. Auch wenn JavaScript in mehrere Dateien aufgeteilt werden kann, werden alle Variablen und Funktionen dennoch zum globalen Bereich hinzugefügt. script
标签中。尽管可以把 JavaScript 拆分为多个文件,但是所有的变量和函数仍然会被添加到全局作用域中。
但是后来 JavaScript 在浏览器中发挥着重要的作用,迫切需要使用第三方代码来完成常见任务,并且需要把代码分解为模块化的文件,避免污染全局命名空间。
ECMAScript 2015 规范在 JavaScript 语言中引入了 module,也有了 import 和 export 语句。在本文中,我们一起来学习 JavaScript 模块,以及怎样用 import
和 export
来组织代码。
在 JavaScript 中出现模块的概念之前,当我们想要把自己的代码组织为多个块时,一般会创建多个文件,并且将它们链接为单独的脚本。下面先举例说明,首先创建一个 index.html
文件和两个JavaScript文件“ functions.js
和 script.js
。
index.html
文件用来显示两个数字的和、差、乘积和商,并链接到 script
标签中的两个 JavaScript 文件。打开 index.html
并添加以下代码:
index.html
nbsp;html> <meta> <meta> <title>JavaScript Modules</title> <h1>Answers</h1> <h2> <strong></strong> and <strong></strong> </h2> <h3>Addition</h3> <p></p> <h3>Subtraction</h3> <p></p> <h3>Multiplication</h3> <p></p> <h3>pision</h3> <p></p> <script></script> <script></script>
这个页面很简单,就不详细说明了。
functions.js
文件中包含将会在第二个脚本中用到的数学函数。打开文件并添加以下内容:
functions.js
function sum(x, y) { return x + y } function difference(x, y) { return x - y } function product(x, y) { return x * y } function quotient(x, y) { return x / y }
最后,script.js
文件用来确定 x 和 y 的值,以及调用前面那些函数并显示结果:
script.js
const x = 10 const y = 5 document.getElementById('x').textContent = x document.getElementById('y').textContent = y document.getElementById('addition').textContent = sum(x, y) document.getElementById('subtraction').textContent = difference(x, y) document.getElementById('multiplication').textContent = product(x, y) document.getElementById('pision').textContent = quotient(x, y)
保存之后在浏览器中打开 index.html
可以看到所有结果:
对于只需要一些小脚本的网站,这不失为一种有效的组织代码的方法。但是这种方法存在一些问题:
sum
、 difference
等)现在都存在于 window
对象中。如果你打算在另一个文件中使用另一个名为 sum
的变量,会很难知道在脚本的其它位置到底用的是哪一个值变量,因为它们用的都是相同的 window.sum
变量。唯一可以使变量私有的方法是将其放在函数的作用域中。甚至在 DOM 中名为 x
的 id
可能会和 var x
存在冲突。 <script></script>
ECMAScript 2015 wurden
Module zusammen mit Import- und Exportanweisungen in die JavaScript-Sprache eingeführt. In diesem Artikel erfahren wir mehr über JavaScript-Module und wie man mit import
und export
Code organisiert.
Bevor das Konzept der Module in JavaScript auftauchte, haben wir, wenn wir unseren Code in mehrere Blöcke organisieren wollten, normalerweise mehrere Dateien erstellt und sie in separate Skripte verknüpft. Lassen Sie uns unten ein Beispiel geben. Erstellen Sie zunächst eine index.html
-Datei und zwei JavaScript-Dateien „functions.js
und script.js
index.html wird zur Anzeige der Summe, Differenz, des Produkts und des Quotienten zweier Zahlen verwendet und ist mit zwei JavaScript-Dateien im Tag script
verknüpft .html und fügen Sie den folgenden Code hinzu:
index.html
export function sum(x, y) { return x + y } export function difference(x, y) { return x - y } export function product(x, y) { return x * y } export function quotient(x, y) { return x / y }
Diese Seite ist sehr einfach, daher werde ich nicht auf Details eingehen Die in den beiden Skripten verwendeten mathematischen Funktionen werden eingefügt und der folgende Inhalt hinzugefügt: functions.jsimport { sum, difference, product, quotient } from './functions.js'
const x = 10
const y = 5
document.getElementById('x').textContent = x
document.getElementById('y').textContent = y
document.getElementById('addition').textContent = sum(x, y)
document.getElementById('subtraction').textContent = difference(x, y)
document.getElementById('multiplication').textContent = product(x, y)
document.getElementById('pision').textContent = quotient(x, y)
script.js
verwendet die Werte von x und y, und Rufen Sie die vorherigen Funktionen auf und zeigen Sie die Ergebnisse an:
<script> </script> <script> </script>
index.html
im Browser, um alle anzuzeigen Ergebnisse: 🎜🎜🎜 🎜Für Websites, die nur einige kleine Skripte benötigen, ist dies eine effektive Möglichkeit, Code zu organisieren. Allerdings gibt es bei dieser Methode einige Probleme: 🎜sum
, difference
usw.) ist jetzt im window
-Objekt vorhanden, wenn Sie vorhaben, eine andere Variable mit dem Namen sum zu verwenden. code> in einer anderen Datei ist es schwierig zu wissen, welche Wertvariable an anderer Stelle im Skript verwendet wird, da alle dieselbe <code>window.sum
-Variable verwenden um es in eine Funktion einzufügen. Sogar die id
mit dem Namen x
im DOM kann mit var x
in Konflikt stehen 🎜 <skript>. 🎜🎜🎜Bevor ES6 der JavaScript-Sprache native Module hinzufügte, versuchte die Community, mehrere Lösungen bereitzustellen. Die erste Lösung besteht darin, in nativem JavaScript zu schreiben, z. B. den gesamten Code in Objekte oder sofort aufgerufene Funktionsausdrücke (IIFEs) zu schreiben und sie auf einem einzelnen Objekt im globalen Namespace abzulegen. Dies ist eine Verbesserung gegenüber dem Multi-Script-Ansatz, birgt aber immer noch das Problem, mindestens ein Objekt in den globalen Namensraum zu stellen, und macht das Problem der konsistenten gemeinsamen Nutzung von Code zwischen Dritten nicht einfacher. 🎜🎜Danach erschienen einige Modullösungen: CommonJS ist eine in Node.js implementierte synchrone Methode, Asynchronous Module Definition (AMD) ist eine asynchrone Methode und es gibt eine universelle Methode, die die beiden vorherigen Stile unterstützt – Common Module Definition (UMD). ). 🎜🎜Das Aufkommen dieser Lösungen erleichtert uns die gemeinsame Nutzung und Wiederverwendung von Code in Form von 🎜Paketen🎜, also Modulen, die verteilt und gemeinsam genutzt werden können, wie z. B. npm. Da es jedoch viele Lösungen gibt und keine davon nativ für JavaScript ist, müssen Sie sich auf Tools wie Babel, Webpack oder Browserify verlassen, um sie im Browser zu verwenden. 🎜🎜Aufgrund der vielen Probleme mit dem Multi-File-Ansatz und der Komplexität der Lösungen sind Entwickler sehr daran interessiert, modulare Entwicklungsmethoden in die JavaScript-Sprache zu integrieren. Daher begann ECMAScript 2015, JavaScript-Module zu unterstützen. 🎜🎜🎜module🎜 ist eine Reihe von Codes, die zur Bereitstellung von Funktionen verwendet werden, die von anderen Modulen verwendet werden, und zur Nutzung der Funktionen anderer Module. Das 🎜Export🎜-Modul stellt Code bereit und das 🎜Import🎜-Modul verwendet anderen Code. Module sind nützlich, weil sie uns die Wiederverwendung von Code ermöglichen, viele stabile, konsistente Schnittstellen zur Verfügung stellen und den globalen Namespace nicht verschmutzen. 🎜<p>模块(有时称为 ES 模块)现在可以在原生 JavaScript 中使用,在本文中,我们一起来探索怎样在代码中使用及实现。</p>
<h2>原生 JavaScript 模块</h2>
<p>JavaScript 中的模块使用<code>import
和 export
关键字:
import
:用于读取从另一个模块导出的代码。export
:用于向其他模块提供代码。接下来把前面的的 functions.js
文件更新为模块并导出函数。在每个函数的前面添加 export
。
functions.js
export function sum(x, y) { return x + y } export function difference(x, y) { return x - y } export function product(x, y) { return x * y } export function quotient(x, y) { return x / y }
在 script.js
中用 import
从前面的 functions.js
模块中检索代码。
注意:import
必须始终位于文件的顶部,然后再写其他代码,并且还必须包括相对路径(在这个例子里为./
)。
把 script.js
中的代码改成下面的样子:
script.js
import { sum, difference, product, quotient } from './functions.js' const x = 10 const y = 5 document.getElementById('x').textContent = x document.getElementById('y').textContent = y document.getElementById('addition').textContent = sum(x, y) document.getElementById('subtraction').textContent = difference(x, y) document.getElementById('multiplication').textContent = product(x, y) document.getElementById('pision').textContent = quotient(x, y)
注意:要通过在花括号中命名单个函数来导入。
为了确保代码作为模块导入,而不是作为常规脚本加载,要在 index.html
中的 script
标签中添加type="module"
。任何使用 import
或 export
的代码都必须使用这个属性:
index.html
<script> </script> <script> </script>
由于受限于 CORS 策略,必须在服务器环境中使用模块,否则会出现下面的错误:
Access to script at 'file:///Users/your_file_path/script.js' from origin 'null' has been blocked by CORS policy: Cross origin requests are only supported for protocol schemes: http, data, chrome, chrome-extension, chrome-untrusted, https.
模块与常规脚本不一样的地方:
window
)作用域添加任何内容。模块仍然经常与打包程序(如 Webpack)一起配合使用,用来增加对浏览器的支持和附加功能,但它们也可以直接用在浏览器中。
接下来探索更多使用 import
和 export
语法的方式。
如前所述,使用 export
语法允许你分别导入按名称导出的值。以这个 function.js
的简化版本为例:
functions.js
export function sum() {} export function difference() {}
这样允许你用花括号按名称导入 sum
和 difference
:
script.js
import {sum, difference} from './functions.js'
也可以用别名来重命名该函数。这样可以避免在同一模块中产生命名冲突。在这个例子中,sum
将重命名为 add
,而 difference
将重命名为 subtract
。
script.js
import { sum as add, difference as subtract } from './functions.js' add(1, 2) // 3
在这里调用 add()
将产生 sum()
函数的结果。
使用 *
语法可以将整个模块的内容导入到一个对象中。在这种情况下,sum
和 difference
将成为 mathFunctions
对象上的方法。
script.js
import * as mathFunctions from './functions.js' mathFunctions.sum(1, 2) // 3 mathFunctions.difference(10, 3) // 7
原始值、函数表达式和定义、异步函数、类和实例化的类都可以导出,只要它们有标识符就行:
// 原始值 export const number = 100 export const string = 'string' export const undef = undefined export const empty = null export const obj = {name: 'Homer'} export const array = ['Bart', 'Lisa', 'Maggie'] // 函数表达式 export const sum = (x, y) => x + y // 函数定义 export function difference(x, y) { return x - y } // 匿名函数 export async function getBooks() {} // 类 export class Book { constructor(name, author) { this.name = name this.author = author } } // 实例化类 export const book = new Book('Lord of the Rings', 'J. R. R. Tolkein')
所有这些导出都可以成功被导入。接下来要探讨的另一种导出类型称为默认导出。
在前面的例子中我们导出了多个命名的导出,并分别或作为一个对象导入了每个导出,将每个导出作为对象上的方法。模块也可以用关键字 default
包含默认导出。默认导出不使用大括号导入,而是直接导入到命名标识符中。
以 functions.js
文件为例:
functions.js
export default function sum(x, y) { return x + y }
在 script.js
文件中,可以用以下命令将默认函数导入为 sum
:
script.js
import sum from './functions.js' sum(1, 2) // 3
不过这样做很危险,因为在导入过程中对默认导出的命名没有做任何限制。在这个例子中,默认函数被导入为 difference
,尽管它实际上是 sum
函数:
script.js
import difference from './functions.js' difference(1, 2) // 3
所以一般首选使用命名导出。与命名导出不同,默认导出不需要标识符——原始值本身或匿名函数都可以用作默认导出。以下是用作默认导出的对象的示例:
functions.js
export default { name: 'Lord of the Rings', author: 'J. R. R. Tolkein', }
可以用以下命令将其作为 book
导入:
functions.js
import book from './functions.js'
同样,下面的例子演示了如何将匿名箭头函数导出为默认导出:
functions.js
export default () => 'This function is anonymous'
可以这样导入:
script.js
import anonymousFunction from './functions.js'
命名导出和默认导出可以彼此并用,例如在这个模块中,导出两个命名值和一个默认值:
functions.js
export const length = 10 export const width = 5 export default function perimeter(x, y) { return 2 * (x + y) }
可以用以下命令导入这些变量和默认函数:
script.js
import calculatePerimeter, {length, width} from './functions.js' calculatePerimeter(length, width) // 30
现在默认值和命名值都可用于脚本了。
模块化编程设计允许我们把代码分成单个组件,这有助于代码重用,同时还可以保护全局命名空间。一个模块接口可以在原生 JavaScript 中用关键字 import
和 export
来实现。
原文地址:https://www.taniarascia.com/javascript-modules-import-export/
作者:Tania Rascia
译文地址:https://segmentfault.com/a/1190000038275195
更多编程相关知识,请访问:编程学习!!
Das obige ist der detaillierte Inhalt vonErfahren Sie mehr über Module, Import und Export in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!