گولنگ در مقابل PHP - مقایسه Go و PHP

<?php

class User {
    public function __construct(
        private string $name,
        private int $age
    ) {}

    public function info(): string {
        return "{$this->name} - {$this->age} سال";
    }
}

// Array operations
$numbers = [1, 2, 3, 4, 5];
$squares = array_map(fn($n) => $n ** 2, $numbers);

// Database with PDO
$pdo = new PDO('mysql:host=localhost;dbname=test', 'user', 'pass');
$users = $pdo->query('SELECT * FROM users')->fetchAll(PDO::FETCH_ASSOC);

// JSON response
header('Content-Type: application/json');
echo json_encode(['users' => $users]);

package main

import (
    "database/sql"
    "encoding/json"
    "fmt"
    "net/http"
    _ "github.com/go-sql-driver/mysql"
)

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func (u User) Info() string {
    return fmt.Sprintf("%s - %d سال", u.Name, u.Age)
}

func main() {
    // Database connection
    db, _ := sql.Open("mysql", "user:pass@/test")
    defer db.Close()

    http.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
        rows, _ := db.Query("SELECT name, age FROM users")
        defer rows.Close()

        var users []User
        for rows.Next() {
            var u User
            rows.Scan(&u.Name, &u.Age)
            users = append(users, u)
        }

        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(users)
    })

    http.ListenAndServe(":8080", nil)
}

<?php
// PHP-FPM: هر request یک process
// محدود به تعداد workers (مثلاً 50)

// برای async، نیاز به extension یا library:
// - Swoole
// - ReactPHP
// - Amp

// مثال با Swoole
$server = new Swoole\HTTP\Server("0.0.0.0", 9501);

$server->on("request", function ($request, $response) {
    // این async است!
    go(function () use ($response) {
        $result = Co\Http\get('https://api.example.com/data');
        $response->end($result->body);
    });
});

$server->start();

package main

import (
    "fmt"
    "net/http"
    "sync"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // هر request در goroutine جداگانه
        var wg sync.WaitGroup
        results := make([]string, 3)

        urls := []string{
            "https://api1.example.com",
            "https://api2.example.com",
            "https://api3.example.com",
        }

        // Fetch همه‌ی URL‌ها همزمان
        for i, url := range urls {
            wg.Add(1)
            go func(idx int, u string) {
                defer wg.Done()
                resp, _ := http.Get(u)
                defer resp.Body.Close()
                results[idx] = u
            }(i, url)
        }

        wg.Wait()
        fmt.Fprintf(w, "Done: %v", results)
    })

    http.ListenAndServe(":8080", nil)
}

# روش سنتی
# آپلود فایل‌ها به هر shared hosting

# روش مدرن (Docker)
FROM php:8.3-fpm
COPY . /var/www/html
RUN composer install --no-dev

# Build
go build -o app main.go

# اجرا - همین!
./app

# Docker
FROM scratch
COPY app /app
CMD ["/app"]

<?php
// routes/api.php
use App\Models\User;
use Illuminate\Http\Request;

Route::get('/users', function () {
    return User::all();
});

Route::get('/users/{id}', function ($id) {
    return User::findOrFail($id);
});

Route::post('/users', function (Request $request) {
    $validated = $request->validate([
        'name' => 'required|string',
        'email' => 'required|email|unique:users',
    ]);

    return User::create($validated);
});

package main

import (
    "fmt"
    "net/http"
    "github.com/gin-gonic/gin"
)

type User struct {
    ID    uint   `json:"id"`
    Name  string `json:"name" binding:"required"`
    Email string `json:"email" binding:"required,email"`
}

var users = []User{
    {ID: 1, Name: "علی", Email: "ali@example.com"},
}

func main() {
    r := gin.Default()

    r.GET("/users", func(c *gin.Context) {
        c.JSON(http.StatusOK, users)
    })

    r.GET("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        for _, u := range users {
            if fmt.Sprint(u.ID) == id {
                c.JSON(http.StatusOK, u)
                return
            }
        }
        c.JSON(http.StatusNotFound, gin.H{"error": "Not found"})
    })

    r.POST("/users", func(c *gin.Context) {
        var user User
        if err := c.ShouldBindJSON(&user); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        user.ID = uint(len(users) + 1)
        users = append(users, user)
        c.JSON(http.StatusCreated, user)
    })

    r.Run(":8080")
}