GO变量、数据类型与方法

# 1、Go的变量

变量三部曲：声明、赋值、输出

package main
import "fmt"
func main() {
    //声明变量
    var i int 
    //变量赋值
    i = 5
    //输出变量
    fmt.Println("i=", i)

    //内部变量声明:=,只能用于局部变量（方法内部）,会自动类型推断（int/float64)，至少有一个新变量，若没有新变量生成，报错
    a := 12
    //i:= 12 //报错，i并不是一个新变量
    fmt.Println(a)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

i=5
12

1、go会自己做类型推断，如果定义变量时后面加上相关类型的值，声明的类型会变灰色。

  package main
  import "fmt"
  func main() {
    var i int = 10 //此时声明int会变灰色
    var a uint = 15 //此时uint不会变成灰色，因为声明后不加uint类型，15会被解释为int类型
  }

1
2
3
4
5
6

2、go为强类型语言，不会帮忙转换任何类型，任何没有用到的声明都会报错。

  package main
  import "fmt"
  func main() {
    var i int = 10 
    var a uint = 15 
    //fmt.Println(a == c) //这句话无法编译
  }

1
2
3
4
5
6
7

3、支持的类型推断

1）若为整数，默认类型为int型

2）若为浮点数，默认类型为float64型

4、同作用域下，同名变量声明只能一次；包外包内重复声明，会从包外变量变为私有变量，后续逻辑按照私有变量值赋值操作。

package main
import "fmt"
var aa string = "aaa"
func main() {
  var i int = 10 
  fmt.Println(i)
  i = 15 //赋予新值，不报错
  //i := 16 重复声明，报错

  var aa int = 14 
  fmt.Println(aa)
  
}

1
2
3
4
5
6
7
8
9
10
11
12
13

10
14

包变量的替代方法：依赖注入

# 2、Go的常量

总体与变量无异，但常量无法修改值！

  package main
  import "fmt"
  const internal = "包内可访问"
  const External = "包外可访问"

  func main() {
    const a = "你好"
    fmt.Println(a)
  }

1
2
3
4
5
6
7
8
9

你好

特殊常量iota：控制常量初始化

  package main
  import "fmt"
  const(
    StatusA = iota //默认为0，每次+1
    StatusB //默认为1 
    StatusC 
    
    StatusD = 6 //插入一个主动赋值就会中断
    StatusE //默认为6，重头开始计算
  )
  //可以使用数学运算，包括位移操作
  const(
    One = iota << 1 //默认为0，每次左移一位，重新赋值
    Two // 默认为2
    Three //默认为4

  )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 3、Go的数据类型

1、基本类型

int： int8、int16、int32、int64、int。int8~int64在内存中分别用1、2、4、8个字节来表达。而int用几个字节则取决于CPU。大多用的是8字节（int64）。

uint： uint8、uint16、uint32、uint64、uint。无符号整数，类似于int，优先使用uint。

float： float32、float64。浮点数，优先使用float64。

2、运算符

加（+/自增++）

  package main
  import "fmt"
  func main() {
    var a int = 456
    var b int = 123
    fmt.Println(a + b)
}

1
2
3
4
5
6
7

578

减（-/自减--）

  package main
  import "fmt"
  func main() {
    var a int = 456
    var b int = 123
    fmt.Println(a - b)
}

1
2
3
4
5
6
7

333

乘（*）

  package main
  import "fmt"
  func main() {
    var a int = 45
    var b int = 3
    fmt.Println(a * b)
}

1
2
3
4
5
6
7

135

除（/）

  package main
  import "fmt"
  func main() {
    var a int = 45
    var b int = 3
    if b != 0 {
      fmt.Println(a / b)
    }
    else 
      fmt.Println("分母不可以为0！")
}

1
2
3
4
5
6
7
8
9
10
11

15

取余（%）

  package main
  import "fmt"
  func main() {
    var a int = 88
    var b int = 3
    if b != 0 {
      fmt.Println(a % b)
    }
    else 
      fmt.Println("分母不可以为0！")
}

1
2
3
4
5
6
7
8
9
10
11

1

1. string

双引号版：如果在字符串里面的双引号需要用\进行转义。

 package main
   func main() {
     fmt.Println("He said:\"hello,go!\"") 
 }

1
2
3
4

He said:"hello,go!"

反引号版：可以换行，但是内部不可以有反引号。

 package main
   func main() {
     fmt.Println(`我可以换行
     这是新的行
     但是这里不可以有反引号
     `) 
 }

1
2
3
4
5
6
7

我可以换行
这是新的行
但是这里不可以有反引号

1. byte

字节，本质是uint8.用它表示ASCII字符。较经常使用为[]byte，即byte切片。

  package main
    func main() {
      var a byte = 'a'
      fmt.Println(a)
      fmt.Println(fmt.Sprintf("%c",a)) 
  }

1
2
3
4
5
6

97
a

注意：[]byte和string可以互相转换。

```go
package main
  func main() {
    var str string = "this is string"
    var bs []byte = []byte(str) //类型转换
    fmt.Println(str,bs)
}
```

this is string [116 104 105 115 32 105 115 32 115 116 114 105 110 103] // 后面是ASCII码转码

1. bool

布尔类型，true 或者 false。

运算规则：AND (&&)、OR （||）、取反（!）

  package main

  import "fmt"

  func main() {
      var a bool = true
      var b bool = false
      var c bool = a && b
      fmt.Println(c)
      var d bool = a || b
      fmt.Println(d)
      var e bool = !a
      fmt.Println(e)
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

false
true
false

相关注意事项

数学基本运算包：math包。string基本运算包：strings包。byte基本运算包：bytes包。
运算相关注意事项：只有同类型才可以执行加减乘除！（Go没有自动类型转换）

  package main
  import "fmt"
    func main() {
      var a int = 88
      var b float64 = 3.5
      fmt.Println(a + b) //编译不通过
      var c int32 = 12
      fmt.Println(a + c) //编译不通过
  }

1
2
3
4
5
6
7
8
9

string相关注意事项：长度特殊。字节长度：和编码无关，用len(str)获取。字符数量：和编码无关，用编码库来计算，默认情况下使用utf8库。
```
package main
import "fmt"
  func main() {
    fmt.Println(len("你好")) 
    fmt.Println(utf8.RuneCountInString("你好")) 
}
```
1
2
3
4
5
6
6
2

# 4、Go的方法签名（方法声明signature）

1）关键字func

2）方法名：首字母大写决定了作用域,首字母大写，可以全局访问，首字母小写，只能在这个包里访问。

3）参数列表：[<name type>]

4）返回列表：[<name type>]

方法格式：名字+参数列表+返回值。

# （1）返回值

  package main
  import "fmt"
  func count() {
    fmt.Println("总数为1") 
  }

1
2
3
4
5

可以有多个返回值，并且返回值可以有名字。方法没有重载的特性，同一个包中不可以有同样的方法名字。

若返回值带名字，在方法中即可生效，并且若返回多个值须都带名字；若没带，则在return时才生效。

  package main
  //单一返回值
  func Func0(name string) string {
    return "Hello World"
  }
  //多个返回值
  func Func1(a,b,c int.str1 string) (string,error){
    return "",nil
  }
  //带名字的返回值
  func Func2(a int, b,int) (str string,err error){
    str = "hello"
    return 
  }
  //带名字的返回值(赋值情况)
  func Func3(a int, b,int) (str string,err error){
    res := "hello"
    return res,nil
  }
  //没有重载的特性，同一个包中不可以有同样的方法名字 
  //func Func3(a int) (str string,err error){
    //res := "hello"
    //return res,nil
  //}
  //若返回值带名字，若返回多个值须都带名字，否则报错
  //func Func4(a int) (str string, error){
    //res := "hello"
    //return res,nil
  //}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# （2）接收返回值（方法调用）

方法调用只需要用足够的参数去接收返回值，并传入调用参数即可。

返回多个返回值时，如果想忽略一些返回值，可以使用**_**即可。

  package main
  import "fmt"
  func Func2(a int, b,int) (str string,err error){
    str = a + b
    return 
  } 
  func Invoke() {
    str, err := Func2(1,2)
    fmt.Println(str,err)
    //忽略返回值 
    _ , _ = Func2(1,3)
    //忽略部分的返回值
    str , _ = Func2(1,3)
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14

编辑

← Hello World GO版 GO的基础语法→

GO变量、数据类型与方法

# 1、Go的变量

# 2、Go的常量

# 3、Go的数据类型

# 4、Go的方法签名（方法声明signature）

# （1） 返回值

# （2）接收返回值（方法调用）

# （1）返回值