Go语言入门存档

package geometry

import (
    "fmt"
    "os"
    "github.com/gin-gonic/gin"
)

func main() {
    var s, sep, string
    for i := 1; i < len(os.Args); i++ { 
        s += sep + os.Args[i]
        sep = " "
    }
    fmt.Println(s)
}

// 1 声明了变量s和sep是string类型
var s, sep string
// 2 简短声明，只适用于函数内部使用
s, sep := "", ""
// 3 比较冗余的方法
var s2 int64 = 1
// 4 go的自动推断，可以根据初始值自动推断变量类型
var s3 = 29
// 5 声明多个变量
var (
 name = "dot"
  age = 29
  height int
)

const a int = 2
const a = 55

const b = math.Sqrt(4) // 右式在运行时计算

// 内建函数complex()用于创建复数，实部和虚部要是相同类型，float32/float64：
c1 := complex(5, 7)
// 或者
c1 := 6+7i

type typeName typeLiteral //语法

// 例子：
type months map[string]int
//其实就像是假名一样

i++
i--

// 基础的for
for initialization; condition; post {
    // statement
}
// 例子
for i:=1; i<=10; i++ {	// 如果是不需要赋初值的i也可以写成： for ;i<10;i++ {...}
  // statement
} 

// while循环
for condition {
    // ...
}
// while(1)
for {
    // ...
}

for _, args := range os.Args[1:] {
    // ...
}

finger := 4
switch finger {
case 1, 3, 4:
    fmt.Println("thunmb")
case 2:
    fmt.Println("Index")
default:
    fmt.Println("warning")
}

num := 75
switch {
    case num>=0 && num<50: 
    	fmt.Println('1')
    case num >=50 && num<100: 
    	fmt.Println('2')
}

import (
    "string"
    "os"
}

strings.Join(os.Args[1:], " ")

import "fmt"

a := []byte("test")
fmt.Println(a)     // 输出：[116 101 115 116] 即使用默认的类型格式显示
fmt.Printf("%s", a)      // 输出：test

s = fmt.Sprintf("%v", a) // 使用格式化规则（即%v）对传入的字符串a格式化，并返回格式化后的结果
fmt.Fprintf(os.Stderr, "%s", a) // 格式化传入字符串a，并将其输出到第一个输入变量规定的的io.Writers类型对象中

if condition{
 	// statement
}	else if {
    // statement
} else {
    // st2atement
}

import {
    "strconv"
    "strings"
}

// ===== 类型转换 ========== 
var num = 1
s := strconv.Itoa(num) // strconv.Itoa() 数字到字符串

i1, err := strconv.Atoi(s) // 字符串到数字 err是错误信息

// ====== 去除string前后空格 =====
buf := make([]byte) {  b  b }
fmt.Printf("%s",strings.TrimSpace(string(buf))) // 输出"b  b"，即去除了前后空格

// 长度为3的int数组
var a[3]int 
// 简略声明
a := [3]int{12, 78, 50}
// 不全赋值的简略声明
a := [3]int{12}
// 自动识别长度
// 如果...出现在数组长度的位置，那么数组长度由初始化数组的元素个数决定
a := [...]int{12, 78, 50}
// 使用index:value方式定义的数组
var d = [...] int{1, 2, 4:5, 6} // [1,2,0,0,5,6]
// 多维数组
a:= [3][2]string{
    {"1", "2"},
    {"3", "4"},
    {"5", "6"},	// 这个最后的逗号还一定得加！
}

i := []int {1,2,3}
i := []int {}
i := make([]int, len, cap)
i := []int {
    1,
    2,
    3,
}

type slice struct{
	Length			int
    Capacity		int
    ZerothElement 	*byte
}

a := [...]int{1,2,3,4,5}	// 数组a
b := a[0:3]					// a的切片
for i:= range b { 
	b[i]++ 
}
fmt.Printlb(a) // 会发现a的值被改变了

func find(num int, nums ...int){
    ...
}
// 在这个函数中，nums被当做整形切片`[]int`

// 如何直接将整型切片当做最后一个参数传入上述find函数？
// 语法糖：
nums := []int{89,59,30}
find(89, nums...) 	// 在切片后加上...后缀

// 键key是string类型，值是int类型
personSalary := make(map[string]int)
personSalary["steve"] = 12000

// 或者在声明的时候赋值
personSalary := map[string]int {
    "steve": 12000,
    "jamie": 15000,
}

// 其他的创建方法
cacheNode:= make(map[*Node]*Node) // 一个哈希表，key是指向Node类型的指针，value也是指向Node类型的指针
var cacheNode map[*Node]*Node

key1 = personSalary["steve"] // 如果steve不存在则会返回值类型的零值
key2, ok = personSalary["steve"] // 这种方法的第二个参数代表了map中是否存在这个键

for key, value := range key1 {
    
}

s := "hello world"

s := "hello world"
temp := []rune(s)
temp[0] = 'a'
result := string(temp)

var a *int // 	指针的创建 初始不赋值的话就是nil
b := 255
a = &b 		// 	指针a指向b的地址
fmt.Println(*a) // 打印出指针a指向的地址的值

// 结构体的声明
type Employee struct {
    firstName, lastname 	string
    age						int
}

// 结构体的使用
emp1 := Employee{
    firstName: "Sam",
    age: 25,
}

emp2 := Employee{"Tom", 29}

// 访问结构体
fmt.Println(emp1.firstName)

// *******匿名字段*********
type Employee struct {
    identity
    age			int
}
type identity struct {
    id			int
    home		string
}
// 初始化
emp3 := Employee {identity{10, "Xiamen"}, 20} // 初始化需要使用Struct名

// 可以从上一层Employee的字段名称访问identity中字段的值
fmt.Println(emp3.home)

// 多个struct一起声明
type(
    StructName1 struct{
        fisrtName 	string
        age			int
    }
    StructName2 struct{
        IndexType	string
        In
    }
)

// struct的field tag 
// 可以添加该tag来快速地转换json和go结构体
type TestStruct struct {
	Bit64 int64  `ddf:"idx=k1"`
	Bytes []byte `ddf:"idx=k2"`
}

func calculate(x int, y int) int{
  ...
}

// 多返回值
func calculate(x, y int)(float64, float64){
  ...
}

// 命名返回值
func calculate(x, y int)(area, perimeter float64){
  area = x * y
  perimeter = (x + y) * 2
  return // 不需要明确指定返回量，因为在函数第一行声明了返回的变量
}

/// 匿名函数
f := func(args string) {
    fmt.Println(args)
}
f("hello world")
// 或者
func(args string) {
    fmt.Println(args)
} ("Hello world")

func (r ReceiverType) funcName(parameters) (results)

type Rectangle struct{
    width, heigh float64
} 
type Circle struct {
    radius float64
}

func (r Rectangle) area (a int, b int) float64 {
  ...
}// 分别是：r：接收器（实现了该方法的对象），a、b方法的输入参数，float64返回类型

x := Rectangle{1,2}
x.calculate(3,4) // 这样使用方法

type VowelsFinder interface {
    FindVowels() []rune
}

type Greeting func(name string) string 
// Greeting函数类型中，所有的函数都是输入string，输出string

func english(name string) string {
    return "Hello, "+name
}
func french(name string) string {
    return "bonjour, "+name
}''

const (
	a int	=	iota	//这个int也可以不加 a=0
    b					//b=1
    c					//c=2
    _					// 这里会被跳过
    d					//d=4
)
//iota也可以写成表达式，比如 1<<iota 就是每行左移一位

go func() // 启动一个goroutine

// 声明channel的方法
var a chan int
// 或者简短声明
a := make(chan int) 
// 单向channel：唯送信道 send only channel
a := make(chan<- int)
// 关闭信道
close(a)
// buffered channel
a := make(chan int, 4) // 在信道内对象没有大于其容量时不会发生阻塞。无缓冲信道的容量为0

a <- 3 // 写数据
<- a // 读数据 这里的接收端空置，合法
s1, s2 := <-a, <-b // s1和s2从channel a和b读数据
// 当goroutine向channel写数据时，程序会在发送数据语句处阻塞，直到有其他goroutine读取了chennel数据
// 同理，当goroutine读数据时，如果没有其他goroutine把数据写入信道，那么读取过程也会阻塞

slice := make([]int, 0, 100)
hash := make(map[int]bool, 10)
ch := make(chan int, 5)

i := new(int)

var v int
i := &v

func TestXxx(*testing.T)