GO 学习笔记

hello world

package main

import "fmt"

func main() {
   /* 这是我的第一个简单的程序 */
   fmt.Println("Hello, World!")
}

格式化字符串

package main

import (
    "fmt"
)

func main() {
   // %d 表示整型数字，%s 表示字符串
    var stockcode=123
    var enddate="2020-12-31"
    var url="Code=%d&endDate=%s"
    var target_url=fmt.Sprintf(url,stockcode,enddate)
    fmt.Println(target_url)
}

package main

import (
    "fmt"
    "os"
)

type point struct {
    x, y int
}

func main() {

    p := point{1, 2}
    fmt.Printf("%v
", p)

    fmt.Printf("%+v
", p)

    fmt.Printf("%#v
", p)

    fmt.Printf("%T
", p)

    fmt.Printf("%t
", true)

    fmt.Printf("%d
", 123)

    fmt.Printf("%b
", 14)

    fmt.Printf("%c
", 33)

    fmt.Printf("%x
", 456)

    fmt.Printf("%f
", 78.9)

    fmt.Printf("%e
", 123400000.0)
    fmt.Printf("%E
", 123400000.0)

    fmt.Printf("%s
", ""string"")

    fmt.Printf("%q
", ""string"")

    fmt.Printf("%x
", "hex this")

    fmt.Printf("%p
", &p)

    fmt.Printf("|%6d|%6d|
", 12, 345)

    fmt.Printf("|%6.2f|%6.2f|
", 1.2, 3.45)

    fmt.Printf("|%-6.2f|%-6.2f|
", 1.2, 3.45)

    fmt.Printf("|%6s|%6s|
", "foo", "b")

    fmt.Printf("|%-6s|%-6s|
", "foo", "b")

    s := fmt.Sprintf("a %s", "string")
    fmt.Println(s)

    fmt.Fprintf(os.Stderr, "an %s
", "error")
}

Go语言变量

// 声明一个变量
var identifier type

// 一次声明多个变量
var identifier1, identifier2 type

 Go语言常量

const identifier [type] = value

Go语言条件语句

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

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var grade string = "B"
   var marks int = 90

   switch marks {
      case 90: grade = "A"
      case 80: grade = "B"
      case 50,60,70 : grade = "C"
      default: grade = "D"  
   }

   switch {
      case grade == "A" :
         fmt.Printf("优秀!
" )    
      case grade == "B", grade == "C" :
         fmt.Printf("良好
" )      
      case grade == "D" :
         fmt.Printf("及格
" )      
      case grade == "F":
         fmt.Printf("不及格
" )
      default:
         fmt.Printf("差
" );
   }
   fmt.Printf("你的等级是 %s
", grade );      
}

Go语言循环语句

for init; condition; post { }

for condition { }

for { }

for key, value := range oldMap {
    newMap[key] = value
}

package main
import "fmt"

func main() {
        strings := []string{"google", "runoob"}
        for i, s := range strings {
                fmt.Println(i, s)
        }


        numbers := [6]int{1, 2, 3, 5}
        for i,x:= range numbers {
                fmt.Printf("第 %d 位 x 的值 = %d
", i,x)
        }  
}

数组

var variable_name [SIZE] variable_type

package main

import "fmt"

func main() {
   var i,j,k int
   // 声明数组的同时快速初始化数组
   balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

   /* 输出数组元素 */         ...
   for i = 0; i < 5; i++ {
      fmt.Printf("balance[%d] = %f
", i, balance[i] )
   }
   
   balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
   /* 输出每个数组元素的值 */
   for j = 0; j < 5; j++ {
      fmt.Printf("balance2[%d] = %f
", j, balance2[j] )
   }

   //  将索引为 1 和 3 的元素初始化
   balance3 := [5]float32{1:2.0,3:7.0}  
   for k = 0; k < 5; k++ {
      fmt.Printf("balance3[%d] = %f
", k, balance3[k] )
   }
}

Go语言结构体

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

切片

内置类型切片（动态数组）

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

也可以简写为

slice1 := make([]type, len)

定义一个切片

声明一个未指定大小的数组

var identifier []type

使用make创建

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

也可以简写为

slice1 := make([]type, len)

len() 和 cap()

切片是可索引的，并且可以由 len() 方法获取长度。

切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)

   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v
",len(x),cap(x),x)
}

append() 和 copy() 函数

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)

   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)

   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)

   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)

   /* 创建切片 numbers1 是之前切片的两倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)

   /* 拷贝 numbers 的内容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)  
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v
",len(x),cap(x),x)
}

Range

range用于for循环中的迭代

package main
import "fmt"
func main() {
    //这是我们使用range去求一个slice的和。使用数组跟这个很类似
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)
    //在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }
    //range也可以用在map的键值对上。
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s
", k, v)
    }
    //range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

Map无序的键值对集合

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

package main

import "fmt"

func main() {
    var countryCapitalMap map[string]string /*创建集合 */
    countryCapitalMap = make(map[string]string)

    /* map插入key - value对,各个国家对应的首都 */
    countryCapitalMap [ "France" ] = "巴黎"
    countryCapitalMap [ "Italy" ] = "罗马"
    countryCapitalMap [ "Japan" ] = "东京"
    countryCapitalMap [ "India " ] = "新德里"

    /*使用键输出地图值 */
    for country := range countryCapitalMap {
        fmt.Println(country, "首都是", countryCapitalMap [country])
    }

    /*查看元素在集合中是否存在 */
    capital, ok := countryCapitalMap [ "American" ] /*如果确定是真实的,则存在,否则不存在 */
    /*fmt.Println(capital) */
    /*fmt.Println(ok) */
    if (ok) {
        fmt.Println("American 的首都是", capital)
    } else {
        fmt.Println("American 的首都不存在")
    }
}

delete() 函数

delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key。实例如下

delete(countryCapitalMap, "France")

接口

 

错误处理

并发

只需要通过 go 关键字来开启 goroutine 即可

通道（channel）