一文搞懂Golang变量和数据类型

Golang的执行：

go build hello.gohello.exego run hello.go

两种执行流程的方式区别：

1. 如果我们先编译生成了可执行文件，那么我们可以将该可执行文件拷贝到没有go开发环境的机器上，仍然可以运行。
2. 如果我们是直接go run xxx.go源代码，那么如果要在另外一个机器上这么运行，也需要go开发环境，否则无法执行。
3. 在编译时，编译器会将程序运行依赖的库文件包含在可执行文件中，所以，可执行文件变大了很多。

Go程序开发的注意事项：

_

import (
	_ "fmt"
)

8. 大括号都是成对出现的，缺一不可。

Golang中注释的两种形式：

//注释内容/*注释内容*/

Golang格式化代码：

Golang变量：

变量的声明，初始化和赋值及注意事项

var i int

package main

import "fmt"

func main() {
	//定义变量(声明变量)
	var i int
	//给i赋值
	i = 10
	//使用变量
	fmt.Println("i=",i)
}
//输出 i= 10

var i = 10.34name :="tom"//声明的同时赋值var name str name = "tom"

package main

import "fmt"
//一次性声明多个变量
func main() {
	//方式1
	var i,j,k int
	fmt.Println("i=",i, "j=",j, "k=",k)
	//方式2
	var n1, name ,n3 = 10, "jack", 30 
	fmt.Println("n1=",n1, "name=",name, "n3=", n3)
	//方式3
	n11, name1 ,n31 := 101, "jack1", 301 
	fmt.Println("n11=",n11, "name1=",name1, "n31=", n31)
}

(5)第五种：全局变量：一次性声明多个全局变量【在go中函数外部定义变量就是全局变量】

package main
import "fmt"
//方式1
var n1 = 100
var n2 = 200
var name = "jack"
//方式2
var (
	n3 = 300
	n4 = 500
	name2 = "tom"
)
func main() {
	fmt.Println("n1=",n1, "name=",name, "n2=", n2)
}

(6)该区域的数据值可以在同一类型范围内不断变化(重点)

var i int = 10
i = 30//正确，因为还是同一类型的
i = 1.2//错误，因为类型改变了

(7)变量在同一个作用域(在一个函数或者在代码块)内不能重名
(8)变量的三要素：变量=变量名+值+数据类型
(9)Golang的变量如果没有赋初值，编译器会使用默认值,比如int默认值0，string默认值为空串，小数默认为0

程序中+号的使用

1)当左右两边都是数值型时，则做加法运算
2)当左右两边都是字符串时，则做字符串拼接

Golang数据类型

整数类型：

int8 int 16 int32的优势就来了，跟系统无关了，byte常用于存放字母。

整数类型的使用细节：

%v : 以默认的方式打印变量的值

var n1 = 100
//fmt.Printf() 可以用于做格式化输出。
fmt.Printf("n1的类型%T",n1)//输出：n1的类型int

3)如何在程序查看某个变量的字节大小和数据类型

package main
import (
	"fmt"
	"unsafe"
)
func main() {
	//如何在程序查看某个变量的占用字节大小和数据类型 （使用较多）
	var n2 int64 = 10
	//unsafe.Sizeof(n2) 是unsafe包的一个函数，可以返回n2变量占用的字节数
	fmt.Printf("n2 的 类型 %T  n2占用的字节数是 %d ", n2, unsafe.Sizeof(n2))
	//输出：n2 的 类型 int64  n2占用的字节数是8
}

4)Golang程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。
5)bit:计算机中的最小存储单位。byte:计算机中基本存储单元。1byte=8bit

小数(浮点)类型：

小数类型分类：

1)浮点数在机器中存放形式：浮点数=符号位+指数位+尾数位。说明：浮点数都是有符号的。
2)尾数部分可能丢失，造成精度损失。说明：float64的精度比float32的要准确，如果我们要保存一个精度高的数，则应该选用float64。
3)Golang浮点类型有固定的范围和字段长度，不受具体OS(操作系统)的影响。没有float，只有float32和float64。
4)Golang的浮点型默认声明为float64类型。

字符类型：

fmt.Printf(“%c”,c1)..

package main
import (
	"fmt"
)
//演示golang中字符类型使用
func main() {
	
	var c1 byte = 'a'
	var c2 byte = '0' //字符的0

	//当我们直接输出byte值，就是输出了的对应的字符的码值
	// 'a' ==> 
	fmt.Println("c1=", c1)
	fmt.Println("c2=", c2)
	//如果我们希望输出对应字符，需要使用格式化输出
	fmt.Printf("c1=%c c2=%c\n", c1, c2)

	//var c3 byte = '北' //overflow溢出
	var c3 int = '北' 
	fmt.Printf("c3=%c c3对应码值=%d\n", c3, c3)

	//可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode 字符
	var c4 int = 22269 // 22269 -> '国' 120->'x'
	fmt.Printf("c4=%c\n", c4)

	//字符类型是可以进行运算的，相当于一个整数,运输时是按照码值运行
	var n1 = 10 + 'a' //  10 + 97 = 107
	fmt.Println("n1=", n1)
}

字符类型的使用细节：

var c1 byte = 'a' var c2 int = '中' var c3 byte = '9'var c3 char = ‘\n’//'\n'表示换行符

布尔类型：

1)布尔类型也叫bool类型，bool类型数据只允许取值true和false。不可以0或非0的整数替代false和true，这点和C语言不同。
2)bool类型占1个字节。
3)bool类型适于逻辑运算，一般用于程序流程控制。

字符串(string)类型：

字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本。

字符串类型的使用细节：

var str = "hello" str[0] = "a"//会报错str := "abc\nabc"

str := `
abc
def
ghi\nk
`//会把``里的内容原封不动的输出

4)字符串拼接方式

var str = "hello " + "world"
str += "!"

5)当一行字符串太长时，需要使用到多行字符串，可以如下处理

基本数据类型的默认值:

在go中，数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值，在go中，默认值又叫零值。

基本数据类型的相互转换：

Golang和java/c不同，Go在不同类型的变量之间赋值时需要显式转换，即var n1 float32要等于float32(i)而不能直接等于i。也就是说Golang中数据类型不能自动转换。
T(v)：将值v转换为类型T：

• T:就是数据类型，比如int32，int64，float32等等。
• v:就是需要转换的变量

var i int32 = 100
var n1 float32 = float32(i)
var n2 int64
n2 = i + 20//会报错
//n2 = int64(i) + 20//正确写法

1)Go中，数据类型的转换可以是从表示范围小–>表示范围大，也可以范围大—>范围小
2)被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化！
3)在转换中，比如将int64转成int8【-128—127】，编译时不会报错，只是转换的结果是按溢出处理，和我们希望的结果不一样。因此在转换时，需要考虑范围。

基本类型转string类型：

方式1：fmt.Sprintf("%参数",表达式)
参数需要和表达式的数据类型相匹配，表达式本身的类型没变，只是把它的值转换了。其中参数的取值详情参考。

方式2：使用strconv包的函数

方式3：strconv包中有一个函数Itoa，只能用于int转string，很好用

package main
import (
	"fmt"
	_ "unsafe"//未用到的前面要加_
	"strconv"
)

//演示golang中基本数据类型转成string使用
func main() {

	var num1 int = 99
	var num2 float64 = 23.456
	var b bool = true
	var myChar byte = 'h'
	var str string //空的str

	//使用第一种方式来转换 fmt.Sprintf方法
	str = fmt.Sprintf("%d", num1)
	fmt.Printf("str type %T str=%q\n", str, str)
	fmt.Printf("num1 type %T num1=%q\n", num1, num1)

	str = fmt.Sprintf("%f", num2)
	fmt.Printf("str type %T str=%q\n", str, str)

	str = fmt.Sprintf("%t", b)
	fmt.Printf("str type %T str=%q\n", str, str)

	str = fmt.Sprintf("%c", myChar)
	fmt.Printf("str type %T str=%q\n", str, str)

	//第二种方式 strconv 函数 
	var num3 int = 99
	var num4 float64 = 23.456
	var b2 bool = true

	str = strconv.FormatInt(int64(num3), 10)
	fmt.Printf("str type %T str=%q\n", str, str)
	
	// strconv.FormatFloat(num4, 'f', 10, 64)
	// 说明： 'f' 格式 10：表示小数位保留10位 64 :表示这个小数是float64
	str = strconv.FormatFloat(num4, 'f', 10, 64)
	fmt.Printf("str type %T str=%q\n", str, str)

	str = strconv.FormatBool(b2)
	fmt.Printf("str type %T str=%q\n", str, str)

	//strconv包中有一个函数Itoa，只能用于int转string
	var num5 int64 = 4567
	str = strconv.Itoa(int(num5))
	fmt.Printf("str type %T str=%q\n", str, str)
}

string类型转基本数据类型：

方法：使用strconv包的函数

注意事项：
在将String类型转成基本数据类型时，要确保String类型能够转成有效的数据，比如我们可以把"123",转成一个整数，但是不能把"hello"转成一个整数，如果这样做，Golang直接将其转成0，其它类型也是一样的理.float=>0bool=>false

package main
import (
	"fmt"
	"strconv"
)

//golang中string转成基本数据类型
func main() {

	var str string = "true"
	var b bool
	// b, _ = strconv.ParseBool(str)
	// 说明
	// 1. strconv.ParseBool(str) 函数会返回两个值 (value bool, err error)
	// 2. 因为只想获取到 value bool ,不想获取 err 所以使用_忽略
	b , _ = strconv.ParseBool(str)
	fmt.Printf("b type %T  b=%v\n", b, b)
	
	var str2 string = "1234590"
	var n1 int64
	var n2 int
	n1, _ = strconv.ParseInt(str2, 10, 64)
	n2 = int(n1)
	fmt.Printf("n1 type %T  n1=%v\n", n1, n1)
	fmt.Printf("n2 type %T n2=%v\n", n2, n2)

	var str3 string = "123.456"
	var f1 float64
	f1, _ = strconv.ParseFloat(str3, 64)
	fmt.Printf("f1 type %T f1=%v\n", f1, f1)

	//注意：
	var str4 string = "hello"
	var n3 int64
	n3, _ = strconv.ParseInt(str4, 10, 64)
	fmt.Printf("n3 type %T n3=%v\n", n3, n3)
}