2024 में वेब डेवलपमेंट के लिए 10 सर्वश्रेष्ठ Rust फ्रेमवर्क

Rust वेब डेवलपमेंट के लिए 10 सर्वश्रेष्ठ फ्रेमवर्क

Rust अपने प्रदर्शन, मेमोरी सुरक्षा और एसिंक्रोनस क्षमताओं के कारण वेब डेवलपमेंट में मजबूती से अपनी जगह बना रहा है। यदि आप Rust में वेब एप्लिकेशन बनाने के लिए एक विश्वसनीय फ्रेमवर्क की तलाश कर रहे हैं, तो यह समीक्षा आपको सही चुनाव करने में मदद करेगी। हम 10 सर्वश्रेष्ठ फ्रेमवर्क, उनकी विशेषताएं और कोड उदाहरण देखेंगे।

1. Actix-web — सबसे अधिक प्रदर्शनकारी

Actix-web Rust फ्रेमवर्क के बीच प्रदर्शन में अग्रणी है। यह Actor-मॉडल और Tokio पर आधारित है। उच्च-लोड API के लिए आदर्श है।

use actix_web::{get, web, App, HttpServer, Responder};

#[get("/hello/{name}")]async fn greet(name: web::Path<String>) -> impl Responder {    format!("Hello {}!", name)}

#[actix_web::main]async fn main() -> std::io::Result<()> {    HttpServer::new(|| {        App::new().service(greet)    })    .bind(("127.0.0.1", 8080))?    .run()    .await}

2. Axum — आधुनिक और पारिस्थितिकी-तंत्रीय

Tokio टीम द्वारा विकसित। यह tower-सर्विसेज और हाइपर का उपयोग करता है। sqlx, tower, serde के साथ उत्कृष्ट रूप से एकीकृत होता है।

use axum::{Router, routing::get, response::Json};use serde_json::{json, Value};

async fn root() -> Json<Value> {    Json(json!({"message": "Hello from Axum"}))}

#[tokio::main]async fn main() {    let app = Router::new().route("/", get(root));    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();    axum::serve(listener, app).await.unwrap();}

3. Rocket — सरलता और सुविधा

त्वरित शुरुआत पर केंद्रित। रूटिंग के लिए मैक्रोज़ का उपयोग करता है। प्रोटोटाइपिंग के लिए आदर्श है।

#[macro_use] extern crate rocket;

#[get("/<name>")]fn hello(name: &str) -> String {    format!("Hello, {}!", name)}

#[launch]fn rocket() -> _ {    rocket::build().mount("/", routes![hello])}

4. Warp — कार्यात्मक और लचीला

फिल्टर (Filters) पर आधारित। हैंडलर्स को श्रृंखला के रूप में जोड़ने की अनुमति देता है। API के लिए उत्कृष्ट विकल्प।

use warp::Filter;

#[tokio::main]async fn main() {    let hello = warp::path!("hello" / String)        .map(|name| format!("Hello, {}!", name));

    warp::serve(hello)        .run(([127, 0, 0, 1], 3030))        .await;}

5. Tide — न्यूनतम और एसिंक्रोनस

Rust async के निर्माताओं द्वारा हल्का फ्रेमवर्क। ट्रेट्स पर आधारित सरल API।

use tide::Request;

#[async_std::main]async fn main() -> tide::Result<()> {    let mut app = tide::new();    app.at("/").get(|_: Request<()>| async { Ok("Hello, Tide!") });    app.listen("127.0.0.1:8080").await?;    Ok(())}

6. Poem — OpenAPI के साथ पूर्ण स्टैक

OpenAPI-विशिष्टता के स्वचालित जनरेशन का समर्थन करता है। HTTP/2, WebSocket के साथ एकीकरण।

use poem::{get, handler, listener::TcpListener, Route, Server};

#[handler]fn hello() -> String {    "Hello, Poem!".to_string()}

#[tokio::main]async fn main() -> Result<(), std::io::Error> {    let app = Route::new().at("/", get(hello));    Server::new(TcpListener::bind("0.0.0.0:3000"))        .run(app)        .await}

7. Salvo — सरल और शक्तिशाली

मिडलवेयर, WebSocket, मल्टीपार्ट-फॉर्म का समर्थन करता है। इसमें OpenAPI के लिए अंतर्निहित समर्थन है।

use salvo::prelude::*;

#[handler]async fn hello(res: &mut Response) {    res.render(Text::Plain("Hello, Salvo!"));}

#[tokio::main]async fn main() {    let router = Router::new().get(hello);    Server::new(TcpListener::bind("0.0.0.0:5800"))        .serve(router)        .await;}

8. Gotham — एसिंक्रोनस और सुरक्षित

सख्त टाइपिंग और कंपाइलेशन स्तर पर सुरक्षा का उपयोग करता है। जटिल अनुप्रयोगों के लिए उपयुक्त है।

use gotham::state::State;use gotham::r
```