'Hello World' à la manière HTTP

Énoncé du problème

Implémentez une application "Hello World" dans n'importe quel langage de programmation de votre choix.

L'application est une application CLI. Il lance d'abord un serveur HTTP sur « localhost:8000 ». Le serveur doit répondre avec une réponse textuelle (type de contenu "text/plain") et le code de réponse 200 sur n'importe quelle route. Lorsque le service HTTP est prêt, l'application envoie une requête GET à son serveur HTTP, lit la réponse ("Hello World") et imprime la réponse sur la sortie standard. Enfin, l'application arrête le serveur HTTP et existe.

L'application peut être testée par curl http://localhost:8000.

Implémentation en Go

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/", handler)
    go func() {
        err := http.ListenAndServe(":8000", nil)
        if err != nil {
            log.Fatalf("http.ListenAndServe failed: %v", err)
        }
    }()
    r, err := http.Get("http://localhost:8000/")
    if err != nil {
        log.Fatalf("http.Get failed: %v", err)
    }
    defer r.Body.Close()
    t, err := io.ReadAll(r.Body)
    if err != nil {
        log.Fatalf("io.ReadAll failed: %v", err)
    }
    fmt.Println(string(t))
}

Implémentation dans Go avec arrêt progressif du serveur HTTP

package main

import (
    "fmt"
    "io"
    "log/slog"
    "net/http"
    "os"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func configureLogging() {
    programLevel := new(slog.LevelVar)

    logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: programLevel}))
    slog.SetDefault(logger)

    if os.Getenv("DEBUG") != "" {
        programLevel.Set(slog.LevelDebug)
    }
}

func main() {
    configureLogging()

    http.HandleFunc("/", handler)

    addr := "localhost:8000"
    server := &http.Server{Addr: addr}

    done := make(chan struct{})
    go func(done chan<- struct{}) {
        slog.Debug("server.ListenAndServe", "addr", addr)
        err := server.ListenAndServe()
        if err != nil {
            slog.Debug("server.ListenAndServe", "error", err)
        }
        close(done)
    }(done)

    r, err := http.Get("http://" + addr)
    if err != nil {
        slog.Error("http.Get failed", "error", err)
        return
    }
    defer r.Body.Close()
    t, err := io.ReadAll(r.Body)
    if err != nil {
        slog.Error("io.ReadAll failed", "error", err)
        return
    }
    fmt.Println(string(t))
    err = server.Shutdown(nil)
    if err != nil {
        slog.Error("server.Shutdown failed", "error", err)
        return
    }
    <-done
}

Implémentation dans Typescript

Chignon

import process from "node:process";

Bun.serve({ fetch: () => new Response("Hello World!"), port: 8000 });

console.log(await (await fetch("http://localhost:8000/")).text());
process.exit();

Déno

Deno.serve(
  { port: 8000, onListen: () => {} }, 
  () => new Response("Hello World!")
);
console.log(await(await fetch("http://localhost:8000/")).text());
Deno.exit();

Le défi pour vous est de savoir comment mettre en œuvre cela.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!