initial commit

10 files changed, 2111 insertions, 0 deletions

diff --git a/files/zh-cn/webassembly/c_to_wasm/index.html b/files/zh-cn/webassembly/c_to_wasm/index.html
new file mode 100644
index 0000000000..afcdbbc3e1
--- /dev/null
+++ b/files/zh-cn/webassembly/c_to_wasm/index.html
@@ -0,0 +1,252 @@
+---
+title: 编译 C/C++ 为 WebAssembly
+slug: WebAssembly/C_to_wasm
+tags:
+  - C
+  - C++
+  - Emscripten
+  - WebAssembly
+  - wasm
+  - 编译
+translation_of: WebAssembly/C_to_wasm
+---
+<div>{{WebAssemblySidebar}}</div>
+
+<p class="summary">当你在用C/C++之类的语言编写模块时，你可以使用<a href="/en-US/docs/Mozilla/Projects/Emscripten">Emscripten</a>来将它编译到WebAssembly。让我们来看看它是如何工作的。</p>
+
+<h2 id="Emscripten_环境安装">Emscripten 环境安装</h2>
+
+<p>首先，让我们来配置所需要的开发环境。</p>
+
+<h3 id="所需条件">所需条件</h3>
+
+<p>你需要将下列工具安装在您的电脑上，首先让我们确认下都有哪些。</p>
+
+<ul>
+ <li><a href="https://git-scm.com/">Git</a> — Linux和OS X的机器一般已经预装了，在Windows下您可以从这里下载<a href="https://git-scm.com/download/win">Git for Windows installer</a>。</li>
+ <li>CMake — 在Linux或者OS X上，使用类似 apt-get 或 <a href="http://brew.sh/">brew</a> 这样的包管理器来安装它，请确保依赖以及路径是否正确。在Windows上，使用<a href="https://cmake.org/download/">CMake installer</a>。</li>
+ <li>主系统编译器 — 在Linux下，<a href="http://askubuntu.com/questions/154402/install-gcc-on-ubuntu-12-04-lts">安装 GCC</a>。在OS X下，<a href="https://itunes.apple.com/us/app/xcode/id497799835">安装 Xcode</a>。在Windows下，安装<a href="https://www.microsoft.com/en-us/download/details.aspx?id=48146">Visual Studio Community 2015 with Update 3 or newer</a>。</li>
+ <li>Python 2.7.x — On Linux and OS X, this is most likely provided out of the box. 从 <a href="https://wiki.python.org/moin/BeginnersGuide/Downloadhere">初学者指南</a> 获取帮助。 在 Windows 上, 从 <a href="https://www.python.org/downloads/">Python 主页</a>获取安装包。</li>
+</ul>
+
+<div class="note">
+<p><strong>注意: </strong>在Windows下您可能需要<a href="https://sourceforge.net/projects/pywin32/files/pywin32/">pywin32</a>，为了降低安装pywin32可能遇到的错误，请使用管理员权限在cmd内运行安装程序。</p>
+</div>
+
+<h3 id="编译Emscripten">编译Emscripten</h3>
+
+<p>接下来，您需要通过源码自己编译一个Emscripten。运行下列命令来自动化地使用Emscripten SDK。(在你想保存Emscripten的文件夹下运行)。</p>
+
+<pre class="brush: bash notranslate">git clone https://github.com/juj/emsdk.git
+cd emsdk
+
+# 在 Linux 或者 Mac OS X 上
+./emsdk install --build=Release sdk-incoming-64bit binaryen-master-64bit
+./emsdk activate --global --build=Release sdk-incoming-64bit binaryen-master-64bit
+# 如果在你的macos上获得以下错误
+Error: No tool or SDK found by name 'sdk-incoming-64bit'
+# 请执行
+<code>./emsdk install latest
+</code># 按照提示配置环境变量即可
+./emsdk activate latest
+
+
+# 在 Windows 上
+emsdk install --build=Release sdk-incoming-64bit binaryen-master-64bit
+emsdk activate --global --build=Release sdk-incoming-64bit binaryen-master-64bit
+
+# 注意：Windows 版本的 Visual Studio 2017 已经被支持，但需要在 emsdk install 需要追加 --vs2017 参数。
+</pre>
+
+<p> 安装过程可以会花上一点时间，是时候去休息一下。安装程序会设置所有Emscripten运行所需要的环境变量。</p>
+
+<div class="note">
+<p><strong>注意: </strong>--global标识会让PATH变量在全局被设置，所以接下来所打开的终端或者命令行窗口都会被设置。如果您仅仅想让Emscripten在当前窗口生效，就删掉这个标识。</p>
+</div>
+
+<div class="note">
+<p><strong>注意</strong>: 每当您想要使用Emscripten时，尝试从远程更新最新的emscripten代码是个很好的习惯（运行 git pull）。如果有更新，重新执行 install 和 activate 命令。这样就可以确保您使用的Emscripten一直保持最新。</p>
+</div>
+
+<p>现在让我们进入emsdk文件夹，输入以下命令来让你进入接下来的流程，编译一个样例C程序到asm.js或者wasm。</p>
+
+<pre class="brush: bash notranslate"># on Linux or Mac OS X
+source ./emsdk_env.sh
+
+# on Windows
+emsdk_env.bat
+</pre>
+
+<h2 id="编译样例代码">编译样例代码</h2>
+
+<p>现在环境配置完毕，让我们看看如何使用它把C代码编译到Emscripten。当使用Emscripten来编译的时候有很多种不同的选择，我们介绍其中主要的2种：</p>
+
+<ul>
+ <li>编译到 wasm 并且生成一个用来运行我们代码的HTML，将所有 wasm 在web环境下运行所需要的 “胶水” JavaScript代码都添加进去。</li>
+ <li>编译到 wasm 然后仅仅生成 JavaScript。</li>
+</ul>
+
+<p>让我们一个一个看看。</p>
+
+<h3 id="生成_HTML_和_JavaScript">生成 HTML 和 JavaScript</h3>
+
+<p>我们先来看一个最简单的例子，通过这个，你可以使用Emscripten来将任何代码生成到WebAssembly，然后在浏览器上运行。</p>
+
+<ol>
+ <li>首先我们需要编译一段样例代码。将下方的C代码复制一份然后命名为hello.c保存在一个新的文件夹内。
+  <pre class="brush: cpp notranslate">#include &lt;stdio.h&gt;
+
+int main(int argc, char ** argv) {
+  printf("Hello World\n");
+}</pre>
+ </li>
+ <li>现在，转到一个已经配置过Emscripten编译环境的终端窗口中，进入刚刚保存hello.c文件的文件夹中，然后运行下列命令：
+  <pre class="brush: bash notranslate">emcc hello.c -s WASM=1 -o hello.html</pre>
+ </li>
+</ol>
+
+<p>下面列出了我们命令中选项的细节：</p>
+
+<ul>
+ <li><code>-s WASM=1</code> — 指定我们想要的wasm输出形式。如果我们不指定这个选项，Emscripten默认将只会生成<a href="http://asmjs.org/">asm.js</a>。</li>
+ <li><code>-o hello.html</code> — 指定这个选项将会生成HTML页面来运行我们的代码，并且会生成wasm模块，以及编译和实例化wasm模块所需要的“胶水”js代码，这样我们就可以直接在web环境中使用了。</li>
+</ul>
+
+<p>这个时候在您的源码文件夹应该有下列文件:</p>
+
+<ul>
+ <li><code>hello.wasm</code>     二进制的wasm模块代码</li>
+ <li><code>hello.js</code>         一个包含了用来在原生C函数和JavaScript/wasm之间转换的胶水代码的JavaScript文件</li>
+ <li><code>hello.html</code>     一个用来加载，编译，实例化你的wasm代码并且将它输出在浏览器显示上的一个HTML文件</li>
+</ul>
+
+<h3 id="运行你的例子">运行你的例子</h3>
+
+<p>现在使用一个支持 WebAssembly 的浏览器，加载生成的 <code>hello.html</code> 。</p>
+
+<div class="note">
+<p>提示 ：Firefox 52+ 和 Chrome 57+ 和最新版本的 Opera 已经默认启用，你也可以在 Firefox 47+ 中通过在 <em>about:config</em> 页面启用 <code>javascript.options.wasm</code> 字段获得支持，Chrome 51+ 和 Opera 38+ 可以在 <em>chrome://flags 页面启用 Experimental WebAssembly 选项以支持 </em>WebAssembly<em>。</em></p>
+</div>
+
+<p>如果一切顺利，你应该可以在页面上的 <code>Emscripten 控制台</code>和 <code>浏览器控制台</code> 中看到 "Hello World" 的输出。</p>
+
+<p>恭喜！你已经成功将 C 代码编译成 JavaScript 并且在浏览器中执行了！</p>
+
+<h2 id="使用自定义HTML模板">使用自定义HTML模板</h2>
+
+<p>有些时候你可能想要使用一个自定义的 HTML 模板。让我们看看怎么实现。</p>
+
+<ol>
+ <li>
+  <p>首先，在一个新文件夹中保存以下 C 代码到 hello2.c 中：</p>
+
+  <pre class="brush: cpp notranslate">#include &lt;stdio.h&gt;
+
+int main(int argc, char ** argv) {
+    printf("Hello World\n");
+}</pre>
+ </li>
+ <li>
+  <p>在  emsdk 中搜索一个叫做 <code>shell_minimal.html</code> 的文件，然后复制它到刚刚创建的目录下的 <code>html_template</code> 文件夹。</p>
+
+  <pre class="brush: bash notranslate">mkdir html_template
+cp ~/emsdk/emscripten/1.38.15/src/shell_minimal.html html_template</pre>
+ </li>
+ <li>
+  <p>现在使用你的Emscripten编译器环境的终端窗口进入你的新目录， 然后运行下面的命令：</p>
+
+  <pre class="brush: bash notranslate">emcc -o hello2.html hello2.c -O3 -s WASM=1 --shell-file html_template/shell_minimal.html</pre>
+
+  <p>这次使用的选项略有不同：</p>
+
+  <ul>
+   <li>我们使用了 <code>-o hello2.html</code> ，这意味编译器将仍然输出 js 胶水代码 和 html 文件。</li>
+   <li>我们还使用了 <code>--shell-file html_template/shell_minimal.html</code> ，这指定了您要运行的例子使用 HTML 页面模板。</li>
+  </ul>
+ </li>
+ <li>
+  <p>下面让我们来运行这个例子。上面的命令已经生成了 hello2.html，内容和我们使用的模板非常相像，只不过多加了一些 js 胶水和加载wasm文件的代码。 在浏览器中打开它，你会看到与上一个例子相同的输出。</p>
+ </li>
+</ol>
+
+<div class="note">
+<p><strong>注意：</strong>通过用.js取代.htm(l)作为文件后缀名，你就可以得到只有JavaScript的输出文件，而不再是完整的HTML文件。例如：<code>emcc -o hello2.js hello2.c -O3 -s WASM=1</code>. 你可以完全从零开始创建你自己的HTML文件。尽管如此，不推荐这样做。因为Emscripten需要大量的JavaScript“胶水”代码从而能够 处理内存分配、内存泄漏以及大量的其他问题。这些问题都已经在提供的模板中得到了处理。使用模板要比自己编写模板要容易得多。不过，当对模板所做的事情越来越熟悉的时候，你就能够按照自己的需要创建定制化的模板了。</p>
+</div>
+
+<h2 id="调用一个定义在C中的自定义方法">调用一个定义在C中的自定义方法</h2>
+
+<p>如果需要调用一个在 C 语言自定义的函数，你可以使用  Emscripten 中的 <code>ccall()</code> 函数，以及 <code>EMSCRIPTEN_KEEPALIVE</code> 声明 （将你的函数添加到导出函数列表中（详见 <a href="https://kripken.github.io/emscripten-site/docs/getting_started/FAQ.html#why-do-functions-in-my-c-c-source-code-vanish-when-i-compile-to-javascript-and-or-i-get-no-functions-to-process">Why do functions in my C/C++ source code vanish when I compile to JavaScript, and/or I get No functions to process?</a>））。</p>
+
+<p>接下来让我们看看这是怎么实现的。</p>
+
+<ol>
+ <li>
+  <p>首先，将以下代码在新目录中保存为 <code>hello3.c</code> ：</p>
+
+  <pre class="brush: cpp notranslate">#include &lt;stdio.h&gt;
+#include &lt;emscripten/emscripten.h&gt;
+
+int main(int argc, char ** argv) {
+    printf("Hello World\n");
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int EMSCRIPTEN_KEEPALIVE myFunction(int argc, char ** argv) {
+  printf("我的函数已被调用\n");
+}
+
+#ifdef __cplusplus
+}
+#endif</pre>
+
+  <p>默认情况下，Emscripten 生成的代码只会调用 <code>main()</code> 函数，其它的函数将被视为无用代码。在一个函数名之前添加 <code>EMSCRIPTEN_KEEPALIVE</code> 能够防止这样的事情发生。你需要导入 <code>emscripten.h</code> 库来使用 <code>EMSCRIPTEN_KEEPALIVE</code>。</p>
+
+  <div class="note">
+  <p><strong>注意</strong>: 为了保证万一你想在 C++ 代码中引用这些代码时代码可以正常工作，我们添加了 <code>#ifdef</code> 代码块。由于 C 与 C++ 中名字修饰规则的差异，添加的代码块有可能产生问题，但目前我们设置了这一额外的代码块以保证你使用 C++ 时，这些代码会被视为外部 C 语言函数。</p>
+  </div>
+ </li>
+ <li>
+  <p>为了方便起见，现在将 <code>html_template/shell_minimal.html</code> 也添加到这一目录（但在实际开发环境中你肯定需要将其放到某一特定位置）。</p>
+ </li>
+ <li>
+  <p>运行以下命令编译：(注意由于使用ccall函数，需要添加指定参数)</p>
+
+  <pre class="brush: bash notranslate">emcc -o hello3.html hello3.c -O3 -s WASM=1 -s "EXTRA_EXPORTED_RUNTIME_METHODS=['ccall']" --shell-file html_template/shell_minimal.html</pre>
+ </li>
+ <li>
+  <p>如果你在浏览器中在此加载实例，你将看到和之前相同的结果。</p>
+ </li>
+ <li>
+  <p>现在我们需要运行新的 <code>myFunction()</code> JavaScript 函数。首先，按照以下实例添加一个 {{htmlelement("button")}} ，就在 <code>&lt;script type='text/javascript'&gt;</code> 开头标签之前。</p>
+
+  <pre class="brush: html notranslate">&lt;button class="mybutton"&gt;运行我的函数&lt;/button&gt;</pre>
+ </li>
+ <li>
+  <p>现在在最后一个 {{htmlelement("script")}} 元素 （就在 <code>&lt;/script&gt;</code> 关闭标签之前）中添加以下代码：</p>
+
+  <pre class="brush: js notranslate">document.querySelector('.mybutton').addEventListener('click', function(){
+  alert('检查控制台');
+  var result = Module.ccall('myFunction', // name of C function
+                             null, // return type
+                             null, // argument types
+                             null); // arguments
+});</pre>
+ </li>
+</ol>
+
+<p>以上就是如何使用 <code>ccall()</code> 调用导出的函数的方式。</p>
+
+<h2 id="另请参见">另请参见</h2>
+
+<ul>
+ <li><a href="http://emscripten.org/">emscripten.org</a> — 了解更多 Emscripten 以及它的多种设置</li>
+ <li><a href="https://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/Interacting-with-code.html#calling-compiled-c-functions-from-javascript-using-ccall-cwrap">Calling compiled C functions from JavaScript using ccall/cwrap</a></li>
+ <li><a href="https://kripken.github.io/emscripten-site/docs/getting_started/FAQ.html#why-do-functions-in-my-c-c-source-code-vanish-when-i-compile-to-javascript-and-or-i-get-no-functions-to-process">Why do functions in my C/C++ source code vanish when I compile to JavaScript, and/or I get No functions to process?</a></li>
+ <li><a href="https://research.mozilla.org/webassembly/">WebAssembly on Mozilla Research</a></li>
+ <li>
+  <p><a href="https://wiki.developer.mozilla.org/en-US/docs/WebAssembly/existing_C_to_wasm">Compiling an Existing C Module to WebAssembly</a></p>
+ </li>
+</ul>
diff --git a/files/zh-cn/webassembly/caching_modules/index.html b/files/zh-cn/webassembly/caching_modules/index.html
new file mode 100644
index 0000000000..0a74fcb5d2
--- /dev/null
+++ b/files/zh-cn/webassembly/caching_modules/index.html
@@ -0,0 +1,156 @@
+---
+title: 缓存已编译的WebAssembly模块
+slug: WebAssembly/Caching_modules
+tags:
+  - IndexedDB
+  - JavaScript
+  - WebAssembly
+  - wasm
+  - 模块
+  - 缓存
+  - 编译
+translation_of: WebAssembly/Caching_modules
+---
+<div>{{WebAssemblySidebar}}</div>
+
+<p class="summary">对于提高应用的性能来说，缓存是很有用的——我们可以在客户端存储已编译的WebAssembly模块，从而可以避免每次都下载和编译它们。本文解释了这方面的最佳实践。</p>
+
+<h2 id="使用IndexedDB实现缓存">使用IndexedDB实现缓存</h2>
+
+<p><a href="https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API">IndexedDB</a>是一个事务型数据库系统，它允许你在客户端存储和获取结构化数据。它适合在本地保存包含应用程序状态的资源，包括文本、二进制大对象以及其他任何可以克隆的对象。</p>
+
+<p>这包括已编译的wasm模块（{{jsxref("WebAssembly.Module")}} JavaScript对象）。</p>
+
+<h2 id="建立缓存库">建立缓存库</h2>
+
+<p>因为IndexedDB在一定程度上是老式风格的API，所以，我们想提供一个库函数以便加快写缓存代码的速度并使它能够更好的与当今更现代的API配合。</p>
+
+<p>在我们的<a href="https://github.com/mdn/webassembly-examples/blob/master/wasm-utils.js">wasm-utils.js</a>脚本库中，你会发现instantiateCachedURL()——该函数使用给定版本的dbVersion获取给定url的wasm模块，使用给定的importObject实例化，并且返回一个将会解析成最终的wasm实例的promise。而且，它会创建一个用来把已编译的wasm模块缓存起来的数据库，尝试在数据库中存储新的模块，并且从数据库中获取之前缓存的模块，从而使你免于再次下载它们。</p>
+
+<div class="note">
+<p><strong>注</strong>： 整个网站的wasm缓存（不只是给定的URL）是通过传入到函数中的dbVersion进行版本控制的。如果wasm模块代码更新了或者它的URL发生了变化，你需要更新dbVersion。对于instantiateCachedURL()的任何后续调用将会清除掉全部的缓存，从而使你避免使用过时的模块。</p>
+</div>
+
+<p>该函数从定义一些必要的常量开始：</p>
+
+<pre class="brush: js">function instantiateCachedURL(dbVersion, url, importObject) {
+  const dbName = 'wasm-cache';
+  const storeName = 'wasm-cache';</pre>
+
+<h3 id="建立数据库">建立数据库</h3>
+
+<p class="brush: js">在instantiateCachedURL()中的第一个辅助函数openDatabase()，创建一个存储wasm模块的对象存储空间，以及在dbVersion更新后清除数据库；它返回一个解析成新的数据库的promise。</p>
+
+<pre class="brush: js">  function openDatabase() {
+    return new Promise((resolve, reject) =&gt; {
+      var request = indexedDB.open(dbName, dbVersion);
+      request.onerror = reject.bind(null, 'Error opening wasm cache database');
+      request.onsuccess = () =&gt; { resolve(request.result) };
+      request.onupgradeneeded = event =&gt; {
+        var db = request.result;
+        if (db.objectStoreNames.contains(storeName)) {
+            console.log(`Clearing out version ${event.oldVersion} wasm cache`);
+            db.deleteObjectStore(storeName);
+        }
+        console.log(`Creating version ${event.newVersion} wasm cache`);
+        db.createObjectStore(storeName)
+      };
+    });
+  }</pre>
+
+<h3 id="在数据库中查找模块">在数据库中查找模块</h3>
+
+<p>我们的下一个函数lookupInDatabase()，提供了一个简单的基于promise的操作，用来在我们之前创建的对象存储空间中查找给定的url。如果成功，它可以解析出存储的已编译模块；如果失败，它会给出一个错误。</p>
+
+<pre class="brush: js">  function lookupInDatabase(db) {
+    return new Promise((resolve, reject) =&gt; {
+      var store = db.transaction([storeName]).objectStore(storeName);
+      var request = store.get(url);
+      request.onerror = reject.bind(null, `Error getting wasm module ${url}`);
+      request.onsuccess = event =&gt; {
+        if (request.result)
+          resolve(request.result);
+        else
+          reject(`Module ${url} was not found in wasm cache`);
+      }
+    });
+  }</pre>
+
+<h3 id="存储和实例化模块">存储和实例化模块</h3>
+
+<p>接下来，我们定义了一个函数storeInDatabase()，它可以触发一个异步操作，从而在给定的数据库中存储给定的wasm模块。</p>
+
+<pre class="brush: js">  function storeInDatabase(db, module) {
+    var store = db.transaction([storeName], 'readwrite').objectStore(storeName);
+    var request = store.put(module, url);
+    request.onerror = err =&gt; { console.log(`Failed to store in wasm cache: ${err}`) };
+    request.onsuccess = err =&gt; { console.log(`Successfully stored ${url} in wasm cache`) };
+  }</pre>
+
+<p>最后，我们定义一个辅助函数——fetchAndInstantiate()，它从给定的url获取数据，将其编译成一个模块，并且使用给定的导入对象实例化该模块。</p>
+
+<pre class="brush: js">  function fetchAndInstantiate() {
+    return fetch(url).then(response =&gt;
+      response.arrayBuffer()
+    ).then(buffer =&gt;
+      WebAssembly.instantiate(buffer, importObject)
+    )
+  }</pre>
+
+<h3 id="使用辅助函数">使用辅助函数</h3>
+
+<p>使用这些定义好的基于Promise的辅助函数，我们现在可以表达一个IndexedDB缓存查找的核心逻辑了。首先，我们通过尝试打开一个数据库，然后，查看在给定的数据库db中是否存在与url相对应的模块：</p>
+
+<pre class="brush: js">  return openDatabase().then(db =&gt; {
+    return lookupInDatabase(db).then(module =&gt; {</pre>
+
+<p>如果找到了模块，那么，使用给定的导入对象对其进行实例化：</p>
+
+<pre class="brush: js">      console.log(`Found ${url} in wasm cache`);
+      return WebAssembly.instantiate(module, importObject);
+    },</pre>
+
+<p>如果没有找到，那么，我们从零开始编译它，然后，使用给定的url作为键，将已编译的模块存储到数据库中，方便下次使用。</p>
+
+<pre class="brush: js">    errMsg =&gt; {
+      console.log(errMsg);
+      return fetchAndInstantiate().then(results =&gt; {
+        storeInDatabase(db, results.module);
+        return results.instance;
+      });
+    })
+  },</pre>
+
+<div class="note">
+<p><strong>注</strong>：<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate">WebAssembly.instantiate()</a>返回一个<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module">模块</a>和<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance">实例</a>为的就是这种用处：模块表示已经编译的代码，并且可以在IndexedDB中存取或者通过<a href="https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage">postMessage()</a>在Workers之间共享；实例是具有状态的，并且包含了可以调用的JavaScript函数，因此不能够被存储或者共享。</p>
+</div>
+
+<p>如果打开数据库失败（比如由于权限或者空间限制），我们改用获取和编译模块的方式，并且不再尝试保存结果（因为没有数据库可以保存它们）。</p>
+
+<pre class="brush: js">  errMsg =&gt; {
+    console.log(errMsg);
+    return fetchAndInstantiate().then(results =&gt;
+      results.instance
+    );
+  });
+}</pre>
+
+<h2 id="缓存wasm模块">缓存wasm模块</h2>
+
+<p>有了上面定义的库函数，取得一个wasm模块实例，并且使用它的导出特性（同时在后台处理缓存）只需要使用下面的参数进行调用即可：</p>
+
+<ul>
+ <li>缓存的版本号——正如我们上面解释的那样，当任何wasm模块发生更新或者移动到不同的URL，你都需要更新它。</li>
+ <li>你想要实例化的wasm模块的URL。</li>
+ <li>一个可选的导入对象。</li>
+</ul>
+
+<pre class="brush: js">const wasmCacheVersion = 1;
+
+instantiateCachedURL(wasmCacheVersion, 'test.wasm').then(instance =&gt;
+  console.log("Instance says the answer is: " + instance.exports.answer())
+).catch(err =&gt;
+  console.error("Failure to instantiate: " + err)
+);</pre>
+
+<p>你可以在GitHub上找到这个例子的源代码 <a href="https://github.com/mdn/webassembly-examples/blob/master/other-examples/indexeddb-cache.html">indexeddb-cache.html</a> (或者<a href="https://mdn.github.io/webassembly-examples/other-examples/indexeddb-cache.html">实时运行</a>)。</p>
diff --git a/files/zh-cn/webassembly/concepts/index.html b/files/zh-cn/webassembly/concepts/index.html
new file mode 100644
index 0000000000..baf2881e6d
--- /dev/null
+++ b/files/zh-cn/webassembly/concepts/index.html
@@ -0,0 +1,169 @@
+---
+title: WebAssembly概念
+slug: WebAssembly/Concepts
+tags:
+  - C
+  - C++
+  - Emscripten
+  - JavaScript
+  - WebAssembly
+  - 文本格式
+  - 概念
+  - 网络平台
+translation_of: WebAssembly/Concepts
+---
+<p>{{WebAssemblySidebar}}</p>
+
+<p>本文解释了WebAssembly如何工作的概念，包括它的目标、它解决的问题以及它是如何在网络浏览器的渲染引擎中运行的。</p>
+
+<h2 id="WebAssembly是什么？">WebAssembly是什么？</h2>
+
+<p>WebAssembly是一种运行在现代网络浏览器中的新型代码，并且提供新的性能特性和效果。它设计的目的不是为了手写代码而是为诸如C、C++和Rust等低级源语言提供一个高效的编译目标。</p>
+
+<p>对于网络平台而言，这具有巨大的意义——这为客户端app提供了一种在网络平台以接近本地速度的方式运行多种语言编写的代码的方式；在这之前，客户端app是不可能做到的。</p>
+
+<p>而且，你在不知道如何编写WebAssembly代码的情况下就可以使用它。WebAssembly的模块可以被导入的到一个网络app（或Node.js）中，并且暴露出供JavaScript使用的WebAssembly函数。JavaScript框架不但可以使用WebAssembly获得巨大性能优势和新特性，而且还能使得各种功能保持对网络开发者的易用性。</p>
+
+<h2 id="WebAssembly的目标">WebAssembly的目标</h2>
+
+<p>作为 <a href="https://www.w3.org/community/webassembly/">W3C WebAssembly Community Group</a>中的一项开放标准，WebAssembly是为下列目标而生的：</p>
+
+<ul>
+ <li>快速、高效、可移植——通过利用<a href="http://webassembly.org/docs/portability/#assumptions-for-efficient-execution">常见的硬件能力</a>，WebAssembly代码在不同平台上能够以接近本地速度运行。</li>
+ <li>可读、可调试——WebAssembly是一门低阶语言，但是它有确实有一种人类可读的文本格式（其标准即将得到最终版本），这允许通过手工来写代码，看代码以及调试代码。</li>
+ <li>保持安全——WebAssembly被限制运行在一个安全的沙箱执行环境中。像其他网络代码一样，它遵循浏览器的同源策略和授权策略。</li>
+ <li>不破坏网络——WebAssembly的设计原则是与其他网络技术和谐共处并保持向后兼容。</li>
+</ul>
+
+<div class="note">
+<p>注：WebAssembly也用在网络和JavaScript环境之外（参考<a href="http://webassembly.org/docs/non-web/">非网络嵌入</a>）。</p>
+</div>
+
+<h2 id="WebAssembly如何适应网络平台？">WebAssembly如何适应网络平台？</h2>
+
+<p>网络平台可以被想象成拥有两个部分：</p>
+
+<ul>
+ <li>一个运行网络程序（Web app）代码——比如，给你的程序提供能力的JavaScript——的虚拟机</li>
+ <li>一系列网络程序能够调用从而控制网络浏览器/设备功能，并且能够让事物发生变化的网络API（<a href="/en-US/docs/Web/API/Document_Object_Model">DOM</a>、<a href="/en-US/docs/Web/API/CSS_Object_Model">CSSOM</a>、<a href="/en-US/docs/Web/API/WebGL_API">WebGL</a>、<a href="/en-US/docs/Web/API/IndexedDB_API">IndexedDB</a>、<a href="/en-US/docs/Web/API/Web_Audio_API">Web Audio API</a>等）。</li>
+</ul>
+
+<p>从历史角度讲，虚拟机过去只能加载JavaScript。这对我们而言足够了，因为JavaScript足够强大从而能够解决人们在当今网络上遇到的绝大部分问题。尽管如此，当试图把JavaScript应用到诸如3D游戏、虚拟现实、增强现实、计算机视觉、图像/视频编辑以及大量的要求原生性能的其他领域的时候，我们遇到了性能问题（参考 <a href="http://webassembly.org/docs/use-cases/">WebAssembly 使用案例</a> 获取更多细节）。</p>
+
+<p>而且，下载、解析以及编译巨大的JavaScript应用程序的成本是过高的。移动平台和其他资源受限平台进一步放大了这些性能瓶颈。</p>
+
+<p>WebAssembly是一门不同于JavaScript的语言，但是，它不是用来取代JavaScript的。相反，它被设计为和JavaScript一起协同工作，从而使得网络开发者能够利用两种语言的优势：</p>
+
+<ul>
+ <li>JavaScript是一门高级语言。对于写网络应用程序而言，它足够灵活且富有表达力。它有许多优势——它是动态类型的，不需要编译环节以及一个巨大的能够提供强大框架、库和其他工具的生态系统。</li>
+ <li>WebAssembly是一门低级的类汇编语言。它有一种紧凑的二进制格式，使其能够以接近原生性能的速度运行，并且为诸如C++和Rust等拥有低级的内存模型语言提供了一个编译目标以便它们能够在网络上运行。（注意，WebAssembly有一个在将来支持使用了垃圾回收内存模型的语言的高级目标。）</li>
+</ul>
+
+<p>随着WebAssembly出现在了浏览器中，我们前面提到的虚拟机将会加载和运行两种类型的代码——JavaScript和WebAssembly。</p>
+
+<p>不同类型的代码能够按照需要进行相互调用——WebAssembly的JavaScript API使用能够被正常调用的JavaScript函数封装了导出的WebAssembly代码，并且WebAssembly代码能够导入和同步调用常规的JavaScript函数。事实上，WebAssembly代码的基本单元被称作一个模块，并且WebAssembly的模块在很多方面都和ES2015的模块是等价的。</p>
+
+<h3 id="WebAssembly关键概念">WebAssembly关键概念</h3>
+
+<p>为了理解WebAssembly如何在浏览器中运行，需要了解几个关键概念。所有这些概念都是一一映射到了<a href="/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly">WebAssembly的JavaScript API</a>中。</p>
+
+<ul>
+ <li><strong>模块</strong>：表示一个已经被浏览器编译为可执行机器码的WebAssembly二进制代码。一个模块是无状态的，并且像一个<a href="/zh-CN/docs/Web/API/Blob">二进制大对象</a>（Blob）一样能够<a href="/zh-CN/docs/WebAssembly/Caching_modules">被缓存到IndexedDB</a>中或者在windows和workers之间进行共享（通过<a href="/zh-CN/docs/Web/API/MessagePort/postMessage">postMessage()</a>函数）。一个模块能够像一个ES2015的模块一样声明导入和导出。</li>
+ <li><strong>内存</strong>：ArrayBuffer，大小可变。本质上是连续的字节数组，WebAssembly的低级内存存取指令可以对它进行读写操作。</li>
+ <li><strong>表格</strong>：带类型数组，大小可变。表格中的项存储了<strong>不能作为原始字节存储在内存里的对象</strong>的引用（为了安全和可移植性的原因）。</li>
+ <li><strong>实例</strong>：一个模块及其在运行时使用的所有状态，包括内存、表格和一系列导入值。一个实例就像一个已经被加载到一个拥有一组特定导入的特定的全局变量的ES2015模块。</li>
+</ul>
+
+<p>JavaScript API为开发者提供了创建模块、内存、表格和实例的能力。给定一个WebAssembly实例，JavaScript代码能够调用普通JavaScript函数暴露出来的导出代码。通过把JavaScript函数导入到WebAssembly实例中，任意的JavaScript函数都能被WebAssembly代码同步调用。</p>
+
+<p>因为JavaScript能够完全控制WebAssembly代码如何下载、编译运行，所以，JavaScript开发者甚至可以把WebAssembly想象成一个高效地生成高性能函数的JavaScript特性。</p>
+
+<p>将来，WebAssembly模块将会<a href="http://webassembly.org/docs/modules/#integration-with-es6-modules">像ES2015模块那样加载</a>（使用&lt;script type='module'&gt;)，这也就意味着JavaScript代码能够像轻松地使用一个ES2015模块那样来获取、编译和导入一个WebAssembly模块。</p>
+
+<h2 id="如何在我的app中使用WebAssembly？">如何在我的app中使用WebAssembly？</h2>
+
+<p>上面我们讨论了WebAssembly向网络平台增加的基本要素：</p>
+
+<ul>
+ <li>代码的二进制格式</li>
+ <li>加载运行该二进制代码的API</li>
+</ul>
+
+<p>现在让我们讨论如何在实践中使用这些基本要素。</p>
+
+<p>WebAssembly生态系统处在初始阶段；更多的工具会毫无疑问得不断出现。当然，有两个主要的着手点：</p>
+
+<ul>
+ <li>使用Emscripten移植一个C/C++应用程序。</li>
+ <li>直接在汇编层，编写或生成WebAssembly代码。</li>
+ <li>编写Rust程序，将WebAssembly作为它的输出。</li>
+</ul>
+
+<p>让我们讨论这几项：</p>
+
+<h3 id="从CC移植">从C/C++移植</h3>
+
+<p> </p>
+
+<p>创建WASM代码的众多选项中有两个是在线WASM汇编程序或<a href="/zh-CN/docs/Mozilla/Projects/Emscripten">Emscripten</a>。有许多在线WASM汇编程序可供选择，例如：</p>
+
+<ul>
+ <li><a href="https://wasdk.github.io/WasmFiddle/">WasmFiddle</a></li>
+ <li><a href="https://anonyco.github.io/WasmFiddle/">WasmFiddle++</a></li>
+ <li><a href="https://mbebenita.github.io/WasmExplorer/">WasmExplorer</a></li>
+</ul>
+
+<p>对于那些想知道从哪里开始的人来说，这些是很好的资源，但是他们缺少一些Emscripten的工具和优化。</p>
+
+<p>Emscripten工具能够将一段C/C++代码，编译出：</p>
+
+<ul>
+ <li>一个.wasm模块</li>
+ <li>用来加载和运行该模块的JavaScript”胶水“代码</li>
+ <li>一个用来展示代码运行结果的HTML文档</li>
+</ul>
+
+<p><img alt="" src="https://mdn.mozillademos.org/files/14647/emscripten-diagram.png"></p>
+
+<p>简而言之，工作流程如下所示：</p>
+
+<ol>
+ <li>Emscripten首先把C/C++提供给clang+LLVM——一个成熟的开源C/C++编译器工具链，比如，在OSX上是XCode的一部分。</li>
+ <li>Emscripten将clang+LLVM编译的结果转换为一个.wasm二进制文件。</li>
+ <li>就自身而言，WebAssembly当前不能直接的存取DOM；它只能调用JavaScript，并且只能传入整形和浮点型的原始数据类型作为参数。这就是说，为了使用任何Web API，WebAssembly需要调用到JavaScript，然后由JavaScript调用Web API。因此，Emscripten创建了HTML和JavaScript胶水代码以便完成这些功能。</li>
+</ol>
+
+<div class="note">
+<p>注意：计划将来<a href="https://github.com/WebAssembly/gc/blob/master/README.md">允许WebAssembly直接调用Web API</a>。</p>
+</div>
+
+<p>JavaScript胶水代码并不是像你想象的那么简单。首先，Emscripten实现了流行的C/C++库，比如， <a href="https://en.wikipedia.org/wiki/Simple_DirectMedia_Layer">SDL</a>、 <a href="https://en.wikipedia.org/wiki/OpenGL">OpenGL</a>、 <a href="https://en.wikipedia.org/wiki/OpenAL">OpenAL</a>以及部分<a href="https://en.wikipedia.org/wiki/POSIX">POSIX</a>。这些库以Web API的形式实现，并且每个库需要一个JavaScript胶水代码来连接WebAssembly和低层的Web API。</p>
+
+<p>因此，部分胶水代码实现了C/C++代码使用的库的功能。而且，胶水代码还包括调用前面提到的WebAssembly的JavaScript API来获取、加载和运行.wasm文件的逻辑。</p>
+
+<p>生成的HTML文档加载JavaScript胶水文件，并且将stdout输出到{{htmlelement("textarea")}}。如果应用程序使用了OpenGL，HTML文档还会包含一个用来渲染目标的{{htmlelement("canvas")}}标签。</p>
+
+<p>修改Emscripten的输出文件并将其转换为需要的web app是很容易的。</p>
+
+<p>你可以在<a href="http://emscripten.org">emscripten.org</a>找到关于Emscripten的完整文档以及在<a href="/zh-CN/docs/WebAssembly/C_to_wasm">Compiling from C/C++ to WebAssembly</a>找到一个实现工具链并交叉编译你自己的C/C++应用程序为wasm的指南。</p>
+
+<h3 id="直接编写WebAssembly代码">直接编写WebAssembly代码</h3>
+
+<p>你想构建自己的编译器，或者你自己的工具，或者创建一个能够在运行时生成WebAssembly代码的JavaScript库？</p>
+
+<p>就像真实的汇编语言一样，WebAssembly的二进制格式也有文本表示——两者之间1:1对应。你可以手工书写或者生成这种格式然后使用这些工具（<a href="http://webassembly.org/getting-started/advanced-tools/">WebAssemby text-to-binary tools</a>）中的任何一个把它转换为二进制格式。</p>
+
+<p>这有一份如何做这些的简单指南，参考我们的文章<a href="/zh-CN/docs/WebAssembly/Text_format_to_wasm">转换WebAssembly文本格式为wasm</a>。</p>
+
+<h2 id="总结">总结</h2>
+
+<p>本文给你解释了WebAssembly是什么，它为什么如此有用，它是如何适应网络的以及你如何才能使用它。</p>
+
+<h2 id="参考">参考</h2>
+
+<ul>
+ <li><a href="https://hacks.mozilla.org/category/webassembly/">Mozilla Hacks博客上关于WebAssembly的文章</a></li>
+ <li><a href="https://research.mozilla.org/webassembly/">Mozilla Research上关于WebAssembly的文章</a></li>
+ <li><a href="/zh-CN/docs/WebAssembly/Loading_and_running">加载运行WebAssembly代码</a>——探究如何把你自己的WebAssembly模块加载到网页中。</li>
+ <li><a href="/zh-CN/docs/WebAssembly/Using_the_JavaScript_API">使用WebAssembly的JavaScript API</a>——探究如何使用WebAssembly的JavaScript API的其他主要特性。</li>
+</ul>
diff --git a/files/zh-cn/webassembly/exported_functions/index.html b/files/zh-cn/webassembly/exported_functions/index.html
new file mode 100644
index 0000000000..c19706f594
--- /dev/null
+++ b/files/zh-cn/webassembly/exported_functions/index.html
@@ -0,0 +1,76 @@
+---
+title: 导出的WebAssembly函数
+slug: WebAssembly/Exported_functions
+tags:
+  - JavaScript
+  - WebAssembly
+  - wasm
+  - 导出
+  - 导出的wasm函数
+  - 导出的函数
+  - 指南
+translation_of: WebAssembly/Exported_functions
+---
+<div>{{WebAssemblySidebar}}</div>
+
+<p class="summary">导出WebAssembly函数的过程，其实就是指这些函数在JavaScript中如何用表示。本文更详细的介绍它们。</p>
+
+<h2 id="导出的...什么？">导出的...什么？</h2>
+
+<p>导出的WebAssembly函数只是用JavaScript来表示WebAssembly函数的封装而已。当你调用它们的时候，就会有一些后台活动把参数转换为wasm能够处理的类型（例如，把JavaScript数字转换为Int32类型），参数被传递到wasm模块中的函数，函数被调用，返回值被转换并传回到JavaScript。</p>
+
+<p>你可以通过两种方式来获得导出的WebAssembly函数：</p>
+
+<ul>
+ <li>在一个已经存在的表格上调用<a href="https://developer.mozilla.org/en-US/docs/WebAssembly/API/Table/get">Table.prototype.get()</a>。</li>
+ <li>通过<a href="https://developer.mozilla.org/en-US/docs/WebAssembly/API/Instance/exports">Instance.exports</a>从一个wasm模块实例获取导出的函数。</li>
+</ul>
+
+<p>无论哪种方式，你得到的都是底层函数的相同封装。从JavaScript的角度来看，每一个wasm函数看起来也是一个JavaScript函数——但是，它们被封装在导出的wasm函数对象实例中，并且只有有限的方式来获取它们。</p>
+
+<h2 id="一个例子">一个例子</h2>
+
+<p>让我们看个例子从而让事情更清晰（你可以在GitHub上找到这个例子<a href="https://github.com/mdn/webassembly-examples/blob/master/other-examples/table-set.html">table-set.html</a>；或者<a href="https://mdn.github.io/webassembly-examples/other-examples/table-set.html">实时运行</a>然后查看wasm<a href="https://github.com/mdn/webassembly-examples/blob/master/text-format-examples/table.wat">文本表示</a>）：</p>
+
+<pre class="brush: js">var otherTable = new WebAssembly.Table({ element: "anyfunc", initial: 2 });
+
+fetchAndInstantiate('table.wasm').then(function(instance) {
+  var tbl = instance.exports.tbl;
+  console.log(tbl.get(0)());  // 13
+  console.log(tbl.get(1)());  // 42
+  otherTable.set(0,tbl.get(0));
+  otherTable.set(1,tbl.get(1));
+  console.log(otherTable.get(0)());
+  console.log(otherTable.get(1)());
+});</pre>
+
+<p>在这里，我们使用<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table">WebAssembly.Table</a>构造函数在JavaScript中创建了一个表格（otherTable），然后使用<a href="https://github.com/mdn/webassembly-examples/blob/master/wasm-utils.js">fetchAndInstantiate()</a>实用函数把table.wasm加载到我们的页面。</p>
+
+<p>然后，我们得到了从模块中导出的函数，通过<a href="https://developer.mozilla.org/en-US/docs/WebAssembly/API/Table/get">tbl.get()</a>获取引用的函数并且把每一次的调用结果输出到控制台。接下来，我们使用set()使得otherTable表格包含了与tbl表格相同的函数。</p>
+
+<p>为了证明这一点，我们从otherTable 中获取了这些引用并且也把他们的结果打印到控制台，结果是一样的。</p>
+
+<h2 id="它们确实是函数">它们确实是函数</h2>
+
+<p>在前面的例子中，每次<a href="https://developer.mozilla.org/en-US/docs/WebAssembly/API/Table/get">Table.prototype.get()</a>调用的返回值都是一个导出的WebAssembly函数——这正是我们一直在讨论的。</p>
+
+<p>它们确实是JavaScript函数也是对WebAssembly函数的封装。如果你把上面的例子加载到<a href="https://developer.mozilla.org/en-US/docs/WebAssembly#Browser_compatibility">支持WebAssembly的浏览器</a>中，然后在你的控制台运行下面几行代码：</p>
+
+<pre class="brush: js">var testFunc = otherTable.get(0);
+typeof testFunc;</pre>
+
+<p>你得到的返回结果是function 。对于这个函数，你可以像对待其他JavaScript<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function">函数</a>那样做你想做的任何事——<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call">call()</a>、 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind">bind()</a>等等。testFunc.toString()返回一个有趣的结果：</p>
+
+<pre class="brush: js">function 0() {
+    [native code]
+}</pre>
+
+<p>这带给你关于封装类型特征的更多理解。</p>
+
+<p>关于导出的WebAssembly函数的一些其他值得关注的特性：</p>
+
+<ul>
+ <li>它们的<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/length">length</a>属性是在wasm函数签名中声明的参数的数量。</li>
+ <li>它们的<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name">name</a>属性是函数在wasm模块中的索引调用toString()的返回值。</li>
+ <li>如果你尝试调用一个接受或返回一个i64类型值的导出的wasm函数，目前它会抛出一个错误，因为JavaScript当前没有精确的方式来表示一个i64。不过，这在将来可能会改变——在将来的标准中，新的int64类型正在考虑之中。到那时，wasm可以使用它。</li>
+</ul>
diff --git a/files/zh-cn/webassembly/index.html b/files/zh-cn/webassembly/index.html
new file mode 100644
index 0000000000..b1975ab866
--- /dev/null
+++ b/files/zh-cn/webassembly/index.html
@@ -0,0 +1,113 @@
+---
+title: WebAssembly
+slug: WebAssembly
+tags:
+  - WebAssembly
+  - wasm
+translation_of: WebAssembly
+---
+<div>{{WebAssemblySidebar}}</div>
+
+<p class="summary" dir="ltr" id="docs-internal-guid-22bb55aa-d69e-e8ef-cbc6-aafea272f684">WebAssembly是一种新的编码方式，可以在现代的网络浏览器中运行 － 它是一种低级的类汇编语言，具有紧凑的二进制格式，可以接近原生的性能运行，并为诸如C / C ++等语言提供一个编译目标，以便它们可以在Web上运行。它也被设计为可以与JavaScript共存，允许两者一起工作。</p>
+
+<h2 dir="ltr" id="简而言之">简而言之</h2>
+
+<p dir="ltr">对于网络平台而言，WebAssembly具有巨大的意义——它提供了一条途径，以使得以各种语言编写的代码都可以以接近原生的速度在Web中运行。在这种情况下，以前无法以此方式运行的客户端软件都将可以运行在Web中。</p>
+
+<p dir="ltr">WebAssembly被设计为可以和JavaScript一起协同工作——通过使用WebAssembly的JavaScript API，你可以把WebAssembly模块加载到一个JavaScript应用中并且在两者之间共享功能。这允许你在同一个应用中利用WebAssembly的性能和威力以及JavaScript的表达力和灵活性，即使你可能并不知道如何编写WebAssembly代码。</p>
+
+<p dir="ltr">而且，更棒的是，这是通过<a href="https://www.w3.org/community/webassembly/">W3C WebAssembly Community Group</a>开发的一项网络标准，并得到了来自各大主要浏览器厂商的积极参与。</p>
+
+<div class="row topicpage-table">
+<div class="section">
+<h2 dir="ltr" id="指南">指南</h2>
+
+<dl>
+ <dt><a href="/zh-CN/docs/WebAssembly/Concepts">WebAssembly概念</a></dt>
+ <dd>通过阅读WebAssembly后面的高层概念开始——也就是说，它为什么如此有用，它是如何适应网络平台的（以及其他）和如何使用它。</dd>
+ <dt><a href="/zh-CN/docs/WebAssembly/C_to_wasm">从C/C++编译为WebAssembly</a></dt>
+ <dd>当你使用C/C++编写了代码后，你可以使用诸如Emscripten的工具把它编译为.wasm文件。让我们看看这是如何工作的。</dd>
+ <dt><a href="/zh-CN/docs/WebAssembly/Loading_and_running">加载运行WebAssembly代码</a></dt>
+ <dd>本文介绍如何通过把<a href="/en-US/docs/Web/API/Fetch_API">Fetch</a>或者<a href="/en-US/docs/Web/API/XMLHttpRequest">XHR</a> API与<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly">WebAssembly JavaScript </a>API结合在一起来获取、编译和实例化.wasm文件。</dd>
+ <dt><a href="/zh-CN/docs/WebAssembly/Caching_modules">缓存编译后的WebAssembly模块</a></dt>
+ <dd>就提升应用启动速度而言，在客户端缓存大的WebAssembly模块是有用的。本文解释了如何使用<a href="/en-US/docs/Web/API/IndexedDB_API">IndexedDB</a>来实现这一点。</dd>
+ <dt><a href="/zh-CN/docs/WebAssembly/Using_the_JavaScript_API">使用WebAssembly的JavaScript API</a></dt>
+ <dd>当加载了一个.wasm模块之后，你就想要使用它。在本文中，我们向你展示了如何通过WebAssembly的JavaScript API来使用WebAssembly。</dd>
+ <dt><a href="/zh-CN/docs/WebAssembly/Exported_functions">导出的WebAssembly函数</a></dt>
+ <dd>导出的WebAssembly函数是WebAssembly函数的JavaScript表现形式，并且允许从JavaScript中调用WebAssembly代码。本文描述它们。</dd>
+ <dt><a href="/zh-CN/docs/WebAssembly/Understanding_the_text_format">理解WebAssembly的文本格式</a></dt>
+ <dd>本文介绍了wasm的文本格式。这是在进行调试的时候浏览器开发者工具中展现出来的.wasm模块的一种低级文本表示。</dd>
+ <dt><a href="/zh-CN/docs/WebAssembly/Text_format_to_wasm">把WebAssembly文本格式转换为wasm</a></dt>
+ <dd>本文提供了一个如何把编写的文本格式的WebAssembly模块转换为 wasm二进制的指南。</dd>
+</dl>
+</div>
+
+<div class="section">
+<h2 dir="ltr" id="API参考">API参考</h2>
+
+<dl>
+ <dt>{{jsxref("Global_objects/WebAssembly", "WebAssembly")}}</dt>
+ <dd>本对象是所有与WebAssembly相关功能的命名空间。</dd>
+ <dt>{{jsxref("Global_objects/WebAssembly/Module", "WebAssembly.Module")}}</dt>
+ <dd>一个<code>WebAssembly.Module</code>对象包括了无状态的WebAssembly代码。该代码已经被浏览器编译并且能够<a href="/en-US/docs/Web/API/Worker/postMessage">通过Workers高效地共享</a>，<a href="/en-US/docs/WebAssembly/Caching_modules">缓存到IndexedDB中</a>以及多次实例化。</dd>
+ <dt>{{jsxref("Global_objects/WebAssembly/Instance", "WebAssembly.Instance")}}</dt>
+ <dd>一个<code>WebAssembly.Instance</code>对象是一个有状态的、可执行的模块的实例。实例对象包含所有的能够从JavaScript调用到WebAssembly代码的<a href="/en-US/docs/WebAssembly/Exported_functions">导出的WebAssembly函数</a>。</dd>
+ <dt>{{jsxref("Global_objects/WebAssembly/instantiate", "WebAssembly.instantiate()")}}</dt>
+ <dd><code>WebAssembly.instantiate()</code> 函数是编译和实例化WebAssembly代码的主要的API，它返回一个<code>Module</code>及其第一个实例。</dd>
+ <dt>{{jsxref("Global_objects/WebAssembly/Memory", "WebAssembly.Memory()")}}</dt>
+ <dd>一个<code>WebAssembly.Memory</code> 对象是一个可变长的{{jsxref("Global_objects/ArrayBuffer", "ArrayBuffer")}}。它拥有能够被实例存取的原始字节内存。</dd>
+ <dt>{{jsxref("Global_objects/WebAssembly/Table", "WebAssembly.Table()")}}</dt>
+ <dd><code>WebAssembly.Table</code>对象是一个可变长类型数组。它存储诸如函数引用之类的不透明值并且能够被实例存取。</dd>
+ <dt>{{jsxref("WebAssembly.CompileError()")}}</dt>
+ <dd>创建一个新的WebAssembly <code>CompileError</code>对象。</dd>
+ <dt>{{jsxref("WebAssembly.LinkError()")}}</dt>
+ <dd>创建一个新的WebAssembly <code>LinkError</code>对象。</dd>
+ <dt>{{jsxref("WebAssembly.RuntimeError()")}}</dt>
+ <dd>创建一个新的WebAssembly <code>RuntimeError</code>对象。</dd>
+</dl>
+</div>
+</div>
+
+<h2 dir="ltr" id="示例">示例</h2>
+
+<ul dir="ltr">
+ <li><a href="https://github.com/JasonWeathersby/WASMSobel">WASMSobel</a></li>
+ <li>参考我们的<a href="https://github.com/mdn/webassembly-examples/">WebAssembly示例</a>库来获取一些其他的例子。</li>
+</ul>
+
+<h2 id="规范">规范</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('WebAssembly JS')}}</td>
+   <td>{{Spec2('WebAssembly JS')}}</td>
+   <td>Initial draft definition of the JavaScript API.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">浏览器兼容性</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.WebAssembly")}}</p>
+</div>
+
+<h2 id="参见">参见</h2>
+
+<ul dir="ltr">
+ <li><a href="https://research.mozilla.org/webassembly/">WebAssembly on Mozilla Research</a></li>
+ <li><a href="http://webassembly.org/">webassembly.org</a></li>
+ <li><a href="https://hacks.mozilla.org/category/webassembly/">WebAssembly articles on Mozilla Hacks blog</a></li>
+ <li><a href="https://www.w3.org/community/webassembly/">W3C WebAssembly Community Group</a></li>
+ <li><a href="/en-US/docs/Web/HTTP/Headers/Large-Allocation">Large-Allocation HTTP header</a></li>
+</ul>
diff --git a/files/zh-cn/webassembly/loading_and_running/index.html b/files/zh-cn/webassembly/loading_and_running/index.html
new file mode 100644
index 0000000000..334aa4a8c0
--- /dev/null
+++ b/files/zh-cn/webassembly/loading_and_running/index.html
@@ -0,0 +1,131 @@
+---
+title: 加载和运行WebAssembly代码
+slug: WebAssembly/Loading_and_running
+tags:
+  - Fetch
+  - WebAssembly
+  - XMLHttpRequest
+  - 字节码
+translation_of: WebAssembly/Loading_and_running
+---
+<div>{{WebAssemblySidebar}}</div>
+
+<p class="summary">为了在JavaScript中使用WebAssembly，在编译/实例化之前，你首先需要把模块放入内存。比如，通过<a href="https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest">XMLHttpRequest</a>或<a href="https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API">Fetch</a>，模块将会被初始化为带类型数组；不过，将来会开发更多的方式。本文提供了一篇关于获取WebAssembly字节码的不同机制以及如何编译/实例化并运行它的参考。</p>
+
+<h2 id="这里的主题是什么？">这里的主题是什么？</h2>
+
+<p>WebAssembly还没有和&lt;script type='module'&gt;或ES6的import语句集成，也就是说，当前还没有内置的方式让浏览器为你获取模块。当前唯一的方式就是创建一个包含你的WebAssembly模块二进制代码的 {{domxref("ArrayBuffer")}} 并且使用{{jsxref("WebAssembly.instantiate()")}}编译它。这与new Function(string)类似，除了使用一个包含了WebAssembly源代码的数组缓存替换掉包含了JavaScript源代码的字符串。</p>
+
+<p>那么，我们该如何获取这些字节并存入到一个数组缓存并编译它呢？下面进行解释。</p>
+
+<h2 id="使用Fetch">使用Fetch</h2>
+
+<p><a href="https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API">Fetch</a>是一个用来获取网络资源的方便现代的API。</p>
+
+<p>假设网络上有一个叫做simple.wasm的WebAssembly模块：</p>
+
+<ul>
+ <li>我们可以使用<a href="https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch">fetch()</a>全局函数来轻松地获取它，该函数返回一个可以解析为<a href="https://developer.mozilla.org/en-US/docs/Web/API/Response">Response</a>对象的promise。</li>
+ <li>我们可以使用<a href="https://developer.mozilla.org/en-US/docs/Web/API/Body/arrayBuffer">arrayBuffer()</a>函数把响应（response）转换为带类型数组，该函数返回一个可以解析为带类型数组的promise。</li>
+ <li>最后，我们使用{{jsxref("WebAssembly.instantiate()")}}函数一步实现编译和实例化带类型数组。</li>
+</ul>
+
+<p>代码块看起来像这样：</p>
+
+<pre class="brush: js">fetch('module.wasm').then(response =&gt;
+  response.arrayBuffer()
+).then(bytes =&gt;
+  WebAssembly.instantiate(bytes, importObject)
+).then(results =&gt; {
+  // Do something with the compiled results!
+});</pre>
+
+<h3 id="顺便说一下instantiate()重载">顺便说一下instantiate()重载</h3>
+
+<p>{{jsxref("WebAssembly.instantiate()")}}函数有两种重载形式——一种是前面展示的那样，接受待编译的字节码作为参数并且返回一个promise并且该promise可以解析为一个包含已编译的模块对象及其实例的对象。</p>
+
+<pre class="brush: js">{
+  module : Module // 新编译的WebAssembly.Module对象，
+  instance : Instance // 新的模块对象实例
+}</pre>
+
+<div class="note">
+<p><strong>注</strong>： 通常，我们只关心实例，但是，当我们想缓存模块，使用 <a href="https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage">postMessage()</a>与另外一个worker或window共享模块或者只是创建更多的实例的时候，拥有模块对象是很有用的。</p>
+</div>
+
+<div class="note">
+<p><strong>注</strong>： 这二种重载形式接受一个<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module">WebAssembly.Module</a>对象作为参数，并且返回一个包含了一个实例对象的promise。参考<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate#Second_overload_example">第二种重载示例</a>。</p>
+</div>
+
+<h3 id="获取及实例化的实用函数">获取及实例化的实用函数</h3>
+
+<p>上面的代码样式可以工作，但是，每次都重新编写它们就显得啰嗦了，特别是当你想要加载多个模块的时候。为了简单起见，我们创建了一个叫做fetchAndInstantiate()的实用函数，它在后台工作并返回一个promise。你可以在<a href="https://github.com/mdn/webassembly-examples/blob/master/wasm-utils.js">wasm-utils.js</a>中找到这个函数。它看起来像这样：</p>
+
+<pre class="brush: js">function fetchAndInstantiate(url, importObject) {
+  return fetch(url).then(response =&gt;
+    response.arrayBuffer()
+  ).then(bytes =&gt;
+    WebAssembly.instantiate(bytes, importObject)
+  ).then(results =&gt;
+    results.instance
+  );
+}</pre>
+
+<p>把这个函数加入到HTML中，你就可以使用一行简单代码做到获取和实例化WebAssembly模块并且得到一个实例。</p>
+
+<pre class="brush: js">fetchAndInstantiate('module.wasm', importObject).then(function(instance) {
+  ...
+})</pre>
+
+<div class="note">
+<p><strong>注</strong>： 在我们的文档中，你可以看到许多这么用的例子（例如，参考<a href="https://mdn.github.io/webassembly-examples/js-api-examples/">index.html</a>）——这是我们推荐的加载模块的标准方式。</p>
+</div>
+
+<h3 id="运行你的WebAssembly代码">运行你的WebAssembly代码</h3>
+
+<p>一旦在JavaScript中得到了可用的WebAssembly实例，你就可以开始使用那些通过 {{jsxref("WebAssembly.Instance/exports", "WebAssembly.Instance.exports")}} 属性导出的特性了。你的代码可能看起来像这样：</p>
+
+<pre class="brush: js">fetchAndInstantiate('myModule.wasm', importObject).then(function(instance) {
+  // 调用导出函数：
+  instance.exports.exported_func();
+
+  // 或者获取导出内存的缓存内容：
+  var i32 = new Uint32Array(instance.exports.memory.buffer);
+
+  // 或者获取导出表格中的元素：
+  var table = instance.exports.table;
+  console.log(table.get(0)());
+})</pre>
+
+<div class="note">
+<p><strong>注</strong>：关于从WebAssembly模块导出是如何工作的更多信息，请阅读使<a href="https://developer.mozilla.org/en-US/docs/WebAssembly/Using_the_JavaScript_API">用WebAssembly的JavaScript API</a>和<a href="https://developer.mozilla.org/en-US/docs/WebAssembly/Understanding_the_text_format">理解WebAssembly文本格式</a>。</p>
+</div>
+
+<h2 id="使用XMLHttpRequest">使用XMLHttpRequest</h2>
+
+<p><a href="https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest">XMLHttpRequest</a>在一定程度上而言要比Fetch老旧一些，但是，仍然可以很好地被用来获取带类型数组。仍然假设我们的模块叫做simple.wasm：</p>
+
+<ol>
+ <li>创建一个 {{domxref("XMLHttpRequest()")}} 实例，然后使用它的{{domxref("XMLHttpRequest.open","open()")}} 方法来开启一个请求——设置请求方法为GET并且声明我们想要获取的文件路径。</li>
+ <li>关键之处在于使用{{domxref("XMLHttpRequest.responseType","responseType")}}属性设置响应类型为'arraybuffer'。</li>
+ <li>接下来使用{{domxref("XMLHttpRequest.send()")}}发送请求。</li>
+ <li>当响应已经完成下载之后，我们使用{{domxref("XMLHttpRequest.onload", "onload")}}事件处理器来调用一个函数——在这个函数中，我们从{{domxref("XMLHttpRequest.response", "response")}}属性中得到数组缓存然后就像使用Fetch那样把它传递给{{jsxref("WebAssembly.instantiate()")}} 。</li>
+</ol>
+
+<p>最终代码看起来像这样：</p>
+
+<pre class="brush: js">request = new XMLHttpRequest();
+request.open('GET', 'simple.wasm');
+request.responseType = 'arraybuffer';
+request.send();
+
+request.onload = function() {
+  var bytes = request.response;
+  WebAssembly.instantiate(bytes, importObject).then(results =&gt; {
+    results.instance.exports.exported_func();
+  });
+};</pre>
+
+<div class="note">
+<p><strong>注</strong>：你可以在<a href="https://mdn.github.io/webassembly-examples/js-api-examples/xhr-wasm.html">xhr-wasm.html</a>看到实际使用的例子。</p>
+</div>
diff --git a/files/zh-cn/webassembly/rust_to_wasm/index.html b/files/zh-cn/webassembly/rust_to_wasm/index.html
new file mode 100644
index 0000000000..0b2a70598e
--- /dev/null
+++ b/files/zh-cn/webassembly/rust_to_wasm/index.html
@@ -0,0 +1,321 @@
+---
+title: 编译 Rust 为 WebAssembly
+slug: WebAssembly/Rust_to_wasm
+tags:
+  - WebAssembly
+  - rust
+  - wasm
+  - 编译
+translation_of: WebAssembly/Rust_to_wasm
+---
+<div>{{WebAssemblySidebar}}</div>
+
+<p class="summary">如果你写了一些 Rust 代码，你可以把它编译成 WebAssembly！这份教程将带你编译 Rust 项目为 wasm 并在一个现存的 web 应用中使用它。</p>
+
+<h2 id="Rust_和_WebAssembly_用例">Rust 和 WebAssembly 用例</h2>
+
+<p>Rust 和 WebAssembly 有两大主要用例：</p>
+
+<ul>
+ <li>构建完整应用 —— 整个 Web 应用都基于 Rust 开发！</li>
+ <li>构建应用的组成部分 —— 在现存的 JavaScript 前端中使用 Rust。</li>
+</ul>
+
+<p>目前，Rust 团队正专注于第二种用例，因此我们也将着重介绍它。对于第一种用例，可以参阅 <code><a href="https://github.com/DenisKolodin/yew">yew</a></code> 这类项目。</p>
+
+<p>在本教程中，我们将使用 Rust 的 npm 包构建工具 <code>wasm-pack</code> 来构建一个 npm 包。这个包只包含 WebAssembly 和 JavaScript 代码，以便包的用户无需安装 Rust 就能使用。他们甚至不需要知道这里包含 WebAssembly！</p>
+
+<h2 id="安装_Rust_环境">安装 Rust 环境</h2>
+
+<p>让我们看看安装 Rust 环境的所有必要步骤。</p>
+
+<h3 id="安装Rust">安装Rust</h3>
+
+<p>前往 <a href="https://www.rust-lang.org/install.html">Install Rust</a> 页面并跟随指示安装 Rust。这里会安装一个名为 “rustup” 的工具，这个工具能让你管理多个不同版本的 Rust。默认情况下，它会安装用于惯常Rust开发的 stable 版本 Rust Release。Rustup 会安装 Rust 的编译器 <code>rustc</code>、Rust 的包管理工具 <code>cargo</code>、Rust 的标准库 <code>rust-std</code> 以及一些有用的文档 <code>rust-docs</code>。</p>
+
+<div class="note">
+<p><strong>Note</strong>: 需要注意，在安装完成后，你需要把 cargo 的 <code>bin</code> 目录添加到你系统的 <code>PATH</code> 。一般来说它会自动添加，但需要你重启终端后才会生效。 </p>
+</div>
+
+<h3 id="wasm-pack">wasm-pack</h3>
+
+<p>要构建我们的包，我们需要一个额外工具 <code>wasm-pack</code>。它会帮助我们把我们的代码编译成 WebAssembly 并制造出正确的 <code>npm</code> 包。使用下面的命令可以下载并安装它：</p>
+
+<pre class="brush: bash notranslate"><code class="shell language-shell">$ cargo install wasm-pack
+</code></pre>
+
+<h3 id="安装_Node.js_并获取_npm_账户">安装 Node.js 并获取 npm 账户</h3>
+
+<p>在这个例子中我们将会构建一个 npm 包，因此你需要确保安装 Node.js 和 npm 已经安装。另外，我们将会把包发布到 npm 上，因此你还需要一个 npm 账号。它们是免费的。发布这个包并不是必须的，但是发布它非常简单，因此在本例中我们默认你会发布这个包。</p>
+
+<p>在 <a href="https://www.npmjs.com/get-npm">Get npm!</a> 页面按照说明下载并安装 Node.js 和 npm。在选择版本时，选择一个你喜欢的版本；本例不限定特定版本。</p>
+
+<p>在 <a href="https://www.npmjs.com/signup">npm signup page</a> 注册 npm 账户，并填写表格。</p>
+
+<p>接下来，在命令行中运行 <code>npm adduser</code>:</p>
+
+<pre class="brush: bash notranslate"><code class="rust language-rust">&gt; npm adduser
+Username: yournpmusername
+Password:
+Email: (this IS public) you@example.com
+</code></pre>
+
+<p>你需要完善你的用户名，密码和邮箱。如果成功了，你将会看到:</p>
+
+<pre class="brush: bash notranslate"><code>Logged in as yournpmusername on https://registry.npmjs.org/.
+</code></pre>
+
+<p>如果并未正常运行，请联系 npm 解决。</p>
+
+<h2 id="构建我们的_WebAssembly_npm_包">构建我们的 WebAssembly npm 包</h2>
+
+<p>万事俱备，来创建一个新的 Rust 包吧。打开你用来存放你私人项目的目录，做这些事：</p>
+
+<pre class="brush: bash notranslate"><code class="shell language-shell">$ cargo new --lib hello-wasm
+     Created library `hello-wasm` project
+</code></pre>
+
+<p>这里会在名为 <code>hello-wasm</code> 的子目录里创建一个新的库，里面有下一步之前你所需要的一切：</p>
+
+<pre class="notranslate"><code class="shell language-shell">+-- Cargo.toml
++-- src
+    +-- lib.rs
+</code></pre>
+
+<p>首先，我们有一个 <code>Cargo.toml</code> 文件，这是我们配置构建的方式。如果你用过 Bundler 的 <code>Gemfile</code> 或者 npm 的 <code>package.json</code>，你应该会感到很熟悉。Cargo 的用法和它们类似。</p>
+
+<p>接下来，Cargo 在 <code>src/lib.rs</code> 生成了一些 Rust 代码：</p>
+
+<pre class="notranslate"><code class="rust language-rust">#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
+    }
+}
+</code></pre>
+
+<p>我们完全不需要使用这些测试代码，所以继续吧，我们删掉它。</p>
+
+<h3 id="来写点_Rust_代码吧！">来写点 Rust 代码吧！</h3>
+
+<p>让我们在 <code>src/lib.rs</code> 写一些代码替换掉原来的：</p>
+
+<pre class="notranslate"><code class="rust language-rust">extern crate wasm_bindgen;
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern {
+    pub fn alert(s: &amp;str);
+}
+
+#[wasm_bindgen]
+pub fn greet(name: &amp;str) {
+    alert(&amp;format!("Hello, {}!", name));
+}
+</code></pre>
+
+<p>这就是我们这个 Rust 项目的内容。它有三个主要部分，让我们按顺序来讲。这里将会给出一个缺少部分细节的高级说明；如果想要了解更多 Rust 知识，请查看在线书籍 <a href="https://doc.rust-lang.org/book/">The Rust Programming Language</a>。</p>
+
+<h4 id="使用_wasm-bindgen_在_Rust_与_JavaScript_之间通信">使用 <code>wasm-bindgen</code> 在 Rust 与 JavaScript 之间通信</h4>
+
+<p>第一部分看起来像这样：</p>
+
+<pre class="notranslate"><code class="rust language-rust">extern crate wasm_bindgen;
+
+use wasm_bindgen::prelude::*;
+</code></pre>
+
+<p>第一行就像在说 “哇 Rust，我们在用一个叫做 wasm_bindgen 的库”。在 Rust 当中，库被称为 “crates”，因为我们使用的是一个外部库，所以有  "extern"。</p>
+
+<p>明白了吗？ <strong>Cargo ships crates</strong>.</p>
+
+<p>第三行包括了一个将库中的代码引入到你的代码中的使用命令。在这个情况下，将会引入 <code>wasm_bindgen::prelude</code> 的全部模块。我们将在下一节中使用这些内容。</p>
+
+<p>在我们开始下一节之前，我们将讲一讲 <code>wasm-bindgen</code>.</p>
+
+<p><code>wasm-pack</code> 使用 <code>wasm-bindgen</code>，其它工具，去提供一个连接 JavaScript 和 Rust 的桥。它允许 JavaScript 使用 string 调用 Rust API，或者调用一个 Rust function 去捕获 JavaScript 异常。</p>
+
+<p>我们将在我们的包中使用 <code>wasm-bindgen</code> 的功能。事实上，这是下一节的内容！</p>
+
+<h4 id="在_Rust_中调用来自_JavaScript_的外部函数">在 Rust 中调用来自 JavaScript  的外部函数</h4>
+
+<p>接下来的部分看起来像这样：</p>
+
+<pre class="notranslate"><code class="rust language-rust">#[wasm_bindgen]
+extern {
+    pub fn alert(s: &amp;str);
+}
+</code></pre>
+
+<p>在 <code>#[]</code> 中的内容叫做 "属性"，并以某种方式改变下面的语句。在这种情况下，下面的语句是一个 <code>extern</code>，它将告诉 Rust that <span class="tlid-translation translation" lang="zh-CN"><span title="">我们想调用一些外部定义的函数</span></span>。这个属性告诉我们 "wasm-bindgen 知道如何找到这些函数"。</p>
+
+<p>第三行是用 Rust 写的函数签名。它告诉我们 "<code>alert</code> 函数接受一个叫做 s 的字符串作为参数。"</p>
+
+<p>你可能会疑惑这个函数是什么，你的疑惑可能是正确的：这是 <a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/alert">the <code>alert</code> function provided by JavaScript</a>！我们将在下一节中调用这个函数。</p>
+
+<p>当你想调用新的 JavaScript 函数时，你可以在这里写他们，<code>wasm-bindgen</code> 将负责为您设置一切。<span class="tlid-translation translation" lang="zh-CN"><span title="">并非一切都得到支持，但我们正在努力！如果缺少某些内容，</span></span>请 <a href="https://github.com/rustwasm/wasm-bindgen/issues/new">file bugs</a> 。</p>
+
+<h4 id="编写能够在JavaScript中调用的_Rust_函数">编写能够在JavaScript中调用的 Rust 函数</h4>
+
+<p>最后一部分是这样的：</p>
+
+<pre class="notranslate"><code class="rust language-rust">#[wasm_bindgen]
+pub fn greet(name: &amp;str) {
+    alert(&amp;format!("Hello, {}!", name));
+}
+</code></pre>
+
+<p>我们又看到了 <code>#[wasm_bindgen]</code> 属性。在这里，它并非定义一个 <code>extern</code> 块，而是 <code>fn，</code>这代表我们希望能够在 JavaScript 中使用这个 Rust 函数。 这和 <code>extern</code> 正相反：我们并非引入函数，而是要把函数给外部世界使用。</p>
+
+<p>这个函数的名字是 <code>greet</code>，它需要一个参数，一个字符串 （写作 <code>&amp;str</code>）。它调用了我们前面在 <code>extern</code> 块中引入的 <code>alert</code> 函数。它传递了一个让我们串联字符串的 <code>format!</code> 宏的调用。</p>
+
+<p><code>format!</code> 在这里有两个参数，一个格式化字符串和一个要填入的变量。格式化字符串是 <code>"Hello, {}!"</code> 部分。它可以包含一个或多个 <code>{}</code>，变量将会被填入其中。传递的变量是 <code>name</code>，也就是这个函数的参数。所以当我们调用 <code>greet("Steve")</code>时我们就能看到 <code>"Hello, Steve!"。</code></p>
+
+<p>这个传递到了 <code>alert()</code>，所以当我们调用这个函数时，我们应该能看到他谈弹出了一个带有 "Hello, Steve!" 的消息框。</p>
+
+<p>我们的库写完了，是时候构建它了。</p>
+
+<h3 id="把我们的代码编译到_WebAssembly">把我们的代码编译到 WebAssembly</h3>
+
+<p>为了能够正确的编译我们的代码，首先我们需要配置 <code>Cargo.toml</code>。打开这个文件，将内容改为如下所示:</p>
+
+<pre class="notranslate"><code class="toml language-toml">[package]
+name = "hello-wasm"
+version = "0.1.0"
+authors = ["Your Name &lt;you@example.com&gt;"]
+description = "A sample project with wasm-pack"
+license = "MIT/Apache-2.0"
+repository = "https://github.com/yourgithubusername/hello-wasm"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+wasm-bindgen = "0.2"
+</code></pre>
+
+<p>你需要改为自己的仓库，同时 Cargo 需要通过 <code>git</code> 来完善 <code>authors</code> 部分。</p>
+
+<p>最重要的是添加底下的部分。第一个部分 — <code>[lib]</code> — 告诉 Rust 为我们的包建立一个 <code>cdylib</code> 版本；在本教程中我们不会讲解它的含义。有关更多信息，请参阅 <a href="https://doc.rust-lang.org/cargo/guide/">Cargo</a> 和 <a href="https://doc.rust-lang.org/reference/linkage.html">Rust Linkage</a> 文档。</p>
+
+<p>第二个部分是 <code>[dependencies]</code> 部分。在这里我们告诉 Cargo 我们需要依赖哪个版本的 <code>wasm-bindgen</code> ；在这个例子中，它是 <code>0.2.z</code> 版本的 (不是 <code>0.3.0</code> 或者其他版本)。</p>
+
+<h3 id="构建包">构建包</h3>
+
+<p>现在我们已经完成了所有配置项，开始构建吧！在命令行输入以下命令:</p>
+
+<pre class="brush: bash notranslate"><code class="shell language-shell">$ wasm-pack build --scope mynpmusername
+</code></pre>
+
+<p>这个命令将做一系列事情 (这会花一些时间，特别是当你第一次运行 <code>wasm-pack</code>)。想了解详细情况，查看<a href="https://hacks.mozilla.org/2018/04/hello-wasm-pack/">这篇在 Mozilla Hacks 上的文章</a>。简单来说，<code>wasm-pack build</code> 将做以下几件事：</p>
+
+<ol>
+ <li>将你的 Rust 代码编译成 WebAssembly。</li>
+ <li>在编译好的 WebAssembly 代码基础上运行 <code>wasm-bindgen</code>，生成一个 JavaScript 文件将 WebAssembly 文件包装成一个模块以便 npm 能够识别它。</li>
+ <li>创建一个 <code>pkg</code> 文件夹并将 JavaScript 文件和生成的 WebAssembly 代码移到其中。</li>
+ <li>读取你的 <code>Cargo.toml</code> 并生成相应的 <code>package.json。</code></li>
+ <li>复制你的 <code>README.md</code> (如果有的话) 到文件夹中。</li>
+</ol>
+
+<p>最后的结果？你在 <code>pkg</code> 文件夹下有了一个 npm 包。</p>
+
+<h4 id="对代码体积的一些说明">对代码体积的一些说明</h4>
+
+<p>如果你检查生成的 WebAssembly 文件体积，它可能有几百 kB。我们没有让 Rust 去压缩生成的代码，从而大大减少生成包的体积。这和本次教程主题无关，但如果你想了解更多，查看 Rust WebAssembly 工作组文档上关于 <a href="https://rustwasm.github.io/book/game-of-life/code-size.html#shrinking-wasm-size">减少 .wasm 体积</a> 的说明。</p>
+
+<h3 id="把我们的包发布到_npm">把我们的包发布到 npm</h3>
+
+<p>把我们的新包发布到 npm registry:</p>
+
+<pre class="brush: bash notranslate"><code class="shell language-shell">$ cd pkg
+$ npm publish --access=public
+</code></pre>
+
+<p>我们现在有了一个 npm 包，使用 Rust 编写，但已经被编译为 WebAssembly 了。现在这个包已经可以被 JavaScript 使用了，而且使用它完全不需要用户安装 Rust ；包中的代码是 WebAssembly 代码，而不是 Rust 源码！</p>
+
+<h2 id="在网站上使用我们的包">在网站上使用我们的包</h2>
+
+<p><span class="tlid-translation translation" lang="zh-CN"><span title="">让我们建立一个使用我们包的网站！</span> <span title="">人们通过各种打包工具使用 npm包，在本教程中，我们将使用 </span></span><code>webpack</code><span class="tlid-translation translation" lang="zh-CN"><span title="">。</span> <span title="">它比其他某些打包工具稍微复杂一点，但展示了更实际的用法。</span><br>
+ <br>
+ <span title="">让我们离开</span></span><code>pkg</code><span class="tlid-translation translation" lang="zh-CN"><span title="">目录，并创建一个新目录</span></span><code>site</code><span class="tlid-translation translation" lang="zh-CN"><span title="">，尝试以下操作：</span></span></p>
+
+<pre class="brush: bash notranslate"><code class="bash language-bash">$ cd ../..
+$ mkdir site
+$ cd site
+</code></pre>
+
+<p>创建一个新文件 <code>package.json</code>，然后输入如下代码：</p>
+
+<pre class="brush: json notranslate"><code class="json language-json">{
+  "scripts": {
+    "serve": "webpack-dev-server"
+  },
+  "dependencies": {
+    "@mynpmusername/hello-wasm": "^0.1.0"
+  },
+  "devDependencies": {
+    "webpack": "^4.25.1",
+    "webpack-cli": "^3.1.2",
+    "webpack-dev-server": "^3.1.10"
+  }
+}
+</code></pre>
+
+<p><span class="tlid-translation translation" lang="zh-CN"><span title="">请注意，您需要在依赖项部分的 </span></span><code>@</code><span class="tlid-translation translation" lang="zh-CN"><span title=""> 之后填写自己的用户名。</span><br>
+ <br>
+ <span title="">接下来，我们需要配置Webpack。</span> <span title="">创建 </span></span><code>webpack.config.js</code><span class="tlid-translation translation" lang="zh-CN"><span title=""> 并输入：</span></span></p>
+
+<pre class="brush: js notranslate"><code class="javascript language-javascript">const path = require('path');
+module.exports = {
+  entry: "./index.js",
+  output: {
+    path: path.resolve(__dirname, "dist"),
+    filename: "index.js",
+  },
+  mode: "development"
+};
+</code></pre>
+
+<p><span class="tlid-translation translation" lang="zh-CN"><span title="">现在我们需要一个HTML文件。</span> <span title="">创建一个<code>index.html</code>并写入如下内容：</span></span></p>
+
+<pre class="notranslate"><code class="html language-html">&lt;!DOCTYPE html&gt;
+&lt;html&gt;
+  &lt;head&gt;
+    &lt;meta charset="utf-8"&gt;
+    &lt;title&gt;hello-wasm example&lt;/title&gt;
+  &lt;/head&gt;
+  &lt;body&gt;
+    &lt;script src="./index.js"&gt;&lt;/script&gt;
+  &lt;/body&gt;
+&lt;/html&gt;
+</code></pre>
+
+<p><span class="tlid-translation translation" lang="zh-CN"><span title="">最后，从HTML文件中引用<code>index.js</code>：</span></span></p>
+
+<pre class="brush: js notranslate"><code class="javascript language-javascript">const js = import("./node_modules/@yournpmusername/hello-wasm/hello_wasm.js");
+js.then(js =&gt; {
+  js.greet("WebAssembly");
+});
+</code></pre>
+
+<p><span class="tlid-translation translation" lang="zh-CN"><span title="">请注意，您需要再次填写您的npm用户名。</span><br>
+ <br>
+ <span title="">这将从<code>node_modules</code>文件夹导入我们的模块。</span><span title="">这不是最佳做法，但这里只做一个演示，因此暂时就这样用。</span> <span title="">加载后，它将从该模块调用<code>greet</code>函数，并传入字符串“WebAssembly”参数。</span><span title="">注意这里看上去没有什么特别的，但是我们正在调用 Rust 代码！</span> <span title="">就JavaScript代码所知，这只是一个普通模块。</span><br>
+ <br>
+ <span title="">我们已经完成了所有的文件！</span> <span title="">让我们试一下：</span></span></p>
+
+<pre class="brush: bash notranslate"><code class="shell language-shell">$ npm install
+$ npm run serve
+</code></pre>
+
+<p><span class="tlid-translation translation" lang="zh-CN"><span title="">这将启动一个Web服务器。</span> <span title="">访问 </span></span><a href="http://localhost:8080">http://localhost:8080 </a><span class="tlid-translation translation" lang="zh-CN"><span title="">，您应该会在屏幕上看到一个警告框，其中包含 </span></span><code>Hello, WebAssembly!</code><span class="tlid-translation translation" lang="zh-CN"> ！<span title="">我们已经成功地从 JavaScript 调用了 Rust，并从 Rust 调用了 JavaScript。</span></span></p>
+
+<p>
+ </p><h2 id="结论">结论</h2>
+
+
+<p>本教程到此结束。希望你觉得它有用。</p>
+
+<p>在这个领域，有很多工作正在推进当中。如果你希望它变得更好，可以参阅  <a href="http://fitzgeraldnick.com/2018/02/27/wasm-domain-working-group.html">Rust Webassembly 工作组</a>。</p>
diff --git a/files/zh-cn/webassembly/text_format_to_wasm/index.html b/files/zh-cn/webassembly/text_format_to_wasm/index.html
new file mode 100644
index 0000000000..671c2a0b71
--- /dev/null
+++ b/files/zh-cn/webassembly/text_format_to_wasm/index.html
@@ -0,0 +1,72 @@
+---
+title: 将WebAssembly文本格式转换为wasm
+slug: WebAssembly/Text_format_to_wasm
+tags:
+  - WebAssembly
+  - wabt
+  - wasm
+  - wast2wasm
+  - 文本格式
+  - 汇编
+  - 转换
+translation_of: WebAssembly/Text_format_to_wasm
+---
+<div>{{WebAssemblySidebar}}</div>
+
+<p class="summary">WebAssembly 有一个基于S-表达式的文本表示形式，设计为在文本编辑器，浏览器开发人员工具等中暴露的一个中间形式。本文解释了它是如何工作的一些内容以及如何使用可用的工具把文本格式文件转换为.wasm汇编格式文件。</p>
+
+<div class="note">
+<p>注：文本格式文件通常被保存为.wat扩展名；有时.wast也被使用，它是说文件包含了额外的测试命令（断言等）并且它们不需要转换到.wasm中。</p>
+</div>
+
+<h2 id="初识文本格式">初识文本格式</h2>
+
+<p>让我们看一个简单的例子——下面的程序从一个叫做imports的模块中导入了一个叫做imported_func的函数并且导出了一个叫做exported_func的函数：</p>
+
+<pre>(module
+  (func $i (import "<code>imports</code>" "<code>imported_func</code>") (param i32))
+  (func (export "exported_func")
+    i32.const 42
+    call $i
+  )
+)</pre>
+
+<p>WebAssembly函数exported_func是被导出供我们的环境（比如，使用了WebAssembly模块的网络应用）使用。当被调用的时，它进而调用了一个被导入的叫做imported_func的函数并且向该函数传递了一个值（42）作为参数。</p>
+
+<h2 id="把.wat文本文件转换为.wasm二进制文件">把.wat文本文件转换为.wasm二进制文件</h2>
+
+<p>让我们尝试一下把前面提到的wat文本表示的例子转换为wasm汇编格式。</p>
+
+<ol>
+ <li>首先，把前面的清单内容复制到一个文本文件中；命名为simple.wat。</li>
+ <li>在使用它之前，我们需要把这个文本表示汇编为浏览器能够识别的汇编语言。为了达到这个目的，我们可以使用wabt工具，该工具包括了在WebAssembly文本表示和wasm之间进行相互转化的编译器以及其他一些功能。访问 <a href="https://github.com/webassembly/wabt">https://github.com/webassembly/wabt</a>——按照该页面的指令来安装好工具。</li>
+ <li>当你安装好工具之后，将/wabt/out目录添加到你的系统路径。</li>
+ <li>下一步，执行wat2wasm程序，把输入文件的路径传递给它，紧跟一个-o参数，然后是输出文件的路径：
+  <pre class="brush: bash">wat2wasm simple.wat -o simple.wasm</pre>
+ </li>
+</ol>
+
+<p>该命令会把wasm输出到一个叫做simple.wasm的文件，该文件包含了.wasm汇编代码。</p>
+
+<div class="note">
+<p><strong>注</strong>：你可以使用wasm2wat工具把汇编代码转换为文本表示；例如，wasm2wat simple.wasm -o text.wat。</p>
+</div>
+
+<h2 id="查看汇编输出">查看汇编输出</h2>
+
+<p>因为输出文件是基于汇编的，所以，它不能在常规的文本编辑器中查看。尽管如此，你可以使用wat2wasm工具的-v选项来查看。试试这个：</p>
+
+<pre class="brush: bash">wat2wasm simple.wat -v</pre>
+
+<p>这会在终端产生一个如下所示的输出：</p>
+
+<p><img alt="several strings of binary with textual descriptions beside them. For example: 0000008: 01 ; section code " src="https://mdn.mozillademos.org/files/14653/assembly-output.png" style="display: block; margin: 0px auto;"></p>
+
+<h2 id="另见">另见</h2>
+
+<ul>
+ <li><a href="https://developer.mozilla.org/en-US/docs/WebAssembly/Understanding_the_text_format">理解WebAssembly文本格式</a>——详细解释文本格式语法。</li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/WebAssembly/C_to_wasm">从C/C++编译为WebAssembly</a>——诸如Binaryen/Emscripten的工具不但把你的代码编译为wasm而且创建必要的用来在一个JavaScript上下文中运行模块的API代码。关于如何使用它们，可以探究更多内容。</li>
+ <li>使用WebAssembly的JavaScript API——如果你想探究关于WebAssembly API代码是如何工作的更多内容，可以阅读这篇文章。</li>
+ <li><a href="https://github.com/WebAssembly/design/blob/master/TextFormat.md">文本格式</a>——在WebAssembly的GitHub仓库上面关于文本格式的更多解释。</li>
+</ul>
diff --git a/files/zh-cn/webassembly/understanding_the_text_format/index.html b/files/zh-cn/webassembly/understanding_the_text_format/index.html
new file mode 100644
index 0000000000..6e4c72ffa4
--- /dev/null
+++ b/files/zh-cn/webassembly/understanding_the_text_format/index.html
@@ -0,0 +1,540 @@
+---
+title: 理解WebAssembly文本格式
+slug: WebAssembly/Understanding_the_text_format
+tags:
+  - JavaScript
+  - S-表达式
+  - WebAssembly
+  - wasm
+  - 共享地址
+  - 内存
+  - 函数
+  - 文本格式
+  - 表格
+  - 调用
+translation_of: WebAssembly/Understanding_the_text_format
+---
+<div>{{WebAssemblySidebar}}</div>
+
+<p class="summary">为了能够让人类阅读和编辑WebAssembly，wasm二进制格式提供了相应的文本表示。这是一种用来在文本编辑器、浏览器开发者工具等工具中显示的中间形式。本文用基本语法的方式解释了这种文本表示是如何工作的，以及它是如何与它表示的底层字节码，及在JavaScript中表示wasm的封装对象关联起来的。<br>
+ 本质上，这种文本形式更类似于处理器的汇编指令。</p>
+
+<div class="note">
+<p><strong>注</strong>：如果你是一个Web开发者并且只是想在页面中加载wasm模块然后在你的代码中使用它（参考<a href="/zh-CN/docs/WebAssembly/Using_the_JavaScript_API">使用WebAssembly的JavaScript API</a>），那么，本文可能有点儿强人所难了。但是，如果你想编写wasm模块从而优化你的JavaScript的性能或者构建你自己的WebAssembly编译器，那么，本文是很有用的。</p>
+</div>
+
+<h2 id="S-表达式">S-表达式</h2>
+
+<p>不论是二进制还是文本格式，WebAssembly代码中的基本单元是一个模块。在文本格式中，一个模块被表示为一个大的S-表达式。</p>
+
+<p>S-表达式是一个非常古老和非常简单的用来表示树的文本格式。因此，我们可以把一个模块想象为一棵由描述了模块结构和代码的节点组成的树。不过，与一门编程语言的抽象语法树不同的是，WebAssembly的树是相当平的，也就是大部分包含了指令列表。</p>
+
+<p>首先，让我们看下S-表达式长什么样。树上的每个一个节点都有一对括号——( ... )——包围。括号内的第一个标签告诉你该节点的类型，其后跟随的是由空格分隔的属性或孩子节点列表。</p>
+
+<p>S-表达式如下：</p>
+
+<pre>(module (memory 1) (func))</pre>
+
+<p>这条表达式，表示一棵根节点为“模块（module）”的树，该树有两个孩子节点，分别是 属性为1的“内存（memory）”节点 和 一个“函数（func）”节点。我们一会儿就会看到这些节点的含义。</p>
+
+<h3 id="最简单的模块">最简单的模块</h3>
+
+<p>让我们从最简单最短的可能的wasm模块开始。</p>
+
+<pre>(module)</pre>
+
+<p>这个模块完全是空的，但是仍然是一个合法的模块。</p>
+
+<p>如果我们现在把该模块转换为二进制（参考<a href="/zh-CN/docs/WebAssembly/Text_format_to_wasm">把WebAssembly文本格式转换为wasm</a>），我们将会看到在<a href="http://webassembly.org/docs/binary-encoding/#high-level-structure">二进制格式</a>中描述的8字节的模块头：</p>
+
+<pre>0000000: 0061 736d              ; WASM_BINARY_MAGIC
+0000004: 0d00 0000              ; WASM_BINARY_VERSION</pre>
+
+<h3 id="向你的模块中增加功能">向你的模块中增加功能</h3>
+
+<p>好了，那并不是很有趣，让我们向模块中增加一些可执行代码。</p>
+
+<p>WebAssembly模块中的所有代码都是划分到函数里面。函数具有下列的伪代码结构：</p>
+
+<pre>( func &lt;signature&gt; &lt;locals&gt; &lt;body&gt; )</pre>
+
+<ul>
+ <li><strong>签名          </strong>声明函数需要的参数以及函数的返回值。</li>
+ <li><strong>局部变量   </strong>像JavaScript中的变量，但是显式的声明了类型。</li>
+ <li><strong>函数体       </strong>是一个低级指令的线性列表。</li>
+</ul>
+
+<h2 id="签名和参数">签名和参数</h2>
+
+<p>签名是由一系列参数类型声明，及其后面的返回值类型声明列表组成。值得注意的是：</p>
+
+<ul>
+ <li>没有(result)意味着函数不返回任何东西。</li>
+ <li>在当前版本中，最多拥有一个返回类型，但是<a href="https://webassembly.org/docs/future-features#multiple-return">以后会放开这个限制</a>到任意数量。</li>
+</ul>
+
+<p>每一个参数都有一个显式声明的类型，wasm当前有四个可用类型：</p>
+
+<ul>
+ <li>i32：32位整数</li>
+ <li>i64：64位整数</li>
+ <li>f32：32位浮点数</li>
+ <li>f64：64位浮点数</li>
+</ul>
+
+<p>参数格式为 <code><strong>(param &lt;类型&gt;)</strong></code>，返回值格式为 <strong><code>(result &lt;类型&gt;)</code></strong>。</p>
+
+<p>因此，接受两个32位整数，返回一个64位浮点数的函数应该这样写：</p>
+
+<pre>(func (param i32) (param i32) (result f64) ... )</pre>
+
+<p>在签名的后面是带有类型的局部变量，格式为 <code><strong>(local &lt;类型&gt;)</strong></code>。函数调用可以通过参数实参值对局部变量进行初始化。</p>
+
+<h2 id="获取和设置局部变量和参数">获取和设置局部变量和参数</h2>
+
+<p>局部变量和参数能够被函数体使用get_local和set_local指令进行读写。</p>
+
+<p>get_local/set_local指令使用数字索引来指向将被存取的条目：按照它们的声明顺序，参数在前，局部变量在后。因此，给定下面的函数：</p>
+
+<pre>(func (param i32) (param f32) (local f64)
+  get_local 0
+  get_local 1
+  get_local 2)</pre>
+
+<ul>
+ <li>get_local 0会得到i32类型的参数</li>
+ <li>get_local 1会得到f32类型的参数</li>
+ <li>get_local 2会得到f64类型的局部变量</li>
+</ul>
+
+<p>由于使用数字索引来指向某个条目容易让人混淆，因此，也可以通过别名的方式来访问它们，方法就是在类型声明的前面添加一个使用美元符号（$）作为前缀的名字。例如：</p>
+
+<pre>(func (param $p1 i32) (param $p2 f32) (local $loc i32) …)</pre>
+
+<p>这里，使用get_local $p1就代替get_local 0，访问参数i32变量时，就可以通过 $p1 进行访问。</p>
+
+<div class="note">
+<p>注意，当文本转换为二进制后，二进制中只包含整数。</p>
+</div>
+
+<h2 id="栈式机器">栈式机器</h2>
+
+<p>虽然浏览器把wasm编译为某种更高效的东西，但是，wasm的执行是以栈式机器定义的。也就是说，其基本理念是每种类型的指令都是在栈上执行数值的入栈出栈操作。</p>
+
+<p>例如，get_local被定义为把它读到的局部变量值压入到栈上，然后i32.add从栈上取出两个i32类型值（它的含义是把前面压入栈上的两个值取出来）计算它们的和（以2^32求模），最后把结果压入栈上。</p>
+
+<p>当函数被调用的时候，它是从一个空栈开始的。随着函数体指令的执行，栈会逐步填满和清空。例如，在执行了下面的函数之后：</p>
+
+<pre>(func (param $p i32)
+  get_local $p
+  get_local $p
+  i32.add)</pre>
+
+<p>栈上只包含一个i32类型值——表达式 ($p + $p)的结果，该结果是由i32.add得到的。函数的返回值就是栈上留下的那个最终值。</p>
+
+<p>WebAssembly验证规则确保栈准确匹配：如果你声明了(result f32)，那么，最终栈上必须包含一个f32类型值。如果没有result类型，那么栈必须是空的。</p>
+
+<h2 id="我们的第一个函数体">我们的第一个函数体</h2>
+
+<p>正如前面提到的，函数体就是函数被调用后执行的指令列表。把已经学到的放在一起，我们能够定义一个包含我们的简单函数的模块：</p>
+
+<pre>(module
+  (func (param $lhs i32) (param $rhs i32) (result i32)
+    get_local $lhs
+    get_local $rhs
+    i32.add))</pre>
+
+<p>这个函数获取两个参数，然后相加，最后返回其结果。</p>
+
+<p>有很多东西都可以放在函数体里面，但是，现在我们从简单的开始，然后随着逐步前进，你会看到更多的例子。访问<a href="http://webassembly.org/docs/semantics/">webassembly.org语义手册</a>获取可用操作码的完整列表。</p>
+
+<h3 id="调用函数">调用函数</h3>
+
+<p>我们的函数自己不会做什么——现在，我们需要调用它。我们该如何做呢？正如在一个ES2015模块里面一样，wasm函数必须通过模块里面的export语句显式地导出。</p>
+
+<p>像局部变量一样，函数默认也是通过索引来区分的，但是为了方便，可以给它们起个名字。让我们由此开始——首先，在关键字func的后面增加一个美元符号开头的名字：</p>
+
+<pre>(func $add … )</pre>
+
+<p>现在，我们需要增加一个导出声明——看起来像下面这样：</p>
+
+<pre>(export "add" (func $add))</pre>
+
+<p>这里的add是JavaScript中用来区别这个函数的名字，而$add则是指出模块中的哪个WebAssembly函数将会被导出：</p>
+
+<p>所以，我们最终的模块（当前）看起来像下面这样：</p>
+
+<pre>(module
+  (func $add (param $lhs i32) (param $rhs i32) (result i32)
+    get_local $lhs
+    get_local $rhs
+    i32.add)
+  (export "add" (func $add))
+)</pre>
+
+<p>如果你想继续研究这个例子，那么把我们上面的模块保存到一个名叫add.wat的文件中，然后使用wabt（参考<a href="/zh-CN/docs/WebAssembly/Text_format_to_wasm">把WebAssembly文本格式转换为wasm</a>）将其转换为名叫add.wasm的二进制文件。</p>
+
+<p>接下来，我们把二进制文件加载到叫做addCode的带类型数组（<a href="/zh-CN/docs/WebAssembly/Fetching_WebAssembly_bytecode">获取WebAssembly字节码</a>），编译并实例化它，然后在JavaScript中执行我们的add函数（现在，我们可以在实例的<a href="/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/exports">exports</a>属性中找到add()）。</p>
+
+<pre class="brush: js">fetchAndInstantiate('add.wasm').then(function(instance) {
+   console.log(instance.exports.add(1, 2));  // "3"
+});
+
+// fetchAndInstantiate() found in wasm-utils.js
+function fetchAndInstantiate(url, importObject) {
+  return fetch(url).then(response =&gt;
+    response.arrayBuffer()
+  ).then(bytes =&gt;
+    WebAssembly.instantiate(bytes, importObject)
+  ).then(results =&gt;
+    results.instance
+  );
+}</pre>
+
+<div class="note">
+<p><strong>注</strong>：你可以在GitHub上找到这个例子 <a href="https://github.com/mdn/webassembly-examples/blob/master/understanding-text-format/add.html">add.html</a> (<a href="https://mdn.github.io/webassembly-examples/understanding-text-format/add.html">实时运行</a>)。另外，参考 <a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate">WebAssembly.instantiate()</a> 来获取关于实例化函数的更多细节以及<a href="https://github.com/mdn/webassembly-examples/blob/master/wasm-utils.js">wasm-utils.js</a>来获取fetchAndInstantiate()的源代码。</p>
+</div>
+
+<h2 id="探索基本原则">探索基本原则</h2>
+
+<p>现在，我们已经讨论了基本概念，让我们继续看看更高级的特性。</p>
+
+<h3 id="在同一模块里的函数调用其他函数成员">在同一模块里的函数调用其他函数成员</h3>
+
+<p>为函数给定一个索引或名字，<code>call</code>指令可以调用它。例如，下面的模块包含两个函数——一个返回值42，另一个返回，第一个函数结果加1。</p>
+
+<pre>(module
+  (func $getAnswer (result i32)
+    i32.const 42)
+  (func (export "getAnswerPlus1") (result i32)
+    call $getAnswer
+    i32.const 1
+    i32.add))</pre>
+
+<div class="note">
+<p><strong>注</strong>：i32.const只是定义一个32位整数并把它压入栈。你可以把i32替换为任何其他可用的类型，并把const值修改为你想要的任何值（这里，我们把这个值设置为42）。</p>
+</div>
+
+<p>在这个例子中，你注意到一个(export "getAnswerPlus1")代码段，并且它声明在第二个函数的func语句之后——这声明我们想导出这个函数，以及定义导出的名字的简便方法。</p>
+
+<p>从功能上来说，这与我们前面做过的那样，在函数外面，即模块的其他地方，包括一个独立的函数语句是等价的。例如：</p>
+
+<pre>(export "getAnswerPlus1" (func $functionName))</pre>
+
+<p>调用我们前面模块的JavaScript看起来像这样：</p>
+
+<pre class="brush: js">fetchAndInstantiate('call.wasm').then(function(instance) {
+  console.log(instance.exports.getAnswerPlus1());  // "43"
+});</pre>
+
+<div class="note">
+<p>注：你可以在GitHub上找到这个例子<a href="https://github.com/mdn/webassembly-examples/blob/master/understanding-text-format/call.html">call.wasm</a> （或<a href="https://mdn.github.io/webassembly-examples/understanding-text-format/call.html">实时运行</a>）。再提一次，查看<a href="https://github.com/mdn/webassembly-examples/blob/master/wasm-utils.js">wasm-utils.js</a>来了解fetchAndInstantiate()的源代码。</p>
+</div>
+
+<h3 id="从JavaScript导入函数">从JavaScript导入函数</h3>
+
+<p>我们已经见过JavaScript调用WebAssembly函数，但是WebAssembly如何调用JavaScript函数呢？事实上，WebAssembly对JavaScript没有任何了解，但是，它有一个可以导入JavaScript或wasm函数的通用方法。让我们看一个例子：</p>
+
+<pre>(module
+  (import "console" "log" (func $log (param i32)))
+  (func (export "logIt")
+    i32.const 13
+    call $log))</pre>
+
+<p>WebAssembly使用了两级命名空间，所以，这里的导入语句是说我们要求从console模块导入log函数。另外，你可以看到在logIt函数中，通过call指令调用了JavaScrpit导入的函数log。</p>
+
+<p>导入的函数就像普通函数一样：它们拥有一个WebAssembly验证机制，会静态检查的签名，可以被设置一个索引，能够被命名和被调用。</p>
+
+<p>JavaScript函数没有签名的概念，因此，无论导入的声明签名是什么，任何JavaScript函数都可以被传递过来。一旦一个模块声明了一个导入， <a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate">WebAssembly.instantiate()</a>的调用者必须传递一个拥有相应属性的导入对象。</p>
+
+<p>就上面而言，我们需要一个（让我们称之为importObject的）对象，并且importObject.console.log是一个JavaScript函数。</p>
+
+<p>这看起来像下面这样：</p>
+
+<pre class="brush: js">var <strong>importObject</strong> = {
+  console: {
+    log: function(arg) {
+      console.log(arg);
+    }
+  }
+};
+
+fetchAndInstantiate('logger.wasm', <em><strong>importObject</strong></em>).then(function(instance) {
+  instance.exports.logIt();
+});</pre>
+
+<div class="note">
+<p><strong>注</strong>：你可以在GitHub上找到这个例子<a href="https://github.com/mdn/webassembly-examples/blob/master/understanding-text-format/logger.html">logger.html</a> (<a href="https://mdn.github.io/webassembly-examples/understanding-text-format/logger.html">实时运行</a>)。</p>
+</div>
+
+<h3 id="WebAssembly内存">WebAssembly内存</h3>
+
+<p>上面的例子是一个相当简单的日志函数：它只是打印一个整数！要是我们想输出一个文本字符串呢？为了处理字符串及其他复杂数据类型，WebAssembly提供了内存。</p>
+
+<p>按照WebAssembly的定义，内存就是一个随着时间增长的字节数组。WebAssembly包含诸如i32.load和i32.store指令来实现对<a href="http://webassembly.org/docs/semantics/#linear-memory">线性内存</a>的读写。</p>
+
+<p>从JavaScript的角度来看，内存就是一个ArrayBuffer，并且它是可变大小的。从字面上来说，这也是asm.js所做的（除了它不能改变大小；参考asm.js<a href="http://asmjs.org/spec/latest/#programming-model">编程模型</a>）。</p>
+
+<p>因此，一个字符串就是位于这个线性内存某处的字节序列。</p>
+
+<p>让我们假设我们已经把一个合适的字符串字节写入到了内存中；那么，我们该如何把那个字符串传递给JavaScript呢？</p>
+
+<p>关键在于JavaScript能够通过{{jsxref("WebAssembly.Memory()")}}接口创建WebAssembly线性内存实例，并且能够通过相关的实例方法获取已经存在的内存实例（当前每一个模块实例只能有一个内存实例）。内存实例拥有一个<a href="/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/buffer">buffer</a>获取器，它返回一个指向整个线性内存的ArrayBuffer。</p>
+
+<p>内存实例也能够增长。举例来说，在JavaScript中可以调用<a href="/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/grow">Memory.grow()</a>方法。由于ArrayBuffer不能改变大小，所以，当增长产生的时候，当前的ArrayBuffer会被移除， 并且一个新的ArrayBuffer会被创建并指向新的、更大的内存。这意味着为了向JavaScript传递一个字符串，我们所需要做的就是把字符串在线性内存中的偏移量，以及表示其长度的方法传递出去。</p>
+
+<p>虽然有许多不同的方法在字符串自身当中保存字符串的长度（例如，C字符串）；但是，这里为了简单起见，我们仅仅把偏移量和长度都作为参数：</p>
+
+<pre>(import "console" "log" (func $log (param i32) (param i32)))</pre>
+
+<p>在JavaScript端，我们可以使用<a href="/zh-CN/docs/Web/API/TextDecoder">文本解码器API</a>，轻松地把我们的字节解码转化为一个JavaScript字符串。（这里，我们使用utf8，不过，许多其他编码也是支持的。）</p>
+
+<pre class="brush: js">consoleLogString(offset, length) {
+  var bytes = new Uint8Array(memory.buffer, offset, length);
+  var string = new TextDecoder('utf8').decode(bytes);
+  console.log(string);
+}</pre>
+
+<p>这个谜题的最后一部分就是consoleLogString从哪里获得？WebAssembly的内存（memory）实例。这里，WebAssembly给我们很大灵活性：我们既可以使用JavaScript创建一个<a href="/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory">内存</a>对象，让WebAssembly模块导入这个内存，或者我们让WebAssembly模块创建这个内存并把它导出给JavaScript。</p>
+
+<p>为了简单起见，让我们用JavaScript创建它，然后把它导入到WebAssembly。我们的导入语句编写如下：</p>
+
+<pre>(import "js" "mem" (memory 1))</pre>
+
+<p>1表示导入的内存必须至少有1页内存。（WebAssembly定义一页为64KB。）</p>
+
+<p>因此，让我们看一个完整的打印字符串“Hi”的模块。在一个常规的已编译的C程序，你会调用一个函数来为字符串分配一段内存。但是，因为我们正在编写自己的汇编，并且我们拥有整个线性内存，所以，我们可以使用数据（data）段把字符串内容写入到一个全局内存中。数据段允许字符串字节在实例化时被写在一个指定的偏移量。而且，它与原生的可执行格式中的数据（.data）段是类似的。</p>
+
+<p>我们最终的wasm模块看起来像这样：</p>
+
+<pre>(module
+  (import "console" "log" (func $log (param i32 i32)))
+  (import "js" "mem" (memory 1))
+  (data (i32.const 0) "Hi")
+  (func (export "writeHi")
+    i32.const 0  ;; pass offset 0 to log
+    i32.const 2  ;; pass length 2 to log
+    call $log))</pre>
+
+<div class="note">
+<p><strong>注</strong>： 注意上面的双分号语法，它允许在WebAssembly文件中添加注释。</p>
+</div>
+
+<p>现在，我们可以从JavaScript中创建一个1页的内存（Memory ）然后把它传递进去。这会在控制台输出"Hi"。</p>
+
+<pre class="brush: js">var memory = new WebAssembly.Memory({initial:1});
+
+var importObj = { console: { log: consoleLogString }, js: { mem: memory } };
+
+fetchAndInstantiate('logger2.wasm', importObject).then(function(instance) {
+  instance.exports.writeHi();
+});</pre>
+
+<div class="note">
+<p><strong>注</strong>：你可以在GitHub上找到完整源代码<a href="https://github.com/mdn/webassembly-examples/blob/master/understanding-text-format/logger2.html">logger2.html</a> (<a href="https://mdn.github.io/webassembly-examples/understanding-text-format/logger2.html">或者实时运行</a>)。</p>
+</div>
+
+<h3 id="WebAssembly表格">WebAssembly表格</h3>
+
+<p>为了结束WebAssembly文本格式之旅，让我们看看最难理解的、常常令人迷惑的WebAssembly部分：表格。</p>
+
+<p>总的来说，表格是从WebAssembly代码中通过索引获取的可变大小的引用数组。</p>
+
+<p>为了了解为什么表格是必须的，我们首先需要观察前面看到的call指令，它接受一个静态函数索引，并且只调用了一个函数——但是，如果被调用者是一个运行时值呢？</p>
+
+<ul>
+ <li>在JavaScript中，我们总是看到：函数是一等值。</li>
+ <li>在C/C++中，我们看到了函数指针。</li>
+ <li>在C++中，我们看到了虚函数。</li>
+</ul>
+
+<p>WebAssembly需要一种做到这一点的调用指令，因此，我们有了接受一个动态函数操作数的call_indirect指令。问题是，在WebAssembly中，当前操作数的仅有的类型是i32/i64/f32/f64。</p>
+
+<p>WebAssembly可以增加一个anyfunc类型（"any"的含义是该类型能够持有任何签名的函数），但是，不幸的是，由于安全原因，这个anyfunc类型不能存储在线性内存中。<em><strong><code>线性内存会把存储的原始内容作为字节暴露出去，并且这会使得wasm内容能够任意的查看和修改原始函数地址</code></strong></em>，而这在网络上是不被允许的。</p>
+
+<p>解决方案是在一个表格中存储函数引用，然后作为 代替，传递表格索引——它们只是i32类型值。因此，call_indirect的操作数可以是一个i32类型索引值。</p>
+
+<h4 id="在wasm中定义一个表格">在wasm中定义一个表格</h4>
+
+<p>那么，我们该如何在表格中放置wasm函数呢？就像数据段能够用来通过字节初始化线性内存区域一样，元素（elem）段能够用来通过函数初始化表格区域：</p>
+
+<pre>(module
+  (table 2 anyfunc)
+  (elem (i32.const 0) $f1 $f2)
+  (func $f1 (result i32)
+    i32.const 42)
+  (func $f2 (result i32)
+    i32.const 13)
+  ...
+)</pre>
+
+<ul>
+ <li>在(table 2 anyfunc)中，数字2表示的是表格的初始大小（也就是它将存储两个引用）并且anyfunc声明的是这些引用的元素类型是“一个具有任何签名的函数”。在当前的WebAssembly版本中，这是唯一被允许的元素类型，但是在将来，更多的元素类型会加入进来。</li>
+ <li>函数(func)部分跟任何其他声明的wasm函数没有什么两样。她们是我们将会在表格中引用的函数（作为例子，每一个只是返回一个静态值）。值得注意的是，函数部分声明的顺序并不重要——你可以在任何地方声明你的函数然后在你的元素段（elem section）中引用它们。</li>
+ <li>元素段（elem section）能够将一个模块中的任意函数子集以任意顺序列入其中，并允许出现重复。列入其中的函数将会被表格引用并，且引用顺序是其出现的顺序。</li>
+ <li>元素段（elem section）中的(i32.const 0)值是一个偏移量——它需要在元素段开始的位置声明，其作用是表明函数引用是在表格中的什么索引位置开始存储的。这里我们指定的偏移量是0，表格大小是2（参考上面），因此，我们可以在索引0和1的位置填入两个引用。如果想在偏移量1的位置开始写入引用，那么，我们必须使用(i32.const 1)并且表格大小必须是3.</li>
+</ul>
+
+<div class="note">
+<p><strong>注</strong>： 未初始化的元素会被设定一个默认的调用即抛出（throw-on-call）值。</p>
+</div>
+
+<p>在JavaScript中，可以创建这样一个表格实例的等价的函数调用看起来如下所示：</p>
+
+<pre class="brush: js">function() {
+  // table section
+  var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
+
+  // function sections:
+  var f1 = function() { … }
+  var f2 = function() { … }
+
+  // elem section
+  tbl.set(0, f1);
+  tbl.set(1, f2);
+};</pre>
+
+<h4 id="使用表格">使用表格</h4>
+
+<p>接着继续。现在，表格已经定义好了，我们需要用某种方法使用它。让我们使用下面的代码段来做到这一点：</p>
+
+<pre>(type $return_i32 (func (result i32))) ;; if this was f32, type checking would fail
+(func (export "callByIndex") (param $i i32) (result i32)
+  get_local $i
+  call_indirect $return_i32)</pre>
+
+<ul>
+ <li>(type $return_i32 (func (result i32)))代码块使用一个引用名字定义了一个类型。该类型被用来在后续的表格函数引用调用时进行类型检查。这里，我们声明的是该引用是一个返回值为i32类型的函数。</li>
+ <li>接下来，我们定义了一个导出名字为callByIndex的函数。它有一个接受i32类型的参数$i。</li>
+ <li>在函数里面，我们在栈顶压入一个值——该值就是传递给参数$i的值。</li>
+ <li>最后，我们使用call_indirect指令调用表格中的函数——这隐含的意思是$的值从栈顶出栈。最终的结果就是callByIndex函数会调用表格中的第$i个函数。</li>
+</ul>
+
+<p>你也可以在命令调用的时候显式地声明call_indirect的参数，就像下面这样：</p>
+
+<pre>(call_indirect $return_i32 (get_local $i))</pre>
+
+<p>在更高层面，像JavaScript这样更具表达力的语言，你可以设想使用一个数组（或者更有可能的是对象）来完成相同的事情。伪代码看起来像这样：tbl[i]()。</p>
+
+<p>回到类型检查。因为WebAssembly是带有类型检查的，并且anyfunc的含义是任何函数签名，所以，我们必须在调用点提供假定的被调用函数签名。这里，我们包含了一个$return_i32类型来告诉程序期望的是一个返回值为i32类型的函数。如果被调用函数没有一个匹配的签名（比如说返回值是f32类型的），那么，程序会抛出<a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError">WebAssembly.RuntimeError</a>异常。</p>
+
+<p>那么，是什么把call_indirect指令和我们要是用的表格联系起来的呢？答案是，现在每一个模块实例只允许唯一一个表格存在，这也就是call_indirect指令隐式地使用的表格。在将来，当多表格被允许了，我们需要在代码行中指明一个某种形式的表格标识符：</p>
+
+<pre>call_indirect $my_spicy_table $i32_to_void</pre>
+
+<p>完整的模块看起来如下所示并且能够在我们的<a href="https://github.com/mdn/webassembly-examples/blob/master/understanding-text-format/wasm-table.wat">wasm-table.wat</a>示例文件中找到：</p>
+
+<pre>(module
+  (table 2 anyfunc)
+  (func $f1 (result i32)
+    i32.const 42)
+  (func $f2 (result i32)
+    i32.const 13)
+  (elem (i32.const 0) $f1 $f2)
+  (type $return_i32 (func (result i32)))
+  (func (export "callByIndex") (param $i i32) (result i32)
+    get_local $i
+    call_indirect $return_i32)
+)</pre>
+
+<p>我们使用下面的JavaScript把它加载到一个网页中：</p>
+
+<pre class="brush: js">fetchAndInstantiate('wasm-table.wasm').then(function(instance) {
+  console.log(instance.exports.callByIndex(0)); // 返回42
+  console.log(instance.exports.callByIndex(1)); // 返回13
+  console.log(instance.exports.callByIndex(2));
+  // 返回一个错误，因为在表格中没有索引值2
+});</pre>
+
+<div class="note">
+<p><strong>注</strong>：你可以在GitHub上找到这个例子 <a href="https://github.com/mdn/webassembly-examples/blob/master/understanding-text-format/wasm-table.html">wasm-table.html</a> (<a href="https://mdn.github.io/webassembly-examples/understanding-text-format/wasm-table.html">实时查看</a>)。</p>
+</div>
+
+<div class="note">
+<p><strong>注</strong>：就像内存一样，表格也能够从JavaScript中创建 (参考 <a href="/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table">WebAssembly.Table()</a>)并且能够导入和导出到其他wasm模块。</p>
+</div>
+
+<h3 id="改变表格和动态链接">改变表格和动态链接</h3>
+
+<p>因为JavaScript对于函数引用有完全的存取权限，所以，从JavaScript中通过<a href="/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/grow">grow()</a>、<a href="/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get">get()</a>和<a href="/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/set">set()</a>方法能够改变表格对象。</p>
+
+<p>因为表格是可变的，所以，它们能够用来实现复杂的加载时和运行时<a href="http://webassembly.org/docs/dynamic-linking">动态链接</a>。当程序被动态地链接，多个实例共享相同的内存和表格。这与原生应用程序的多个.dll共享一个进程地址空间是等价的。</p>
+
+<p>为了看看实际情况，我们会创建一个包含一个内存对象和一个表格对象的导入对象，并且把这个导入对象传递到多个<a href="/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate">instantiate()</a>调用中去。</p>
+
+<p>我们的.wat看起来像这样：</p>
+
+<p><code>shared0.wat</code>:</p>
+
+<pre>(module
+  (import "js" "memory" (memory 1))
+  (import "js" "table" (table 1 anyfunc))
+  (elem (i32.const 0) $shared0func)
+  (func $shared0func (result i32)
+   i32.const 0
+   i32.load)
+)</pre>
+
+<p><code>shared1.wat</code>:</p>
+
+<pre>(module
+  (import "js" "memory" (memory 1))
+  (import "js" "table" (table 1 anyfunc))
+  (type $void_to_i32 (func (result i32)))
+  (func (export “doIt”) (result i32)
+   i32.const 0
+   i32.const 42
+   i32.store  ;; store 42 at address 0
+   i32.const 0
+   call_indirect $void_to_i32)
+)</pre>
+
+<p>运行逻辑如下：</p>
+
+<ol>
+ <li>函数shared0func在shared0.wat中定义并存储在我们的导出表格对象(table)中。</li>
+ <li>该函数先创建一个常量值为0，然后执行i32.load指令。用给定的内存索引，去加载存储到内存对象中的值，给定的索引值为0。—— 这样，会隐式地将之前的值出栈。所以，shared0func加载并返回了存储在内存对象索引0处的值。</li>
+ <li>在shared1.wat中，我们导出了一个名为doIt的函数——这个函数创建了两个常量值，分别为0和42，然后使用i32.store指令把给定的值存储在指定索引位置的内存对象中。同样的，该指令会把这些值出栈，所以，结果就是把42存储在内存索引0处。</li>
+ <li>在这个函数的最后一部分，我们创建了常量值0，然后调用表格中索引0处的函数，该函数正是我们之前在shared0.wat中的使用元素代码段（elem block）存储的shared0func。</li>
+ <li>shared0func在被调用之后会加载我们在shared1.wat中使用i32.store指令存储在内存中的42。</li>
+</ol>
+
+<div class="note">
+<p><strong>注</strong>：上面的表达式会隐式地把这些值出栈，但是，你可以在使用指令的时候进行显式地声明。例如：</p>
+
+<pre>(i32.store (i32.const 0) (i32.const 42))
+(call_indirect $void_to_i32 (i32.const 0))</pre>
+</div>
+
+<p>在转换为汇编之后，我们可以在JavaScript中通过下面的代码使用shared0.wasm和shared1.wasm：</p>
+
+<pre class="brush: js">var importObj = {
+  js: {
+    memory : new WebAssembly.Memory({ initial: 1 }),
+    table : new WebAssembly.Table({ initial: 1, element: "anyfunc" })
+  }
+};
+
+Promise.all([
+  fetchAndInstantiate('shared0.wasm', importObj),
+  fetchAndInstantiate('shared1.wasm', importObj)
+]).then(function(results) {
+  console.log(results[1].exports.doIt());  // prints 42
+});</pre>
+
+<p>每一个将被编译的模块都可以导入相同的内存和表格对象，这也就是共享相同的线性内存和表格的“地址空间”。</p>
+
+<div class="note">
+<p><strong>注</strong>：你可以在GitHub上找到这个例子<a href="https://github.com/mdn/webassembly-examples/blob/master/understanding-text-format/shared-address-space.html">shared-address-space.html</a> (<a href="https://mdn.github.io/webassembly-examples/understanding-text-format/shared-address-space.html">或者实时运行</a>)。</p>
+</div>
+
+<h2 id="总结">总结</h2>
+
+<p>以上我们概括浏览了，关于WebAssembly文本格式的主要部分，以及它们是如何映射到WebAssembly JS API中的。 </p>
+
+<h2 id="另见">另见</h2>
+
+<ul>
+ <li>没有介绍的一个主要的部分是在函数体中会出现的所有指令的清单。参考<a href="http://webassembly.org/docs/semantics">WebAssembly语义</a>来了解每条指令的含义。</li>
+ <li>参考被规范解释器实现的<a href="https://github.com/WebAssembly/spec/blob/master/interpreter/README.md#s-expression-syntax">文本格式语法</a>。</li>
+</ul>
diff --git a/files/zh-cn/webassembly/using_the_javascript_api/index.html b/files/zh-cn/webassembly/using_the_javascript_api/index.html
new file mode 100644
index 0000000000..91b318c700
--- /dev/null
+++ b/files/zh-cn/webassembly/using_the_javascript_api/index.html
@@ -0,0 +1,281 @@
+---
+title: 使用WebAssembly JavaScript API
+slug: WebAssembly/Using_the_JavaScript_API
+tags:
+  - API
+  - JavaScript
+  - WebAssembly
+  - wasm
+  - 内存
+  - 实例化
+  - 开发者工具
+  - 编译
+  - 表格
+translation_of: WebAssembly/Using_the_JavaScript_API
+---
+<div>{{WebAssemblySidebar}}</div>
+
+<p class="summary">如果您已经使用Emscripten等工具编译了另一种语言的模块，或者自己加载并运行代码，那么下一步是了解如何使用WebAssembly JavaScript API的其他功能。这篇文章告诉你你需要知道什么。</p>
+
+<div class="note">
+<p><strong>注</strong>：如果你不熟悉本文中提到到基础概念并且需要更多的解释，先阅读 <a href="/zh-CN/docs/WebAssembly/Concepts">WebAssembly概念</a> 然后再回来。</p>
+</div>
+
+<h2 id="一个简单的例子">一个简单的例子</h2>
+
+<p>让我们通过一步一步的例子来了解如何在WebAssembly 中使用 Javascript API，和如何在网页中加载一个 wasm 模块。</p>
+
+<div class="note">
+<p><strong>注</strong>：你可以发现同样的代码在 <a href="https://github.com/mdn/webassembly-examples">webassembly-examples</a> GitHub 仓库.</p>
+</div>
+
+<h3 id="准备工作">准备工作</h3>
+
+<ol>
+ <li>首先需要一个 wasm 模块！下载 <a href="https://github.com/mdn/webassembly-examples/raw/master/js-api-examples/simple.wasm">simple.wasm</a> 文件到本机的一个新的目录下.</li>
+ <li>确保本机使用的是支持 webassembly 的浏览器。Firefox 52+ 和 Chrome 57+ 是默认支持 webassembly 的.</li>
+ <li>然后, 创建一个简单的HTML 文件命名为 index.html 和并且你的本机的 wasm 文件处于同一目录下 ( 如果你没有模板可以使用我们提供的 <a href="https://github.com/mdn/webassembly-examples/blob/master/template/template.html">simple template</a> ).</li>
+ <li>现在, 为了帮助我们理解发生了什么, 让我们来看看这个 wasm 模块的文本表示(也可以在<a href="/zh-CN/docs/WebAssembly/Text_format_to_wasm#初识文本格式">将WebAssembly文本格式转换为wasm</a>见到):
+  <pre class="notranslate">(module
+  (func $i (import "imports" "imported_func") (param i32))
+  (func (export "exported_func")
+    i32.const 42
+    call $i))</pre>
+ </li>
+ <li>在第二行, 你将看到导入有一个两级命名空间 —— 内部函数 <code>$i</code> 是从<font face="consolas, Liberation Mono, courier, monospace"> imports.imported_func 导入的</font>. 编写要导入到wasm模块的对象时，我们需要在JavaScript中反映这个两级命名空间. 创建一个 <code>&lt;script&gt;&lt;/script&gt;</code> 节点在你的HTML 文件中, 并且添加下面的代码:
+  <pre class="brush: js notranslate">var importObject = {
+  imports: {
+      imported_func: function(arg) {
+        console.log(arg);
+      }
+    }
+  };</pre>
+ </li>
+</ol>
+
+<p>如上所述，  我们在 <code>imports.imported_func 中有我们导入的函数</code>.</p>
+
+<div class="note">
+<p><strong>注</strong>：使用 <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">ES6箭头函数</a> 将会更加简洁:</p>
+
+<pre class="brush: js notranslate">let importObject = {
+    imports: {
+        imported_func: arg =&gt; console.log(arg),
+    }
+};
+</pre>
+</div>
+
+<p>具体哪种风格由你决定.</p>
+
+<h3 id="加载并使用_wasm_模块">加载并使用 wasm 模块</h3>
+
+<p>当我们导入了对象后, 我们将获取 wasm 文件, 使其在 array buffer 可用, 然后就可以使用其导出的函数.</p>
+
+<p>在第一个块下面添加以下代码到你的脚本中:</p>
+
+<pre class="brush: js notranslate">fetch('simple.wasm')
+.then(res =&gt;
+  res.arrayBuffer()
+).then(bytes =&gt;
+  WebAssembly.instantiate(bytes, importObject)
+).then(results =&gt; {
+  results.instance.exports.exported_func();
+});</pre>
+
+<div class="note">
+<p><strong>注</strong>：我们已经非常详细地解释了这种语法如何工作通过<a href="/zh-CN/docs/WebAssembly/Loading_and_running#使用Fetch">加载和运行WebAssembly代码</a>。如果不确定，请回到那里进行复习。</p>
+</div>
+
+<p>这样做的结果是执行我们导出的 WebAssembly 函数 exported_func，<font face="consolas, Liberation Mono, courier, monospace">这样又调用了另一个我们导入的 JavaScript 函数 imported_func</font>, 它将WebAssembly实例（42）中提供的值记录到控制台. 如果你保存实例代码并且在支持 WebAssembly 的浏览器中运行，你将看到此操作。</p>
+
+<div class="note">
+<p><strong>注</strong>：WebAssembly 在 Firefox 52+ 和 Chrome 57+/latest Opera 是默认支持的(你也可以运行 wasm 代码 在 Firefox 47+ 通过将 <em>about:config</em> 中的 <code>javascript.options.wasm</code> flag 设置为 enabling , 或者在 Chrome (51+) 以及 Opera (38+) 通过访问 <em>chrome://flags</em> 并且将 <em>Experimental WebAssembly</em> flag 设置为 enabling.)</p>
+</div>
+
+<p>这是一个冗长的，令人费解的例子并且实现了很少的功能, 但它确实有助于说明这是可能的 —— 在 Web 应用中与 JavaScript 一起使用 WebAssembly 代码. 正如我们一直说的,  WebAssembly 并不旨在替代 JavaScript; 两者可以一起工作，借鉴对方的优势。</p>
+
+<h3 id="在开发者工具查看wasm">在开发者工具查看wasm </h3>
+
+<p>在 Firefox 54+,  Developer Tool Debugger Panel 有用于公开网页中包含的任何 wasm 代码的文本表示的功能. 为了查看它们, 要查看它，您可以转到 Debugger Panel 然后单击 “xxx &gt; wasm” .</p>
+
+<p><img alt="" src="https://mdn.mozillademos.org/files/14655/wasm-debugger-output.png" style="display: block; height: 354px; margin: 0px auto; width: 1026px;"></p>
+
+<p>从 Firfox 开始，除了将WebAssembly视为文本，开发者可以使用文本格式调试 (打断点, 检查调用堆栈, 单步调试等等.) WebAssembly 代码. 通过这个视频<a href="https://www.youtube.com/watch?v=R1WtBkMeGds">使用Firefox开发者工具调试WebAssembly</a><span class="watch-title" dir="ltr" id="eow-title" title="WebAssembly debugging with Firefox DevTools">预览。</span></p>
+
+<h2 id="内存">内存</h2>
+
+<p>在WebAssembly的底层内存模型中，内存被表示为称为 <a href="http://webassembly.org/docs/semantics/#linear-memory">线性内存</a> 的无类型字节的连续范围，通过模块中的<a href="http://webassembly.org/docs/semantics/#linear-memory-accesses">加载和存储指令</a>读取和写入。  在这个内存模型中， 任何加载或存储都可以访问整个线性存储器中的任何字节，这是忠实地表示C / C ++概念（如指针）所必需的。</p>
+
+<p>然后，和原生 C/C++ 程序不同的是可用内存范围跨越整个进程，特定WebAssembly实例可访问的内存被限制在由WebAssembly Memory对象包含的一个特定的 —— 可能非常小的范围内。</p>
+
+<p>在 JavaScript 中，内存实例可以被认为是可调整大小的ArrayBuffer，就像ArrayBuffers一样，一个Web应用程序可以创建许多独立的内存对象。 您可以使用 {{jsxref("WebAssembly.Memory()")}} 构造函数创建一个，它将参数作为初始大小和（可选）最大大小）。</p>
+
+<p>我们通过一个快速的例子来开始探索。</p>
+
+<ol>
+ <li>
+  <p>创建另一个简单的 HTML 页面 (复制我们的 <a href="https://github.com/mdn/webassembly-examples/blob/master/template/template.html">simple template</a>) 并且命名为 <code>memory.html。</code>添加一个 <code>&lt;script&gt;&lt;/script&gt;</code> 节点到页面中。</p>
+ </li>
+ <li>
+  <p>在脚本的顶部添加下面的一行代码来创建一个内存实例:</p>
+
+  <pre class="brush: js notranslate">var memory = new WebAssembly.Memory({initial:10, maximum:100});</pre>
+
+  <p>初始和最大的单位是 WebAssembly pages ——这些页面的大小固定为64KB。这意味着上述内存实例的初始大小为640KB，最大大小为6.4MB。</p>
+
+  <p>WebAssembly内存通过简单地提供一个返回ArrayBuffer的缓冲区getter / setter来显示它的字节。例如，要直接将42写入线性内存的第一个单词，你可以这样做：</p>
+
+  <pre class="brush: js notranslate">new Uint32Array(memory.buffer)[0] = 42;</pre>
+
+  <p>你也可以得到刚才的值通过:</p>
+
+  <pre class="brush: js notranslate">new Uint32Array(memory.buffer)[0]</pre>
+ </li>
+ <li>
+  <p>现在尝试这个演示 —— 保存目前为止添加的内容，将其加载到浏览器中，然后尝试在JavaScript控制台中输入上述两行。</p>
+ </li>
+</ol>
+
+<h3 id="增加内存">增加内存</h3>
+
+<p>一个内存实例的大小可以通过 {{jsxref("Memory.prototype.grow()")}} 来增加，再次以 WebAssembly pages 为单位指定参数:</p>
+
+<pre class="brush: js notranslate">memory.grow(1);</pre>
+
+<p>如果在创建内存实例时提供了最大值，则尝试超过此最大值将抛出 {{jsxref("WebAssembly.RangeError")}} 异常。 引擎利用这个提供的上限来提前预留内存，这样可以使调整大小更有效率。</p>
+
+<p>Note: 由于 {{domxref("ArrayBuffer")}} 的byteLength是不可变的，所以在成功 {{jsxref("Memory.prototype.grow()")}} 操作之后，缓冲区getter将返回一个新的ArrayBuffer对象 新的byteLength）和任何先前的ArrayBuffer对象变成“分离”，或者与先前指向的底层内存断开连接。</p>
+
+<p>和函数一样，线性内存可以在模块内部进行定义或者导入。类似地，模块还可以可选地导出其内存。这这意味着JavaScript可以通过创建<code>new WebAssembly.Memory</code> 并将其作为导入或通过接收内存导出传递给WebAssembly实例的内存来访问(通过 <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/exports">Instance.prototype.exports</a></code>).</p>
+
+<h3 id="更复杂的内存示例">更复杂的内存示例</h3>
+
+<p>让我们通过看一个更复杂的内存示例——一个对整数数组进行求和的WebAssembly模块——来明确上面的概念。你可以在这里<a href="https://github.com/mdn/webassembly-examples/raw/master/js-api-examples/memory.wasm">memory.wasm</a>找到示例。</p>
+
+<ol>
+ <li>
+  <p>像前面那样在相同的目录下复制一份memory.wasm。</p>
+
+  <div class="note">
+  <p><strong>注</strong>：你可以在这里<a href="https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/memory.wat">memory.wat</a>找到模块的文本表示形式。</p>
+  </div>
+ </li>
+ <li>
+  <p>回到你的示例文件memory.html，像前面那样获取、编译和实例化你的wasm模块——在你的脚本代码底部加入下面的代码：</p>
+
+  <pre class="brush: js notranslate">fetch('memory.wasm').then(response =&gt;
+  response.arrayBuffer()
+).then(bytes =&gt;
+  WebAssembly.instantiate(bytes)
+).then(results =&gt; {
+  // 在这里加入你的代码
+});</pre>
+ </li>
+ <li>
+  <p>因为该模块导出了它的内存，给定该模块的一个实例，我们可以使用一个导出函数accumulate()在该模块实例的线性内存（mem）中创建和填入一个输入数组。在前面指明的地方加入如下代码：</p>
+
+  <pre class="brush: js notranslate">var i32 = new Uint32Array(results.instance.exports.mem.buffer);
+for (var i = 0; i &lt; 10; i++) {
+  i32[i] = i;
+}
+
+var sum = results.instance.exports.accumulate(0, 10);
+console.log(sum);</pre>
+ </li>
+</ol>
+
+<p>注意我们是如何在内存对象的缓存上创建了 {{domxref("Uint32Array")}}视图，而不是在内存对象本身这么做。</p>
+
+<p>内存导入与函数导入很像，只是内存对象取代了JavaScript函数作为了传入值。内存导入在下面两方面很有用：</p>
+
+<ul>
+ <li>它们允许JavaScript在模块编译之前或者同时获取和创建内存的初始内容。</li>
+ <li>它们允许一个单一的内存对象被多个模块实例导入，对于实现WebAssembly动态链接来说，这是一个关键的构建模块。</li>
+</ul>
+
+<div class="note">
+<p><strong>注</strong>：你可以在这里<a href="https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/memory.html">memory.html</a> (<a href="https://mdn.github.io/webassembly-examples/js-api-examples/memory.html">或实时运行</a>) 找到我们的完整例子——这个版本使用了<a href="https://github.com/mdn/webassembly-examples/blob/master/wasm-utils.js">fetchAndInstantiate()</a>函数。</p>
+</div>
+
+<h2 id="表格">表格</h2>
+
+<p>WebAssembly表格是一个可变大小的带类型的引用数组，其中的引用可以被JavaScript和WebAssembly代码存取。然而，内存提供的是一个可变大小的带类型的原始字节数组。所以，把引用存储在内存中是不安全。由于安全、可移植性和稳定性等原因，作为引擎信任的引用值是千万不能被直接读写的。</p>
+
+<p>表格有一个元素类型，其限制了可以存储在表格的引用类型。在当前的WebAssembly版本中，只有一种WebAssembly代码所需要的引用类型——函数——也就是唯一合法的元素类型。在将来的版本中，更多的元素类型会被加入。</p>
+
+<p>函数引用对于编译诸如C/C++这类拥有函数指针的语言来说是必要的。在C/C++的原生实现中，函数指针是通过函数代码在进程的虚地址空间的原始地址表示的，并且由于前面提到的安全原因，它是不能被直接存储在线性内存中的。取而代之的是，函数引用被存储在表格之中。它们的整数索引可以存储在线性内存中并进行传递。</p>
+
+<p>当调用一个函数指针的时候，WebAssembly调用函数提供索引。在进行索引和调用索引到的函数引用之前，可以对该索引进行表格的边界检查。因而，目前的表格是一个相当底层的用来安全地和可移植地编译底层编程语言特性的基本类型。</p>
+
+<p>表格可以通过<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/set">Table.prototype.set()</a>和 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/grow">Table.prototype.grow()</a>进行更改，它们会更新表格中的一个值和增加可以存储在表格的大小。这允许间接可调用函数集合可以随着时间而改变，其对于<a href="http://webassembly.org/docs/dynamic-linking/">动态链接技术</a>来说是必要的。这些更改对于JavaScript和wasm模块来说是立即生效的。同时，在JavaScript可以通过<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get">Table.prototype.get()</a>得到最新值。</p>
+
+<h3 id="表格示例">表格示例</h3>
+
+<p>让我们看一个简单的表格示例——一个WebAssembly模块，该模块创建并导出了一个带有两个元素的表格：元素0返回13，元素1返回42。你可以在<a href="https://github.com/mdn/webassembly-examples/raw/master/js-api-examples/table.wasm">table.wasm</a>中找到该示例。</p>
+
+<ol>
+ <li>
+  <p>在一个新的目录中复制一份table.wasm。</p>
+
+  <div class="note">
+  <p><strong>注</strong>：你可以在<a href="https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table.wat">table.wat</a>中查看模块的文本表示。</p>
+  </div>
+ </li>
+ <li>
+  <p>创建一份<a href="https://github.com/mdn/webassembly-examples/blob/master/template/template.html">HTML 模板</a>的新副本并将其命名为<code>table.html</code>.</p>
+ </li>
+ <li>
+  <p>如前所示，获取、编译并且实例化你的wasm模块——将下面的代码放入到HTML body底部的<a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script">&lt;script&gt;</a>节点里面：</p>
+
+  <pre class="brush: js notranslate">fetch('table.wasm').then(response =&gt;
+  response.arrayBuffer()
+).then(bytes =&gt;
+  WebAssembly.instantiate(bytes)
+).then(results =&gt; {
+  // 在这里添加你的代码
+});</pre>
+ </li>
+ <li>
+  <p>现在，让我们获取表格中的数据——将下面的代码放入到指定的位置：</p>
+
+  <pre class="brush: js notranslate">var tbl = results.instance.exports.tbl;
+console.log(tbl.get(0)());  // 13
+console.log(tbl.get(1)());  // 42</pre>
+ </li>
+</ol>
+
+<p>这段代码获取获取了存储在表格中的每一个函数引用，然后实例化它们从而将它们拥有的值打印到控制台——注意每一各函数引用是如何使用<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get">Table.prototype.get()</a>函数获取的以及在其后面增加一对小括号从而真正的调用该函数。</p>
+
+<div class="note">
+<p><strong>注</strong>：你可以在<a href="https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table.html">table.html</a> (<a href="https://mdn.github.io/webassembly-examples/js-api-examples/table.html">或实时查看运行</a>)找到我们完整的示例——这个版本使用了<code><a href="https://github.com/mdn/webassembly-examples/blob/master/wasm-utils.js">fetchAndInstantiate()</a></code>函数。</p>
+</div>
+
+<h2 id="多样性">多样性</h2>
+
+<p>现在，我们已经展示了WebAssembly的主要组成模块的使用，这里是提到多样性概念的好地方。这为WebAssembly提供了大量的关于架构效率的优势：</p>
+
+<ul>
+ <li>一个模块可以有N个实例，这与一个函数可以产生N个闭包值一样。</li>
+ <li>一个模块实例可以使用0-1个内存实例，它为这个实例提供了“地址空间”。将来的WebAssembly版本可能允许每个模块实例拥有0-N个内存实例（参考<a href="http://webassembly.org/docs/future-features/#multiple-tables-and-memories">多表格与内存</a>）。</li>
+ <li>一个模块实例可以使用0-1个表格实例——这是该实例的“函数地址空间”，可以用来实现C函数指针。将来的WebAssembly版本可能允许每个模块实例拥有0-N个表格实例。</li>
+ <li>一个内存或表格实例能够被0-N个模块实例使用——这些实例全部共享相同的地址空间，这使得<a href="http://webassembly.org/docs/dynamic-linking">动态链接</a>成为可能。</li>
+</ul>
+
+<p>你可以在我们的理解文本格式一本中看到多样性的应用——参考修改表格和动态链接部分（TBD）。</p>
+
+<h2 id="总结">总结</h2>
+
+<p>本文带你了解了使用WebAssembly的JavaScript API的基本知识，包括在JavaScript上下文中导入一个WebAssembly模块、使用该模块的函数以及在JavaScript中使用WebAssembly的内存和表格。同时，我们也介绍了多样性的概念。</p>
+
+<h2 id="另见">另见</h2>
+
+<ul>
+ <li><a href="http://webassembly.org/">webassembly.org</a></li>
+ <li><a href="/en-US/docs/WebAssembly/Concepts">WebAssembly concepts</a></li>
+ <li><a href="https://research.mozilla.org/webassembly/">WebAssembly on Mozilla Research</a></li>
+</ul>
+
+<div id="gtx-trans" style="position: absolute; left: 118px; top: 1787px;">
+<div class="gtx-trans-icon"></div>
+</div>