将 JavaScript 字符串传递给编译为 WebAssembly 的 Rust 函数
Passing a JavaScript string to a Rust function compiled to WebAssembly
我有这个简单的 Rust 函数：
#[no_mangle]
pub fn compute(operator: &str, n1: i32, n2: i32) -> i32 {
match operator {
"SUM" => n1 + n2,
"DIFF" => n1 - n2,
"MULT" => n1 * n2,
"DIV" => n1 / n2,
_ => 0
}
}
我正在将其成功编译为 WebAssembly，但无法将 operator 参数从 JS 传递给 Rust。
调用 Rust 函数的 JS 行如下所示：
instance.exports.compute(operator, n1, n2);
operator是一个JS String和n1,n2是JS Numbers.
n1 和 n2 被正确传递并且可以在编译函数中读取所以我猜问题是我如何传递字符串。我想它是作为一个指针从 JS 传递到 WebAssembly 但找不到证据或 material 关于它是如何工作的。
我没有使用 Emscripten，并希望它保持独立（编译目标 wasm32-unknown-unknown），但我看到他们将编译后的函数包装在 Module.cwrap 中，也许这会有帮助？
正如 Shepmaster 所指出的，只能将数字传递给 WebAssembly，因此我们需要将字符串转换为 Uint16Array.
为此我们可以使用这个 str2ab 函数 found here:
function str2ab(str) {
var buf = new ArrayBuffer(str.length*2); // 2 bytes for each char
var bufView = new Uint16Array(buf);
for (var i=0, strLen=str.length; i < strLen; i++) {
bufView[i] = str.charCodeAt(i);
}
return buf;
}
这现在有效：
instance.exports.compute(
str2ab(operator),
n1, n2
);
因为我们正在传递对无符号整数数组的引用。
最简单、最惯用的解决方案
大多数人应该使用wasm-bindgen，这使得整个过程大大简单！
Low-level 手动实施
要在 JavaScript 和 Rust 之间传输字符串数据，您需要决定
- 文本编码：UTF-8（Rust原生）或UTF-16（JS原生）。
- 谁将拥有内存缓冲区：JS（调用者）或 Rust（被调用者）。
- 如何表示字符串数据和长度：NUL-terminated (C-style) or distinct length (Rust-style).
- 如果数据和长度是分开的，如何传递它们。
常用设置
为 WASM 构建 C dylib 以帮助它们更小是很重要的。
Cargo.toml
[package]
name = "quick-maths"
version = "0.1.0"
authors = ["An Devloper <an.devloper@example.com>"]
[lib]
crate-type = ["cdylib"]
.cargo/config
[target.wasm32-unknown-unknown]
rustflags = [
"-C", "link-args=--import-memory",
]
package.json
{
"name": "quick-maths",
"version": "0.1.0",
"main": "index.js",
"author": "An Devloper <an.devloper@example.com>",
"license": "MIT",
"scripts": {
"example": "node ./index.js"
},
"dependencies": {
"fs-extra": "^8.0.1",
"text-encoding": "^0.7.0"
}
}
我正在使用 NodeJS 12.1.0。
执行
$ rustup component add rust-std --target wasm32-unknown-unknown
$ cargo build --release --target wasm32-unknown-unknown
解决方案 1
我决定：
- 将JS字符串转为UTF-8，也就是说
TextEncoderJS API最合适
- 调用者应该拥有内存缓冲区。
- 让长度成为一个单独的值。
- 应该进行另一个结构和分配来保存指针和长度。
lib/src.rs
// A struct with a known memory layout that we can pass string information in
#[repr(C)]
pub struct JsInteropString {
data: *const u8,
len: usize,
}
// Our FFI shim function
#[no_mangle]
pub unsafe extern "C" fn compute(s: *const JsInteropString, n1: i32, n2: i32) -> i32 {
// Check for NULL (see corresponding comment in JS)
let s = match s.as_ref() {
Some(s) => s,
None => return -1,
};
// Convert the pointer and length to a `&[u8]`.
let data = std::slice::from_raw_parts(s.data, s.len);
// Convert the `&[u8]` to a `&str`
match std::str::from_utf8(data) {
Ok(s) => real_code::compute(s, n1, n2),
Err(_) => -2,
}
}
// I advocate that you keep your interesting code in a different
// crate for easy development and testing. Have a separate crate
// with the FFI shims.
mod real_code {
pub fn compute(operator: &str, n1: i32, n2: i32) -> i32 {
match operator {
"SUM" => n1 + n2,
"DIFF" => n1 - n2,
"MULT" => n1 * n2,
"DIV" => n1 / n2,
_ => 0,
}
}
}
index.js
const fs = require('fs-extra');
const { TextEncoder } = require('text-encoding');
// Allocate some memory.
const memory = new WebAssembly.Memory({ initial: 20, maximum: 100 });
// Connect these memory regions to the imported module
const importObject = {
env: { memory }
};
// Create an object that handles converting our strings for us
const memoryManager = (memory) => {
var base = 0;
// NULL is conventionally at address 0, so we "use up" the first 4
// bytes of address space to make our lives a bit simpler.
base += 4;
return {
encodeString: (jsString) => {
// Convert the JS String to UTF-8 data
const encoder = new TextEncoder();
const encodedString = encoder.encode(jsString);
// Organize memory with space for the JsInteropString at the
// beginning, followed by the UTF-8 string bytes.
const asU32 = new Uint32Array(memory.buffer, base, 2);
const asBytes = new Uint8Array(memory.buffer, asU32.byteOffset + asU32.byteLength, encodedString.length);
// Copy the UTF-8 into the WASM memory.
asBytes.set(encodedString);
// Assign the data pointer and length values.
asU32[0] = asBytes.byteOffset;
asU32[1] = asBytes.length;
// Update our memory allocator base address for the next call
const originalBase = base;
base += asBytes.byteOffset + asBytes.byteLength;
return originalBase;
}
};
};
const myMemory = memoryManager(memory);
fs.readFile('./target/wasm32-unknown-unknown/release/quick_maths.wasm')
.then(bytes => WebAssembly.instantiate(bytes, importObject))
.then(({ instance }) => {
const argString = "MULT";
const argN1 = 42;
const argN2 = 100;
const s = myMemory.encodeString(argString);
const result = instance.exports.compute(s, argN1, argN2);
console.log(result);
});
执行
$ yarn run example
4200
解决方案 2
我决定：
- 将JS字符串转为UTF-8，也就是说
TextEncoderJS API最合适
- 模块应该拥有内存缓冲区。
- 让长度成为一个单独的值。
- 使用
Box<String>作为底层数据结构。这允许 Rust 代码进一步使用分配。
src/lib.rs
// Very important to use `transparent` to prevent ABI issues
#[repr(transparent)]
pub struct JsInteropString(*mut String);
impl JsInteropString {
// Unsafe because we create a string and say it's full of valid
// UTF-8 data, but it isn't!
unsafe fn with_capacity(cap: usize) -> Self {
let mut d = Vec::with_capacity(cap);
d.set_len(cap);
let s = Box::new(String::from_utf8_unchecked(d));
JsInteropString(Box::into_raw(s))
}
unsafe fn as_string(&self) -> &String {
&*self.0
}
unsafe fn as_mut_string(&mut self) -> &mut String {
&mut *self.0
}
unsafe fn into_boxed_string(self) -> Box<String> {
Box::from_raw(self.0)
}
unsafe fn as_mut_ptr(&mut self) -> *mut u8 {
self.as_mut_string().as_mut_vec().as_mut_ptr()
}
}
#[no_mangle]
pub unsafe extern "C" fn stringPrepare(cap: usize) -> JsInteropString {
JsInteropString::with_capacity(cap)
}
#[no_mangle]
pub unsafe extern "C" fn stringData(mut s: JsInteropString) -> *mut u8 {
s.as_mut_ptr()
}
#[no_mangle]
pub unsafe extern "C" fn stringLen(s: JsInteropString) -> usize {
s.as_string().len()
}
#[no_mangle]
pub unsafe extern "C" fn compute(s: JsInteropString, n1: i32, n2: i32) -> i32 {
let s = s.into_boxed_string();
real_code::compute(&s, n1, n2)
}
mod real_code {
pub fn compute(operator: &str, n1: i32, n2: i32) -> i32 {
match operator {
"SUM" => n1 + n2,
"DIFF" => n1 - n2,
"MULT" => n1 * n2,
"DIV" => n1 / n2,
_ => 0,
}
}
}
index.js
const fs = require('fs-extra');
const { TextEncoder } = require('text-encoding');
class QuickMaths {
constructor(instance) {
this.instance = instance;
}
difference(n1, n2) {
const { compute } = this.instance.exports;
const op = this.copyJsStringToRust("DIFF");
return compute(op, n1, n2);
}
copyJsStringToRust(jsString) {
const { memory, stringPrepare, stringData, stringLen } = this.instance.exports;
const encoder = new TextEncoder();
const encodedString = encoder.encode(jsString);
// Ask Rust code to allocate a string inside of the module's memory
const rustString = stringPrepare(encodedString.length);
// Get a JS view of the string data
const rustStringData = stringData(rustString);
const asBytes = new Uint8Array(memory.buffer, rustStringData, encodedString.length);
// Copy the UTF-8 into the WASM memory.
asBytes.set(encodedString);
return rustString;
}
}
async function main() {
const bytes = await fs.readFile('./target/wasm32-unknown-unknown/release/quick_maths.wasm');
const { instance } = await WebAssembly.instantiate(bytes);
const maffs = new QuickMaths(instance);
console.log(maffs.difference(100, 201));
}
main();
执行
$ yarn run example
-101
请注意，此过程可用于其他类型。您 "just" 必须决定如何将数据表示为双方同意的一组字节，然后将其发送。
另请参阅：
WebAssembly 程序有自己的内存space。而这个 space 通常由 WebAssembly 程序本身管理，借助分配器库，例如 wee_alloc.
JavaScript 可以查看和修改内存 space，但它无法知道分配器库结构是如何组织的。因此，如果我们简单地从 JavaScript 写入 WASM 内存，那么我们很可能会覆盖一些重要的东西并将事情搞砸。因此 WebAssembly 程序本身必须首先分配内存区域，将其传递给 JavaScript，然后 JavaScript 可以用数据填充该区域。
在下面的示例中，我们就是这样做的：在 WASM 内存中分配一个缓冲区 space，将 UTF-8 字节复制到那里，将缓冲区位置传递给 Rust 函数，然后释放缓冲区。
生锈：
#![feature(allocator_api)]
use std::heap::{Alloc, Heap, Layout};
#[no_mangle]
pub fn alloc(len: i32) -> *mut u8 {
let mut heap = Heap;
let layout = Layout::from_size_align(len as usize, 1).expect("!from_size_align");
unsafe { heap.alloc(layout).expect("!alloc") }
}
#[no_mangle]
pub fn dealloc(ptr: *mut u8, len: i32) {
let mut heap = Heap;
let layout = Layout::from_size_align(len as usize, 1).expect("!from_size_align");
unsafe { heap.dealloc(ptr, layout) }
}
#[no_mangle]
pub fn is_foobar(buf: *const u8, len: i32) -> i32 {
let js = unsafe { std::slice::from_raw_parts(buf, len as usize) };
let js = unsafe { std::str::from_utf8_unchecked(js) };
if js == "foobar" {
1
} else {
0
}
}
打字稿：
// cf. https://github.com/Microsoft/TypeScript/issues/18099
declare class TextEncoder {constructor (label?: string); encode (input?: string): Uint8Array}
declare class TextDecoder {constructor (utfLabel?: string); decode (input?: ArrayBufferView): string}
// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/webassembly-js-api/index.d.ts
declare namespace WebAssembly {
class Instance {readonly exports: any}
interface ResultObject {instance: Instance}
function instantiateStreaming (file: Promise<Response>, options?: any): Promise<ResultObject>}
var main: {
memory: {readonly buffer: ArrayBuffer}
alloc (size: number): number
dealloc (ptr: number, len: number): void
is_foobar (buf: number, len: number): number}
function withRustString (str: string, cb: (ptr: number, len: number) => any): any {
// Convert the JavaScript string to an array of UTF-8 bytes.
const utf8 = (new TextEncoder()).encode (str)
// Reserve a WASM memory buffer for the UTF-8 array.
const rsBuf = main.alloc (utf8.length)
// Copy the UTF-8 array into the WASM memory.
new Uint8Array (main.memory.buffer, rsBuf, utf8.length) .set (utf8)
// Pass the WASM memory location and size into the callback.
const ret = cb (rsBuf, utf8.length)
// Free the WASM memory buffer.
main.dealloc (rsBuf, utf8.length)
return ret}
WebAssembly.instantiateStreaming (fetch ('main.wasm')) .then (results => {
main = results.instance.exports
// Prints "foobar is_foobar? 1".
console.log ('foobar is_foobar? ' +
withRustString ("foobar", function (buf, len) {return main.is_foobar (buf, len)}))
// Prints "woot is_foobar? 0".
console.log ('woot is_foobar? ' +
withRustString ("woot", function (buf, len) {return main.is_foobar (buf, len)}))})
P.S。 The Module._malloc in Emscripten might be semantically equivalent to the alloc function we implemented above. Under the "wasm32-unknown-emscripten" target you can use the Module._malloc with Rust.
我有这个简单的 Rust 函数：
#[no_mangle]
pub fn compute(operator: &str, n1: i32, n2: i32) -> i32 {
match operator {
"SUM" => n1 + n2,
"DIFF" => n1 - n2,
"MULT" => n1 * n2,
"DIV" => n1 / n2,
_ => 0
}
}
我正在将其成功编译为 WebAssembly，但无法将 operator 参数从 JS 传递给 Rust。
调用 Rust 函数的 JS 行如下所示：
instance.exports.compute(operator, n1, n2);
operator是一个JS String和n1,n2是JS Numbers.
n1 和 n2 被正确传递并且可以在编译函数中读取所以我猜问题是我如何传递字符串。我想它是作为一个指针从 JS 传递到 WebAssembly 但找不到证据或 material 关于它是如何工作的。
我没有使用 Emscripten，并希望它保持独立（编译目标 wasm32-unknown-unknown），但我看到他们将编译后的函数包装在 Module.cwrap 中，也许这会有帮助？
正如 Shepmaster 所指出的，只能将数字传递给 WebAssembly，因此我们需要将字符串转换为 Uint16Array.
为此我们可以使用这个 str2ab 函数 found here:
function str2ab(str) {
var buf = new ArrayBuffer(str.length*2); // 2 bytes for each char
var bufView = new Uint16Array(buf);
for (var i=0, strLen=str.length; i < strLen; i++) {
bufView[i] = str.charCodeAt(i);
}
return buf;
}
这现在有效：
instance.exports.compute(
str2ab(operator),
n1, n2
);
因为我们正在传递对无符号整数数组的引用。
最简单、最惯用的解决方案
大多数人应该使用wasm-bindgen，这使得整个过程大大简单！
Low-level 手动实施
要在 JavaScript 和 Rust 之间传输字符串数据，您需要决定
- 文本编码：UTF-8（Rust原生）或UTF-16（JS原生）。
- 谁将拥有内存缓冲区：JS（调用者）或 Rust（被调用者）。
- 如何表示字符串数据和长度：NUL-terminated (C-style) or distinct length (Rust-style).
- 如果数据和长度是分开的，如何传递它们。
常用设置
为 WASM 构建 C dylib 以帮助它们更小是很重要的。
Cargo.toml
[package]
name = "quick-maths"
version = "0.1.0"
authors = ["An Devloper <an.devloper@example.com>"]
[lib]
crate-type = ["cdylib"]
.cargo/config
[target.wasm32-unknown-unknown]
rustflags = [
"-C", "link-args=--import-memory",
]
package.json
{
"name": "quick-maths",
"version": "0.1.0",
"main": "index.js",
"author": "An Devloper <an.devloper@example.com>",
"license": "MIT",
"scripts": {
"example": "node ./index.js"
},
"dependencies": {
"fs-extra": "^8.0.1",
"text-encoding": "^0.7.0"
}
}
我正在使用 NodeJS 12.1.0。
执行
$ rustup component add rust-std --target wasm32-unknown-unknown
$ cargo build --release --target wasm32-unknown-unknown
解决方案 1
我决定：
- 将JS字符串转为UTF-8，也就是说
TextEncoderJS API最合适 - 调用者应该拥有内存缓冲区。
- 让长度成为一个单独的值。
- 应该进行另一个结构和分配来保存指针和长度。
lib/src.rs
// A struct with a known memory layout that we can pass string information in
#[repr(C)]
pub struct JsInteropString {
data: *const u8,
len: usize,
}
// Our FFI shim function
#[no_mangle]
pub unsafe extern "C" fn compute(s: *const JsInteropString, n1: i32, n2: i32) -> i32 {
// Check for NULL (see corresponding comment in JS)
let s = match s.as_ref() {
Some(s) => s,
None => return -1,
};
// Convert the pointer and length to a `&[u8]`.
let data = std::slice::from_raw_parts(s.data, s.len);
// Convert the `&[u8]` to a `&str`
match std::str::from_utf8(data) {
Ok(s) => real_code::compute(s, n1, n2),
Err(_) => -2,
}
}
// I advocate that you keep your interesting code in a different
// crate for easy development and testing. Have a separate crate
// with the FFI shims.
mod real_code {
pub fn compute(operator: &str, n1: i32, n2: i32) -> i32 {
match operator {
"SUM" => n1 + n2,
"DIFF" => n1 - n2,
"MULT" => n1 * n2,
"DIV" => n1 / n2,
_ => 0,
}
}
}
index.js
const fs = require('fs-extra');
const { TextEncoder } = require('text-encoding');
// Allocate some memory.
const memory = new WebAssembly.Memory({ initial: 20, maximum: 100 });
// Connect these memory regions to the imported module
const importObject = {
env: { memory }
};
// Create an object that handles converting our strings for us
const memoryManager = (memory) => {
var base = 0;
// NULL is conventionally at address 0, so we "use up" the first 4
// bytes of address space to make our lives a bit simpler.
base += 4;
return {
encodeString: (jsString) => {
// Convert the JS String to UTF-8 data
const encoder = new TextEncoder();
const encodedString = encoder.encode(jsString);
// Organize memory with space for the JsInteropString at the
// beginning, followed by the UTF-8 string bytes.
const asU32 = new Uint32Array(memory.buffer, base, 2);
const asBytes = new Uint8Array(memory.buffer, asU32.byteOffset + asU32.byteLength, encodedString.length);
// Copy the UTF-8 into the WASM memory.
asBytes.set(encodedString);
// Assign the data pointer and length values.
asU32[0] = asBytes.byteOffset;
asU32[1] = asBytes.length;
// Update our memory allocator base address for the next call
const originalBase = base;
base += asBytes.byteOffset + asBytes.byteLength;
return originalBase;
}
};
};
const myMemory = memoryManager(memory);
fs.readFile('./target/wasm32-unknown-unknown/release/quick_maths.wasm')
.then(bytes => WebAssembly.instantiate(bytes, importObject))
.then(({ instance }) => {
const argString = "MULT";
const argN1 = 42;
const argN2 = 100;
const s = myMemory.encodeString(argString);
const result = instance.exports.compute(s, argN1, argN2);
console.log(result);
});
执行
$ yarn run example
4200
解决方案 2
我决定：
- 将JS字符串转为UTF-8，也就是说
TextEncoderJS API最合适 - 模块应该拥有内存缓冲区。
- 让长度成为一个单独的值。
- 使用
Box<String>作为底层数据结构。这允许 Rust 代码进一步使用分配。
src/lib.rs
// Very important to use `transparent` to prevent ABI issues
#[repr(transparent)]
pub struct JsInteropString(*mut String);
impl JsInteropString {
// Unsafe because we create a string and say it's full of valid
// UTF-8 data, but it isn't!
unsafe fn with_capacity(cap: usize) -> Self {
let mut d = Vec::with_capacity(cap);
d.set_len(cap);
let s = Box::new(String::from_utf8_unchecked(d));
JsInteropString(Box::into_raw(s))
}
unsafe fn as_string(&self) -> &String {
&*self.0
}
unsafe fn as_mut_string(&mut self) -> &mut String {
&mut *self.0
}
unsafe fn into_boxed_string(self) -> Box<String> {
Box::from_raw(self.0)
}
unsafe fn as_mut_ptr(&mut self) -> *mut u8 {
self.as_mut_string().as_mut_vec().as_mut_ptr()
}
}
#[no_mangle]
pub unsafe extern "C" fn stringPrepare(cap: usize) -> JsInteropString {
JsInteropString::with_capacity(cap)
}
#[no_mangle]
pub unsafe extern "C" fn stringData(mut s: JsInteropString) -> *mut u8 {
s.as_mut_ptr()
}
#[no_mangle]
pub unsafe extern "C" fn stringLen(s: JsInteropString) -> usize {
s.as_string().len()
}
#[no_mangle]
pub unsafe extern "C" fn compute(s: JsInteropString, n1: i32, n2: i32) -> i32 {
let s = s.into_boxed_string();
real_code::compute(&s, n1, n2)
}
mod real_code {
pub fn compute(operator: &str, n1: i32, n2: i32) -> i32 {
match operator {
"SUM" => n1 + n2,
"DIFF" => n1 - n2,
"MULT" => n1 * n2,
"DIV" => n1 / n2,
_ => 0,
}
}
}
index.js
const fs = require('fs-extra');
const { TextEncoder } = require('text-encoding');
class QuickMaths {
constructor(instance) {
this.instance = instance;
}
difference(n1, n2) {
const { compute } = this.instance.exports;
const op = this.copyJsStringToRust("DIFF");
return compute(op, n1, n2);
}
copyJsStringToRust(jsString) {
const { memory, stringPrepare, stringData, stringLen } = this.instance.exports;
const encoder = new TextEncoder();
const encodedString = encoder.encode(jsString);
// Ask Rust code to allocate a string inside of the module's memory
const rustString = stringPrepare(encodedString.length);
// Get a JS view of the string data
const rustStringData = stringData(rustString);
const asBytes = new Uint8Array(memory.buffer, rustStringData, encodedString.length);
// Copy the UTF-8 into the WASM memory.
asBytes.set(encodedString);
return rustString;
}
}
async function main() {
const bytes = await fs.readFile('./target/wasm32-unknown-unknown/release/quick_maths.wasm');
const { instance } = await WebAssembly.instantiate(bytes);
const maffs = new QuickMaths(instance);
console.log(maffs.difference(100, 201));
}
main();
执行
$ yarn run example
-101
请注意，此过程可用于其他类型。您 "just" 必须决定如何将数据表示为双方同意的一组字节，然后将其发送。
另请参阅：
WebAssembly 程序有自己的内存space。而这个 space 通常由 WebAssembly 程序本身管理，借助分配器库，例如 wee_alloc.
JavaScript 可以查看和修改内存 space，但它无法知道分配器库结构是如何组织的。因此，如果我们简单地从 JavaScript 写入 WASM 内存，那么我们很可能会覆盖一些重要的东西并将事情搞砸。因此 WebAssembly 程序本身必须首先分配内存区域，将其传递给 JavaScript，然后 JavaScript 可以用数据填充该区域。
在下面的示例中，我们就是这样做的：在 WASM 内存中分配一个缓冲区 space，将 UTF-8 字节复制到那里，将缓冲区位置传递给 Rust 函数，然后释放缓冲区。
生锈：
#![feature(allocator_api)]
use std::heap::{Alloc, Heap, Layout};
#[no_mangle]
pub fn alloc(len: i32) -> *mut u8 {
let mut heap = Heap;
let layout = Layout::from_size_align(len as usize, 1).expect("!from_size_align");
unsafe { heap.alloc(layout).expect("!alloc") }
}
#[no_mangle]
pub fn dealloc(ptr: *mut u8, len: i32) {
let mut heap = Heap;
let layout = Layout::from_size_align(len as usize, 1).expect("!from_size_align");
unsafe { heap.dealloc(ptr, layout) }
}
#[no_mangle]
pub fn is_foobar(buf: *const u8, len: i32) -> i32 {
let js = unsafe { std::slice::from_raw_parts(buf, len as usize) };
let js = unsafe { std::str::from_utf8_unchecked(js) };
if js == "foobar" {
1
} else {
0
}
}
打字稿：
// cf. https://github.com/Microsoft/TypeScript/issues/18099
declare class TextEncoder {constructor (label?: string); encode (input?: string): Uint8Array}
declare class TextDecoder {constructor (utfLabel?: string); decode (input?: ArrayBufferView): string}
// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/webassembly-js-api/index.d.ts
declare namespace WebAssembly {
class Instance {readonly exports: any}
interface ResultObject {instance: Instance}
function instantiateStreaming (file: Promise<Response>, options?: any): Promise<ResultObject>}
var main: {
memory: {readonly buffer: ArrayBuffer}
alloc (size: number): number
dealloc (ptr: number, len: number): void
is_foobar (buf: number, len: number): number}
function withRustString (str: string, cb: (ptr: number, len: number) => any): any {
// Convert the JavaScript string to an array of UTF-8 bytes.
const utf8 = (new TextEncoder()).encode (str)
// Reserve a WASM memory buffer for the UTF-8 array.
const rsBuf = main.alloc (utf8.length)
// Copy the UTF-8 array into the WASM memory.
new Uint8Array (main.memory.buffer, rsBuf, utf8.length) .set (utf8)
// Pass the WASM memory location and size into the callback.
const ret = cb (rsBuf, utf8.length)
// Free the WASM memory buffer.
main.dealloc (rsBuf, utf8.length)
return ret}
WebAssembly.instantiateStreaming (fetch ('main.wasm')) .then (results => {
main = results.instance.exports
// Prints "foobar is_foobar? 1".
console.log ('foobar is_foobar? ' +
withRustString ("foobar", function (buf, len) {return main.is_foobar (buf, len)}))
// Prints "woot is_foobar? 0".
console.log ('woot is_foobar? ' +
withRustString ("woot", function (buf, len) {return main.is_foobar (buf, len)}))})
P.S。 The Module._malloc in Emscripten might be semantically equivalent to the alloc function we implemented above. Under the "wasm32-unknown-emscripten" target you can use the Module._malloc with Rust.