Integração eficiente entre JS e WASM com `wasm-bindgen`
Domine `wasm-bindgen` para trocar estruturas de dados complexas de forma transparente e integrar Rust WASM com JavaScript.
Integração eficiente entre JS e WASM com `wasm-bindgen` é uma aula grátis de WebAssembly (WASM) for High Performance Apps no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de WebAssembly (WASM) for High Performance Apps, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de WebAssembly (WASM) for High Performance Apps inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
Unlocking Complex Interop
Welcome to the final lesson on building high-performance WASM with Rust! So far, you've learned to set up Rust for WASM and write basic functions.
But what about exchanging complex data like strings, objects, or arrays? This is where wasm-bindgen comes in. It's a Rust tool that simplifies interaction between Rust and JavaScript.
What is `wasm-bindgen`?
wasm-bindgen is a utility that helps you create JavaScript bindings for Rust WebAssembly modules. It handles the low-level details of passing data types between the two languages.
- Automates FFI: It automatically generates JavaScript glue code and Rust FFI (Foreign Function Interface) declarations.
- Rich Type Support: It allows you to pass more complex types like
String, JavaScript objects, and even DOM elements directly. - Improved Developer Experience: It makes your Rust WASM modules feel more like native JavaScript modules.
Setting Up for `wasm-bindgen`
To use wasm-bindgen, you need to add it as a dependency in your Cargo.toml. You'll also use the wasm-pack tool, which leverages wasm-bindgen to build your WASM module.
Add this to your Cargo.toml:
[dependencies]
wasm-bindgen = "0.2"Then, mark your functions with #[wasm_bindgen].
Exporting Basic Functions
Let's start with a simple function. The #[wasm_bindgen] attribute makes a Rust function available to JavaScript.
Try running this example. The add_numbers function is exposed, and run_add_example demonstrates calling it.
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn add_numbers(a: u32, b: u32) -> u32 {
a + b
}
// This function serves as a runnable entry point for demonstration.
#[wasm_bindgen]
pub fn run_add_example() -> u32 {
add_numbers(10, 5)
}Passing Strings to Rust
One of wasm-bindgen's great features is how it handles strings. You can pass a JavaScript string directly to a Rust function expecting &str or String.
Here, the greet function takes a string argument from JavaScript.
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn greet(name: &str) -> String {
format!("Hello, {}!", name)
}
#[wasm_bindgen]
pub fn run_greet_example() -> String {
greet("CoddyKit User")
}Returning Strings from Rust
Similarly, Rust functions returning a String will automatically be converted into a JavaScript string. This makes working with text across the boundary very natural.
The get_message function returns a Rust String.
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn get_message() -> String {
String::from("This message came from Rust!")
}
#[wasm_bindgen]
pub fn run_get_message_example() -> String {
get_message()
}Exporting Structs as JS Classes
wasm-bindgen can also expose Rust structs as JavaScript classes. This allows you to create and manipulate Rust objects directly from JavaScript.
The User struct below becomes a class in JavaScript, complete with a constructor.
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub struct User {
name: String,
age: u8,
}
#[wasm_bindgen]
impl User {
#[wasm_bindgen(constructor)]
pub fn new(name: String, age: u8) -> User {
User { name, age }
}
}
#[wasm_bindgen]
pub fn create_user_example() -> User {
User::new("Alice".to_string(), 30)
}Adding Methods to JS Classes
Once a Rust struct is exposed as a JavaScript class, you can add methods to its impl block. These methods will be callable directly on the JavaScript object.
Let's add a greet method to our User struct.
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub struct User {
name: String,
age: u8,
}
#[wasm_bindgen]
impl User {
#[wasm_bindgen(constructor)]
pub fn new(name: String, age: u8) -> User {
User { name, age }
}
pub fn greet(&self) -> String {
format!("Hi, my name is {} and I'm {} years old.", self.name, self.age)
}
}
#[wasm_bindgen]
pub fn run_user_greet_example() -> String {
let user = User::new("Bob".to_string(), 25);
user.greet()
}Passing Rust Vectors to JS
wasm-bindgen can also handle basic collection types like Vec for primitive types. It will convert a Rust Vec into a JavaScript array.
This allows you to pass lists of numbers or strings easily.
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub fn process_numbers(numbers: Vec<u32>) -> Vec<u32> {
numbers.iter().map(|n| n * 2).collect()
}
#[wasm_bindgen]
pub fn run_process_numbers_example() -> Vec<u32> {
let input = vec![1, 2, 3];
process_numbers(input)
}`wasm-bindgen` Interop Check
Which of the following statements about wasm-bindgen are TRUE?
Recap: Mastering Interop
You've now mastered wasm-bindgen, a powerful tool for seamless interaction between Rust and JavaScript in your WebAssembly projects.
- It automates binding generation, making your Rust functions and types easily accessible from JS.
- It enables the exchange of complex data types like strings, structs (as JS classes), and vectors.
- This significantly improves developer experience, letting you write high-performance Rust logic that feels native in a JavaScript environment.
With wasm-bindgen, your Rust WASM modules can become integral, high-performance components of any web application!
Perguntas Frequentes
A aula “Integração eficiente entre JS e WASM com `wasm-bindgen`” é grátis?
Sim — o texto completo de “Integração eficiente entre JS e WASM com `wasm-bindgen`” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de WebAssembly (WASM) for High Performance Apps, atualize para CoddyKit PRO. O curso de WebAssembly (WASM) for High Performance Apps inclui 4 aulas no total.
O que vou aprender em “Integração eficiente entre JS e WASM com `wasm-bindgen`”?
Domine `wasm-bindgen` para trocar estruturas de dados complexas de forma transparente e integrar Rust WASM com JavaScript. Você pratica WebAssembly (WASM) for High Performance Apps com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar WebAssembly (WASM) for High Performance Apps?
Nenhuma experiência prévia é necessária. WebAssembly (WASM) for High Performance Apps no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Integração eficiente entre JS e WASM com `wasm-bindgen`”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de WebAssembly (WASM) for High Performance Apps?
Sim. Cada aula de WebAssembly (WASM) for High Performance Apps inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Configurando Rust para WebAssembly
- Escrevendo funções Rust para WASM
- Integração eficiente entre JS e WASM com `wasm-bindgen`
- Tratamento de erros além da fronteira do WASM