【Golang】一、基础篇 -- 基本数据类型

MAC环境下安装go，下面所有操作都是针对MAC OS环境构建，本篇文章只有基础教程，无框架介绍！

安装

基本数据类型

一、数据类型

1. 整数

func _int()  {
	var var_int8 int8 = 123	// int8表示8个字节
	fmt.Println(var_int8)

	var var_uint uint = 1  // 无符号整型
	var var_int int = -1 // 有符号整型
	fmt.Println("有符号：", var_uint, "无符号：", var_int)

	// -128 ~ 127 占8位，首位0/1表示正负，所有是（-2^7 ～ 2^7 - 1）
	var i1 int8 = 0
	fmt.Println(i1)

	// 0~255，所以是（0 ～ -2^8）
	var i2 uint8 = 0
	fmt.Println(i2)

	//byte == uint8    基本存储单元（8bit = 1byte）
	var i_byte byte = 0
	fmt.Println(i_byte)
}

2. 浮点数

func _float()  {
	var var_f32 float32 = 2222.00000009 //单精度，会造成精度损失（输出：2222）
	var var_f64 float64 = -2222.00000009 //双精度
	fmt.Println(var_f32, var_f64)

	var float1 = 1.1 // 默认float64
	fmt.Printf("float1类型：%T\n", float1)

	// 科学计数法  e指代10，e2指代10的2次方
	f2 := 5.1244e2 // => 等价于5.12*10^2
	f3 := 5.1244 * 10 * 10
	fmt.Println("f2：",f2, "-----\tf3：",f3)
}

3. 字符型

func _char()  {
	var b1 byte = 'a'
	//直接输出byte相当于直接输出字符二进制码值
	fmt.Println("b1：",b1) // 输出 =》b1： 97
	fmt.Printf("格式化b1：%c", b1) // 输出 =》格式化b1：a

	// 可以用作符号运算
	var b2 byte = 'a' + 1  // 输出 b (a+1 = a的下一位）
	fmt.Printf("\nbyte运算：%c\n", b2)
}

4. 字符串

func _string()  {
	var var_s string = "string"
	fmt.Println(var_s)
	fmt.Println("string占用长度：", unsafe.Sizeof(var_s))

	// 反引号输出
	str := `fmt.Println("字符串型：===============")
		_string()`
	fmt.Println("反引号：",str)
}

5. 布尔型

func _bool() {
	var var_b1 bool = true
	var var_b2 bool = false
	fmt.Println(var_b1,var_b2)
}

二、复杂数据类型

（1）指针

func main() {
	// 指针
	var name int = 10
	fmt.Println("name地址：",&name)
	fmt.Println("name值：", name)

	// i存储的是name的地址的值
	var i *int = &name
	// i指向地址的值修改为12
	*i = 12
	// *i是取出i存储地址对应的值
	fmt.Println("*i指向地址的值：", *i)
	fmt.Println("*i修改内容后的name的值得：",name)
}

输出：

二、格式化

（1）fmt.Printf的参数详解

1. 布尔类型

   %t 单词true或false

2. 整数

   %b 表示为二进制
   %c 该值对应的unicode码值
   %d 表示为十进制
   %o 表示为八进制
   %q 该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
   %x 表示为十六进制，使用a-f
   %X 表示为十六进制，使用A-F
   %U 表示为Unicode格式：U+1234，等价于"U+%04X"

3. 浮点数、复数的两个组分

   %b 无小数部分、二进制指数的科学计数法，如-123456p-78
   %G 根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）
   %e 科学计数法，例如 -1234.456e+78 Printf("%e", 10.2) 1.020000e+01
   %E 科学计数法，例如 -1234.456E+78 Printf("%e", 10.2) 1.020000E+01
   %f 有小数点而无指数，例如 123.456 Printf("%f", 10.2) 10.200000
   %g 根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出 Printf("%g", 10.20) 10.2

4. 字符串和[]byte

   %s 直接输出字符串或者[]byte %q
   %x 每个字节用两字符十六进制数表示（使用a-f）
   %X 每个字节用两字符十六进制数表示（使用A-F）

5. 指针

   %p 表示为十六进制，并加上前导的0x

（2）基本数据类型转string

1. 方式1：fmt转化

package main
import (
	"fmt"
)
func main()  {
	var var_f float64 = 1.111111
	var var_i int8 = -128
	var var_b bool = true
	var str string

	// float 转化 string
	str = fmt.Sprintf("%f", var_f)
	fmt.Printf("var_f转化类型：%T， %q\n", str, str)

	// int8 转化 string
	str = fmt.Sprintf("%d", var_i)
	fmt.Printf("var_i转化类型：%T， %q\n", str, str)

	// bool 转化 string
	str = fmt.Sprintf("%t", var_b)
	fmt.Printf("var_b转化类型：%T， %q\n", str, str)
	
	// char 转化为 string
	str = fmt.Sprintf("%c", var_c)
	fmt.Printf("var_c转化类型：%T，%q\n", str, str)
}

// 输出如下
// var_f转化类型：string， "1.111111"
// var_i转化类型：string， "-128"
// var_b转化类型：string， "true"
// var_c转化类型：string，"a"

1. 方式2：strconv转化

package main
import (
	"fmt"
	"strconv"
)
func main()  {
	var var_f float64 = 1.111111
	var var_i int8 = -128
	var var_b bool = true
	var var_c byte = 'a'
	var str string

	// bool转化
	str = strconv.FormatBool(var_b)
	fmt.Printf("%q",str)

	// int转化，参数1需要接收int64的类型
	str = strconv.FormatInt(int64(var_i), 8)
	fmt.Printf("%q", str)
	
	// int 转化 string快捷方法（接收参数为int）
	var int_ii int = -126
	str = strconv.Itoa(int_ii)
	fmt.Printf("%q\n", str)

	// 参数1：转化值 
	// 参数2：转化的类型
	// 参数3：精度，小数保留多少位（10表示保留10位小时）
	// 参数4：64表示float64，32表示float32
	str = strconv.FormatFloat(var_f, 'f', 10, 64)
	fmt.Printf("%q", str)
}

（3）string转基本数据类型

转化失败的情况，会直接转化为0

package main
import (
 "fmt"
 "strconv"
)
func main(){
  var str1 string = "true"
  var str2 string = "1"
  var var_b bool

	// bool转化
  var_b, _ = strconv.ParseBool(str1)
  fmt.Printf("%t 类型%T\n", var_b, var_b)
  var_b, _ = strconv.ParseBool(str2)
  fmt.Printf("%t 类型%T\n", var_b, var_b)

	// int64转化
	// ParseInt(字符串, 进制, int8/int16/int32/int64)
	var var_i int64
	var_i, _ = strconv.ParseInt(str2, 10, 64)
	fmt.Printf("%d 类型%T\n", var_i, var_i)

	// float转化
	str := "1.05245585"
	var var_f float64
	var_f, _ = strconv.ParseFloat(str, 64)
	fmt.Printf("%f 类型%T\n",var_f, var_f)
}
// 输出
// true 类型bool
// true 类型bool
// 1 类型int64
// 1.052456 类型float64