// 场景1：普通指针 - 安全
var x int = 42
p := &x
// x 不会被回收，因为有指针 p 指向它

// 场景2：unsafe.Pointer - 安全
var x int = 42
up := unsafe.Pointer(&x)
// x 不会被回收，因为 unsafe.Pointer 是真正的指针

// 场景3：uintptr - 危险！
var x int = 42
addr := uintptr(unsafe.Pointer(&x))
// 此时 GC 认为 x 可能被回收，因为 addr 是整数，不是指针
// 后续如果通过 addr 访问内存，可能导致 use-after-free

// 安全：立即使用转换结果
ptr := (*TargetType)(unsafe.Pointer(&value))

// 危险：保存 uintptr
addr := uintptr(unsafe.Pointer(&value))
// ... 其他可能触发 GC 的代码 ...
ptr := unsafe.Pointer(addr)  // 可能已失效

var s string
fmt.Println(s == "")    // true
fmt.Println(s == nil)   // 编译错误：不能将 nil 用作 string 类型
fmt.Printf("%q\n", s)   // "" （显示为空字符串）
fmt.Printf("%v\n", s)   //  （空输出）
fmt.Printf("%#v\n", s)  // "" （Go 语法表示）

package main

import "fmt"

func main() {
    // 值类型 - 初始化为零值
    var s1 string        // ""
    var i1 int          // 0
    var b1 bool         // false
    
    // 引用类型 - 初始化为 nil
    var p1 *string      // nil
    var sl1 []string    // nil
    var m1 map[string]string  // nil
    
    fmt.Println("string 零值:", s1 == "")      // true
    fmt.Println("*string 零值:", p1 == nil)   // true
    fmt.Println("slice 零值:", sl1 == nil)    // true
    fmt.Println("map 零值:", m1 == nil)      // true
    
    // 错误示例
    // fmt.Println(s1 == nil)  // 编译错误
}

package main

import "fmt"

func processString(s string) {
    if s == "" {
        fmt.Println("收到空字符串")
    }
    // 不能检查 s == nil
}

func processStringPtr(s *string) {
    if s == nil {
        fmt.Println("指针为 nil")
    } else if *s == "" {
        fmt.Println("指针非 nil，但指向空字符串")
    }
}

func main() {
    // 情况1：值类型
    var s1 string
    processString(s1)  // 输出：收到空字符串
    
    // 情况2：指针类型
    var s2 *string
    processStringPtr(s2)  // 输出：指针为 nil
    
    s3 := ""
    processStringPtr(&s3)  // 输出：指针非 nil，但指向空字符串
}

// string 实际是 runtime 中的一个结构体
type stringStruct struct {
    str unsafe.Pointer
    len int
}

// 空字符串的表示
var s string
// 相当于：stringStruct{str: nil, len: 0}
// 但注意：这是运行时内部表示，对用户透明

func printLength(s string) {
    fmt.Println(len(s))
}

func main() {
    var s string
    printLength(s)  // 输出 0，不会 panic
    // 这没问题，空字符串长度是 0
}

func main() {
    var s string
    var i interface{} = s
    fmt.Println(i == nil)  // false！i 包含 (string, "")
    
    var i2 interface{}
    fmt.Println(i2 == nil)  // true
}

// 1. 检查字符串是否为空
func process(s string) {
    if s == "" {
        // 处理空字符串
    }
}

// 2. 使用指针时需要检查 nil
func processPtr(s *string) {
    if s == nil {
        // 处理 nil 指针
        return
    }
    if *s == "" {
        // 处理空字符串
    }
}

// 3. 在结构体中使用字符串
type User struct {
    Name   string  // 总是有效，零值是 ""
    Email  *string // 可能为 nil
}

// 4. 函数返回字符串
func getName() string {
    return ""  // 返回空字符串，不是 nil
}

func getNamePtr() *string {
    return nil  // 可以返回 nil
}

package main

import "fmt"

func main() {
    // 测试1
    var s1 string
    fmt.Printf("测试1: s1 = %q, len = %d\n", s1, len(s1))
    
    // 测试2
    s2 := ""
    fmt.Printf("测试2: s1 == s2? %v\n", s1 == s2)
    
    // 测试3
    var s3 *string
    if s3 == nil {
        fmt.Println("测试3: s3 是 nil")
    }
    
    // 测试4
    s4 := new(string)  // 分配内存，指向空字符串
    fmt.Printf("测试4: s4 = %v, *s4 = %q\n", s4, *s4)
    
    // 测试5 - JSON 反序列化
    // 在 JSON 中，空字符串和 null 是不同的
    // Go 的 json 包会将 JSON null 反序列化为指针的 nil
    // 但字符串字段会得到 ""
}

package main

import (
    "fmt"
    "time"
)

func main() {
    // 方法1：使用标准布局
    dateStr := "2023-12-25"
    
    // Go 的参考时间是：2006-01-02 15:04:05
    // 对应格式是：yyyy-mm-dd HH:MM:SS
    layout := "2006-01-02"
    
    t, err := time.Parse(layout, dateStr)
    if err != nil {
        fmt.Println("解析错误:", err)
        return
    }
    
    fmt.Printf("解析结果: %v\n", t)
    fmt.Printf("格式化输出: %s\n", t.Format("2006-01-02"))
    fmt.Printf("年: %d, 月: %d, 日: %d\n", 
        t.Year(), t.Month(), t.Day())
}

func main() {
    dateStr := "2023-12-25"
    
    // 方法2：使用预定义常量
    t1, err := time.Parse(time.DateOnly, dateStr)
    if err != nil {
        fmt.Println("解析错误:", err)
        return
    }
    
    fmt.Printf("使用 DateOnly: %v\n", t1)
    
    // 如果字符串包含时间部分
    datetimeStr := "2023-12-25 14:30:00"
    t2, err := time.Parse(time.DateTime, datetimeStr)
    if err != nil {
        fmt.Println("解析错误:", err)
        return
    }
    
    fmt.Printf("使用 DateTime: %v\n", t2)
}

const (
    Layout      = "01/02 03:04:05PM '06 -0700" // 不常用
    ANSIC       = "Mon Jan _2 15:04:05 2006"
    UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
    RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
    RFC822      = "02 Jan 06 15:04 MST"
    RFC822Z     = "02 Jan 06 15:04 -0700"
    RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
    RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
    RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700"
    RFC3339     = "2006-01-02T15:04:05Z07:00"
    RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
    Kitchen     = "3:04PM"
    Stamp       = "Jan _2 15:04:05"
    StampMilli  = "Jan _2 15:04:05.000"
    StampMicro  = "Jan _2 15:04:05.000000"
    StampNano   = "Jan _2 15:04:05.000000000"
    
    // Go 1.20 新增的常用常量
    DateOnly   = "2006-01-02"      // 只包含日期
    TimeOnly   = "15:04:05"        // 只包含时间
    DateTime   = "2006-01-02 15:04:05"  // 日期和时间
)

func main() {
    dateStr := "2023-12-25"
    layout := "2006-01-02"
    
    t, err := time.Parse(layout, dateStr)
    if err != nil {
        panic(err)
    }
    
    fmt.Println("默认时区:", t.Location())  // UTC
    fmt.Println("UTC 时间:", t.UTC())
    fmt.Println("本地时间:", t.Local())
}

func main() {
    dateStr := "2023-12-25"
    
    // 方法1：使用 ParseInLocation
    layout := "2006-01-02"
    
    // 解析为本地时区
    t1, err := time.ParseInLocation(layout, dateStr, time.Local)
    if err != nil {
        panic(err)
    }
    
    // 解析为特定时区
    loc, _ := time.LoadLocation("America/New_York")
    t2, err := time.ParseInLocation(layout, dateStr, loc)
    if err != nil {
        panic(err)
    }
    
    // 解析为 UTC
    t3, err := time.ParseInLocation(layout, dateStr, time.UTC)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("本地时间: %v (时区: %v)\n", t1, t1.Location())
    fmt.Printf("纽约时间: %v (时区: %v)\n", t2, t2.Location())
    fmt.Printf("UTC 时间: %v (时区: %v)\n", t3, t3.Location())
}

func main() {
    // 多种日期格式示例
    dateFormats := []string{
        "2023-12-25",      // yyyy-mm-dd
        "2023/12/25",      // yyyy/mm/dd
        "12/25/2023",      // mm/dd/yyyy
        "25/12/2023",      // dd/mm/yyyy
        "2023-12-25 14:30", // 包含时间
        "2023年12月25日",   // 中文格式
    }
    
    layouts := []string{
        "2006-01-02",
        "2006/01/02",
        "01/02/2006",
        "02/01/2006",
        "2006-01-02 15:04",
        "2006年01月02日",
    }
    
    for i, dateStr := range dateFormats {
        t, err := time.Parse(layouts[i], dateStr)
        if err != nil {
            fmt.Printf("格式 %s 解析错误: %v\n", dateStr, err)
            continue
        }
        fmt.Printf("%s → %v\n", dateStr, t.Format("2006-01-02"))
    }
}

package main

import (
    "fmt"
    "time"
)

func parseDate(dateStr string) (time.Time, error) {
    // 尝试多种格式
    layouts := []string{
        "2006-01-02",      // yyyy-mm-dd
        "2006/01/02",      // yyyy/mm/dd
        "20060102",        // yyyymmdd
        "02-01-2006",      // dd-mm-yyyy
        "01/02/2006",      // mm/dd/yyyy
    }
    
    var lastErr error
    for _, layout := range layouts {
        t, err := time.Parse(layout, dateStr)
        if err == nil {
            return t, nil
        }
        lastErr = err
    }
    
    return time.Time{}, fmt.Errorf("无法解析日期: %s, 最后错误: %v", dateStr, lastErr)
}

func isValidDate(dateStr string) bool {
    _, err := time.Parse("2006-01-02", dateStr)
    return err == nil
}

func main() {
    // 测试用例
    testDates := []string{
        "2023-12-25",   // 有效
        "2023-13-25",   // 无效月份
        "2023-12-32",   // 无效日期
        "20231225",     // 紧凑格式
        "25-12-2023",  // 欧洲格式
    }
    
    for _, dateStr := range testDates {
        fmt.Printf("检查: %-15s ", dateStr)
        
        if !isValidDate(dateStr) {
            fmt.Print("(标准格式无效) ")
        }
        
        t, err := parseDate(dateStr)
        if err != nil {
            fmt.Printf("错误: %v\n", err)
        } else {
            fmt.Printf("成功: %s\n", t.Format("2006-01-02 (Monday)"))
        }
    }
}

// 使用 github.com/araddon/dateparse
/*
import (
    "fmt"
    "github.com/araddon/dateparse"
)

func main() {
    dateStr := "2023-12-25"
    t, err := dateparse.ParseAny(dateStr)
    if err != nil {
        panic(err)
    }
    fmt.Println(t)
}
*/

// 使用 github.com/rickb777/date
/*
import (
    "fmt"
    "github.com/rickb777/date"
)

func main() {
    d, err := date.Parse("2006-01-02", "2023-12-25")
    if err != nil {
        panic(err)
    }
    fmt.Println(d)
}
*/

func main() {
    // 处理两位数年
    dateStr := "23-12-25"  // yy-mm-dd
    
    // 方法1：添加前缀
    fullDateStr := "20" + dateStr
    t1, _ := time.Parse("2006-01-02", fullDateStr)
    
    // 方法2：自定义解析
    layout := "06-01-02"  // 06 表示两位数年份
    t2, _ := time.Parse(layout, dateStr)
    
    // 注意：06 表示 2006，会自动处理 00-68 为 2000-2068，69-99 为 1969-1999
    fmt.Printf("完整年份: %v\n", t1.Year())  // 2023
    fmt.Printf("两位数年份: %v\n", t2.Year())  // 2023
}

func main() {
    // 自动处理补零
    dateStr1 := "2023-1-5"   // 月份和日期没有补零
    dateStr2 := "2023-01-05" // 补零
    
    // 使用 _2 和 _1 处理不补零的情况
    layout1 := "2006-1-2"     // 允许单数字
    layout2 := "2006-01-02"   // 需要两位
    
    t1, err1 := time.Parse(layout1, dateStr1)
    t2, err2 := time.Parse(layout2, dateStr2)
    
    fmt.Printf("不补零: %v (错误: %v)\n", t1.Format("2006-01-02"), err1)
    fmt.Printf("补零: %v (错误: %v)\n", t2.Format("2006-01-02"), err2)
}

// 如果需要频繁解析相同格式，可以预编译布局
func main() {
    // 预编译布局（time.Parse 内部会编译，但可以复用）
    layout := "2006-01-02"
    
    // 批量解析
    dateStrings := []string{
        "2023-01-01",
        "2023-06-15",
        "2023-12-31",
    }
    
    for _, dateStr := range dateStrings {
        t, err := time.Parse(layout, dateStr)
        if err != nil {
            fmt.Printf("解析 %s 失败: %v\n", dateStr, err)
            continue
        }
        fmt.Printf("%s → %v\n", dateStr, t.Weekday())
    }
}

package main

import (
    "fmt"
    "time"
)

// ParseDate 安全解析日期，返回本地时区的时间
func ParseDate(dateStr string) (time.Time, error) {
    t, err := time.ParseInLocation("2006-01-02", dateStr, time.Local)
    if err != nil {
        return time.Time{}, fmt.Errorf("日期格式错误: %s (应为 yyyy-mm-dd)", dateStr)
    }
    return t, nil
}

// MustParseDate 解析日期，失败则 panic
func MustParseDate(dateStr string) time.Time {
    t, err := ParseDate(dateStr)
    if err != nil {
        panic(err)
    }
    return t
}

// IsValidDate 验证日期字符串
func IsValidDate(dateStr string) bool {
    _, err := ParseDate(dateStr)
    return err == nil
}

// DaysBetween 计算两个日期之间的天数
func DaysBetween(dateStr1, dateStr2 string) (int, error) {
    t1, err1 := ParseDate(dateStr1)
    t2, err2 := ParseDate(dateStr2)
    
    if err1 != nil || err2 != nil {
        return 0, fmt.Errorf("日期解析错误: %v, %v", err1, err2)
    }
    
    hours := t2.Sub(t1).Hours()
    days := int(hours / 24)
    
    if days < 0 {
        days = -days
    }
    
    return days, nil
}

func main() {
    // 使用工具函数
    date1 := "2023-12-25"
    date2 := "2023-12-31"
    
    t1 := MustParseDate(date1)
    fmt.Printf("圣诞节: %v (%s)\n", t1, t1.Weekday())
    
    days, _ := DaysBetween(date1, date2)
    fmt.Printf("从 %s 到 %s 有 %d 天\n", date1, date2, days)
    
    // 验证日期
    fmt.Printf("2023-13-45 是否有效: %v\n", IsValidDate("2023-13-45"))
}

t, err := time.Parse("2006-01-02", "2023-12-25")
// 或（Go 1.20+）
t, err := time.Parse(time.DateOnly, "2023-12-25")

//go:noinline
func ShortFunction() int {
    return 42
}

// 现在可以正常打桩
func TestShortFunction(t *testing.T) {
    patches := gomonkey.ApplyFunc(ShortFunction, func() int {
        return 100
    })
    defer patches.Reset()
    
    result := ShortFunction()
    fmt.Println(result) // 输出 100
}

## 禁用内联优化
go test -gcflags="-N -l" ./...

## 或禁用所有优化
go test -gcflags="all=-l" ./...

## 结合覆盖率测试
go test -gcflags="all=-l" -coverprofile=coverage.out ./...

// 原函数
func GetConfig() string {
    return "default"
}

// 修改后
func GetConfig() string {
    // 添加无副作用的占位代码
    if false {
        // 这些代码永远不会执行，但能防止内联
        fmt.Println("dummy")
        panic("never reached")
    }
    return "default"
}

// 或使用更优雅的方式
var _ = func() struct{} {
    // 编译时计算，运行时无开销
    return struct{}{}
}()

func GetConfig() string {
    return "default"
}

// 定义接口
type ConfigGetter interface {
    Get() string
}

// 实现
type DefaultConfig struct{}

func (d *DefaultConfig) Get() string {
    return "default"
}

// 生产代码使用接口
func ProcessConfig(getter ConfigGetter) {
    config := getter.Get()
    // 使用 config
}

// 测试代码
func TestProcessConfig(t *testing.T) {
    mockGetter := &MockConfigGetter{}
    mockGetter.On("Get").Return("mocked")
    
    ProcessConfig(mockGetter)
    // 验证
}

// 避免直接打桩极短函数，改为打桩调用它的函数
func BusinessLogic() string {
    return GetConfig() + "_processed"
}

// 测试 BusinessLogic 而不是 GetConfig
func TestBusinessLogic(t *testing.T) {
    patches := gomonkey.ApplyFunc(GetConfig, func() string {
        return "mocked"
    })
    defer patches.Reset()
    
    result := BusinessLogic()
    // 断言 result 应为 "mocked_processed"
}

// 标准库的 time.Now() 很短，可能无法直接打桩
func TestTimeSensitive(t *testing.T) {
    // 方案：打桩调用 time.Now() 的包装函数
    fixedTime := time.Date(2023, 12, 25, 0, 0, 0, 0, time.UTC)
    patches := gomonkey.ApplyFunc(time.Now, func() time.Time {
        return fixedTime
    })
    defer patches.Reset()
    
    // 如果报错，改用方案4的接口方式
}

type Service struct{}

//go:noinline
func (s *Service) privateMethod() int {
    return 1
}

func TestPrivateMethod(t *testing.T) {
    s := &Service{}
    
    // 使用反射或 gomonkey 的 ApplyMethod
    patches := gomonkey.ApplyMethod(
        reflect.TypeOf(s),
        "privateMethod",
        func(_ *Service) int {
            return 2
        },
    )
    defer patches.Reset()
}

var GlobalFunc = func() int {
    return 1
}

func TestGlobalFunc(t *testing.T) {
    // 全局变量可以直接替换
    oldFunc := GlobalFunc
    GlobalFunc = func() int {
        return 2
    }
    defer func() { GlobalFunc = oldFunc }()
    
    // 或者使用 gomonkey
    patches := gomonkey.ApplyFuncVar(&GlobalFunc, func() int {
        return 3
    })
    defer patches.Reset()
}

package main

import (
    "fmt"
    "testing"
    "github.com/agiledragon/gomonkey/v2"
)

// 原始短函数 - 会报错
// func GetAnswer() int {
//     return 42
// }

// 解决方案1：添加 noinline 注释
//go:noinline
func GetAnswer() int {
    return 42
}

// 解决方案2：延长函数体
func GetAnswer2() int {
    // 防止内联的占位代码
    if false {
        fmt.Println("This never executes")
    }
    return 42
}

// 解决方案3：使用接口
type AnswerGetter interface {
    Get() int
}

type DefaultAnswer struct{}

func (d *DefaultAnswer) Get() int {
    return 42
}

func TestWithInterface(answerGetter AnswerGetter) int {
    return answerGetter.Get() * 2
}

func TestGomonkeyPatch(t *testing.T) {
    // 测试方案1
    patches := gomonkey.ApplyFunc(GetAnswer, func() int {
        return 100
    })
    defer patches.Reset()
    
    if GetAnswer() != 100 {
        t.Error("Patch failed")
    }
    
    // 测试方案3
    mockGetter := &struct {
        AnswerGetter
    }{}
    patches2 := gomonkey.ApplyMethod(
        reflect.TypeOf(mockGetter),
        "Get",
        func(_ AnswerGetter) int {
            return 200
        },
    )
    defer patches2.Reset()
}

func main() {
    // 编译测试
    fmt.Println("正常编译:", GetAnswer())
    
    // 运行测试
    // go test -v -gcflags="all=-l"
}

## 1. 常规测试（可能失败）
go test ./...

## 2. 禁用优化测试（推荐）
go test -gcflags="all=-l" ./...

## 3. 仅禁用内联
go test -gcflags="-l" ./...

## 4. 结合覆盖率
go test -gcflags="all=-l" -coverprofile=coverage.out ./...

## 5. 查看汇编代码，分析函数长度
go build -gcflags="-S" . 2>&1 | grep -A5 "GetAnswer"

// 1. 使用 testify/mock
import (
    "github.com/stretchr/testify/mock"
)

type MockService struct {
    mock.Mock
}

func (m *MockService) GetValue() int {
    args := m.Called()
    return args.Int(0)
}

// 2. 使用 sqlmock 等专用 mock 库
// 3. 使用 httptest 测试 HTTP 服务
// 4. 使用 go-sqlmock 测试数据库

package main

import "fmt"

// 定义函数类型
type MathFunc func(int, int) int

func main() {
    // 声明函数变量
    var add MathFunc
    
    // 为变量赋值
    add = func(a, b int) int {
        return a + b
    }
    
    result := add(3, 4)
    fmt.Println("3 + 4 =", result)  // 输出: 3 + 4 = 7
}

func main() {
    // 直接声明并赋值
    multiply := func(x, y int) int {
        return x * y
    }
    
    fmt.Println("5 * 6 =", multiply(5, 6))  // 输出: 5 * 6 = 30
}

func main() {
    // 使用 var 声明
    var divide func(float64, float64) float64
    
    divide = func(a, b float64) float64 {
        if b == 0 {
            return 0
        }
        return a / b
    }
    
    fmt.Println("10 / 2 =", divide(10, 2))  // 输出: 10 / 2 = 5
}

// 基本语法
type FuncType func(参数类型列表) 返回值类型列表

// 示例
type (
    // 无参数，无返回值
    SimpleFunc func()
    
    // 多个参数，单个返回值
    BinaryOp func(int, int) int
    
    // 变长参数
    VariadicFunc func(...int) int
    
    // 多个返回值
    MultiReturn func() (int, error)
    
    // 命名返回值
    NamedReturn func(a, b int) (sum, product int)
)

package main

import "fmt"

// 回调函数类型
type Callback func(string)

// 处理函数
func Process(name string, callback Callback) {
    fmt.Println("Processing:", name)
    callback("Hello, " + name)
}

func main() {
    // 定义回调函数
    myCallback := func(msg string) {
        fmt.Println("Callback received:", msg)
    }
    
    Process("Alice", myCallback)
    // 输出:
    // Processing: Alice
    // Callback received: Hello, Alice
}