Golang

// 第一种：定义变量，然后赋值
var num1 int
num1 = 30
fmt.Printf("num1: %d\n", num1)

// 写在一行
var num2 int = 15
fmt.Printf("num2: %d\n", num2)

// 第二种：类型推断

var word = "hello"
fmt.Printf("类型是: %T, 数值是: %s\n", word, word)
// 类型是: string, 数值是: hello

// 第三种：简短定义
sum := 100
fmt.Println(sum)

var (
    name1 type1
    name2 type2
)

// 显式类型定义
const b string = "abc"

// 隐式类型定义
const b = "abc"

const(
    a = iota    // 0
    b = iota    // 1
    c = iota    // 2
)

fmt.Println(a)
fmt.Println(b)
fmt.Println(c)

// 打印
fmt.Print()

// 格式化打印
fmt.Printf()

// 打印之后换行
fmt.Println()

package main

import (
    "fmt"
)

func main() {
    var x int
    var y float64

    fmt.Println("请输入一个整数，一个浮点类型：")
    // 读取键盘的输入，通过操作地址，赋值给x和y阻塞式
    fmt.Scanln(&x, &y)
    fmt.Printf("x的数值：%d，y的数值：%f\n", x, y)

    fmt.Scanf("%d, %f", &x, &y)
    fmt.Printf("x:%d, y:%f\n", x, y)
}

package main

import (
    "fmt"
    "os"
    "bufio"
)

func main() {
    fmt.Println("请输入一个字符串：")
    reader := bufio.NewReader(os.Stdin)
    s1, err := reader.ReadString('\n')
    fmt.Println("读到的数据：", s1)
}

package main

import (
    "fmt"
    "os"
    "bufio"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    scanner.Scan()
    lines := scanner.Text()
    fmt.Println(lines)
}

package main

import (
    "fmt"
)

func main() {
    // 判断前先执行前面的语句，num赋值为10
    if num := 10; num % 2 == 0 {
        fmt.Println(num, "is even")
    } else {
        fmt.Println(num, "is odd")
    }
}

package main

import (
    "fmt"
)

func main() {
    n := 2
    switch n {
    case 1:
        fmt.Println("我是老大")
    case 2:
        fmt.Println("我是老二")
        fallthrough
    case 3:
        fmt.Println("我是老三")
    case 4:
        fmt.Println("我是老四")
    }
}

// 输出
我是老二
我是老三

package main

import "fmt"

func main() {
   var x interface{}
     
   switch i := x.(type) {
      case nil:	  
         fmt.Printf(" x 的类型 :%T",i)                
      case int:	  
         fmt.Printf("x 是 int 型")                       
      case float64:
         fmt.Printf("x 是 float64 型")           
      case func(int) float64:
         fmt.Printf("x 是 func(int) 型")                      
      case bool, string:
         fmt.Printf("x 是 bool 或 string 型" )       
      default:
         fmt.Printf("未知型")     
   }   
}

// 输出
x 的类型 :<nil>

package main

import (  
    "fmt"
)

func main() {  
    for i := 1; i <= 10; i++ {
        if i == 1 {
            fmt.Printf("%d",i)
        } else {
            fmt.Printf(" %d",i)
        }
    }
}

// 输出
1 2 3 4 5 6 7 8 9 10

var balance [10]float32
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}

f := [...] int{0: 1, 4: 1, 9: 1} // [1 0 0 0 1 0 0 0 0 1]
fmt.Println(f)

a = [3][4]int{  
    {0, 1, 2, 3} ,   /*  第一行索引为 0 */
    {4, 5, 6, 7} ,   /*  第二行索引为 1 */
    {8, 9, 10, 11}   /*  第三行索引为 2 */
}

package main

import "fmt"

func main() {  
    a := [...]float64{67.7, 89.8, 21, 78}
    sum := float64(0)
    for i, v := range a {
        // range returns both the index and value
        fmt.Printf("%d the element of a is %.2f\n", i, v)
        sum += v
    }
    fmt.Println("\nsum of all elements of a",sum)
}

// 输出
0 the element of a is 67.70
1 the element of a is 89.80
2 the element of a is 21.00
3 the element of a is 78.00

sum of all elements of a 256.5

package main

import "fmt"

func main() {  
    arr := []int{15, 23, 8, 10, 7}

    for i := 1; i < len(arr); i++ {
        for j := 0; j < len(arr) - i; j++ {
            if arr[j] > arr[j + 1] {
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
            }
        }
        fmt.Println(arr)
    }
}

// 输出
[15 8 10 7 23]
[8 10 7 15 23]
[8 7 10 15 23]
[7 8 10 15 23]

var identifier []type

var slice1 []type = make([]type, len)

// 也可以简写为
slice1 := make([]type, len)

package main

import "fmt"

func main() {  
    s := make([]int, 0, 5)
    fmt.Println(s)

    // 同时添加多个元素
    s = append(s, 1, 2)
    fmt.Println(s)
}

// 输出
[]
[1 2]

package main

import "fmt"

func main() {  
    // 数组：值类型
    a1 := [4]int{1, 2, 3, 4}
    a2 := a1
    a1[0] = 100
    fmt.Println(a1, a2)
    fmt.Println("---------------------")

    // 切片：引用类型
    s1 := []int{1, 2, 3, 4}
    s2 := s1
    fmt.Println(s1, s2)

    s1[0] = 100
    fmt.Println(s1, s2)
}

// 输出
[100 2 3 4] [1 2 3 4]
---------------------
[1 2 3 4] [1 2 3 4]
[100 2 3 4] [100 2 3 4]

package main

import "fmt"

func main() {  
    s1 := []int{1, 2, 3, 4}
    // len:0, cap:0
    s2 := make([]int, 0)

    for i := 0; i < len(s1); i++ {
        s2 = append(s2, s1[i])
    }
    fmt.Println(s1)
    fmt.Println(s2)

    s1[0] = 100
    fmt.Println(s1)
    fmt.Println(s2)
}

// 输出
[1 2 3 4]
[1 2 3 4]
[100 2 3 4]
[1 2 3 4]

// 创建map的三种方式
// 1. 声明变量，默认 map 是 nil
var map1 map[int]string // 没有初始化，是一个nil的map
// 2. 使用 make 函数
var map2 = make(map[int]string) // make创建

var map3 = map[string]int{"Go": 98, "Python": 89, "Java": 79}

fmt.Println(map1)
fmt.Println(map2)
fmt.Println(map3)

fmt.Println(map1 == nil)
fmt.Println(map2 == nil)
fmt.Println(map3 == nil)

// 输出
map[]
map[]
map[Go:98 Java:79 Python:89]
true
false
false

package main

import (
    "fmt"
)

func main() {
    m := make(map[string]int)

    m["a"] = 1
    x, ok := m["b"]
    fmt.Println(x, ok)

    x, ok = m["a"]
    fmt.Println(x, ok)
}

// 输出
0 false
1 true

package main

import (
    "fmt"
)

func main() {
    map1 := make(map[int]string)

    map1[1] = "烤肉"
    map1[2] = "炒菜"
    map1[3] = "汤"

    for k, v := range map1 {
        fmt.Println(k, v)
    }
}

// 输出
2 炒菜
3 汤
1 烤肉

package main

import (
    "fmt"
)

func main() {
    map1 := make(map[string]string)
    map1["name"] = "张三"
    map1["age"] = "20"
    map1["sex"] = "男性"
    fmt.Println(map1)

    map2 := map[string]string{"name":"李四", "age":"30", "sex":"女性"}
    fmt.Println(map2)

    // 创建切片
    s1 := make([]map[string]string, 0, 3)
    s1 = append(s1, map1)
    s1 = append(s1, map2)

    // 遍历切片
    for i, val := range s1 {
        fmt.Printf("第 %d 个人的信息是：\n", i+1)
        fmt.Printf("姓名：%s\n", val["name"])
        fmt.Printf("年龄：%s\n", val["age"])
        fmt.Printf("性别：%s\n", val["sex"])
    }
}

// 输出
map[age:20 name:张三 sex:男性]
map[age:30 name:李四 sex:女性]
第 1 个人的信息是：
姓名：张三
年龄：20
性别：男性
第 2 个人的信息是：
姓名：李四
年龄：30
性别：女性

func myfunc(arg ... int) {}

package main

import (
    "fmt"
)

func main() {
    func () {
        fmt.Println("我是匿名函数")
    }()
}

// 输出
我是匿名函数

package main

import (
    "fmt"
)

func main() {
    // 这里不要加括号，加括号就是调用，不加括号才是函数本身
    res1 := oper(10, 20, add)
    fmt.Println(res1)
}

func add(a, b int) int {
    return a + b
}

func oper(a, b int, fun func(int, int)int) int {
    fmt.Println(a, b, fun)
    // 这里才执行
    res := fun(a, b)
    return res
}

// 输出
10 20 0x499140
30

package main

import (
    "fmt"
)

func main() {
    res1 := increment()
    fmt.Println(res1)
    v1 := res1()
    fmt.Println(v1)

    fmt.Println(res1())
}

func increment() func()int {
    // 1. 定义局部变量
    i := 0
    // 2. 定义匿名函数，给变量自增并返回
    fun := func () int {
        i++
        return i
    }
    // 3. 返回该匿名函数
    return fun
}

// 输出
0x4992a0
1
2

// 指针，一个存储了5个浮点类型数据的数组的指针
*[5]float64

// 数组，存储了5个浮点类型数据的地址的数组
[5]*float64

// 指针，一个数组的指针，存储了5个浮点类型的数据的指针地址的数组的指针
*[5]*float64

// 指针。存储了4个字符串数据的数组的指针的指针
**[4]string

// 指针。存储了4个字符串的指针地址的数组，的指针的指针
**[4]*string

package main

import (
    "fmt"
)

func main() {
    // 1. 创建一个数组
    arr1 := [4]int{1, 2, 3, 4}

    // 2. 创建一个指针，存储该数组地址 -> 数组指针
    var p1 *[4]int
    p1 = &arr1

    // 3. 根据数组指针，操作数组
    (*p1)[0] = 100
    fmt.Println(arr1)

    // 简化写法
    p1[0] = 200
    fmt.Println(arr1)
}

// 输出
[100 2 3 4]
[200 2 3 4]

package main

import (
    "fmt"
)

func main() {
    // 1. 创建一个数组
    a := 1
    b := 2
    c := 3
    d := 4

    arr2 := [4]int{a, b, c, d}
    arr3 := [4]*int{&a, &b, &c, &d}

    arr2[0] = 100
    fmt.Println(arr2)   // [100 2 3 4]
    fmt.Println(a)  // 1

    *arr3[0] = 200
    fmt.Println(arr3)   // [0xc0000b6010 0xc0000b6018 0xc0000b6020 0xc0000b6028]
    fmt.Println(a)  // 200

    b = 1000
    fmt.Println(arr2)   // [100 2 3 4]

    for i := 0; i < len(arr3); i++ {
        fmt.Println(*arr3[i])
    }
}

// 输出
[100 2 3 4]
1
[0xc0000b6010 0xc0000b6018 0xc0000b6020 0xc0000b6028]
200
[100 2 3 4]
200
1000
3
4

package main

import (
    "fmt"
)

func main() {
    arr1 := fun1()
    fmt.Printf("arr1的类型是: %T, 地址是: %p, 数值是: %v\n", arr1, &arr1, arr1)

    arr2 := fun2()
    fmt.Printf("arr2的类型是: %T, 地址是: %p, 数值是: %v\n", arr2, &arr2, arr2)
}

// 指针函数
func fun2() *[4]int {
    arr := [4]int{5, 6, 7, 8}
    return &arr
}

// 普通函数
func fun1() [4]int {
    arr := [4]int{1, 2, 3, 4}
    return arr
}

// 输出
arr1的类型是: [4]int, 地址是: 0xc000014020, 数值是: [1 2 3 4]
arr2的类型是: *[4]int, 地址是: 0xc00000e030, 数值是: &[5 6 7 8]

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

// 1.按照顺序提供初始化值
P := person{"Tom", 25}
// 2.通过field:value的方式初始化，这样可以任意顺序
P := person{age:24, name:"Tom"}
// 3.new方式,未设置初始值的，会赋予类型的默认初始值
p := new(person)
p.age=24

s2 := struct{
    name string
    age int
}{
    name:"李四"
    age:19
}

type Book struct {
    bookName string
    price float64
}

// 定义结构体
type Student struct {
    name string
    age int
    book Book
}

// 定义结构体
type Student2 struct {
    name string
    age int
    book *Book
}

// 1. 模拟继承性：is - a
type A struct {
    field
}
type B struct {
    A   // 匿名字段
}

// 2. 模拟聚合关系：has - a
type C struct {
    field
}
type D struct {
    c C // 聚合关系
}

package main

import (  
    "fmt"
)

type Address struct {
    country, state string
}

type Person struct {
    name string
    age int
    address Address
}

func main() {

    var p Person
    p.name = "Juliet"
    p.age = 18
    p.address = Address{
        country: "Italy",
        state: "Veneto"
    }

    fmt.Println("Name:", p.name)
    fmt.Println("Age:", p.age)
    fmt.Println("Country:", p.address.country)
    fmt.Println("State:", p.address.state)
}

// result
Name: Juliet  
Age: 18  
Country: Italy  
State: Veneto

package main

import (  
    "fmt"
)

type Address struct {
    country, state string
}

type Person struct {
    name string
    age int
    Address // 匿名字段，默认Person包含了Address的所有字段
}

func main() {

    var p Person
    p.name = "Juliet"
    p.age = 18
    p.Address = Address{
        country: "Italy",
        state: "Veneto"
    }

    fmt.Println("Name:", p.name)
    fmt.Println("Age:", p.age)
    fmt.Println("Country:", p.country) //city is promoted field
    fmt.Println("State:", p.state) //state is promoted field
}

// result
Name: Juliet  
Age: 18  
Country: Italy  
State: Veneto

// 定义方法的语法
func (t Type) methodName(parameter list)(return list) {
  
}
func funcName(parameter list)(return list){
    
}

package main

import (
    "fmt"
)

func main() {
    w1 := Worker{name:"张三", age:24, sex:"男"}
    w1.work()

    w2 := &Worker{name:"李四", age:36, sex:"女"}
    fmt.Printf("%T\n", w2)
    w2.work()

    w2.rest()
    w1.rest()
}

// 1. 定义一个工人结构体
type Worker struct {
    name string
    age int
    sex string
}
// 2. 定义行为方法
func (w Worker) work() {
    fmt.Println(w.name, "在工作...")
}

// 接收者写成指针
func (p *Worker) rest() {
    fmt.Println(p.name, "在休息...")
}

// 输出
张三 在工作...
*main.Worker
李四 在工作...
李四 在休息...
张三 在休息...

package main

import (
    "fmt"
)

func main() {
    // 1. 创建Person类型
    p1 := Person{name:"张三", age:18}
    fmt.Println(p1.name, p1.age)
    p1.eat()

    // 2. 创建Student类型
    s1 := Student{Person{"ruby", 30}, "bilibili"}
    fmt.Println(s1.name)    // s1.Person.name
    fmt.Println(s1.age)     // 子类对象：可以直接访问父类字段（提升字段）
    fmt.Println(s1.school)  // 子类对象：访问自己新增的子段属性
    s1.eat()                // 子类对象：访问父类的方法
    s1.study()              // 子类对象：访问自己新增的方法

    s1.eat()                // 如果存在方法的重写，子类对象访问重写的方法
}

// 定义一个"父类"
type Person struct {
    name string
    age int
}

// 定义一个"子类"
type Student struct {
    Person  // 结构体嵌套，模拟继承性
    school string
}

// 方法
func (p Person) eat() {
    fmt.Println("父类的方法：吃汉堡")
}

// 新增方法
func (s Student) study() {
    fmt.Println("子类新增的方法：学习")
}

// 重写父类方法
func (s Student) eat() {
    fmt.Println("子类重写的方法：吃炸鸡")
}

// 输出
张三 18
父类的方法：吃汉堡
ruby
30
bilibili
子类重写的方法：吃炸鸡
子类新增的方法：学习
子类重写的方法：吃炸鸡

/* 定义接口 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* 定义结构体 */
type struct_name struct {
   /* variables */
}

/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* 方法实现*/
}

package main

import (
    "fmt"
)

func main() {
    // 1. 创建Mouse类型
    m1 := Mouse{"罗技小红"}
    fmt.Println(m1.name)
    // 2. 创建FlashDisk类型
    f1 := FlashDisk{"闪迪64G"}
    fmt.Println(f1.name)

    testInterface(m1)

    testInterface(f1)
}

// 1. 定义接口
type USB interface {
    start()
    end()
}

// 2. 实现类
type Mouse struct {
    name string
}

type FlashDisk struct {
    name string
}

func (m Mouse) start() {
    fmt.Println(m.name, "鼠标准备就绪")
}

func (m Mouse) end() {
    fmt.Println(m.name, "鼠标结束工作")
}

func (f FlashDisk) start() {
    fmt.Println(f.name, "U盘准备就绪")
}

func (f FlashDisk) end() {
    fmt.Println(f.name, "U盘结束工作")
}

// 3. 测试方法
func testInterface(usb USB) {
    usb.start()
    usb.end()
}

// 输出
罗技小红
闪迪64G
罗技小红 鼠标准备就绪
罗技小红 鼠标结束工作
闪迪64G U盘准备就绪
闪迪64G U盘结束工作

package main

import (
    "fmt"
)

func main() {
    var cat = Cat{}
    cat.test1()
    cat.test2()
    cat.test3()
    fmt.Println("----------------")

    // 接口A类型
    var a1 = cat
    a1.test1()
    fmt.Println("----------------")

    // 接口B类型
    var b1 = cat
    b1.test2()
    fmt.Println("----------------")

    // 接口C类型
    var c1 = cat
    c1.test1()
    c1.test2()
    c1.test3()
    fmt.Println("----------------")


}

type A interface {
    test1()
}

type B interface {
    test2()
}

type C interface {
    A
    B
    test3()
}

type Cat struct {

}

func (c Cat) test1() {
    fmt.Println("test1()...")
}

func (c Cat) test2() {
    fmt.Println("test2()...")
}

func (c Cat) test3() {
    fmt.Println("test3()...")
}

// 输出
test1()...
test2()...
test3()...
----------------
test1()...
----------------
test2()...
----------------
test1()...
test2()...
test3()...
----------------

// 接口断言方法1：
1. interface := 接口对象.(实际类型) // 不安全，会panic()
2. interface, ok := 接口对象.(实际类型) // 安全

// 接口断言方法2：
switch instance := 接口对象.(type) {
case 实际类型1:
    ...
case 实际类型2:
    ...
...
}

// 实例
switch ins := s.(type) {
    case Triangle:
        fmt.Println("三角形。。。",ins.a,ins.b,ins.c)
    case Circle:
        fmt.Println("圆形。。。。",ins.radius)
    case int:
        fmt.Println("整型数据。。")
}

package main

import (
    "fmt"
    "math"
)

func main() {
    var t1 = Triangle{3, 4, 5}
    fmt.Println(t1.peri())
    fmt.Println(t1.area())
    fmt.Println(t1.a, t1.b, t1.c)
    fmt.Println("----------------")

    var c1 = Circle{4}
    fmt.Println(c1.peri())
    fmt.Println(c1.area())
    fmt.Println(c1.radius)
    fmt.Println("----------------")

    getType(t1)
    getType(c1)

}

func getType(s Shape) {
    // 断言
    if ins, ok := s.(Triangle) ; ok {
        fmt.Println("是三角形，三边是：", ins.a, ins.b, ins.c)
    } else if ins, ok := s.(Circle) ; ok {
        fmt.Println("是圆形，半径是：", ins.radius)
    } else {
        fmt.Println("我也不知道了...")
    }
}

// 1. 定义一个接口
type Shape interface {
    peri() float64
    area() float64
}

// 2. 定义实现类：三角形
type Triangle struct {
    a, b, c float64
}

func (t Triangle) peri() float64 {
    return t.a + t.b + t.c
}

func (t Triangle) area() float64 {
    p := t.peri() / 2
    s := math.Sqrt(p * (p - t.a) * (p - t.b) * (p - t.c))
    return s
}

type Circle struct {
    radius float64
}

func (c Circle) peri() float64 {
    return c.radius * 2 * math.Pi
}

func (c Circle) area() float64 {
    return math.Pow(c.radius, 2) * math.Pi
}

// 输出
12
6
3 4 5
----------------
25.132741228718345
50.26548245743669
4
----------------
是三角形，三边是： 3 4 5
是圆形，半径是： 4

//errors包：
func New(text string) error {}

//fmt包：
func Errorf(format string, a ...interface{}) error {}

package main

import (  
    "errors"
    "fmt"
    "math"
)

func circleArea(radius float64) (float64, error) {  
    if radius < 0 {
        return 0, errors.New("Area calculation failed, radius is less than zero")
        // return 0, fmt.Errorf("Area calculation failed, radius %0.2f is less than zero", radius)
    }
    return math.Pi * radius * radius, nil
}

func main() {  
    radius := -20.0
    area, err := circleArea(radius)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("Area of circle %0.2f", area)
}

// 输出
Area calculation failed, radius is less than zero

package main

import (
    "fmt"
)

func main() {
    GO()
    PHP()
    PYTHON()
}

//Go语言追求简洁优雅，所以，Go语言不支持传统的 try…catch…finally 这种异常，因为Go语言的设计者们认为，将异常与控制结构混在一起会很容易使得代码变得混乱。因为开发者很容易滥用异常，甚至一个小小的错误都抛出一个异常。在Go语言中，使用多值返回来返回错误。不要用异常代替错误，更不要用来控制流程。在极个别的情况下，也就是说，遇到真正的异常的情况下（比如除数为0了）。才使用Go中引入的Exception处理：defer, panic, recover。

//Go没有异常机制，但有panic/recover模式来处理错误
//Panic可以在任何地方引发，但recover只有在defer调用的函数中有效
func GO() {
    fmt.Println("我是GO，现在没有发生异常，我是正常执行的。")
}

func PHP() {
    // 必须要先声明defer，否则不能捕获到panic异常,也就是说要先注册函数，后面有异常了，才可以调用
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("终于捕获到了panic产生的异常：", err) // 这里的err其实就是panic传入的内容
            fmt.Println("我是defer里的匿名函数，我捕获到panic的异常了，我要recover，恢复过来了。")
        }
    }() //注意这个()就是调用该匿名函数的，不写会报expression in defer must be function call

    // panic一般会导致程序挂掉（除非recover）  然后Go运行时会打印出调用栈
    //但是，关键的一点是，即使函数执行的时候panic了，函数不往下走了，运行时并不是立刻向上传递panic，而是到defer那，等defer的东西都跑完了，panic再向上传递。所以这时候 defer 有点类似 try-catch-finally 中的 finally。panic就是这么简单。抛出个真正意义上的异常。
    panic("我是PHP,我要抛出一个异常了，等下defer会通过recover捕获这个异常，捕获到我时，在PHP里是不会输出的，会在defer里被捕获输出，然后正常处理，使后续程序正常运行。但是注意的是，在PHP函数里，排在panic后面的代码也不会执行的。")
    fmt.Println("我是PHP里panic后面要打印出的内容。但是我是永远也打印不出来了。因为逻辑并不会恢复到panic那个点去，函数还是会在defer之后返回，也就是说执行到defer后，程序直接返回到main()里，接下来开始执行PYTHON()")
}

func PYTHON() {
    fmt.Println("我是PYTHON，没有defer来recover捕获panic的异常，我是不会被正常执行的。")
}

// 输出
我是GO，现在没有发生异常，我是正常执行的。
终于捕获到了panic产生的异常： 我是PHP,我要抛出一个异常了，等下defer会通过recover捕获这个异常，捕获到我时，在PHP里是不会输出的，会在defer里被捕获输出，然后正常处理，使后续程序正常运行。但是注意的是，在PHP函数里，排在panic后面的代码也不会执行的。
我是defer里的匿名函数，我捕获到panic的异常了，我要recover，恢复过来了。
我是PYTHON，没有defer来recover捕获panic的异常，我是不会被正常执行的。

package main

import (
    "fmt"
    "time"
)

func main() {
    // 1. 获取当前的时间
    t1 := time.Now()
    fmt.Println(t1)
    fmt.Println("----------------")

    // 2. 获取指定的时间
    t2 := time.Date(2008, 7, 15, 16, 30, 28, 0, time.Local)
    fmt.Println(t2)
    fmt.Println("----------------")

    // 3. time -> string之间的转换
    s1 := t1.Format("2006-1-2 15:04:05")
    fmt.Println(s1)

    s3 := "1999年10月10日"  // string
    t3, err := time.Parse("2006年01月02日", s3)
    if err != nil {
        fmt.Println("err: ", err)
    }
    fmt.Println(t3)
    fmt.Println("----------------")

    // 4. 根据当前时间，获取指定内容
    year, month, day := t1.Date()
    fmt.Println(year, month, day)

    hour, min, sec := t1.Clock()
    fmt.Println(hour, min, sec)
    fmt.Println("----------------")

    // 5. 时间戳：指定的日期，距离1970年1月1日0时0分0秒的时间差值
    t4 := time.Date(2021, 2, 7, 0, 0, 0, 0, time.UTC)
    timeStamp := t4.Unix()
    fmt.Println(timeStamp)
    fmt.Println("----------------")

// 输出
2009-11-10 23:00:00 +0000 UTC m=+0.000000001
----------------
2008-07-15 16:30:28 +0000 UTC
----------------
2009-11-10 23:00:00
1999-10-10 00:00:00 +0000 UTC
----------------
2009 November 10
23 0 0
----------------
1612656000
----------------
}

// 输出

package main

import (
    "os"
    "fmt"
)

func main() {
    /*
    FileInfo：文件信息
        interface
            Name()，文件名
            Size()，文件大小，字节为单位
            IsDir()，是否是目录
            ModTime()，修改时间
            Mode()，权限

     */
    fileInfo,err :=  os.Stat("/Users/ruby/Documents/pro/a/aa.txt")
    if err != nil{
        fmt.Println("err :",err)
        return
    }
    fmt.Printf("%T\n",fileInfo)
    //文件名
    fmt.Println(fileInfo.Name())
    //文件大小
    fmt.Println(fileInfo.Size())
    //是否是目录
    fmt.Println(fileInfo.IsDir()) //IsDirectory
    //修改时间
    fmt.Println(fileInfo.ModTime())
    //权限
    fmt.Println(fileInfo.Mode()) //-rw-r--r--
}