03【保姆级】-GO语言变量和数据类型和相互转换

03【保姆级】-GO语言变量和数据类型

  • 一、变量
    • [1.1 变量的定义:](#1.1 变量的定义:)
    • [1.2 变量的声明、初始化、赋值](#1.2 变量的声明、初始化、赋值)
    • [1.3 变量使用的注意事项](#1.3 变量使用的注意事项)
  • 插播-关于fmt.Printf格式打印%的作用
  • [二、 变量的数据类型](#二、 变量的数据类型)
    • 2.1整数的基本类型
      • [2.1.1 有符号类型 int8/16/32/64](#2.1.1 有符号类型 int8/16/32/64)
      • [2.1.2 无符号类型 int8/16/32/64](#2.1.2 无符号类型 int8/16/32/64)
      • [2.1.3 整型类型 int、uint、rune、byte](#2.1.3 整型类型 int、uint、rune、byte)
      • [2.1.4 整型的使用细节](#2.1.4 整型的使用细节)
    • [2.2 浮点类型](#2.2 浮点类型)
      • [2.2.1 小数类型分类](#2.2.1 小数类型分类)
    • [2.3 字符类型](#2.3 字符类型)
      • [2.3.1 基本介绍](#2.3.1 基本介绍)
      • [2.3.2 字符使用细节](#2.3.2 字符使用细节)
    • [2.4 布尔类型](#2.4 布尔类型)
      • [2.4.1 基本概述](#2.4.1 基本概述)
    • [2.5 String类型](#2.5 String类型)
      • [2.5.1 基本概述](#2.5.1 基本概述)
      • [2.5.2 String使用注意事项和细节](#2.5.2 String使用注意事项和细节)
    • [2.6 基本数据类型的默认值](#2.6 基本数据类型的默认值)
    • [2.7 基本数据类型的相互转换](#2.7 基本数据类型的相互转换)
    • [2.8 转换的细节(重要)](#2.8 转换的细节(重要))
    • [2.9 基本数据类型转String(重要)](#2.9 基本数据类型转String(重要))
      • [2.9.1 fmt.Sprintf("%参数", 变量名)](#2.9.1 fmt.Sprintf("%参数", 变量名))
      • [2.9.2 使用strconv包的函数](#2.9.2 使用strconv包的函数)
    • [2.10 String类型转为基本类型](#2.10 String类型转为基本类型)
      • [2.10.1 使用strconv包的函数](#2.10.1 使用strconv包的函数)

之前我学过C、Java、Python语言时总结的经验:

  1. 先建立整体框架,然后再去抠细节。
  2. 先Know how,然后know why。
  3. 先做出来,然后再去一点点研究,才会事半功倍。
  4. 适当的囫囵吞枣。因为死抠某个知识点很浪费时间的。
  5. 对于GO语言,切记遵守语法格式规则。(例如python语言、例如SpringBoot框架等)
    解释:某些知识点,就是很难了解,那么先做出来,然后继续向前学习,可能在某个时间点我们就会恍然大悟。

一、变量

1.1 变量的定义:

  • 任何高级程序语言写程序,变量都是程序的基本组成单位。
  • 变量相当于内存中一个数据存储空间的表示,你可以把变量看做是一个房间的门牌号,通过门牌号我们可以找到房间,同样的道理,通过变量名可以访问到变量()

1.2 变量的声明、初始化、赋值

  1. 声明变量(定义变量)

基本语法: var 变量名 数据类型

var a int

  1. 变量赋值

在声明变量的时候,就给值

var a int = 1

var b = 300

  1. 使用变量

var a int

a = 100

例如下面的a/b/c都是变量

go 复制代码
package main

import "fmt"

func main() {
	var a int  //声明变量
	a = 10     //变量赋值
	b := 20    //变量赋值
	c := a + b //使用变量
	fmt.Println(a) // 10
	fmt.Println(b) // 20
	fmt.Println(c) // 30
}

1.3 变量使用的注意事项

  1. 变量表示内存中的一个存储区域
  2. 该区域有自己的名称(变量名)和类型(数据类型)

所有代码会用磁盘中读取到内存中,进行运行。

那么变量,例如a = 10 。那么就会存储到内存中。

  1. Golang变量使用的三种方式

    1. 第一种:指定变量类型,声明后若不赋值,使用默认值。

    int类型默认为0

    String类型默认为空

    1. 第二种:根据值自行判定变量类型(类型推导)

    如果不指定类型,那么就会go语言类型推导。

    var a = "abc" 在打印的时候就会输出string类型

    1. 第三种省略var,注意:=左侧的变量不应该是已经声明过的,否则会导致编译错误

    两种方式:(方式一的两句话,等价于方式二)

    > var name1 string

    name1 = "zhangsan1" //方式一

    name2 := "zhangsan2" //方式二

  2. 多变量声明

    在编程中,有时我们需要一次性声明多个变量,Golang也提供这样的语法

go 复制代码
形式一:
var a, a1, a2, a3 int
a = 10
a1 = 20
a2 = 30
a3 = 40


形式二:
var a1, a2, a3, name = 1, 2, 3, "zhangsan"
	fmt.Println(a1,a12,a23,a4)

形式三:
a, b, c, d, name := 1, 2, 3, 4, "zhangsan"
fmt.Println(a,b,c,d,name)

关于全局变量:

go 复制代码
var (
	a    = 1
	b    = 2
	c    = 3
	d    = 4
	name = "zhangsan"
)
func main() {
	fmt.Println(a, b, c, d, name)
}
  1. 该区域的数据值可以在同一类型范围内不断变化
  2. 变量在同一个作用域内不能重名
  3. 变量=变量名+值+数据类型,这一点请大家注意。
  4. Golang的变量如果没有赋初值,编译器会使用默认值,比如int默认值0 string默认值为空用

插播-关于fmt.Printf格式打印%的作用

参考的官网地址是:https://studygolang.com/pkgdoc

go 复制代码
通用:
%v	值的默认格式表示
%+v	类似%v,但输出结构体时会添加字段名
%#v	值的Go语法表示
%T	值的类型的Go语法表示
%%	百分号

布尔值:
%t	单词true或false

整数:

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

浮点数与复数的两个组分:

%b	无小数部分、二进制指数的科学计数法,如-123456p-78;参见strconv.FormatFloat
%e	科学计数法,如-1234.456e+78
%E	科学计数法,如-1234.456E+78
%f	有小数部分但无指数部分,如123.456
%F	等价于%f
%g	根据实际情况采用%e或%f格式(以获得更简洁、准确的输出)
%G	根据实际情况采用%E或%F格式(以获得更简洁、准确的输出)

字符串和[]byte:

%s	直接输出字符串或者[]byte
%q	该值对应的双引号括起来的go语法字符串字面值,必要时会采用安全的转义表示
%x	每个字节用两字符十六进制数表示(使用a-f)
%X	每个字节用两字符十六进制数表示(使用A-F)    

指针:

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

二、 变量的数据类型

2.1整数的基本类型

简单的说,就是用于存放整数值的,比如 0,-1,2345 等等。

2.1.1 有符号类型 int8/16/32/64

** int8 范围是:-128 ~ 127**

2.1.2 无符号类型 int8/16/32/64

int 无符号类型:

2.1.3 整型类型 int、uint、rune、byte

2.1.4 整型的使用细节

  1. Golang 各整数类型分: 有符号和无符号,int uint 的大小和系统有关
  2. Golang 的整型默认声明为 int 型
  3. 如何在程序查看某个变量的字节大小和数据类型
go 复制代码
import (
	"fmt"
	unsafe "unsafe"
)

	var n1 = 100
	fmt.Printf("n1 的类型是 %T ", n1) //n1 的类型是 int

	var n2 int64 = 1
	fmt.Printf("n1 的数据类型是 %T, n2 占用的字节数是%d", n2, unsafe.Sizeof(n2))
	//   n1 的数据类型是 int64, n2 占用的字节数是8
  1. olang 程序中整型变量在使用时,遵守保小不保大的原则,即:在保证程序正确运行下,尽量使用占用空间小的数据类型。[如: 年龄]
  2. bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。[二进制再详细说] 1byte = 8 bit

2.2 浮点类型

Golang的浮点类型可以表示一个小数,比如1.2 / 3333.11 / 3232.324等等

2.2.1 小数类型分类

  1. 关于浮点数在机器中存放形式的简单说明.浮点数=符号位+指数位+尾数位说明: 浮点数都是有符号的.
  2. 如果使用float32 可能造成精度损失。

开发过程中,推荐使用float64。 并且默认也是float64 .

Golang浮点类型有固定的范围和字段类型,不受具体操作系统的影响。

  1. 浮点型的存储分为三个部分:符号位+指数位+尾数位。 在存储过程中,精度会有丢失

2.3 字符类型

2.3.1 基本介绍

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

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

  1. 如果我们保存的字符在 ASCII 表的,比如[0-1,a-z,A-Z.]直接可以保存到 byte2)
  2. 如果我们保存的字符对应码值大于 255,这时我们可以考虑使用 int 类型保存3)
  3. 如果我们需要安装字符的方式输出,这时我们需要格式化输出,即 fmt.Printfr"%c",cl)...
go 复制代码
var n2 int = '你'
	fmt.Printf("n2 的数据类型是 %T, n2 占用的字节数是%d.  \n", n2, unsafe.Sizeof(n2))
	// n2 的数据类型是 int, n2 占用的字节数是8. 

	var c3 int = '你'
	fmt.Printf("c3 = %c \n", c3)	//c3 = 你	
	fmt.Printf("%c", c3) 			//你

2.3.2 字符使用细节

  1. 字符型 存储到 计算机中,需要将字符对应的码值 (整数) 找出来存储:字符--->对应码值---->二进制-->存储
    读取:二进制----> 码值 ----> 字符 -> 读取
  2. 字符和码值的对应关系是通过字符编码表决定的(是规定好)
  3. Go 语言的编码都统一成了 utf-8。非常的方便,很统一,再也没有编码乱码的困扰了

2.4 布尔类型

2.4.1 基本概述

  1. 布尔类型也叫 bool类型,bool 类型数据只允许取值 true 和 false
  2. bool类型占1 个字节。
  3. bool 类型适于逻辑运算,一般用于程序流程控制
go 复制代码
	seg := true
	fmt.Printf("%T  \n", seg) //bool
	fmt.Println("seg=", seg)    //seg= true

if seg {
		fmt.Println("如果是true, 我就打印")
	} else {
		fmt.Println("如果是false, 我就打印")
	}

2.5 String类型

2.5.1 基本概述

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

go 复制代码
var name string = "今年张三,英文ZhangSan,23岁了。"
	fmt.Println(name)

2.5.2 String使用注意事项和细节

  1. Go语言的字符串的字节使用UTF-8编码标识Unicode文本,这样Golang统一使用Utf-8编码,中文乱码就不会出现了。
  2. 字符串一旦赋值后,字符串就不能单个字符修改了。在Go中字符串是不可变的。
go 复制代码
var str = "hello"
str[0] = 'b'  //这里就会报错了。字符串单个字符是不可变的。

可以直接从新赋值:
str ="word"
  1. 字符串的两种表示方式

  2. 双引号,会识别转义字符

  3. 反引号,以字符串的原生形式输出,包括换行和特殊字符,可以实现防止攻击、输出源代码等效果。

  4. 字符串拼接方式

go 复制代码
	str := "hello "
	name := "zhangsan"
	strName := str + name
	fmt.Println(strName)  //hello zhangsan
  1. 当一行字符串太长时,需要使用多行字符串,可以用"" + 进行绑定。 重点是:+ 号必须保持在上一行中。
go 复制代码
str := "lisi " + "wangwu " + " zhaoliu " + " a" +
	" b" + "c " +
	"D"

fmt.Println(str)  //lisi wangwu  zhaoliu  a bc D

2.6 基本数据类型的默认值

在Go中,数据类型都有一个默认值,当没有赋值时,就会保留默认值,在Go中,默认值又叫"零值"

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

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

基本语法:

  • 表达式T(v) 将值 v 转换为类型T
    • T:就是数据类型,比如:int32 , int64 ,float32, float64等
    • V:就是需要转换的变量
go 复制代码
var n1 int = 100
var n2 float64 = float64(n1)
n2 += 0.905
var n3 int = int(n2)
fmt.Printf("n1=%v, n2=%v, n3=%v", n1, n2, n3)
// n1=100, n2=100.905, n3=100

2.8 转换的细节(重要)

  1. 在Go中,数据类型的转换可以是从 小范围 转换到 大范围。也可以从 大范围 转换成 小范围。
  2. 被转换的是变量存储的数据(既值) ,变量本身的数据类型并没有变化。

例如:

我们将 n1 float =1.23 转换成 n2 int = 100

那么分别打印 n1 =1.23. 打印n2 =100

var n1 float64 = 1.23

var n2 int = int(n1)

fmt.Printf("n1=%v, n2=%v", n1, n2)

// 打印结果:n1=1.23, n2=1

  1. 在转换结果中,比如将Int64转换成int8 ,编译时不会报错 ,只是转换的结果是按溢出处理,和我们希望的结果不一样。
go 复制代码
var n1 int64 = 999999
var n2 int8 = int8(n1)
fmt.Printf("n1=%v, n2=%v", n1, n2)
//  n1=999999, n2=63

2.9 基本数据类型转String(重要)

在程序开发中,我们经常需要将基本数据类型转成String类型。

或者String类型转换成基本数据类型。

2.9.1 fmt.Sprintf("%参数", 变量名)

方式一: fmt.Sprintf("%参数", 表达式)

  1. 参数需要和表达式的数据类型相匹配
  2. fmt.Sprintf() 会返回转换后的字符串
go 复制代码
package main

import "fmt"

func main() {
	var n1 int = 123
	var n2 float64 = 1.23
	var n3 byte = 'a'
	var n4 bool = true
	var str string

	// %T 的意思是:该变量的类型
	// %q 的意思是:打印变量的类型,并且用双引号,引起来。
	str = fmt.Sprintf("%d", n1)
	fmt.Printf("str的类型是:%T, Str等于%q\n", str, str)

	str = fmt.Sprintf("%f", n2)
	fmt.Printf("str的类型是%T,str等于:%q \n", str, str)

	str = fmt.Sprintf("%c", n3)
	fmt.Printf("str的类型是:%T,str等于%q \n", str, str)
	str = fmt.Sprintf("%t", n4)
	fmt.Printf("str的类型是%T,str等于%q \n", str, str)
}
str的类型是string, Str等于"123"
str的类型是string, str等于:"1.230000" 
str的类型是:string str等于"a" 
str的类型是string, str等于"true" 

2.9.2 使用strconv包的函数

方式二:使用strconv包的函数

  1. func FomatBool(b lool) String

  2. func FomatInt(i int64, base int ) String

go 复制代码
	var num1 int = 123
	var num2 float64 = 1.234
	var num3 bool = true
	var str string

	fmt.Printf("num1的类型是:%T \n", num1)
	str = strconv.FormatInt(int64(num1), 10)
	fmt.Printf("str的类型是:%T,str的值是:%q \n", str, str)

	//要转换的变量,
	//'f':格式是:ddd.dddd。 一般使用的比较多
	//精度(小数点后面几位),该float的位数,例如64/32
	str = strconv.FormatFloat(num2, 'f', 2, 64)
	fmt.Printf("str的类型是:%T,str的值是%q \n", str, str)

	str = strconv.FormatBool(num3)
	fmt.Sprintf("str的类型是:%T,str的值是%q", str, str)

num1的类型是:int 
str的类型是:string,str的值是:"123" 
str的类型是:string,str的值是"1.23" 

 
Itoa 将int类型转为String类型:
var num1 int = 100
	var str string = strconv.Itoa(num1)
	fmt.Printf(str)

关于strconv.FormatFloat的参数说明:

2.10 String类型转为基本类型

2.10.1 使用strconv包的函数

func ParseBool
func ParseBool(str string) (value bool, err error)

返回字符串表示的bool值。它接受1、0、t、f、T、F、true、false、True、False、TRUE、FALSE;否则返回错误。

go 复制代码
	var str string = "true"
	var err error
	var b bool
	b, err = strconv.ParseBool(str)
	fmt.Printf("b的类型是 %T,b的值是%v,b的错误结果是:%v \n", b, b, err)

func ParseInt
func ParseInt(s string, base int, bitSize int) (i int64, err error)

返回字符串表示的整数值,接受正负号。

base指定进制(2到36),如果base为0,则会从字符串前置判断,"0x"是16进制,"0"是8进制,否则是10进制;

bitSize指定结果必须能无溢出赋值的整数类型,0、8、16、32、64 分别代表 int、int8、int16、int32、int64;返回的err是*NumErr类型的,如果语法有误,err.Error = ErrSyntax;如果结果超出类型范围err.Error = ErrRange。

go 复制代码
	var str string = "123"
	var i int64
	// 要转的字符串,base:转成10进制,bitSize:转成64位
	i, _ = strconv.ParseInt(str, 10, 0)
	fmt.Printf("i的格式是:%T,  i的值是:%v", i, i)
	// i的格式是:int64,  i的值是:123
  • func ParseFloat
    func ParseFloat(s string, bitSize int) (f float64, err error)

解析一个表示浮点数的字符串并返回其值。

如果s合乎语法规则,函数会返回最为接近s表示值的一个浮点数(使用IEEE754规范舍入)。bitSize指定了期望的接收类型,32是float32(返回值可以不改变精确值的赋值给float32),64是float64;返回值err是*NumErr类型的,语法有误的,err.Error=ErrSyntax;结果超出表示范围的,返回值f为±Inf,err.Error= ErrRange。

go 复制代码
	var str string = "1.2345"
	var f float64
	f, _ = strconv.ParseFloat(str, 64)
	fmt.Printf("f的类型是%T, f的值是:%v", f, f)
	// f的类型是float64, f的值是:1.2345
相关推荐
Swift社区2 小时前
在 Swift 中实现字符串分割问题:以字典中的单词构造句子
开发语言·ios·swift
没头脑的ht2 小时前
Swift内存访问冲突
开发语言·ios·swift
没头脑的ht2 小时前
Swift闭包的本质
开发语言·ios·swift
wjs20242 小时前
Swift 数组
开发语言
stm 学习ing3 小时前
FPGA 第十讲 避免latch的产生
c语言·开发语言·单片机·嵌入式硬件·fpga开发·fpga
Estar.Lee3 小时前
查手机号归属地免费API接口教程
android·网络·后端·网络协议·tcp/ip·oneapi
湫ccc4 小时前
《Python基础》之字符串格式化输出
开发语言·python
mqiqe5 小时前
Python MySQL通过Binlog 获取变更记录 恢复数据
开发语言·python·mysql
AttackingLin5 小时前
2024强网杯--babyheap house of apple2解法
linux·开发语言·python