go语言学习【二】

Go语言基本数据类型

一. 变量及其相关内容
二.整数类型
三.浮点类型
四.字符类型
五.布尔类型
六.字符串类型
七.基本数据类型的相互转换
八.指针

一. 变量及其相关内容

1. 变量的使用步骤:

（1）声明变量（定义变量）
（2）赋值
（3）使用

• 简单案例

package main
import "fmt"
func main() {
	var i int //定义变量
	i=10      //赋值
	fmt.Println("i=",i) //使用变量
}

输出结果是：

i=10

2. 变量使用的三种方式

(1）指定变量类型【声明后若不赋值，使用默认值】

var a int
fmt.Println("a=",a)//输出结果是a=0

(2）根据值自行判定变量类型（类型推导）

var b = 9.99 //未指定b的类型，根据等号后的值确定b的类型

(3）省略var【注意：=左侧的变量应是未声明的，否则会导致编译错误】

name := "tom"//省略var，需要在等号前加上:
/*等价于 var name string  
         name = "tom"*/

注：一次性声明多个变量：

var a1,a2,a3 int //定义相同类型多个变量
var num,name,age = 1,"tom",18  // 先定义不同类型变量，再进行赋值，等号右边数据依次赋值给左边类型
num,name,age := 1,"tom",18 //省略var,即未定义变量，在赋值时需要使用 :=

上述一次性声明不同类型变量的输出结果：

3.变量的数据类型

二. 整数类型

• 查看某个变量的数据类型和占用的字节数

package main
import(
	"fmt"
	"unsafe" //引入unsafe包
)

func main() {
	var i = 100
fmt.Printf("i的数据类型是:%T  i占用的字节数:%d",i,unsafe.Sizeof(i)) //使用unsafe包里的函数用来输出变量字节数，fmt.Printf()用于格式化输出
}

三. 浮点类型

1）浮点数=符号位+指数位+尾数位
2）使用浮点数时，尾数部分可能丢失，造成精度损失。
3）浮点型默认声明为 float64

var num =9.9
fmt.Printf("num类型为：%T",num)

输出结果是：

num类型为：float64

4）通常情况下使用 float64 ，精确度更高。

四. 字符类型

• Golang中没有专门的字符类型，如果要存储单个字符（字母），一般使用byte来保存。
• Golang字符串是由字节组成的，传统字符串是由字符组成的。

关于go语言字符类型使用：

package main
import "fmt"
	
func main() {
	var a byte = 'm'
	var b byte = '0'
	//当直接输出byte值时，就是输出了字符对应的码值
    fmt.Println("a=",a,"\tb=",b) //这里输出 a=109  b=48
    
    //如需输出对应字符，需要使用格式化输出
    fmt.Printf("a=%c\tb=%c",a,b) //此时输出结果是字符
}

1）需要保存的字符在ASCII表里的，可以直接保存到byte。
2）需要保存的字符对应码值大于255，可以使用 int 类型保存。
3）如果我们需要按照字符的方式输出，这时我们需要格式化输出，即fmt.Printf("%c",c1)…

五.布尔类型（bool）

1. bool类型数据只允许取值true和false （不可以用0或非0的整数替代false和true，这点和c语言不同）
2. bool类型占1个字节
3. bool类型适于逻辑运算，一般用于程序流程控制。
4. bool类型默认值是false

六.字符串类型（bool）

字符串就是一串固定长度的字符连接起来的字符序列。

1）Go的字符串是由单个字节连接起来的，Go语言的字符串的字节使用UTF-8编码标识Unicode文本，没有乱码的困扰。

2）字符串一旦赋值了，就不能修改，在Go中字符串是不可变的。

3）字符串的两种表示形式：

1. 双引号，会识别转义字符
2. 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果。

package main
import "fmt"
	
func main() {
	str1 := "abc\nabc" //双引号内的转义字符可以输出
	str2 := `package main
	import "fmt"`      //对于特殊字符，只有使用反引号才可以正确输出
	fmt.Println(str1)
	fmt.Println(str2)
}

4）字符串拼接

//当一个拼接的操作很长时，可以分行写，注意：需要将 + 保留在上一行
str :="hell0"+"world"+"hell0"+"world"+"hell0"+"world"+
"hell0"+"world"+"hell0"+"world"
fmt.Println(str)

七.基本数据类型的相互转换

• Golang和 java/c 不同，Go在不同类型的变量之间赋值时需要显示转换，也就是说Golang中数据类型不能自动转换。

package main
import "fmt"
	
func main() {
	//Golang中基本数据类型的转换
	var i int =100
	var n1 float32 = float32(i) //将i转换为float32类型
	fmt.Printf("i=%v n1=%v",i,n1) // %v表示按照变量的值输出
}

输出结果是：

i=100 n1=100

注：被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化！（这里 i 的数据类型仍是 int ）

• 基本数据类型转换为string

package main
import (
    "fmt"
    "strconv"
	)
func main() {
	//使用fmt.Sprintf方法转换(方法一)
	var num1 int = 16
	 var str string //空的str
	str = fmt.Sprintf("%d",num1)//把num1存储的值转换为string类型，返回值给str
    fmt.Printf("str Type:%T  str=%q\n",str,str) //使用%q输出时自带""
    //使用strconv包里的函数（方法二）
    var num2 = 18
    var num3 = 19.999
    str = strconv.FormatInt(int64(num2),10)
	fmt.Printf("str Type:%T  str=%q\n",str,str) 
    str=strconv.FormatFloat(num3,'f',10,64) //'f':格式 10：表示小数位保留10位 64：表示这个小数是float64
    fmt.Printf("str Type:%T  str=%q",str,str)
}

输出结果是：

str Type:string  str="16"
str Type:string  str="18"
str Type:string  str="19.9990000000"

• string转成基本数据类型

package main
import (
    "fmt"
    "strconv"
	)
func main() {
	var str string = "true"
	var a bool
    a,_ = strconv.ParseBool(str) //strconv.ParseBool(str)函数会返回两个值（value bool,err error）
	                             //因为只需要获取到value bool，不想获取err,所以使用_忽略
	fmt.Printf("a type:%T a=%v\n",a,a)

	var str2 string = "12345"
	var n int64
	n,_ = strconv.ParseInt(str2,10,64) //返回值类型是64,若需要其他int类型，可以进行强制转换
	fmt.Printf("n type:%T n=%v\n",n,n)

	var str3 string = "19.999"
	var m float64
	m,_ = strconv.ParseFloat(str3,64)
	fmt.Printf("m type:%T m=%v",m,m)
}

输出结果是：

a type:bool a=true
n type:int64 n=12345
m type:float64 m=19.999

八.指针

• 指针类型
  变量存的是一个地址，这个地址指向的空间存的才是值。
  比如：var ptr *int = & num
  获取指针类型所指向的值，使用 * ，比如使用 *ptr 获取ptr指向的值。

package main

import "fmt"

func main() {
	var a int = 10
	fmt.Println("a的地址=",&a)

	var ptr *int = &a 
	//1. ptr是一个指针变量 
	//2. ptr的类型是 *int 
	//3. ptr本身的值是 &a
	fmt.Printf("ptr=%v\n",ptr) //输出结果与a的地址相同
	fmt.Printf("ptr的地址=%v\n",&ptr)
	fmt.Printf("ptr指向的值=%v",*ptr)
}

输出结果是：

a的地址= 0xc0000120a8
ptr=0xc0000120a8
ptr的地址=0xc000006030
ptr指向的值=10

• 值类型
  变量直接存储值，内存通常在栈中分配。
  值类型包括：基本数据类型 int 系列、float 系列、bool、string ，数组和结构体struct 。

• 引用类型
  变量存储的是一个地址，这个地址对应的空间才是真正存储数据（值），内存通常在堆中分配。
  引用类型包括：指针、slice 切片、map 、管道chan 、interface 等。