گولنگ در مقابل Node.js - مقایسه Go و Node.js

// تعریف کلاس
class User {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }

    info() {
        return `${this.name} - ${this.age} سال`;
    }
}

// Async/Await
async function fetchUsers() {
    try {
        const response = await fetch('https://api.example.com/users');
        const users = await response.json();
        return users;
    } catch (error) {
        console.error('Error:', error);
    }
}

// Arrow functions
const greet = (name) => `سلام ${name}!`;

const user = new User('علی', 25);
console.log(user.info());

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

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 fetchUsers() ([]User, error) {
    resp, err := http.Get("https://api.example.com/users")
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var users []User
    if err := json.NewDecoder(resp.Body).Decode(&users); err != nil {
        return nil, err
    }
    return users, nil
}

func greet(name string) string {
    return fmt.Sprintf("سلام %s!", name)
}

func main() {
    user := User{Name: "علی", Age: 25}
    fmt.Println(user.Info())
}

const express = require('express');
const app = express();

// همه requestها در یک thread پردازش می‌شوند
app.get('/heavy', async (req, res) => {
    // این کد thread را block نمی‌کند
    const data = await fetchFromDB();
    res.json(data);
});

// مشکل: CPU-intensive کار
app.get('/compute', (req, res) => {
    // این thread اصلی را BLOCK می‌کند!
    const result = heavyComputation();
    res.json({ result });
});

app.listen(3000);

package main

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

func main() {
    http.HandleFunc("/heavy", func(w http.ResponseWriter, r *http.Request) {
        // هر request در goroutine جداگانه
        data := fetchFromDB()
        w.Write(data)
    })

    http.HandleFunc("/compute", func(w http.ResponseWriter, r *http.Request) {
        // CPU-intensive هم مشکلی ندارد!
        result := heavyComputation()
        fmt.Fprintf(w, "Result: %d", result)
    })

    // پردازش موازی
    http.HandleFunc("/parallel", func(w http.ResponseWriter, r *http.Request) {
        var wg sync.WaitGroup
        results := make([]int, 4)

        for i := 0; i < 4; i++ {
            wg.Add(1)
            go func(idx int) {
                defer wg.Done()
                results[idx] = compute(idx)
            }(i)
        }

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

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

// خطاها فقط در runtime مشخص می‌شوند
function processUser(user) {
    // user می‌تواند هر چیزی باشد!
    return user.name.toUpperCase();
}

processUser({ name: 'علی' });  // OK
processUser({ naam: 'علی' }); // Runtime Error!
processUser(null);            // Runtime Error!

// TypeScript کمک می‌کند ولی اختیاری است

type User struct {
    Name string
}

func processUser(user User) string {
    // user حتماً User است
    return strings.ToUpper(user.Name)
}

// کامپایل نمی‌شود!
// processUser(nil)
// processUser(map[string]string{})

async function fetchData() {
    try {
        const response = await fetch(url);
        if (!response.ok) {
            throw new Error(`HTTP ${response.status}`);
        }
        return await response.json();
    } catch (error) {
        console.error('Error:', error.message);
        throw error;
    }
}

// Promise chains
fetchData()
    .then(data => process(data))
    .catch(error => handleError(error));

// Callback hell (قدیمی)
fs.readFile('file.txt', (err, data) => {
    if (err) {
        // ...
    }
});

func fetchData(url string) ([]byte, error) {
    resp, err := http.Get(url)
    if err != nil {
        return nil, fmt.Errorf("fetch failed: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
    }

    data, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("read failed: %w", err)
    }

    return data, nil
}

// استفاده
data, err := fetchData("https://api.example.com")
if err != nil {
    log.Printf("Error: %v", err)
    return
}
// استفاده از data

# Dockerfile برای Node.js
FROM node:20-alpine

WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY . .

CMD ["node", "index.js"]

# Dockerfile برای Go (Multi-stage)
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 go build -o main .

FROM scratch
COPY --from=builder /app/main /main
CMD ["/main"]

const express = require('express');
const app = express();

app.use(express.json());

let users = [{ id: 1, name: 'علی', email: 'ali@example.com' }];

app.get('/users', (req, res) => {
    res.json(users);
});

app.get('/users/:id', (req, res) => {
    const user = users.find(u => u.id === parseInt(req.params.id));
    if (!user) return res.status(404).json({ error: 'Not found' });
    res.json(user);
});

app.post('/users', (req, res) => {
    const user = { id: users.length + 1, ...req.body };
    users.push(user);
    res.status(201).json(user);
});

app.listen(3000, () => console.log('Server running on :3000'));

package main

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

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"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, err := strconv.Atoi(c.Param("id"))
        if err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid ID"})
            return
        }
        for _, u := range users {
            if 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 = len(users) + 1
        users = append(users, user)
        c.JSON(http.StatusCreated, user)
    })

    r.Run(":8080")
}