go 入门

package main
import "fmt"

func main() {
	fmt.Println("Hello World")
}

s1 := "aaa"
fmt.Println(s1)

> aaa

var a := '中'
var b := 'x'

s1 := "a"
fmt.Println(s1)

> 97

var s1 string
s1 = "aaa"

s2 := "aaa"

var s3, s4 string
s5,s6 := "G","o"

// 使用匿名变量来忽略函数的返回值、临时存储值，以及在需要忽略某些返回值的情况下使用。请注意，匿名变量不能被重新赋值或在其他地方使用，作用仅限于被声明的位置。
_, _ = 10, 20

arrs := [3]int{1, 2, 3}
arr := [...]int{1, 2}
c := [5]int{3: 100, 4: 500}
d := [2][3]int{{1, 2, 3}, {4, 5, 6}}

s1 := []int{1, 2, 3}
s1 = append(s1, 1234)

s3 := make([]int, 5)
fmt.Println(s1,s3)

a := 10
    b := &a
    fmt.Printf("a:%d ptr:%p\n", a, &a) // a:10 ptr:0xc00001a078
    fmt.Printf("b:%p type:%T\n", b, b) // b:0xc00001a078 type:*int
    fmt.Println(&b)                    // 0xc00000e018

//指针取值
  a := 10
  b := &a // 取变量a的地址，将指针保存到b中
  fmt.Printf("type of b:%T\n", b)
  c := *b // 指针取值（根据指针去内存取值）
  fmt.Printf("type of c:%T\n", c)
  fmt.Printf("value of c:%v\n", c)

type of b:*int
  type of c:int
  value of c:10

func modify1(x int) {
    x = 100
}

func modify2(x *int) {
    *x = 100
}

func main() {
    a := 10
    modify1(a)
    fmt.Println(a) // 10
    modify2(&a)
    fmt.Println(a) // 100
}

var p *string
    fmt.Println(p)
    fmt.Printf("p的值是%s/n", p)
    if p != nil {
        fmt.Println("非空")
    } else {
        fmt.Println("空值")
    }

map[KeyType]ValueType

make(map[KeyType]ValueType, [cap])

func main() {
    scoreMap := make(map[string]int, 8)
    scoreMap["张三"] = 90
    scoreMap["小明"] = 100
    fmt.Println(scoreMap)
    fmt.Println(scoreMap["小明"])
    fmt.Printf("type of a:%T\n", scoreMap)
}

scoreMap := map[string]int{
	"A": 100,
	"B": 60,
}
fmt.Println(scoreMap)

	value,ok := scoreMap["A"]
	if ok{
		fmt.Println(value)
	} else {
		fmt.Println("not exist")
	}

	values,okk := scoreMap["C"]
	if okk{
		fmt.Println(values)
	} else {
		fmt.Println("not exist")
	}

100
not exist

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

for k := range scoreMap {
        fmt.Println(k)
    }

type person struct {
    name string
    city string
    age  int8
}

func main() {
    var p1 person
    p1.name = "pprof.cn"
    p1.city = "北京"
    p1.age = 18
    fmt.Printf("p1=%v\n", p1)  //p1={pprof.cn 北京 18}
    fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"pprof.cn", city:"北京", age:18}
}

var p2 = new(person)
  fmt.Printf("%T\n", p2)     //*main.person
  fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"", city:"", age:0}

p3 := &person{}
fmt.Printf("%T\n", p3)     //*main.person
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"", city:"", age:0}
p3.name = "博客"
p3.age = 30
p3.city = "成都"
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"博客", city:"成都", age:30}

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

for i, n := 0, len(s); i < n; i++ { // 常见的 for 循环，支持初始化语句。
    println(s[i])
}

n := len(s)
for n > 0 {                // 替代 while (n > 0) {}
    println(s[n])        // 替代 for (; n > 0;) {}
    n-- 
}

for {                    // 替代 while (true) {}
    println(s)            // 替代 for (;;) {}
}

for a := 0; a < 10; a++ {
   fmt.Printf("a 的值为: %d\n", a)
}

for a < b {
   a++
   fmt.Printf("a 的值为: %d\n", a)
   }

for i,x:= range numbers {
   fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
}   

• 无需声明原型。
• 支持不定 变参。
• 支持多返回值。
• 支持命名返回参数。 
• 支持匿名函数和闭包。
• 函数也是一种类型，一个函数可以赋值给变量。

• 不支持 嵌套 (nested) 一个包不能有两个名字一样的函数。
• 不支持 重载 (overload) 
• 不支持 默认参数 (default parameter)。

func test(x, y int, s string) (int, string) {
    // 类型相同的相邻参数，参数类型可合并。 多返回值必须用括号。
    n := x + y          
    return n, fmt.Sprintf(s, n)
}

package main

import "fmt"

func test(fn func() int) int {
    return fn()
}
// 定义函数类型。
type FormatFunc func(s string, x, y int) string 

func format(fn FormatFunc, s string, x, y int) string {
    return fn(s, x, y)
}

func main() {
    s1 := test(func() int { return 100 }) // 直接将匿名函数当参数。

    s2 := format(func(s string, x, y int) string {
        return fmt.Sprintf(s, x, y)
    }, "%d, %d", 10, 20)

    println(s1, s2)
}

func main() {
	func(a, b int) {
		fmt.Println(a + b)
	}(1, 2)

func init()  {
	fmt.Println(123)
}

func add(nums ...int) int {
	total := 0
	for _, v := range nums {
		total += v
	}
	return total
}

ackage main

import (
    "fmt"
)

func a() func() int {
    i := 0
    b := func() int {
        i++
        fmt.Println(i)
        return i
    }
    return b
}

func main() {
    c := a()
    c()
    c()
    c()

    a() //不会输出i
}

    1
    2
    3

package main

import "fmt"

func test() func() {
    x := 100
    fmt.Printf("x (%p) = %d\n", &x, x)

    return func() {
        fmt.Printf("x (%p) = %d\n", &x, x)
    }
}

func main() {
    f := test()
    f()
}

dongle.Encode.FromString(text).ByBase64().ToString()
dongle.Decode.FromString(cipher).ByBase64().ToString()

func hello()  {
	fmt.Println("Hello World")
}
func main() {
	go hello()
	fmt.Println("Hello World in main")
}

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup

func hello(i int)  {
	defer wg.Done() // goroutine结束就登记-1
	fmt.Println("Hello World")
}
func main() {
	for i := 0; i < 10; i++ {
        wg.Add(1) // 启动一个goroutine就登记+1
        go hello(i)
    }
    wg.Wait() // 等待所有登记的goroutine都结束
	fmt.Println("Hello World in main")
}

package main

import (
    "fmt"
    "time"
)

func main() {
    // 合起来写
    go func() {
        i := 0
        for {
            i++
            fmt.Printf("new goroutine: i = %d\n", i)
            time.Sleep(time.Second)
        }
    }()
    i := 0
    for {
        i++
        fmt.Printf("main goroutine: i = %d\n", i)
        time.Sleep(time.Second)
        if i == 2 {
            break
        }
    }
}

package main

import (
	"fmt"
	"runtime"
)

func main() {
	// 协程
	go func(s string) {
		for i := 0; i < 2; i++ {
			fmt.Println(s)
		}
	}("Hello")

	// 主协程
	for i := 0; i < 2; i++ {
		// 切一下，再分配任务
		runtime.Gosched()
		fmt.Println("hello")
	}
}

package main

import (
    "fmt"
    "runtime"
)

func main() {
    go func() {
        defer fmt.Println("A.defer")
        func() {
            defer fmt.Println("B.defer")
            // 结束协程
            runtime.Goexit()
            defer fmt.Println("C.defer")
            fmt.Println("B")
        }()
        fmt.Println("A")
    }()
    for {
    }
}

  var 变量 chan 元素类型
var ch1 chan int   // 声明一个传递整型的通道
  var ch2 chan bool  // 声明一个传递布尔型的通道
  var ch3 chan []int // 声明一个传递int切片的通道

var ch chan int
fmt.Println(ch) // <nil>

ch4 := make(chan int)
ch5 := make(chan bool)
ch6 := make(chan []int)

ch := make(chan int)

ch <- 10 // 把10发送到ch中

x := <- ch // 从ch中接收值并赋值给变量x
<-ch       // 从ch中接收值，忽略结果

close(ch)

func main() {
    ch := make(chan int)
    ch <- 10
    fmt.Println("发送成功")
}

package main

import "fmt"

func recv(ch chan int) {
	ret := <-ch
	fmt.Println(ret, "接收成功")
}
func main() {
	// 定义一个通道
	ch := make(chan int)
	go recv(ch)
	ch <- 10
	fmt.Println(ch, "发送成功")
}

func main() {
    ch := make(chan int, 1) // 创建一个容量为1的有缓冲区通道
    ch <- 10
    fmt.Println("发送成功")
}

package main

import "fmt"

func main() {
    c := make(chan int)
    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        close(c)
    }()
    for {
        if data, ok := <-c; ok {
            fmt.Println(data)
        } else {
            break
        }
    }
    fmt.Println("main结束")
}

func counter(out chan<- int) {
    for i := 0; i < 100; i++ {
        out <- i
    }
    close(out)
}

func squarer(out chan<- int, in <-chan int) {
    for i := range in {
        out <- i * i
    }
    close(out)
}
func printer(in <-chan int) {
    for i := range in {
        fmt.Println(i)
    }
}

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    go counter(ch1)
    go squarer(ch2, ch1)
    printer(ch2)
}

package main

import (
    "fmt"
    "time"
)

func main() {
    timer := time.NewTimer(time.Second)
    fmt.Println("Timer started...")

    <-timer.C // 等待定时器触发
    fmt.Println("Timer expired!")
}

package main

import (
	"fmt"
	"time"
)

func main() {
	ticker := time.NewTicker(1 * time.Second)
	i := 0
	go func() {
		for {
			i++
			fmt.Println(<-ticker.C)
			if i == 5 {
				ticker.Stop()
			}
		}
	}()
	for {

	}
}

package main

import (
	"fmt"
	"time"
)

func test1(ch chan string) {
	time.Sleep(time.Second * 5)
	ch <- "test1"
}
func test2(ch chan string) {
	time.Sleep(time.Second * 2)
	ch <- "test2"
}

func main() {
	// 2个管道
	output1 := make(chan string)
	output2 := make(chan string)
	// 跑2个子协程，写数据
	go test1(output1)
	go test2(output2)
	// 用select监控
	select {
	case s1 := <-output1:
		fmt.Println("s1=", s1)
	case s2 := <-output2:
		fmt.Println("s2=", s2)
	}
}

package main

import (
   "fmt"
)

func main() {
   // 创建2个管道
   int_chan := make(chan int, 1)
   string_chan := make(chan string, 1)
   go func() {
      //time.Sleep(2 * time.Second)
      int_chan <- 1
   }()
   go func() {
      string_chan <- "hello"
   }()
   select {
   case value := <-int_chan:
      fmt.Println("int:", value)
   case value := <-string_chan:
      fmt.Println("string:", value)
   }
   fmt.Println("main结束")
}

package main

import (
	"fmt"
	"sync"
)

var x int64
var wg sync.WaitGroup

func add() {
	for i := 0; i < 5000; i++ {
		x = x + 1
	}
	wg.Done()
}
func sub() {
	for i := 0; i < 5000; i++ {
		x = x - 1
	}
	wg.Done()
}
func main() {
	wg.Add(2)
	go add()
	go sub()
	wg.Wait()
	fmt.Println(x)
}

package main

import (
	"fmt"
	"sync"
)

var x int64
var wg sync.WaitGroup
var lock sync.Mutex

func add() {
	for i := 0; i < 5000; i++ {
		lock.Lock() //加锁
		x = x + 1
		lock.Unlock() //解锁
	}
	wg.Done()
}
func sub() {
	for i := 0; i < 5000; i++ {
		lock.Lock() //加锁
		x = x - 1
		lock.Unlock() //解锁
	}
	wg.Done()
}
func main() {
	wg.Add(2)
	go add()
	go sub()
	wg.Wait()
	fmt.Println(x)
}

• 只能为当前包内命名类型定义方法。
• 参数 receiver 可任意命名。如方法中未曾使用 ，可省略参数名。
• 参数 receiver 类型可以是 T 或 *T。基类型 T 不能是接口或指针。 
• 不支持方法重载，receiver 只是参数签名的组成部分。
• 可用实例 value 或 pointer 调用全部方法，编译器自动转换。

func (recevier type) methodName(参数列表)(返回值列表){}

    参数和返回值可以省略

package main

type Test struct{}

// 无参数、无返回值
func (t Test) method0() {

}

// 单参数、无返回值
func (t Test) method1(i int) {

}

// 多参数、无返回值
func (t Test) method2(x, y int) {

}

// 无参数、单返回值
func (t Test) method3() (i int) {
    return
}

// 多参数、多返回值
func (t Test) method4(x, y int) (z int, err error) {
    return
}

// 无参数、无返回值
func (t *Test) method5() {

}

// 单参数、无返回值
func (t *Test) method6(i int) {

}

// 多参数、无返回值
func (t *Test) method7(x, y int) {

}

// 无参数、单返回值
func (t *Test) method8() (i int) {
    return
}

// 多参数、多返回值
func (t *Test) method9(x, y int) (z int, err error) {
    return
}

func main() {}

package main

import "fmt"

type User struct {
	name string
	age  int
}

// 方法
func (u User) Notify() {
	fmt.Printf("name: %v, age: %v\n", u.name, u.age)
}	
func main() {
	// 创建对象
	user := User{"Tom", 18}
	user.Notify()

	user2 := User{"Jerry", 20}
	user3 := &user2
	user3.Notify()

}

package main

import "fmt"

type Data struct {
    x int
}

func (self Data) ValueTest() { // func ValueTest(self Data);
    fmt.Printf("Value: %p\n", &self)
}

func (self *Data) PointerTest() { // func PointerTest(self *Data);
    fmt.Printf("Pointer: %p\n", self)
}

func main() {
    d := Data{}
    p := &d
    fmt.Printf("Data: %p\n", p)

    d.ValueTest()   // ValueTest(d)
    d.PointerTest() // PointerTest(&d)

    p.ValueTest()   // ValueTest(*p)
    p.PointerTest() // PointerTest(p)
}

package main

//普通函数与方法的区别（在接收者分别为值类型和指针类型的时候）

import "fmt"

// 1.普通函数
// 接收值类型参数的函数
func valueIntTest(a int) int {
	return a + 10
}

// 接收指针类型参数的函数
func pointerIntTest(a *int) int {
	return *a + 10
}

func structTestValue() {
	a := 2
	fmt.Println("valueIntTest:", valueIntTest(a))
	//函数的参数为值类型，则不能直接将指针作为参数传递
	//fmt.Println("valueIntTest:", valueIntTest(&a))
	//compile error: cannot use &a (type *int) as type int in function argument

	b := 5
	fmt.Println("pointerIntTest:", pointerIntTest(&b))
	//同样，当函数的参数为指针类型时，也不能直接将值类型作为参数传递
	//fmt.Println("pointerIntTest:", pointerIntTest(b))
	//cannot use b (variable of type int) as *int value in argument to pointerIntTest
}

//2.方法
type PersonD struct {
    id   int
    name string
}

//接收者为值类型
func (p PersonD) valueShowName() {
    fmt.Println(p.name)
}

//接收者为指针类型
func (p *PersonD) pointShowName() {
    fmt.Println(p.name)
}

func structTestFunc() {
    //值类型调用方法
    personValue := PersonD{101, "hello world"}
    personValue.valueShowName()
    personValue.pointShowName()

    //指针类型调用方法
    personPointer := &PersonD{102, "hello golang"}
    personPointer.valueShowName()
    personPointer.pointShowName()

    //与普通函数不同，接收者为指针类型和值类型的方法，指针类型和值类型的变量均可相互调用
}

func main() {
	structTestValue()
	structTestFunc()
}

package main

import "fmt"

type User struct {
    id   int
    name string
}

type Manager struct {
    User
}

func (self *User) ToString() string { // receiver = &(Manager.User)
    return fmt.Sprintf("User: %p, %v", self, self)
}

func main() {
    m := Manager{User{1, "Tom"}}
    fmt.Printf("Manager: %p\n", &m)
    fmt.Println(m.ToString())
}

package main

import "fmt"

type User struct {
    id   int
    name string
}

type Manager struct {
    User
    title string
}

func (self *User) ToString() string {
    return fmt.Sprintf("User: %p, %v", self, self)
}

func (self *Manager) ToString() string {
    return fmt.Sprintf("Manager: %p, %v", self, self)
}

func main() {
    m := Manager{User{1, "Tom"}, "Administrator"}

    fmt.Println(m.ToString())

    fmt.Println(m.User.ToString())
}

package main

import "fmt"

type User struct {
    id   int
    name string
}

func (self *User) Test() {
    fmt.Printf("%p, %v\n", self, self)
}

func main() {
    u := User{1, "Tom"}
    u.Test()

    mValue := u.Test
    mValue() // 隐式传递 receiver

    mExpression := (*User).Test
    mExpression(&u) // 显式传递 receiver
}

package main

import (
	"errors"
	"fmt"
)

func divide(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.New("除数不能为0")
	} else {
		return a / b, nil
	}

}

func main() {
	d, err := divide(4, 0)
	if err != nil {
		fmt.Println("错误：", err)
	} else {
		fmt.Println("结果：", d)
	}
}

package main

import "fmt"

type MyError struct {
	When string
	What string
}

func (e *MyError) Error() string {
	return fmt.Sprintf("在 %s 发生错误: %s", e.When, e.What)
}

func run() error {
	err := &MyError{
		When: "2020-10-20",
		What: "程序出错",
	}
	return err
}

func main() {
	error := run()
	if error != nil {
		fmt.Println(error)
	}
}

type Person struct {
	name string
	sex byte
	age int
}
type Student struct {
	Person	// 匿名字段，只有类型，没有名字。它继承了Person的所有成员
	id int
	addr string
}

// 初始化
s1 := Student{Person{"5lmh", "man", 20}, 1, "bj"}
fmt.Println(s1)

s2 := Student{Person: Person{"5lmh", "man", 20}}
fmt.Println(s2)

s3 := Student{Person: Person{name: "5lmh"}}
fmt.Println(s3)

package main

import "fmt"

//人
type Person struct {
    name string
    sex  string
    age  int
}

type Student struct {
    Person
    id   int
    addr string
    //同名字段
    name string
}

func main() {
    var s Student
    // 给自己字段赋值了
    s.name = "5lmh"
    fmt.Println(s)

    // 若给父类同名字段赋值，如下
    s.Person.name = "枯藤"
    fmt.Println(s)
}

package main

import "fmt"

//人
type Person struct {
    name string
    sex  string
    age  int
}

// 自定义类型
type mystr string

// 学生
type Student struct {
    Person
    int
    mystr
}

func main() {
    s1 := Student{Person{"5lmh", "man", 18}, 1, "bj"}
    fmt.Println(s1)
}

package main

import "fmt"

//人
type Person struct {
    name string
    sex  string
    age  int
}

// 学生
type Student struct {
    *Person
    id   int
    addr string
}

func main() {
    s1 := Student{&Person{"5lmh", "man", 18}, 1, "bj"}
    fmt.Println(s1)
    fmt.Println(s1.name)
    fmt.Println(s1.Person.name)
}

type Shape interface {
    Area() float64
    Perimeter() float64
}

//定义一个圆
type Circle struct {
    Radius float64
}

// Circle类型实现Shape接口(实现了Area和Perimeter方法)
func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}
func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}

var s Shape = Circle{Radius: 1} //接口变量可以存储实现了接口的类型的对象

package main

import (
	"fmt"
	"math"
)

//定义接口
type Shape interface {
    Area() float64
    Perimeter() float64
}

//定义一个圆
type Circle struct {
    Radius float64
}

// Circle类型实现Shape接口(实现了Area和Perimeter方法)
func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}
func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}

func main() {
    var s Shape = Circle{Radius: 1} //接口变量可以存储实现了接口的类型的对象
    fmt.Println("Area: ", s.Area())
    fmt.Println("Perimeter: ", s.Perimeter())
}

// 读取文件 Open仅仅只是只读的，无法被修改
file, err := os.Open("1.txt")
if os.IsNotExist(err) {
	fmt.Println("File not found")
} else if err != nil {
	log.Fatal(err)
} else {
	fmt.Println("File found:", file)
	defer file.Close()
}

const (
   // 只读，只写，读写 三种必须指定一个
   O_RDONLY int = syscall.O_RDONLY // 以只读的模式打开文件
   O_WRONLY int = syscall.O_WRONLY // 以只写的模式打开文件
   O_RDWR   int = syscall.O_RDWR   // 以读写的模式打开文件
   // 剩余的值用于控制行为
   O_APPEND int = syscall.O_APPEND // 当写入文件时，将数据添加到文件末尾
   O_CREATE int = syscall.O_CREAT  // 如果文件不存在则创建文件
   O_EXCL   int = syscall.O_EXCL   // 与O_CREATE一起使用, 文件必须不存在
   O_SYNC   int = syscall.O_SYNC   // 以同步IO的方式打开文件
   O_TRUNC  int = syscall.O_TRUNC  // 当打开的时候截断可写的文件
)

const (
   ModeDir        = fs.ModeDir        // d: 目录
   ModeAppend     = fs.ModeAppend     // a: 只能添加
   ModeExclusive  = fs.ModeExclusive  // l: 专用
   ModeTemporary  = fs.ModeTemporary  // T: 临时文件
   ModeSymlink    = fs.ModeSymlink    // L: 符号链接
   ModeDevice     = fs.ModeDevice     // D: 设备文件
   ModeNamedPipe  = fs.ModeNamedPipe  // p: 具名管道 (FIFO)
   ModeSocket     = fs.ModeSocket     // S: Unix 域套接字
   ModeSetuid     = fs.ModeSetuid     // u: setuid
   ModeSetgid     = fs.ModeSetgid     // g: setgid
   ModeCharDevice = fs.ModeCharDevice // c: Unix 字符设备, 前提是设置了 ModeDevice
   ModeSticky     = fs.ModeSticky     // t: 黏滞位
   ModeIrregular  = fs.ModeIrregular  // ?: 非常规文件

   // 类型位的掩码. 对于常规文件而言，什么都不会设置.
   ModeType = fs.ModeType

   ModePerm = fs.ModePerm // Unix 权限位, 0o777
)

file2, err := os.OpenFile("README.md", os.O_RDWR|os.O_CREATE, 0666)
if os.IsNotExist(err) {
	fmt.Println("File not found")
} else if err != nil {
	log.Fatal(err)
} else {
	fmt.Println("File found:", file2.Name())
}

info, err := os.Stat("README.md")
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println(fmt.Sprintf("File found:%+v", info))
	}

bytes, err := os.ReadFile("1.txt")
if err != nil {
	log.Fatal(err)
} else {
	fmt.Println(string(bytes))
}