从零开始学GO ---- 变量、常量、基本数据类型

从零开始学GO ---- 变量、常量、基本数据类型

第一个GO程序：hello world

代码如下：

package main // 声明 main 包，表明当前是一个可执行程序

import "fmt" // 导入内置 fmt 包

func main() { // main函数，是程序执行的入口
	fmt.Printf("Hello World!") // 在终端打印 Hello World!
}

然后执行： go build hello.go 进行编译，之后便可以看到有一个exe文件，可以直接运行。

一些细节：

• 声明main包，表示当前是一个可执行程序
• 通过import导入其他包，fmt是标准输入输出包，包含有Print函数
• main函数表示程序入口，并且main函数所在的包名必须是main
• 函数以func开头

变量和常量

变量

显示变量声明：var vatName dateType [= value]

其中，var是关键字，用于变量声明，varName是变量名字，dateType表示数据类型，value是初始值，初始值可以是字面量，也可以是其他变量名或者表达式，不显示初始化的话将默认为零值。

tips：GO的变量声明后将立即分配空间

var number int = 1
var name string = "jessy"

//也可以利用类型推导将变量的类型省略
var name, age = "Q1mi", 20

短类型变量声明： varName := value

只能在函数内部短类型声明，可以使用更简略的 := 方式声明并初始化变量 ，GO编译器将自动类型推断

//...
func main() {
	n := 10
	m := 200 // 此处声明局部变量m
	//...
}

匿名变量：在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。 匿名变量用一个下划线_表示

func function() (int, string) {
	return 10, "string"
}
func main() {
	x, _ := function()
	_, y := function()
	fmt.Println("x=", x)
	fmt.Println("y=", y)
}

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。_多用于占位，表示忽略值

常量

常量使用一个名称绑定一个内存地址，该内存地址存储的数据类型和内容声明后不可以再变。

//变量前加const就表示常量声明
const pi = 3.1415
const e = 2.7182

//可以声明多个变量
const (
    pi = 3.1415
    e = 2.7182
)
//const同时声明多个常量时，如果省略了值则表示和上面一行的值相同
const (
    n1 = 100
    n2
    n3
)       //则n2 n3都是100

预声明标识符iota用在常量声明中，初始值为0，一组多个变量同时声明时其值逐行增加，专门用来初始化常量

const (
	c0=iota  //c0==0
	c1=iota  //c1==1
	c2=iota  //c2==2
)
//  <===>  等价于
const(
	c0=iota   //c0==0
    c1        //c1==1
    c2        //c2==2
)
//iota是逐行增加的
const(
	a=1<<iota  // iota==0,so a==1
    b=1<<iota  // iota==1,so b==2
    c=3        //c==3  and iota==3
    d=1<<iota  //iota==3,so d==8
)

基本数据类型

布尔型

Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true和false，并且在Go语言中，布尔型数据和整型数据不可以相互转换，如果声明的布尔型不进行初始化，则默认为false

var a bool=true
var b bool=(x>y)&&(x>0)

整型

Go语言内置了12种整数类型， 分别是：int8、int16、int32、int64 对应的有符号整型，和uint8、uint16、uint32、uint64对应的无符号整型，以及byte，int，uint，uintptr。

byte是unit8的别名，int和uint表示整数类型，受特定 CPU 平台的字长影响。

类型	描述
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位整型 (-9223372036854775808 到 9223372036854775807)

浮点型

Go语言支持两种浮点型数：float32和float64

使用浮点数要注意，浮点数字会被自动推断为float64类型，并且使用浮点数不应该使用==或 != 来进行比较，而应该采用一个精度的大小比较去判断，高精度要求应该采用math标准库。

var b :=10.00  //会被推断为float64
var a float32=1.2

打印浮点数时，可以使用fmt包配合%f进行格式化输出

fmt.Printf("%f\n", math.Pi)  //3.141593
fmt.Printf("%.2f\n", math.Pi) //3.14

复数类型

Go语言内置的复数类型有两种：complex64和complex128,复数在计算机中用两个浮点数表示，一个表示实部一个表示虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。

var value1 complex64=3.2+14i
var value2 =2+10i

Go的复数类型有三个内置函数：complex real imag，分别用于构建复数、返回实部、返回虚部

var v=complex(2.1,3)  //构造复数
a:=real(v)   //a=2.1
b:=imag(v)   //b=3

字符串

Go语言将字符串作为一种原生的基本数据类型，可以直接使用字符串字面量来进行初始化。

• 字符串是常量，可以通过索引访问，但是不能修改某个字节的值

  var a ="hello world!"
  b:=a[0]
  a[1]='a'  //错误，不可以修改某字节的值
  

• 字符串尾部不包含NULL字符，与C++不同

• 采用切片操作时要慎用，因为每转换一次都需要复制内容(尤其数据量大的时候)

  a:="hello world!"
  b:=[]byte(a)
  

• 字符串的底层实现是一个二元数据结构，一个是指针指向字节数组的起点，另一个是长度

  type stringStruct struct{
  	str unsafe.Pointer //指向底层字节数组的指针
      len int            //字节数组长度
  }
  

• 基于字符串创建的切片和原字符串指向相同的底层字符数组，一样不能修改，对字符串的切片操作返回的字串仍是string，而非slice

• string类型常用的一些方法：

  方法	介绍
  len(str)	求长度
  +	拼接字符串
  strings.Split	分割
  strings.contains	判断是否包含

• 修改字符串：要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

  func changeString() {
  	s1 := "big"
  	// 强制类型转换
  	byteS1 := []byte(s1)
  	byteS1[0] = 'p'
  	fmt.Println(string(byteS1))  //pig
  }
  

• 字符串的切片：

  str := "hello,world"
  fmt.Println(str[6:])  
  //打印结果：world
  

byte和rune类型

Go语言的字符类型有两种：

1. uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。
2. rune类型，代表一个 UTF-8字符。

当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。

遍历一个字符串：

	s := "hello,world!"
	for _, r := range s { //rune
		fmt.Printf("%c", r)
	}
	fmt.Println()