Golang基础

Go语言基础

关键字

break, default, func, interface, select

case, defer, go, map, struct

chan, else, goto, package, switch

const, fallthrough, if, range, type

continue, for, import, return, var

定义变量

• var variablename type = value
• var vname1, vname2, vname3 type = v1, v2, v3
• 可以忽略类型声明，Go会根据相应值得类型来初始化：var vname1, vname2, vname3 = v1, v2, v3
• 继续简化:vname1, vname2, vname3 := v1, v2, v3, :=取代了var和type，这种形式叫做简短声明。不过它有一个限制，只能用在函数内部；在函数外部使用则会无法编译通过，所以一般用var定义全局变量
• _下划线是一个特殊的变量名，任何赋予它的值都会被丢弃：_, b := 1, 2
• Go对已声明但未使用的变量会在编译阶段报错

  package main
  
  func main() {
      var i int //报错，声明了i但未使用
  }

  常量

• 常量可以定义为数值、布尔值或字符串等类型

  const constantName = value
  //如果需要也可以明确指定常量的类型
  const Pi float32 = 3.1415926

  内置基础类型

• Boolean

  var isActive bool //全局变量
  var enable, disable = true, false //忽略类型的声明
  func test() {
      var available bool //一般声明
      valid := false //简短声明
      vaailable = true //赋值操作
  }

• 数值类型

1. 整数类型有无符号和带符号两种。有符号：rune, int8, int16, int32, int64;无符号：byte, uint8, uint16, uint32, uint64。其中rune是int32的别称，byte是uint8的别称
2. 浮点数的类型有float32和float64两种，默认是float64
3. 复数，默认类型为complex128（64位实数 + 64位虚数），complex64(32位实数 + 32位虚数);复数形式：RE + IMi

   var c complex64 = 5 + 5i

4. 这些类型的变量之间不允许互相赋值或操作，不然会在编译时引起编译器报错

• 字符串

1. 声明

   var sName string //声明变量为字符串的一般方法
   var sName1 string = "" //声明一个字符串变量，并赋值为空
   func test() {
       a, b, c := "no", "yes", "maybe"//简短声明
   }

2. Go中字符串是不可改变的

   var s string = "hello"
   s[0] = "c" //cannot assign to s[0]

3. 如何改变字符串

   s := "hello"
   c := []byte(s) //将字符串 s 转换为 []byte 类型
   c[0] = "c"
   s2 := string(c) //再转换为 string 类型
   fmt.Printf("%s\n", s2)

4. 字符串连接+
5. 字符串切片s[start: end]
6. 声明多行的字符串

   m := `hello
           world`

• 分组声明

  import(
      "fmt"
      "os"
  )
  const(
      i = 100
      pi = 3.1415
      s = "hello"
  )
  var(
      i int
      pi float32
      s string
  )

• iota枚举，这个关键字用来声明enum时使用，默认开始值为0，const中每增加一行加1

  package main
  
  import (
      "fmt"
  )
  
  const (
      x = iota // x == 0
      y = iota // y == 1
      z = iota // z == 2
      w //常量声明省略值时，默认和之前一个值的字面意思相同。这里隐式表达`w = iota`，因此`w == 3`。
  )
  
  const v = iota //每遇到一个const关键字，iota就会重置，此时v == 0
  
  const (
      h, j, k = iota, iota, iota //h==0, j == 0, k == 0 iota在同一行
  )
  
  const (
      a = iota // a == 0
      b = "hi"
      c = iota // c == 2
      d, e, f := iota, iota, iota // d == 3, e == 3, f == 3
      g = iota // g == 4
  )

• 数组

1. 声明

   var arr [n]type //n-->length, type-->存储元素的类型
   a := [3]int{1, 2, 3} //声明一个长度为3的int数组
   b := [10]int{1, 2, 3} //声明一个长度为10的int数组，其中前三个元素赋值1、2、3，其他默认为0
   c := [...]int{4,5,6} //省略长度，go会根据元素个数来计算长度
   twoDarr := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}} //声明二维数组
   simple := [2][4]int{{1,2,3,4},{5,6,7,8}} //简化声明，忽略内部类型

• slice

1. 在很多应用场景中，数组并不能满足我们的需求。在初始定义数组时，我们并不知道需要多大的数组，因此我们需要“动态数组”。在GO里面这种数据结构叫slice
2. slice并不是真正意义上的动态数组，而是一个引用类型。slice总是指向一个底层array，slice的声明也可以像array一样，只是不需要长度

   var fslice []int //和声明数组一样，只是少了长度
   //声明一个slice，并初始化数据
   slice := []byte{"a", "b", "c", "d"}
   //slice可以从一个数组或一个已经存在的slice中再次声明
   var arr = [6]byte{"a", "b", "c", "d", "e", "f"}
   var a, b []byte
   a = arr[1:3]
   b = arr[3:]

3. slice内置函数

   len获取slice长度

   cap获取slice容量

   append向slice里面追加一个或多个元素，然后返回一个和slice一样类型的slice

   copy函数复制从源slice的src中复制元素到目标dst，并且返回复制的元素的个数

   append函数会改变slice所引用的数组的内容，从而影响到引用同一数组的其他slice

   //三参数的slice
   var arr [10]int
   slice := arr[2:4] //slice的容量为10-2=8
   newSlice := arr[2:4:7] //slice的容量为7-2=5，无法访问最后的三个元素

• map格式为map[keyType]valueType,和python中字典的概念类似

  //声明一个key是字符串，值为int的字典，这种方式的声明需要在使用之前使用make初始化
  var number map[string]int
  //另一种map的声明方式
  numbers = make(map[string]int)
  numbers["one"] = 1 //赋值

1. map是无序的，每次打印出来的map都会不一样，必须通过key获取
2. 长度不固定，是一种引用类型，如果两个map同时指向一个底层，那么一个改变，另一个也相应改变
3. 内置的len函数同样适用于map，返回map拥有的key的数量
4. 可以通过delete删除map的元素

• make和new操作

  make用于内建类型(map,slice,channel)的内存分配。new用于各种类型的内存分配

原文地址：https://www.cnblogs.com/yfife/p/9012898.html