golang基础（1）-阿里云开发者社区

一 ,基础语法

1.1 什么是go语言

高性能高并发
语法简单,学习曲线平缓
丰富的标准库
完整的工具链
静态链接
快速编译
跨平台
也有很强大的交叉编译特性,笔记本上编译的软件树莓派也可以运行
垃圾回收

课前准备

安装 Go 语言

访问 https://go.dev/ ，点击 Download ，下载对应平台安装包，安装即可
如果无法访问上述网址，可以改为访问 https://studygolang.com/dl 下载安装
如果访问 github 速度比较慢，建议配置 go mod proxy，参考 https://goproxy.cn/ 里面的描述配置，下载第三方依赖包的速度可以大大加快

go run 运行

go build 编译和运行

函数上悬浮一秒钟可以得到在线文档的连接

基础语法

init函数和导包

他是在main函数执行之前执行用来初始化

package main
import (
  "go/gostudy/init/lib1"
  "go/gostudy/init/lib2"
)
func main() {
  lib1.Lib1Test()
  lib2.Lib1Test()
}

导包的时候需要从根目录写起,或者是从gopath写起

还有对外提供的函数必须是大写,小写的函数只能在包内所使用

导入包却不使用会自动给清除,所以可以匿名使用,使得init函数能正常调用

方法是包前面加个_

起别名

包前面加上别名即可

变量和常量

使用var 或者:=定义变量

使用const 定义常量

func main() {
  var a = "initial"
  var b, c int = 1, 2
  var d = true
  var e float64
    
    //多行进行变量声明
    var (
        vv int =  100
        ss boool = ture 
    )
  f := float32(e)
//只能用在函数体内
  g := a + "foo"
  fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
  fmt.Println(g)                // initialapple
    //声明常量(只读)
  const s string = "constant"
  const h = 500000000
  const i = 3e20 / h
    
    //使用常量来定义枚举,第一个是0 然后依次累加,iota只能配合const来使用
const (
  BEIJING = iota
  SHANGHAI
  SHENZHEN
)
  fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}

golang中的常量没有类型,它根据使用的上下文自动推断类型

if else

package main
import "fmt"
func main() {
  if 7%2 == 0 {
    fmt.Println("7 is even")
  } else {
    fmt.Println("7 is odd")
  }
  if 8%4 == 0 {
    fmt.Println("8 is divisible by 4")
  }
  if num := 9; num < 0 {
    fmt.Println(num, "is negative")
  } else if num < 10 {
    fmt.Println(num, "has 1 digit")
  } else {
    fmt.Println(num, "has multiple digits")
  }
}

if中没有小括号

数组

package main
import "fmt"
func main() {
  var a [5]int
  a[4] = 100
  fmt.Println("get:", a[2])
  fmt.Println("len:", len(a))
  b := [5]int{1, 2, 3, 4, 5}
  fmt.Println(b)
  var twoD [2][3]int
  for i := 0; i < 2; i++ {
    for j := 0; j < 3; j++ {
      twoD[i][j] = i + j
    }
  }
  fmt.Println("2d: ", twoD)
}

package main
import "fmt"
func main() {
  var list [10]int
  for i := 0; i < len(list); i++ {
    list[i] = i + 5
  }
  for _, value := range list {
    fmt.Println(value)
  }
}

变量数组可以使用 range

如果不想报定义的变量未使用,可以使用_来接收

切片

package main
import "fmt"
func main() {
  s := make([]string, 3)
  s[0] = "a"
  s[1] = "b"
  s[2] = "c"
  fmt.Println("get:", s[2])   // c
  fmt.Println("len:", len(s)) // 3
  s = append(s, "d")
  s = append(s, "e", "f")
  fmt.Println(s) // [a b c d e f]
  c := make([]string, len(s))
  copy(c, s)
  fmt.Println(c) // [a b c d e f]
  fmt.Println(s[2:5]) // [c d e]
  fmt.Println(s[:5])  // [a b c d e]
  fmt.Println(s[2:])  // [c d e f]
  good := []string{"g", "o", "o", "d"}
  fmt.Println(good) // [g o o d]
    
    
}

使用make([]类型,长度)

实际上是存储了一个长度+容量+一个指向数组的指针

//将s1的内容拷贝到s2,深拷贝
  s2 := make([]int, 3)
  copy(s2, s1)

package main
import "fmt"
func main() {
  s1 := make([]int, 3, 5)
  fmt.Printf("len= %d,cap=%d", len(s1), cap(s1))
}

map

package main
import "fmt"
func main() {
    //实现定好容量
    m1:=make(map[string]int,3)
    
  m := make(map[string]int)
  m["one"] = 1
  m["two"] = 2
  fmt.Println(m)           // map[one:1 two:2]
  fmt.Println(len(m))      // 2
  fmt.Println(m["one"])    // 1
  fmt.Println(m["unknow"]) // 0
  r, ok := m["unknow"]
  fmt.Println(r, ok) // 0 false
  delete(m, "one")
  m2 := map[string]int{"one": 1, "two": 2}
  var m3 = map[string]int{"one": 1, "two": 2}
  fmt.Println(m2, m3)
    
    //遍历
    for key , value := range cityMap {
fmt.Println("key = ", key)fmt.Println("value = ", value)
}
    
    //删除
delete(cityMap,"China")
//修改
cityMap ["USA"] = "DC"
}

语法是make(map[key的类型]value的类型)

获取map的值时在后面加上ok判别map中是否有这个key存在

golang中的map是完全无序的

cap表示之后每次扩容的距离

range

package main
import "fmt"
func main() {
  nums := []int{2, 3, 4}
  sum := 0
  for i, num := range nums {
    sum += num
    if num == 2 {
      fmt.Println("index:", i, "num:", num) // index: 0 num: 2
    }
  }
  fmt.Println(sum) // 9
  m := map[string]string{"a": "A", "b": "B"}
  for k, v := range m {
    fmt.Println(k, v) // b 8; a A
  }
  for k := range m {
    fmt.Println("key", k) // key a; key b
  }
}

range 可以遍历数组和map 遍历数组时返回的两个值是索引和数组中的值,遍历map的时候两个值是key和value

函数

package main
import "fmt"
func add(a int, b int) int {
  return a + b
}
//返回多个值有形参名称的,这样只需要给这形参名称赋值,最后只return 空就行
func fool(a string, b int) (c int, d string, f string) {
  fmt.Println("a= ", a)
  fmt.Println("b= ", b)
  c = b
  d = a
  f = "hello"
  return
}
func add2(a, b int) int {
  return a + b
}
func exists(m map[string]string, k string) (v string, ok bool) {
  v, ok = m[k]
  return v, ok
}
func main() {
  res := add(1, 2)
  fmt.Println(res) // 3
  v, ok := exists(map[string]string{"a": "A"}, "a")
  fmt.Println(v, ok) // A True
}

变量类型是后置的,原生支持返回多个值

指针

package main
import "fmt"
func add2(n int) {
  n += 2
}
func add2ptr(n *int) {  //传入一个地址类型的值
  *n += 2   //获取地址里面的内容
}
func main() {
  n := 5
  add2(n)
  fmt.Println(n) // 5
  add2ptr(&n) //这里取地址
  fmt.Println(n) // 7
}

golang基础（2）https://developer.aliyun.com/article/1530652

golang基础（1）