2023 年，Rust 能干掉 JavaScript 吗？

use leptos::*; #[component]pub fn SimpleCounter(cx: Scope, initial_value: i32) -> impl IntoView {    // create a reactive signal with the initial value    let (value, set_value) = create_signal(cx, initial_value);     // create event handlers for our buttons    // note that `value` and `set_value` are `Copy`, so it's super easy to move them into closures// (for reference: closures are like anonymous/arrow functions in Javascript)    let clear = move |_| set_value(0);    let decrement = move |_| set_value.update(|value| *value -= 1);    let increment = move |_| set_value.update(|value| *value += 1);     // create user interfaces with the declarative `view!` macro    view! {        cx,        <div>            <button on:click=clear>"Clear"</button>            <button on:click=decrement>"-1"</button>            <span>"Value: " {value} "!"</span>            <button on:click=increment>"+1"</button>        </div>    }} // Easy to use with Trunk (trunkrs.dev) or with a simple wasm-bindgen setuppub fn main() {    mount_to_body(|cx| view! { cx,  <SimpleCounter initial_value=3 /> })}

// An example of a navbarfn navbar(cx: Scope) -> Element {    cx.render(rsx! {        ul {            // NEW            Link { to: "/", "Home"}            br {}            Link { to: "/blog", "Blog"}        }    })} // An example of using URL parametersfn get_blog_post(id: &str) -> String {    match id {        "foo" => "Welcome to the foo blog post!".to_string(),        "bar" => "This is the bar blog post!".to_string(),        id => format!("Blog post '{id}' does not exist!")    }

// this is a unit structpub struct APICalls; // we can implement the unit struct to bundle functions under it// like so:Impl APICalls {         pub async fn get_dog_api_data() -> Json<Dog> {... some code here// this should probably return some json data}         pub async fn get_cat_api_data() -> Json<Cat> {... some code here// this should probably return some json data}} fn navbar (cx: Scope) -> Element {// now we can call the data like this, or something similar    let dogs = APICalls::get_dog_api_data().await;}

async fn foo() -> Result<String, String>{let bar = String::from("foobar!");// return is implicit, no need to write "return"match bar.trim() {    "foobar!" => Ok(bar),      _ => Err("Was not foobar!".to_string())             }   } #[tokio::main]fn main() -> Result<String, String> {let Ok(res) = foo().await else {   return Err("Was not foobar :(".to_string());} println!("The string was: {res}!");}

// main.rs#[shuttle_runtime::main]pub async fn axum (#[shuttle_shared_db::Postgres] postgres: PgPool,#[shuttle_secrets::Secrets] secrets: SecretStore,#[shuttle_static_folder] static: PathBuf) -> shuttle_axum::ShuttleAxum {// carry out database migrations (this assumes migrations are idempotent)    sqlx::migrate!().run(&postgres).await.expect("Migrations failed :(");     let hello_world = secrets.get("MY_VARIABLE")   .expect("Is MY_VARIABLE set in Secrets.toml?"); // Make a router serving API routes that require a DB connection    let api_router = create_api_router(postgres); // Add a compiled frontend (like e.g. from Next.js, React, Vue etc) to the router    let router = Router::new()        .nest("/api", api_router)        .nest_service("/", get_service(ServeDir::new(static)        .handle_error(handle_error)); // Rust returns implicitly so writing "return" is not requiredOk(router.into())}