Golang基础

最新推荐文章于 2025-09-05 14:44:44 发布

weixin_30879169

最新推荐文章于 2025-09-05 14:44:44 发布

阅读量64

点赞数

CC 4.0 BY-SA版权

文章标签： golang python 数据结构与算法

原文链接：http://www.cnblogs.com/yfife/p/9012898.html

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 //赋值操作
  }

数值类型

整数类型有无符号和带符号两种。有符号：rune, int8, int16, int32, int64;无符号：byte, uint8, uint16, uint32, uint64。其中rune是int32的别称，byte是uint8的别称
浮点数的类型有float32和float64两种，默认是float64
复数，默认类型为complex128（64位实数 + 64位虚数），complex64(32位实数 + 32位虚数);复数形式：RE + IMi
```
 var c complex64 = 5 + 5i
```
这些类型的变量之间不允许互相赋值或操作，不然会在编译时引起编译器报错

字符串

声明

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

Go中字符串是不可改变的

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

如何改变字符串

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

字符串连接+
字符串切片s[start: end]
声明多行的字符串
```
 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
  )

数组

声明

 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

在很多应用场景中，数组并不能满足我们的需求。在初始定义数组时，我们并不知道需要多大的数组，因此我们需要“动态数组”。在GO里面这种数据结构叫slice

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:]

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 //赋值