Go基础语法——变量1. 整数的类型类型有无符号占用存储空间表数范围备注 int8 有 1个字节 $-128\

1. 整数的类型

类型	有无符号	占用存储空间	表数范围	备注
int8	有	1个字节	$-128\sim 127$
int16	有	2个字节	$-2^{15}\sim2^{15}-1$
int32	有	4个字节	$-2^{31}\sim2^{31}-1$
int64	有	8个字节	$-2^{63}\sim2^{63}-1$
uint8	无	1个字节	$0\sim255$
uint16	无	2个字节	$0\sim2^{16}-1$
uint32	无	4个字节	$0\sim2^{32}-1$
uint64	无	8个字节	$0\sim2^{64}-1$
int	有	32位系统4个字节，64位系统8个字节	32位系统 $-2^{31}\sim2^{31}-1$ ，64位系统 $-2^{63}\sim2^{63}-1$
uint	无	32位系统4个字节，64位系统8个字节	32位系统 $0\sim2^{32}-1$ ，64位系统 $0\sim2^{64}-1$
rune	有	等价于int32	$-2^{31}\sim2^{31}-1$	表示一个Unicode编码
byte	无	等价于uint8	$0\sim255$	当要存储一个字符时用byte

2. 浮点数的类型

类型	占用存储空间	表数范围
单精度float32	4字节	$-3.403E38\sim3.403E38$
双精度float64	8字节	$-1.798E308\sim1.798E308$

3. 字符型

GoLang中没有专门的字符类型，如果要存储单个字符（字母），一般使用byte来保存。

字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。也就是说传统的字符串是由字符组成的，而Go的字符串不同，它是由字节组成的。

func main(){
    var c1 byte = 'a'
    var c2 byte = '0'
    
    // 直接输出byte值，会输出相应得ASCCII码
    fmt.Println(c1)
    fmt.Println(c2)
    
    //如果想输出相应的字符，需要格式化输出
    fmt.Printf("%c %c",c1, c2)
    
    var c3 int = "宸"
    //当字符ascii值大于255时(byte8个bit位,2的8次方是256,即1byte最多存储到ascii码值为255的字符，超过的部分得用大于1byte的类型来存储)，考虑用int来保存字符的ascii码。Go语言存的其实是utf-8码，但Utf-8码和ascii码前面的部分相同，所以不影响理解
    fmt.Printf("%c", c3)
}

1）字符常量是用单引号('')括起来的单个字符

2）Go中允许使用转义字符''来将其后的字符转变为特殊字符型常量。例如var c int ='\n'

3）Go语言中的字符使用的是UTF-8编码，字符的本质是一个整数，直接输出时是输出该字符对应的UTF-8编码值

4）可以直接给某一个变量赋一个数字，然后格式化输出%c，会输出该数字对应的unicode字符

var  a int = 23480    //宸的unicode编码是23480
fmt.Printf("a=%c", a)

5）字符类型是可以计算的

var a = 10 + "a"    // 10 + 97 = 107
fmt.Println(a) //会输出107

4. 布尔型

var flag bool = true

bool类型占一个字节

默认值是false

5. string型

1）Go的字符串是由单个字节连接起来的，Go的字符串使用UTF-8编码标示unicode编码。这样GoLang统一使用UTF-8编码，中文乱码问题不再困扰程序员

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

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

双引号，会识别转义字符
反引号``, 以字符串的原生形式输出，包括转移字符和特殊字符。可以防止攻击、输出源代码

var str = `
package main
import "fmt"

func main(){
    var  a  bool
    fmt.Println(a)
}
`

4）字符串拼接方式

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

5）当一行字符串太长时，可以分行写，但是 + 号必须留在上一行

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

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

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

var i int32 =100
// 希望将 i => float
var n1 float32 = float32(i)

1）Go中，数据类型的转换可以是从表示范围小-->表示范围大，也可以范围大--->范围小

2）被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化!

3）在转换中，比如将int64 转成int8 [-128---127] ，编译时不会报错，只是转换的结果是按溢出处理，和我们希望的结果不一样。因此在转换时，需要考虑范围.

var num1 int64 = 99999
var num2 int8 = int8(num1)    //高精度向低精度转换时，可能会丢失精度
fmt.Println("num2=", num2)  // num2 -> 63  ，丢失掉了高位

7. 基本数据类型和string的转换

7.1 基本类型转string类型

方式1：fmt.Sprintf("%参数"，表达式) [个人习惯这个，灵活] 函数签名

func Sprintf

func Sprintf(format string, a ..interface{}) string

Sprintf根据format参数生成格式化的字符串并返回该字符串。

参数需要和表达式的数据类型相匹配 fimt.Sprintf())..会返回转换后的字符串

//演示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)

    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)
}

方式2：使用strconv包的函数

func FormatBool(b bool) string
func FormatFloat(f float64, fnt byte, prec, bitSize int) string
func FormatInt(i int64, base int) string
func FormatUint(i uint64, base int) string

案例

    //第二种方式 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
    var num5 int64 = 4567
    str = strconv . Itoa(int(num5))|
    fmt. Printf("str type %T str=%q\n", str, str)

7.2 string类型转基本类型

使用strconv包的函数

func ParseBool(str string) (vahue bool, err error)
func ParseFloat(s string, bitSize int) (f float64, err error)
func ParseInt(s string, base int, bitSize int) (int64, emr error)
func ParseUint(s string, b int, bitSize int) (n uint64, enr error)

案例说明

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)
}

7.3 注意事项

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

案例

//注意:
var str4 string = "hello"
var n3 int64 = 11
n3,_ = strconv.ParseInt(str4, 10, 64)
fmt.Printf("n3 type %T n3=%v\n", n3, n3)  //如果没有转成功，则n3为默认值n

8. 指针

9. 值类型和引用类型

9.1 值类型和引用类型的说明

1）值类型：基本数据类型：整数系列，浮点数系列， bool， string；数组和结构体struct

2）引用类型：指针，silce切片，map，管道chan，interface等

9.2 值类型和引用类型的特点

10. 变量使用的方式

1. 指定变量类型

var i int
fmt.Println(i)    // int的默认值是0

注：若声明后不赋值，则会使用默认值

2. 根据值，自行判断变量类型（类型推导）

var num = 10.11
fmt.Println(num)

3. 省略var，用`:=`

name := "Tom"
fmt.Println("name=", Tom)

注：:=只能用于初次声明变量，:=左侧的变量不应该是已经使用过的，否则会报错

多变量的声明

方式1：

var n1, n2, n3 int     //同时声明3个int型的变量
var n1 int, n2 int32, n3 float32     //同时声明3个类型不同的变量

方式2：使用类型推导

var n1, name, n2  =  100, "tom", 101

方式3：省略var，使用:= + 类型推导

n1, name, n2  :=  100, "tom", 101

Go基础语法——变量