Golang基础-变量与数据类型

变量

变量的定义

1.声明
2.赋值
3.使用

// 声明：var 变量名 变量类型
var name string
// 赋值：
name = "xiaoming"
// 使用：
fmt.Println(name)

// 声明+赋值 
// var 变量名 变量类型 = 变量值
var age int = 18
// 使用
fmt.Println(age)

完整代码如下：

package main

import "fmt"

func main() {
	// 1.变量的声明
	var name string
	// 2.变量的赋值
	name = "xiaoming"
	// 3.变量的使用
	fmt.Println(name)
	
	// 1.声明+赋值
	var age int = 18
	// 2.变量的使用
	fmt.Println(age)

}

变量的4种使用形式

1.指定变量的类型并且赋值
2.指定变量的类型不赋值使用默认值
3.如果不指定变量的类型，会根据变量的值来进行判定变量的类型（自动类型推断）
4.省略 var 关键字，直接使用 :=
Ps: 这种方法只适合函数内部，函数外边不能使用

完整代码如下:

package main

import "fmt"

func main() {
	// 第一种:指定变量的类型并且赋值
	var num int = 18
	fmt.Println(num)
	// 第二种:指定变量的类型不赋值使用默认值
	var num2 int
	fmt.Println(num2)
	// 第三种:如果不指定变量的类型，会根据变量的值来进行判定变量的类型（自动类型推断）
	var num3 = 10
	fmt.Println(num3)
	// 第四种:省略 var 关键字，直接使用 `:=`
	// 注意：这种方法只适合函数内部，函数外边不能使用
	sex := "男"
	fmt.Println(sex)
}

批量声明多个变量

package main

import "fmt"

// 多变量声明

func main() {

	// 第一种方式
	var n1, n2, n3 int
	fmt.Println(n1, n2, n3)

	// 第二种方式
	var (
		n4 string
		n5 int
		n6 bool
	)
	fmt.Println(n4, n5, n6)

	// 第三种方式
	var name, age, sex = "jack", 18, "男"
	fmt.Println(name, age, sex)

	// 第四种方式
	name1, age1, sex1 := "xiaoming", 20, "nan"
	fmt.Println(name1, age1, sex1)

}

全局变量

定义在函数之外的变量

package main

import "fmt"

// 全局变量：定义在函数之外的变量
var name string = "xiaoming"
var age = 20

func main() {
	fmt.Println(name)
	fmt.Println(age)
}

数据类型

分为基本数据类型和复杂数据类型/派生数据类型

基本数据类型：

• 数值型
• • 整数类型（int,int8,int16,int32,int64,uint,uint8,uint16,uint32,uint64,byte）
• • 浮点类型（float32,float64）
• 字符型（没有单独的字符型，使用byte来保存单个字母字符）
• 布尔型（bool）
• 字符串（string）

复杂数据类型：

• 指针
• 数组
• 结构体
• 管道
• 函数
• 切片
• 接口
• map

整数类型

用于存放整数值，比如 10，-45，6789等

有符号整数类型

无符号整数类型

其他整数类型

Ps: Golang 的整数类型默认声明为 int 类型

package main

import "fmt"

func main() {

	var age = 18
	// Printf函数作用是格式化输出，把age的类型填充到%T的位置上
	fmt.Printf("age的类型是: %T", age)
	// unsafe.Size():返回数据所占用的字节数
	fmt.Println(unsafe.Sizeof(age))
	
}

浮点类型

用于存放小数值的，比如 3.14,0.5,-2.4

浮点类型种类

Ps: Golang中默认的浮点类型为：float64

package main

import "fmt"

func main() {
	// 定义浮点类型的数据
	var num1 float32 = 3.14
	fmt.Println(num1)

	var num2 float32 = -3.14
	fmt.Println(num2)

	var num3 = 5.6
	// num3的类型为：float64
	fmt.Printf("num3的类型为：%T", num3)

}

字符类型

Golang 中没有专门的字符类型，如果要存储单个字符(字母)一般使用 byte 来保存

Golang 中字符使用 UTF-8 编码

字符类型：本质就是一个整数，也可以直接参与运算，输出字符的时候，会将对应一个码值输出

字母、数字、标点等字符，底层是按照 ASCII 进行存储

ASCII表

package main

import "fmt"

func main() {
	// 定义字符类型的数据
	var c1 byte = 'a'
	fmt.Println(c1) // 97

	var c2 byte = '6'
	fmt.Println(c2) // 54

	var c3 byte = '('
	fmt.Println(c3) // 40
	// 字符类型：本质就是一个整数，也可以直接参与运算，输出字符的时候，会将对应一个码值输出
	// 字母、数字、标点等字符，底层是按照 ASCII 进行存储
	
	// 想显示对应的字符，必须采用格式化输出
	var c4 byte = 'A'
	fmt.Printf("c4=%c", c4) //c4=A

}

布尔类型

布尔类型也叫 bool 类型，bool 类型数据只允许取值 true 和 false

布尔类型占 1 个字节

布尔类型适合用于逻辑运算，一般用于流程控制

package main

import "fmt"

func main() {
	// 布尔类型的数值
	var b1 bool = true
	fmt.Println(b1)

	var b2 bool = false
	fmt.Println(b2)

}

字符串类型

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

package main

import "fmt"

func main() {
	// 字符串
	var name string = "xiaoming"
	fmt.Println(name)
	// 字符串是不可变的,字符串一旦定义好其中字符的值不能改变
	var s1 string = "abc"
	fmt.Println(s1)
	// 字符串的表示形式
	// (1) 如果字符串中没有特殊字符，字符串表示形式用双引号
	var s2 string = "hello,world"
	fmt.Println(s2)
	// (2) 如果字符串中有特殊字符，字符串表示形式用 ``
	var s3 string = `hello "world"`
	fmt.Println(s3)
	// 字符串的拼接
	var s4 string = "abc" + "def"
	fmt.Println(s4)
	s4 += "ghi"
	fmt.Println(s4)
	// 当字符串过长时：注意将 + 号保留在上一行
	var s5 string = "abcdefghijklmnopqrstuvwxyz" +
		"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	fmt.Println(s5)
}

1.字符串是不可变的,字符串一旦定义好其中字符的值不能改变

2.字符串的表示形式
　(1) 如果字符串中没有特殊字符，字符串表示形式用双引号
　(2) 如果字符串中有特殊字符，字符串表示形式用 “

3.字符串的拼接使用 + 号

4.当字符串过长时：注意将 + 号保留在上一行

基本数据类型之间的转换

Go 在不同类型的变量之间赋值时需要显式转换,并且只有显式转换(强制转换)

语法:
　表达式T(v)将值 v 转换为类型 T
　T 就是数据类型
　v 就是需要转换的变量

package main

import "fmt"

func main() {
	// 类型转换
	var n1 int = 100
	// T(v):float32(n1)
	var n2 float32 = float32(n1)
	fmt.Println(n2)
	// n1的类型其实还是int类型，只是把n1的值转换为float32类型
}

基本数据类型转为string

在程序开发中经常需要将基本数据类型转为 string 类型或者将 string 类型转为基本数据类型

基本类型转 string 类型
方式1：fmt.Sprintf(“%参数”,表达式)
方式2：使用 strconv 包的函数

方式1:

package main

import (
	"fmt"
)

func main() {
	// 基本数据类型转为 string 类型
	
	var n1 int = 19
	var n2 float32 = 4.145
	var n3 bool = false
	var n4 byte = 'A'

	s1 := fmt.Sprintf("%d", n1)
	fmt.Printf("%T,%v\n", s1, s1)

	s2 := fmt.Sprintf("%f", n2)
	fmt.Printf("%T,%v\n", s2, s2)

	s3 := fmt.Sprintf("%t", n3)
	fmt.Printf("%T,%v\n", s3, s3)

	s4 := fmt.Sprintf("%c", n4)
	fmt.Printf("%T,%v\n", s4, s4)

}

方式2:

package main

import (
	"fmt"
	"strconv"
)

func main() {

	var n1 int = 10
	var n2 float32 = 3.14
	var n3 bool = true

	// 参数：第一个参数必须转为 int64类型，第二个参数指定字面值的进制形式为十进制
	s1 := strconv.FormatInt(int64(n1), 10)
	fmt.Printf("s1的类型为:%T,对应的值为：%v\n", s1, s1)
	// 参数：第一个参数必须为 float64类型，第二个参数'f'(-ddd.dddd)，第三个参数保留小数点后几位，第四个参数指 float64类型
	s2 := strconv.FormatFloat(float64(n2), 'f', 9, 32)
	fmt.Printf("s2的类型为:%T,对应的值为：%v\n", s2, s2)
	// 参数：第一个参数必须为 bool 类型
	s3 := strconv.FormatBool(n3)
	fmt.Printf("s3的类型为:%T,对应的值为：%v\n", s3, s3)

}

string类型转基本类型

使用 strconv 包的函数

package main

import (
	"fmt"
	"strconv"
)

func main() {

	// string --> bool
	var s1 string = "true"
	// ParseBool这个函数的返回值有两个 bool, error
	// bool 是我们得到的布尔类型的数据，error代表出现的错误
	// 我们只关注得到的布尔类型的数据，error可以使用 _ 直接忽略
	b, _ := strconv.ParseBool(s1)
	fmt.Printf("B的类型为：%T，B的值为：%v\n", b, b)

	// string --> int64
	var s2 string = "19"
	n1, _ := strconv.ParseInt(s2, 10, 64)
	fmt.Printf("n1的类型为：%T，n1的值为：%v\n", n1, n1)

	// string --> float32/64
	var s3 string = "3.14"
	f1, _ := strconv.ParseFloat(s3, 64)
	fmt.Printf("f1的类型为：%T，f1的值为：%v\n", f1, f1)

}

复杂数据类型-指针

指针就是内存地址

& : 取内存地址
*: 根据内存地址取具体的值

基本数据类型变量

package main

import "fmt"

func main() {

	// 在内存中为age开辟一个空间，这个空间存储的数值为18
	var age int = 18
	// & 加上变量可以获取这个变量的地址
	// age对应的地址
	fmt.Println(&age) // 0xc00001c048
}

指针数据变量

package main

import "fmt"

func main() {

	// 在内存中为age开辟一个空间，这个空间存储的数值为18
	var age int = 18
	// & 加上变量可以获取这个变量的地址
	// age对应的地址
	fmt.Println(&age) // 0xc00001c048

	// 定义一个指针变量
	// var 代表要声明一个变量
	// ptr 指针变量的名字
	// ptr对应的类型是：*int，它是一个指针类型(指向int类型的指针)
	// &age 就是一个地址，是 ptr 变量具体的值
	var ptr *int = &age
	// 获取ptr这个指针指向的具体数据，使用 *变量名
	fmt.Println(*ptr)

}

可以通过指针更改指向值

package main

import "fmt"

func main() {

   // 定义一个int类型的变量num，值为10
	var num int = 10
	// 定义一个指针变量ptr，值为num变量的内存地址
	var ptr *int = &num
	// 通过 *ptr 修改这个内存地址所指向的具体数值为20
	*ptr = 20
	// num值变为：20
	fmt.Println(num) // 20
	fmt.Println(*ptr)// 20
}

指针变量接收的一定是地址值

指针变量的地址不可以不匹配

Ps：*float32 意味着这个指针指向的是 float32 类型的数据，但 &num 对应的是 int 类型

基本数据类型(又叫值类型)，都有对应的指针类型，形式为 *数据类型，比如 *int

原文地址：http://www.cnblogs.com/ZunSir/p/16812185.html