基础类型

命名

Go语言中的命名遵循下面的几个规则

• 必须以字母或者是下划线开头
• 不能使用Go语言中的关键字 或者是预定义的名字
• 大小写表示的含义不同

Go语言中的关键字有下面25个

此外还有大约30多个预定义的名字

变量

变量就是程序运行中可以变化的量 它是所有编程语言的最基本组成元素

从根本上来说 变量就是对于一块空间的重命名 程序可以通过指针或引用等方式来修改该空间的内容 从而达到修改变量的效果

变量声明

Go语言和C/C++的变量声明有很大的不同

对于纯粹的变量声明 Go语言引入了一个关键字 var

而类型的信息放在变量名之后（类似于mysql的变量声明 ）

示例如下

package main     
    
import "fmt"    
    
func main(){    
  // 定义单个变量    
  var v1 int     
  var v2 int     
    
  // 一次定义多个变量 方式一    
  var v3 , v4 int     
  // 方式二    
  var (    
    v5 int     
    v6 int    
  )    
    
  fmt.Println(v1 , v2 , v3 , v4 , v5 , v6)                                                     
} 

需要注意的是 如果在Go语言中只声明 不定义 编译的时候也会报错

变量初始化

如果我们声明的变量需要初始化 我们var关键字依然可以保留 但是此时的var关键字不再是必要的元素了

package main    
    
import "fmt"    
    
func main(){    
  var a int = 10 // 初始化方式一  var 和 int都不省略    
  b int = 20 // 初始化方式二 省略var关键字    
  var c = 30 // 初始化方式三 编译器自动推导c的类型     
  d := 40 // 初始化方式四 编译器自动推导类型                                                        
} 

我们这里需要注意的是最后一种初始化方式

当我们使用 := 来初始化的时候有两点需要注意

• 表达式左边必须要是未声明的变量
• 定义时必须初始化

否则就会报错

变量赋值

变量赋值这块其实和C++中的赋值没有太大区别 语法也很常规

  var a int                                     
  a = 10;  // 常规赋值                          
                                                
  var b , c , d  int                           
  b , c, d = 20 , 30 , 40  // 多重赋值    

匿名变量

匿名变量是Go语言中很有意思的一个变量 它的变量名一般是下划线

交给下划线的值会被丢弃

它的用法如下

_, i, _, j := 1, 2, 3, 4

func test() (int, string) {
return 250, "sb"
}

_, str := test()

如果我们不想要函数返回值中的某些值 但是我们又必须要接受它 此时我们就可以使用匿名变量来解决

很多同学可能看到test函数有两个返回值而感到惊讶 没错 在Go语言中函数可以返回多个返回值 这也是Go语言的特点之一

常量

在Go语言中 常量是指在编译期间就确定 并且不可改变的值

常量可以是数值类型 布尔类型 字符串类型等

字面常量

一般是指程序中硬编码的常量 比如

  _ = 3.12     
  _ =3                                                                                              
  _ = "hello"    
  _ = true 

注意 我们这里使用匿名变量的原因其实上面也说过了 因为go语言不允许常量或者变量未使用

常量定义

Go语言定义常量的关键字和C++一样 也是const

并且const关键字也是放在最前面修饰

代码表示如下

const  a int = 20 

需要注意的是 我们常量定义时不能够使用var关键字

iota枚举

常量声明可以使用iota常量生成器初始化 它用于生成一组以相似规则初始化的常量

它有下面几个特点

1. 在第一个常量所在的行 iota 它将会被设置为0 （注意这里说的是行 也就是说 只要是同一行 值就是一样的 这个后面代码会演示）
2. 每往后一行的常量声明 iota值加一
3. 在碰到下一个const时候 iota值会被重置为0
4. iota在一组声明中可以省略

下面我们会用代码依次验证上面的概念

iota生成器会依次加一

func test4(){    
  const (    
    a = iota     
    b = iota                                                                                        
    c = iota     
  )    
    
  fmt.Println(a , b, c)    
} 

iota在一组声明中可以省略

  const (                         
    a = iota                      
    b = iota                      
    c = iota                      
    d    // 这里省略了 iota 其实 b c后面的 iota也可以省略                                           
  )                                                           
    
  fmt.Println(a , b, c , d)   

在碰到下一个const时候 iota值会被重置为0

  const (    
    a = iota     
    b = iota     
    c = iota     
    d    // 这里省略了 iota 其实 b c后面的 iota也可以省略    
  )    
    
  const e = iota     
    
  fmt.Println(a , b, c , d , e)   

只要是同一行 值就是一样的

func test4(){    
  const (    
    a = iota     
    b = iota     
    c = iota     
    d    // 这里省略了 iota 其实 b c后面的 iota也可以省略    
  )    
    
  const e = iota     
    
  const f , g, h = iota , iota , iota                                                               
  fmt.Println(a , b, c , d , e , f , g, h)    
} 

基础数据类型

分类

Go语言的基础数据类型和C++差不多 唯一值得说的也就是一个布尔类型和一个复数类型

bool类型

package main

import "fmt"


func test(){
  var a bool 
  a = true;

  fmt.Println(a)
}


func main(){
  test()
}

需要注意的是 在Go语言中 bool类型的数据只能被赋值true或者false 不能被赋值整形数据 否则会报错

	var a bool
	a = true

	a = 1 // 报错

复数类型

复数由两个实数 在计算机中由浮点数组成 一个表示实部 一个表示虚部

它有下面几种定义方式

func test2(){
  var v1 complex64 
  v1 = 3.2 + 12i
  v2 := 3.2 + 12i
  v3 := complex(3.2 , 12) // 注意 这是不是12i 而是12

  fmt.Println(v1 , v2 , v3)
}

此外我们可以通过 real 和 imag函数来获取一个函数的实部和虚部

  fmt.Println(real(v1) ,  imag(v1)) // 我们可以使用real 和 imag来获取一个复数的实部 和 虚部

fmt包的标准输入输出

格式说明

格式	含义
%b	输出二进制数字
%%	只输出一个%
%c	输出一个字符
%T	输出Go语法输出值的类型
%t	输出bool类型

使用方式如下

	// 整形
	a := 15
	fmt.Printf("a = %b\n" , a) // %b 二进制 1111
	fmt.Printf("%%\n") // 只输出一个%

输入

我们在Go语言中一般会使用Scan函数来进行输入

func test2(){
	// 演示输入
	var a int 

	fmt.Println("请输入一个整数")
	fmt.Scan(&a)
	fmt.Println(a)
}

类型转换

Go语言中不允许隐式类型转换 所有的类型转换必须显示声明

代码如下

	// 类型转换 
	// Go语言中不允许隐式类型转换 所有类型转换必须显式声明
	var a int 
	a = 3.14  // err

如果我们想要类型转换必须要显示的强制转换

	var a int 
	// a = 3.14  // err
	var ch byte = 97
	a = int(ch) // correct

类型取别名

在Go语言中 我们使用type关键字来给一个类型取别名

代码表示如下

	type bigint int // 给int取别名bigint

	var a bigint = 20

如果想一次性给多个类型取别名我们可以这么做

	type(
		bigdouble double
		tinyint int8
	)