从前端转go的一些感悟对比(附详细代码)

package main

import "fmt"

func main() {
	// 1. 创建一个切片 (底层自动创建了一个数组)
	s1 := []int{10, 20, 30}
	fmt.Printf("s1: %v, len: %d, cap: %d\n", s1, len(s1), cap(s1)) // len=3, cap=3

	// 2. 追加元素，未超过容量
	s1 = append(s1, 40) // 超过容量！
	fmt.Printf("After append(40): %v, len: %d, cap: %d\n", s1, len(s1), cap(s1)) // len=4, cap=6 (Go通常会按2倍扩容)

	// 3. 切片是引用类型
	s2 := s1 // s2 和 s1 现在指向同一个底层数组
	s2[0] = 99
	fmt.Printf("s1[0] is now: %d\n", s1[0]) // s1[0] 也变成了 99！

	// 4. 从数组创建切片（“窗口”的体现）
	arr := [5]string{"A", "B", "C", "D", "E"}
	s3 := arr[1:4] // 创建一个从索引1到3的切片
	fmt.Printf("arr: %v\n", arr)
	fmt.Printf("s3: %v, len: %d, cap: %d\n", s3, len(s3), cap(s3)) // len=3, cap=4 (从1到数组末尾)

	// 修改切片，会影响原数组
	s3[0] = "X"
	fmt.Printf("After s3[0] = 'X':\n")
	fmt.Printf("arr: %v\n", arr) // arr[1] 变成了 "X"
}

async function fetchAllUsers() {
  const user1Promise = fetch('/user/1'); // 发起请求1，不等待
  const user2Promise = fetch('/user/2'); // 发起请求2，不等待
  const user3Promise = fetch('/user/3'); // 发起请求3，不等待
  // 现在三个网络请求都在“后台”飞着了，大厨（主线程）是空闲的
  const user1 = await user1Promise; // 等待请求1完成
  const user2 = await user2Promise; // 等待请求2完成
  const user3 = await user3Promise; // 等待请求3完成
  return [user1, user2, user3];
}

// Go (真并发)
fmt.Println("Start")
go func() { // 启动一个goroutine
    fmt.Println("Task 1")
}()
go func() { // 再启动一个goroutine
    fmt.Println("Task 2")
}()
fmt.Println("End")
time.Sleep(1 * time.Second) // 等待一下，让goroutines有时间执行
// 输出可能是: Start, End, Task 2, Task 1 (多核并行，顺序不保证)

// Express
const express = require('express');
const app = express();
app.get('/api/users/:id', (req, res) => {
  const id = req.params.id;
  res.json({ id: id, name: `User ${id}` });
});
app.listen(3000);

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}
func userHandler(w http.ResponseWriter, r *http.Request) {
    // 从URL路径获取参数
    idStr := r.URL.Path[len("/api/users/"):]
    id, err := strconv.Atoi(idStr)
    if err != nil {
        http.Error(w, "Invalid user ID", http.StatusBadRequest)
        return
    }
    user := User{ID: id, Name: fmt.Sprintf("User %d", id)}
    // 设置响应头并返回JSON
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}
func main() {
    http.HandleFunc("/api/users/", userHandler) // 注册路由
    log.Println("Server starting on port 8080...")
    log.Fatal(http.ListenAndServe(":8080", nil)) // 启动服务器
}

// 定义一个邮件发送器
type EmailSender struct{}
func (e *EmailSender) Send(message string) {
	fmt.Printf("通过邮件发送: %s\n", message)
}
// 我们的业务逻辑函数
func NotifyUser(sender *EmailSender, msg string) {
	sender.Send(msg)
}
func main() {
	emailSender := &EmailSender{}
	NotifyUser(emailSender, "欢迎注册！")
}

// 定义一个短信发送器
type SmsSender struct{}
func (s *SmsSender) Send(message string) {
	fmt.Printf("通过短信发送: %s\n", message)
}

import "reflect" // 需要用反射来判断类型，非常复杂且性能差
func NotifyUser(sender interface{}, msg string) {
    if _, ok := sender.(*EmailSender); ok {
        // ...
    } else if _, ok := sender.(*SmsSender); ok {
        // ...
    }
    // ... 无尽的 else if
}

// 定义一个“发送器”的能力证书
type Notifier interface {
	Send(message string)
}
// 它不再关心传进来的是EmailSender还是SmsSender
// 它只关心：你“能不能”Send
func NotifyUser(notifier Notifier, msg string) {
	notifier.Send(msg)
}
func main() {
    emailSender := &EmailSender{}
    smsSender := &SmsSender{}
    NotifyUser(emailSender, "欢迎注册！")    // ✅ 可以！
    NotifyUser(smsSender, "您的验证码是123") // ✅ 也可以！
    // 将来有了微信发送器
    // wechatSender := &WechatSender{}
    // NotifyUser(wechatSender, "您有新的订单") // ✅ 还是可以！
}

// JavaScript Class
class User {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  greet() {
    console.log(`Hello, I'm ${this.name}`);
  }
}
const u = new User("Bob", 40);
u.greet();

// Go struct and method
type User struct { // 定义数据结构
	Name string
	Age  int
}
// (u User) 是接收者，表示greet方法属于User类型
func (u User) Greet() {
	fmt.Printf("Hello, I'm %s\n", u.Name)
}
func main() {
	u := User{Name: "Bob", Age: 40} // 创建实例
	u.Greet() // 调用方法
}