变量和数据类型

package main

import "fmt"

func main() {
    // 声明一个 int 类型变量 a
    var a int
    a = 10
    fmt.Println("a =", a)

    // 声明并初始化
    var b int = 20
    fmt.Println("b =", b)

    // 多个变量声明
    var x, y string
    x = "hello"
    y = "world"
    fmt.Println(x, y)
}

var c = 30
var d = "go"
fmt.Printf("Type of c is %T\n", c)
fmt.Printf("Type of d is %T\n", d)
// Type of c is int
// Type of d is string

e := 42         // int
f := "Hello"    // string
g, h := true, 3.14 // bool, float64
fmt.Println(e, f, g, h)

package main

import "fmt"

func getValues() (int, int) {
    return 100, 200
}

func main() {
    _, b := getValues() // 忽略第一个返回值
    fmt.Println("b =", b)
}

nums := []int{1, 2, 3}
for _, num := range nums {
    fmt.Println(num)
}

func main() {
    if true {
        insideIf := "I'm inside if"
        fmt.Println(insideIf)
    }

    // 下面这行会报错：undefined: insideIf
    // fmt.Println(insideIf)
}

package main

import "fmt"

const UntypedPi = 3.1415926535 // 无类型浮点常量
const TypedPi float64 = 3.1415926535 // 有类型浮点常量

const (
    Big = 1 << 100 // 无类型整数常量，非常大
    Small = Big >> 99 // 1 << 1 = 2
)

const (
    C0 = iota // 0
    C1 = iota // 1
    C2 = iota // 2
)

const (
    Red = iota // 0
    Green      // 1 (隐式使用 iota)
    Blue       // 2 (隐式使用 iota)
)

func needInt(x int) int { return x * 10 }
func needFloat64(x float64) float64 { return x * 0.1 }

func main() {
    var f32 float32 = UntypedPi // 无类型常量可以赋给 float32 (如果值在范围内)
    // var f32_2 float32 = TypedPi // 编译错误: cannot use TypedPi (type float64) as type float32 in assignment

    fmt.Println(f32)
    fmt.Println(TypedPi)

    fmt.Println(needInt(Small)) // Untyped Small (2) 隐式转换为 int
    fmt.Println(needFloat64(Small)) // Untyped Small (2) 隐式转换为 float64
    // fmt.Println(needInt(Big)) // 编译错误: constant 126765... overflows int

    const Greeting = "Hello" // 无类型字符串常量
    var s string = Greeting  // 可以赋值给 string
    fmt.Println(s)

    fmt.Printf("C0: %d, C1: %d, C2: %d\n", C0, C1, C2)
    fmt.Printf("Red: %d, Green: %d, Blue: %d\n", Red, Green, Blue)
}

// 输出:
// 3.1415927
// 3.1415926535
// 20
// 0.2
// Hello
// C0: 0, C1: 1, C2: 2
// Red: 0, Green: 1, Blue: 2

package main

import "fmt"

func main() {
	var i int
	var f float64
	var b bool
	var s string
	var p *int
    var sl []int
    var m map[string]int
    var arr [3]int
    type Person struct{ Name string; Age int }
    var person Person

	fmt.Printf("int: %d\n", i)
	fmt.Printf("float64: %f\n", f)
	fmt.Printf("bool: %t\n", b)
	fmt.Printf("string: '%s'\n", s)
	fmt.Printf("pointer: %v\n", p)
    fmt.Printf("slice: %v, is nil? %t\n", sl, sl == nil)
    fmt.Printf("map: %v, is nil? %t\n", m, m == nil)
    fmt.Printf("array: %v\n", arr)
    fmt.Printf("struct: %+v\n", person)
}

// 输出:
// int: 0
// float64: 0.000000
// bool: false
// string: ''
// pointer: <nil>
// slice: [], is nil? true
// map: map[], is nil? true
// array: [0 0 0]
// struct: {Name: Age:0}

package main

import "fmt"

func main() {
    var isEnabled bool = true
    var isUserAdmin bool // 默认值为 false

    fmt.Printf("isEnabled: %t\n", isEnabled)
    fmt.Printf("isUserAdmin: %t\n", isUserAdmin)

    canProceed := isEnabled && !isUserAdmin
    fmt.Printf("Can proceed? %t\n", canProceed)
}

// 输出:
// isEnabled: true
// isUserAdmin: false
// Can proceed? true

package main

import "fmt"

func main() {
    var a int8 = -10
    var b uint16 = 200

    // int 会根据你的系统架构决定大小
    var defaultInt int = 1234567890
    
    // byte 是 uint8 的别名
    var c byte = 'A' // 存储的是字符'A'的ASCII码

    // rune 是 int32 的别名
    var d rune = '你' // 存储的是'你'的Unicode码点

    fmt.Printf("a (int8): %d\n", a)
    fmt.Printf("b (uint16): %d\n", b)
    fmt.Printf("defaultInt (int): %d\n", defaultInt)
    fmt.Printf("c (byte): %d, 对应字符: %c\n", c, c)
    fmt.Printf("d (rune): %d, 对应字符: %c\n", d, d)
}

// 输出:
// a (int8): -10
// b (uint16): 200
// defaultInt (int): 1234567890
// c (byte): 65, 对应字符: A
// d (rune): 20320, 对应字符: 你

package main

import "fmt"

func main() {
    var pi32 float32 = 3.14159
    var pi64 float64 = 3.141592653589793

    // 如果不指定类型，默认推断为 float64
    pi := 3.14 

    fmt.Printf("pi32: %f\n", pi32)
    fmt.Printf("pi64: %.10f\n", pi64)
    fmt.Printf("pi (默认类型是 float64): %f\n", pi)
}

// 输出:
// pi32: 3.141590
// pi64: 3.1415926536
// pi (默认类型是 float64): 3.140000

package main

import "fmt"

func main() {
    var c1 complex64 = 5 + 10i
    c2 := complex(3, 4) // complex128

    fmt.Printf("c1 (complex64): %v\n", c1)
    fmt.Printf("c2 (complex128): %v\n", c2)
    fmt.Printf("Real part of c2: %f\n", real(c2))
    fmt.Printf("Imaginary part of c2: %f\n", imag(c2))
}
// 输出:
// c1 (complex64): (5+10i)
// c2 (complex128): (3+4i)
// Real part of c2: 3.000000
// Imaginary part of c2: 4.000000

package main

import "fmt"

func main() {
    s1 := "Hello, World!"
    s2 := "你好, 世界！"

    // 使用反引号创建多行字符串
    s3 := `这是
一个
多行字符串。`

    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)

    // 字符串是不可变的，下面这行代码会编译错误
    // s1[0] = 'h' 

    // 遍历字符串
    for i, r := range s2 { // r 是 rune 类型
        fmt.Printf("Index: %d, Rune: %c, Unicode: %U\n", i, r, r)
    }
}

// 输出:
// Hello, World!
// 你好, 世界！
// 这是
// 一个
// 多行字符串。
// Index: 0, Rune: 你, Unicode: U+4F60
// Index: 3, Rune: 好, Unicode: U+597D
// Index: 6, Rune: ,, Unicode: U+002C
// Index: 7, Rune:  , Unicode: U+0020
// Index: 8, Rune: 世, Unicode: U+4E16
// Index: 11, Rune: 界, Unicode: U+754C
// Index: 14, Rune: ！, Unicode: U+FF01

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "  Hello, Gopher! Gopher is great.  "
	fmt.Printf("Original: '%s'\n", s)

	fmt.Printf("Contains 'Gopher': %t\n", strings.Contains(s, "Gopher"))
	fmt.Printf("Count 'Gopher': %d\n", strings.Count(s, "Gopher"))
	fmt.Printf("HasPrefix '  Hello': %t\n", strings.HasPrefix(s, "  Hello"))
	fmt.Printf("Index of 'Gopher': %d\n", strings.Index(s, "Gopher"))

	words := []string{"Go", "is", "awesome"}
	fmt.Printf("Joined: '%s'\n", strings.Join(words, "-"))

	data := "apple,banana,orange"
	fruits := strings.Split(data, ",")
	fmt.Printf("Split: %v\n", fruits)

	fmt.Printf("ToLower: '%s'\n", strings.ToLower(s))
	fmt.Printf("TrimSpace: '%s'\n", strings.TrimSpace(s))
	fmt.Printf("ReplaceAll: '%s'\n", strings.ReplaceAll(s, "Gopher", "GoLang"))
}

// 输出:
// Original: '  Hello, Gopher! Gopher is great.  '
// Contains 'Gopher': true
// Count 'Gopher': 2
// HasPrefix '  Hello': true
// Index of 'Gopher': 9
// Joined: 'Go-is-awesome'
// Split: [apple banana orange]
// ToLower: '  hello, gopher! gopher is great.  '
// TrimSpace: 'Hello, Gopher! Gopher is great.'
// ReplaceAll: '  Hello, GoLang! GoLang is great.  '

package main

import (
	"bytes"
	"fmt"
)

func main() {
	var buf bytes.Buffer // 创建一个Buffer

	buf.WriteString("Hello, ")
	buf.WriteByte('W')
	buf.Write([]byte("orld!"))

	fmt.Println(buf.String()) // 输出: Hello, World!

	// 从 Buffer 读取
	data := make([]byte, 5)
	n, _ := buf.Read(data) // 读取前5个字节
	fmt.Printf("Read %d bytes: %s\n", n, data[:n]) // Read 5 bytes: Hello
	fmt.Printf("Remaining in buffer: %s\n", buf.String()) // Remaining in buffer: , World!
}
// 输出:
// Hello, World!
// Read 5 bytes: Hello
// Remaining in buffer: , World!

package main

import "fmt"

// 结构体
type Point struct {
    X, Y int
}

// 接口
type Shaper interface {
    Area() float64
}

func main() {
    // 数组
    var arr [3]int = [3]int{1, 2, 3}
    fmt.Println("Array:", arr)

    // 切片
    slice := []int{10, 20, 30, 40}
    fmt.Println("Slice:", slice)

    // Map
    m := make(map[string]int)
    m["one"] = 1
    m["two"] = 2
    fmt.Println("Map:", m)

    // 结构体实例
    pt := Point{X: 5, Y: 10}
    fmt.Printf("Point: %+v\n", pt)

    // 指针
    num := 42
    ptr := &num
    fmt.Printf("Pointer %p points to value %d\n", ptr, *ptr)

    // 通道 (更多在并发中使用)
    // ch := make(chan int)
}
// 输出:
// Array: [1 2 3]
// Slice: [10 20 30 40]
// Map: map[one:1 two:2]
// Point: {X:5 Y:10}
// Pointer 0xc000018030 points to value 42 (地址会变化)

package main

import "fmt"

func main() {
    var i int = 100
    var u uint = uint(i) // int 转换为 uint
    var f float64 = float64(i) // int 转换为 float64

    fmt.Printf("i (int): %d\n", i)
    fmt.Printf("u (uint): %d\n", u)
    fmt.Printf("f (float64): %.2f\n", f)

    var fValue float64 = 3.14
    // 将 float64 转换为 int 时，小数部分会被截断
    var iValue int = int(fValue) 

    fmt.Printf("fValue (float64): %.2f\n", fValue)
    fmt.Printf("iValue (int from float64): %d\n", iValue)
    
    // 不同类型不能直接运算，下面这行会编译错误
    // sum := i + fValue
    
    // 必须先转换
    sum := float64(i) + fValue
    fmt.Printf("Sum: %.2f\n", sum)
}

// 输出:
// i (int): 100
// u (uint): 100
// f (float64): 100.00
// fValue (float64): 3.14
// iValue (int from float64): 3
// Sum: 103.14

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// 1. int -> string
	num := 123
	strNum := strconv.Itoa(num)
	fmt.Printf("从 int 转换: 值='%s', 类型=%T\n", strNum, strNum)

	// 2. string -> int
	str := "456"
	numFromStr, err := strconv.Atoi(str)
	if err != nil {
		fmt.Println("Atoi 转换失败:", err)
	} else {
		fmt.Printf("从 string 转换: 值=%d, 类型=%T\n", numFromStr, numFromStr)
	}
    
    invalidStr := "hello"
    _, err = strconv.Atoi(invalidStr)
    if err != nil {
        fmt.Printf("'%s' 无法转换为 int: %v\n", invalidStr, err)
    }

	// 3. float64 -> string
	f := 3.14159
	// 'f' 表示格式，-1 表示尽可能精确（但通常指定小数位数），64 表示 float64
	strFloat := strconv.FormatFloat(f, 'f', 2, 64) // 保留2位小数
	fmt.Printf("从 float64 转换: 值='%s', 类型=%T\n", strFloat, strFloat)

	// 4. string -> float64
	strF := "2.718"
	floatFromStr, err := strconv.ParseFloat(strF, 64) // 64 表示目标是 float64
	if err != nil {
		fmt.Println("ParseFloat 转换失败:", err)
	} else {
		fmt.Printf("从 string 转换: 值=%f, 类型=%T\n", floatFromStr, floatFromStr)
	}

    // 5. bool -> string
    bStr := strconv.FormatBool(true)
    fmt.Printf("从 bool 转换: 值='%s', 类型=%T\n", bStr, bStr)

    // 6. string -> bool
    strB := "true"
    bFromStr, err := strconv.ParseBool(strB)
    if err != nil {
        fmt.Println("ParseBool 转换失败:", err)
    } else {
        fmt.Printf("从 string 转换: 值=%t, 类型=%T\n", bFromStr, bFromStr)
    }
}

// 输出:
// 从 int 转换: 值='123', 类型=string
// 从 string 转换: 值=456, 类型=int
// 'hello' 无法转换为 int: strconv.Atoi: parsing "hello": invalid syntax
// 从 float64 转换: 值='3.14', 类型=string
// 从 string 转换: 值=2.718000, 类型=float64
// 从 bool 转换: 值='true', 类型=string
// 从 string 转换: 值=true, 类型=bool

package main

import "fmt"

func main() {
	s := "Hello, Go!"

	// string -> []byte
	byteSlice := []byte(s)
	fmt.Printf("字符串 '%s' -> 字节切片: %v (ASCII: %d %d %d...)\n", s, byteSlice, byteSlice[0], byteSlice[1], byteSlice[2])

	// []byte -> string
	newString := string(byteSlice)
	fmt.Printf("字节切片 %v -> 字符串: '%s'\n", byteSlice, newString)
    
    // 修改字节切片不会影响原字符串（因为字符串是不可变的）
    // 但从字节切片创建新字符串后，新字符串与原字符串也无关
    byteSlice[0] = 'h' // 修改字节切片的内容
    fmt.Printf("修改后的字节切片: %v\n", byteSlice)
    fmt.Printf("原始字符串 s 仍然是: '%s'\n", s) // s 不变
    fmt.Printf("从修改后的字节切片生成的新字符串: '%s'\n", string(byteSlice)) // 新字符串反映了修改
}

// 输出:
// 字符串 'Hello, Go!' -> 字节切片: [72 101 108 108 111 44 32 71 111 33] (ASCII: 72 101 108...)
// 字节切片 [72 101 108 108 111 44 32 71 111 33] -> 字符串: 'Hello, Go!'
// 修改后的字节切片: [104 101 108 108 111 44 32 71 111 33]
// 原始字符串 s 仍然是: 'Hello, Go!'
// 从修改后的字节切片生成的新字符串: 'hello, Go!'

package main

import "fmt"

func main() {
    var i interface{} = "hello"

    // 安全的类型断言
    s, ok := i.(string)
    if ok {
        fmt.Printf("断言成功: s = '%s'\n", s)
    } else {
        fmt.Println("断言为 string 失败")
    }

    // 尝试断言为 int (会失败)
    n, ok := i.(int)
    if ok {
        fmt.Printf("断言成功: n = %d\n", n)
    } else {
        fmt.Printf("断言为 int 失败, n (int的零值) 为: %v, ok 的值为: %t\n", n, ok)
    }

    // 不安全的类型断言 (如果类型不匹配会 panic)
    // f := i.(float64) // 这行代码会引发 panic: interface conversion: interface {} is string, not float64
    // fmt.Println(f)

    var x interface{} = 10
    num := x.(int) // 安全，因为 x 的动态类型是 int
    fmt.Printf("x 断言为 int: %d\n", num)

    var y interface{} // y 是 nil 接口
    // z, ok := y.(int) // ok 会是 false, z 会是 0
    // fmt.Printf("nil interface断言: z=%v, ok=%t\n", z, ok)
    // y.(int) // 这行会 panic: interface conversion: interface {} is nil, not int
}

// 输出:
// 断言成功: s = 'hello'
// 断言为 int 失败, n (int的零值) 为: 0, ok 的值为: false
// x 断言为 int: 10

package main

import "fmt"

func checkType(i interface{}) {
    switch v := i.(type) { // v 在每个 case 块中是该 case 对应的类型
    case int:
        fmt.Printf("类型是 int, 值是 %d, v 的类型是 %T\n", v, v)
    case string:
        fmt.Printf("类型是 string, 值是 '%s', v 的类型是 %T\n", v, v)
    case bool:
        fmt.Printf("类型是 bool, 值是 %t, v 的类型是 %T\n", v, v)
    case nil:
        fmt.Printf("值是 nil\n")
    default: // 可选
        fmt.Printf("未知的类型: %T, 值为: %v\n", v, v)
    }
}

func main() {
    checkType(42)
    checkType("Go语言")
    checkType(true)
    checkType(3.14) // 会进入 default
    var x interface{}
    checkType(x) // x 是 nil 接口值
}

// 输出:
// 类型是 int, 值是 42, v 的类型是 int
// 类型是 string, 值是 'Go语言', v 的类型是 string
// 类型是 bool, 值是 true, v 的类型是 bool
// 未知的类型: float64, 值为: 3.14
// 值是 nil

package main

import "fmt"

// 类型别名
type MyString = string      // MyString 和 string 是同一类型
type UserID = int64       // UserID 和 int64 是同一类型

// 定义新类型
type Celsius float64    // Celsius 是一个新类型，底层是 float64
type Fahrenheit float64 // Fahrenheit 是一个新类型，底层是 float64

// 为新类型定义方法
func (c Celsius) ToFahrenheit() Fahrenheit {
    return Fahrenheit(c*9/5 + 32)
}

func (f Fahrenheit) ToCelsius() Celsius {
    return Celsius((f - 32) * 5 / 9)
}

func main() {
    // 类型别名
    var s1 string = "hello"
    var s2 MyString = s1 // 直接赋值，因为 MyString IS string
    fmt.Printf("s1 type: %T, s2 type: %T, s1 == s2: %t\n", s1, s2, s1 == s2)

    var id1 int64 = 101
    var id2 UserID = id1 // 直接赋值
    fmt.Printf("id1 type: %T, id2 type: %T, id1 == id2: %t\n", id1, id2, id1 == id2)

    // 定义新类型
    var tempC Celsius = 25.0
    var tempF Fahrenheit = 77.0

    // tempC = tempF // 编译错误: cannot use tempF (type Fahrenheit) as type Celsius in assignment
    // 需要显式转换
    convertedC := Celsius(tempF) // 只是转换底层类型，不调用 ToCelsius
    fmt.Printf("%.1f F is %.1f C (direct conversion)\n", tempF, convertedC) // 注意：这里只是底层类型转换，数值可能不是期望的温度转换

    // 使用方法进行有意义的转换
    fmt.Printf("%.1f C is %.1f F (using method)\n", tempC, tempC.ToFahrenheit())
    fmt.Printf("%.1f F is %.1f C (using method)\n", tempF, tempF.ToCelsius())
}

// 输出:
// s1 type: string, s2 type: string, s1 == s2: true
// id1 type: int64, id2 type: int64, id1 == id2: true
// 77.0 F is 77.0 C (direct conversion)
// 25.0 C is 77.0 F (using method)
// 77.0 F is 25.0 C (using method)

func main() {
    var a int = 20
    var b int = 10

    fmt.Println("a + b =", a + b)
    fmt.Println("a - b =", a - b)
    fmt.Println("a * b =", a * b)
    fmt.Println("a / b =", a / b)
    fmt.Println("a % b =", a % b)
}

package main

import "fmt"

func main() {
    var a int = 20
    var b int = 10

    // 关系运算符
    result = (a == b)
    fmt.Printf("a == b -> %t\n", result)

    result = (a > b)
    fmt.Printf("a > b -> %t\n", result)
}

package main

import "fmt"

func main() {
    // 逻辑运算符
    var x, y bool = true, false
    fmt.Printf("x && y -> %t\n", x && y)
    fmt.Printf("x || y -> %t\n", x || y)
    fmt.Printf("!x -> %t\n", !x)
}

package main

import "fmt"

func main() {
    var a int = 20
    var b int = 10

    // 位运算符
    fmt.Printf("a & b = %d\n", a & b)   // AND
    fmt.Printf("a | b = %d\n", a | b)   // OR
    fmt.Printf("a ^ b = %d\n", a ^ b)   // XOR
    fmt.Printf("a << 2 = %d\n", a << 2) // Left shift
    fmt.Printf("a >> 2 = %d\n", a >> 2) // Right shift
}

package main

import "fmt"

func main() {
    var a int = 20
    var b int = 10

    // 赋值运算符
    c = a
    fmt.Println("c = a -> c =", c)

    c += a
    fmt.Println("c += a -> c =", c)

    c <<= 2
    fmt.Println("c <<= 2 -> c =", c)
}