Go学习之路（一）变量、常量、数据类型

Go的测试文件写法：
1、源码文件以_test结尾：xxx_test.go
2、测试方法名以 Test 开头：func TestXXX(t *testing.T){...}

Go的25个关键字或保留字

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
Go 的 36 个预定义标识符
append	bool	byte	cap	close
-	-	-	-	-
copy	false	float32	float64	imag
int 32	int64	iota	len	make
print	println	real	recover	string

Go 的数据类型

• 布尔型
• 数字类型
  • 整数型
    • uint8 无符号 8 位整数型(0 到 255)
    • uint16 无符号 16 位整数型(0 到 65535)
    • uint32 无符号 32 位整数型(0 到 4294967295)
    • uint64 无符号 64 位整数型(0 到 18446744073709551615)
    • int8 有符号 8 位整数(-128 到 127)
    • int16 有符号 16 位整数(-32768 到 32767)
    • int32 有符号 32 位整数(-2147483648 到 2147483647)
    • int64 有符号 64 位整数(-923372036854775808 到 923372036854775807)
  • 浮点型
    • float32 IEEE-754 32位浮点型数
    • float64 IEEE-754 64位浮点型数
    • complex64 32 位实数和虚数
    • complex128 64 位实数和虚数
  • 其他数字类型
    • byte 类似 uint8
    • rune 类似 int32
    • uint 32或64位
    • int 与 uint 一样大小
    • uintptr 无符号整型，用于存放一个指针
• 字符串类型
• 派生类型
  • 指针类型(Pointer)
  • 数组类型
  • 结构化类型(struct)
  • Channel 类型
  • 函数类型
  • 切片类型
  • 接口类型(interface)
  • Map 类型

Go与其他主要变成语言的差异

• 赋值可以进行自动类型推断
• 在一个赋值语句中可以对多个变量进行同时赋值

变量声明方法：

  // 第一种书写方法变量声明   var 变量名 类型 = 值
      var a int = 1  
      var b int = 1
    // 第二种书写方法     这种写法在
    var (
        a int =1
        b int = 1
  )
    
  // 第三种书写方法   这种方法用了go的类型推断，和Python相似
  a :=1
  b :=1
  a,b,c := 1,2,"str"

实现一个小demo
斐波那锲

  package main
  import (
    "fmt"
    "testing"
  )
  func TestFibList(t *testing.T){
    var a int = 1
    var b int = 1
    fmt.Println(a)
    for i :=0; i < 5; i++{
      fmt.Println(" ",b)
      tmp := a
      a = b
      b = tmp + a
     }
    fmt.Println()
  }

交换两个变量的值

func TestExchange(t *testing.T){
  a := 1
  b := 1
  tmp := a
  a = b
  b = tmp  
}
// 第二种方法(这种方法必须是两个变量的类型相同)
a,b = b,a 

_ 实际上是一个只写变量，你不能得到他的值，这样做是因为Go语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。

package main
import "fmt"
func main(){
  numb,_,str1 := numbers()
  fmt.Println(numb,str1)   // 这里如果打印_就会报错
}

func numbers()(int,int,string){     // 这里的第二个括号中是返回的数据类型
  a,b,c := 1,2,"str"
  return a,b,c
}
// 输出结果：
2 str

常量

常量的定义格式：

const identifier [type] = value
const a string = "abc"    // 显示类型定义
const b = "abc"    // 隐式类型定义
// 多个相同类型的声明
const name1,name2 = "abc","ace"

常量名一般默认是全大写
举个栗子：

package main
import "fmt"
func main(){
  const LENGTH int = 10
  const WIDTH int = 5
  var area int
  const a,b,c = 1, false, "str"    // 这个是个多重赋值
  area = LENGTH * WIDTH
  fmt.Printf("面积为 : %d", area)
  println()
  println(a,b,c)
}
// 运行结果
面积为 : 50
1 false str

iota

iota 特殊常量，可以认为是一个可以被编译器修改的常量
iota 在 const 关键字出现时将被重置为0(这个重置为0是在 const 内部的第一行之前，如果是在别的行，那就是恢复为几减一，如const中第七个数，再次出现iota则会恢复为6)，const 中每新增一行常量声明将使 iota 计数一次( iota 可以理解成 const 语句块中的行索引)。

// 第一种写法
const(
  a = iota
  b = iota
  c = iota
)
// 第二种写法
const(
  a = iota
  b
  c
)
// 运行结果：
a = 0, b = 1, c = 2

举个栗子：

package main
import "fmt"
func main(){
  const(
    a = iota   // 这里是 0 
    b
    c
    d = "ha"   // 独立值，哈iota没关系，但是iota在这里会+1
    e             // "ha" iota+=1
    f = 100    // 同样是独立值 iota+=1
    g             // 100 iota+=1
    h = iota   // iota 恢复计数
    i
  )
  fmt.Println(a,b,c,d,e,f,g,h,i)
}

Go不支持隐式类型转换

// 错误的例子
package main
import "testing"
func TestImplicit(t *testing.T){
  var a int32 = 1
  var b int64
  b = a
  t.Log(a,b)
}
// 修改上面的错误
package main
import "testing"
func TestImplicit(t *testing.T){
  var a int32 = 1
  var b int64
  b = int64(a)
  t.Log(a,b)
}
// 自写类型
package main
import "testing"
type MyInt int64        // 这个就是自写类型
func TestImplicit(t *testing.T){
  var a int32 = 1
  var b int64
  b = int64(a)
  var c MyInt
  c = MyInt(a)     // 这里自写类型转换
  t.Log(a,b,c)
}

$\color{red}{Go不支持任何类型的隐式转换，也不支持元类型的隐式转换}$
$\color{red}{在Go语言中不支持指针运算}$
$\color{red}{Go的字符串指类型，他的初始化是空字符串，而不是空}$