WebAssembly (WASM) til applikationer med høj ydeevne · Lektion

Fejlhåndtering på tværs af WASM-grænsen

Håndtér Rust Results, Options og panics korrekt, når de krydser over i JavaScript ved hjælp af wasm-bindgen.

Lektion 4 af 413 trin

Fejlhåndtering på tværs af WASM-grænsen er en gratis WebAssembly (WASM) til applikationer med høj ydeevne-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i WebAssembly (WASM) til applikationer med høj ydeevne, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. WebAssembly (WASM) til applikationer med høj ydeevne-kurset indeholder 4 lektioner i alt.

Fejl kræver en bro

Rust bruger Result og Option til fejl, mens JavaScript bruger undtagelser og null/undefined.

wasm-bindgen bygger bro mellem disse to verdener, så fejl naturligt bliver synlige på begge sider.

Returnering af Result til JS

En Rust-funktion, der returnerer Result<T, JsValue>, bliver til en JS-funktion, der enten returnerer værdien eller udløser en undtagelse.

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn parse(input: &str) -> Result<i32, JsValue> {
    input.parse::<i32>()
        .map_err(|e| JsValue::from_str(&e.to_string()))
}

Opfangning i JavaScript

På JS-siden ankommer en Err som en udløst undtagelse, så pak kald ind i try/catch.

try {
  const n = parse('abc');
} catch (e) {
  console.error('Parse failed:', e);
}

Kortlægning af brugerdefinerede fejl

Konvertér dine egne fejltyper til en JsValue, så JS modtager en nyttig meddelelse. Operatoren ? sammen med map_err holder koden enkel.

#[wasm_bindgen]
pub fn divide(a: i32, b: i32) -> Result<i32, JsValue> {
    if b == 0 {
        return Err(JsValue::from_str('division by zero'));
    }
    Ok(a / b)
}

Returnering af Option

Rusts Option<T> knyttes til en værdi eller undefined i JS, hvilket er perfekt til resultater, der kan være tomme.

#[wasm_bindgen]
pub fn first_char(s: &str) -> Option<char> {
    s.chars().next()
}

Hvad sker der ved panik

En Rust-panik i WASM afbryder modulet og er svær at fejlfinde. Som standard får du en lidet hjælpsom fejl med teksten 'unreachable'.

Panikker bør være sjældne; foretræk Result ved forventelige fejl.

Bedre panikmeddelelser

Crate'et console_error_panic_hook videresender panikmeddelelser til browserens konsol, hvilket gør fejlfinding langt lettere.

#[wasm_bindgen(start)]
pub fn main() {
    console_error_panic_hook::set_once();
}

Result eller panik

Vælg bevidst:

Result, forventede fejl, der kan håndteres (ugyldigt input, ikke fundet)
Panic, programmeringsfejl og invariansbetingelser, der aldrig bør brydes

Brug aldrig panics til normal kontrolflow på tværs af grænsen.

Brug af en brugerdefineret fejltype

Hvis du har brug for mere detaljerede fejl, skal du definere en struct, der eksporteres til JS, så JS kan læse felterne i stedet for kun en streng.

#[wasm_bindgen]
pub struct AppError { pub code: i32 }

#[wasm_bindgen]
impl AppError {
    #[wasm_bindgen(getter)]
    pub fn code(&self) -> i32 { self.code }
}

Propagér med ?

Inde i en funktion, der returnerer Result<_, JsValue>, videresender operatoren ? fejl på en enkel måde, når typerne kan konverteres.

#[wasm_bindgen]
pub fn run(input: &str) -> Result<i32, JsValue> {
    let n: i32 = input.parse().map_err(|_| JsValue::from_str('bad'))?;
    Ok(n * 2)
}

Opsummering af bedste praksis

For robust fejlhåndtering:

Returnér Result<T, JsValue>, så fejl bliver til JS-undtagelser
Returnér Option for værdier, der kan være null
Installér console_error_panic_hook for panics, der er nemme at fejlfinde
Forbehold panics til reelle fejl, og brug Result til forventede fejl

Hurtigt tjek

Hvordan opfører en Rust-funktion, der returnerer Result<T, JsValue>, sig, når den returnerer Err og kaldes fra JavaScript?

Besvar den i den interaktive lektion

Opsamling

Du kan nu håndtere fejl på en enkel måde på tværs af grænsen:

Result bliver til et JS-throw; Option bliver til værdi-eller-undefined
Omdan brugerdefinerede fejl til JsValue
Brug console_error_panic_hook til at fejlfinde panics
Foretræk Result frem for panic ved forventede fejl

Tydelig fejlsemantik gør Rust+WASM-biblioteker behagelige og sikre at bruge fra JS.

Gratis at komme i gang

Lær WebAssembly (WASM) til applikationer med høj ydeevne med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Fejlhåndtering på tværs af WASM-grænsen” gratis?

Ja — hele teksten til “Fejlhåndtering på tværs af WASM-grænsen” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af WebAssembly (WASM) til applikationer med høj ydeevne-kurset, skal du opgradere til CoddyKit PRO. WebAssembly (WASM) til applikationer med høj ydeevne-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Fejlhåndtering på tværs af WASM-grænsen”?

Håndtér Rust Results, Options og panics korrekt, når de krydser over i JavaScript ved hjælp af wasm-bindgen. Du øver dig i WebAssembly (WASM) til applikationer med høj ydeevne med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på WebAssembly (WASM) til applikationer med høj ydeevne?

Der kræves ingen tidligere erfaring. WebAssembly (WASM) til applikationer med høj ydeevne på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Fejlhåndtering på tværs af WASM-grænsen”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne WebAssembly (WASM) til applikationer med høj ydeevne-lektion?

Ja. Alle WebAssembly (WASM) til applikationer med høj ydeevne-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Opsætning af Rust til WebAssembly
Skrivning af Rust-funktioner til WASM
Effektiv JS-interoperabilitet med `wasm-bindgen`
Fejlhåndtering på tværs af WASM-grænsen

← Tilbage til WebAssembly (WASM) til applikationer med høj ydeevne