浅学Golang_02

二、 基础知识

2.1 基本语法

2.1.1 Go语言转义字符

（1） \t :一个制表位，实现对齐的功能（常用于排版）

（2） \n ：换行符

（3） \ ： 一个\

（4） \" ：一个"

（5） \r ：一个回车

package main
import "fmt"
func main(){
	//制表
	fmt.Println("春花秋月\t何时了")
	//换行
	fmt.Println("春花秋月 \n何时了")
	// \"
	fmt.Println("人生\"得意\"须尽欢")
	// 回车  从当前行的最前面开始输出，覆盖掉以前的内容
	fmt.Println("人生得意\r须尽\r欢")
}
--------------------------------
执行结果：
花秋月        何时了
春花秋月 
何时了
人生"得意"须尽欢
欢尽得意

2.2 变量

2.2.1 变量的使用步骤

1. 声明变量

2. 非变量赋值

3. 使用变量

package main
import "fmt"

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

2.2.2 变量使用注意事项

（1）变量表示内存中的一个存储区域

（2）该区域有自己的名称（变量名）和类型(数据类型)

（3）GoLang变量使用的三种方式

​ a. 第一种：指定变量类型，声明后若不赋值，使用默认值

​ b. 第二种：根据值自行判断变量类型（类型推到）

​ c. 第三种：省略 var ，（注意：=左侧的变量不应该是已经声明过的，否则会导致编译错误）

package main
import "fmt"

func main(){
	// 第一种：指定变量类型，声明后若不赋值，使用默认值
	var i int
	fmt.Println("i=", i)

	// 第二种：根据值自行判断变量类型（类型推到）
	var j = 10.11
	fmt.Println("j=", j)

	// 第三种：省略 var   冒号不能省略
	k := "abc"
	fmt.Println("k=",k)
}

（4）该区域的数据值可以在同一类型范围内不断变化

（5）变量在同一个作用域内不能重名

（6）变量 = 变量名+值 +数据类型

（7）如果变量没有赋予初值，编译器会使用默认值

2.2.3 多变量声明

一次性声明多个变量

//  多变量声明
package main
import "fmt"

func main(){
	// 方式一
	var n1, n2, n3 int
	fmt.Println("n1=", n1,"n2=", n2,"n3=", n3)

	// 方式二
	var sort, name ,age = 100,"tom",18
	fmt.Println("sort=", sort,"name=", name,"age=", age)

	// 方式三 （类型推导）
	sort2, name2, age2 := 100,"tom",18
	fmt.Println("sort2=", sort2,"name2=", name2,"age2=", age2)
}

2.2.4 全局变量声明

package main
import "fmt"

// 定义全局变量 方式一
var c1 = 101
var c2 = "chenhua"
// 定义全局变量 方式二
var (
	c3 = 202
	c4 = "heshiliao"
)

func main(){
	fmt.Println("c1=", c1)
	fmt.Println("c2=", c2)
	fmt.Println("c3=", c3)
	fmt.Println("c4=", c4)
}

2.2.5 + 加号的使用

（1） 当左右两边都是数值型时，则做加法运算

（2）当左右两边都是字符串，则做字符串拼接

ackage main
import "fmt"

func main(){
	var i = 1
	var j = 2
	var r int
	r = i + j
	fmt.Println ("r=",r)

	var  str1 = "chen"
	var  str2 = "hua"
	var s = str1 + str2
	fmt.Println(s)
}

2.2.6 查看数据类型

package main
import "fmt"
import "unsafe"

func main(){
	//查看某个变量的数据类型
	var n = 20;
	fmt.Printf("n1 的类型是：%T ",n)

	//查看某个变量的占用字节大小和数据类型
	var m int8= 12;
	fmt.Printf("\nm 的数据类型 %T,    m 占用的字节数是 %d",m, unsafe.Sizeof(m))
}

2.3 变量的数据类型

(1) 基本数据类型：

​ a. 数值型（整数类型，浮点类型） (int8,int16,int32,int64,uint,uint8,uint16,uint32,uint64,byte / float32,float64)

​ b. 字符型（没有专门的字符型，使用byte[]来保存单个字母字符）

​ c. 布尔型（bool)

​ d. 字符串（string)

(2) 派生/复杂数据类型

​ a. 指针(pointer)

​ b. 数组

​ c. 结构体（struct）

​ d. 管道（channel)

​ e. 函数

​ f. 切片(slice)

​ g. 接口(interface)

​ h. map

2.3.1 整数类型

简单的说，就是用于存放整数值的

有符号： int

无符号：uint

rune 等价 int32，表示一个unicode码

byte 等价uint8 （当要存储字符时，选用byte）

注意：Golang程序中整型变量在使用时，遵守保小不保大的原则

2.3.2 小数类型/浮点型

小数类型就是用于存放小数的

说明：

（1）浮点数在在机器中存放的形式：浮点数=符号位+指数位+尾数位

（2）尾数部分可能丢失，造成精度损失

2.3.2 字符类型

（1）如果保存的字符在ASCII表中，可以使用byte类型保存

（2）如果保存的字符对应码值大于255，可以使用int类型保存

package main
import "fmt"

func main(){
	var c1 byte = 'a'
	var c2 byte = '0'

	//直接输出byte值时，输出的对应的字符的Ascll码值
	fmt.Println("c1=",c1)
	fmt.Println("c2=",c2)

	//如果需要输出对应字符，需要使用格式化输出
	fmt.Printf("c1=%c c2=%c",c1,c2)

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

2.3.3 布尔类型

（1）bool类型只允许取值true和false（不能赋予数值）

（2）bool类型占1个字节

（3）bool类型适于逻辑运算，一般用于流程控制

2.3.4 字符串类型

（1）Go语言的字符串使用UTF-8编码标识Unicode文本

（2）字符串一旦赋值，就不可再做修改

（3）字符串的两种表现形式

​ a. 双引号，会识别转移字符

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

package main
import "fmt"

func main(){
	var s1 = "hello"
	fmt.Println("s1=",s1[0])

	fmt.Println("人生得意\n需尽欢！")
	fmt.Println(`"""人生得意\n需尽欢！`)	


	//字符串拼接
	var s2= "hello" + "world" +
	 "hello" + "world" +
	 "hello" + "world"
	 fmt.Println(s2)
}

2.4 基本数据类型的转换

Golang和java等不同，Go在不同类型的变量质检赋值时需要显式转换，不可自动转换

package main
import "fmt"

func main(){
	var i int = 100
	// 转float
	var f1 float32 = float32(i)
	fmt.Println("f1=",f1)
	fmt.Printf("f1的类型 %T",f1)
	// f1 转int
	var ii int = int(f1)
	fmt.Println("\nii=",ii)
}

细节：

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

2、被转换的是变量存储的数据（变量的值），变量本身的数据类型并没有变化

2.5 基本数据类型和string的转换

2.5.1 基本数据类型转string

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

方式二： 使用strconv包的函数

package main
import (
	"fmt"
	"strconv"
)
// 基本数据类型转string
func main(){

	var num1 int = 101
	var num2 float32 = 3.36
	var b bool = true
	var myc byte = 'h'

	// 方式一：使用Sprintf
	var str string 
	str = fmt.Sprintf("%d",num1)
	fmt.Printf("str的类型  %T;str=%v;",str,str)

	str = fmt.Sprintf("%f",num2)
	fmt.Printf("\nstr的类型  %T;str=%v;",str,str)


	str = fmt.Sprintf("%t",b)
	fmt.Printf("\nstr的类型  %T;str=%q;",str,str)

	str = fmt.Sprintf("%c",myc)
	fmt.Printf("\nstr的类型  %T;str=%q;",str,str)

	// 方式二  strconv包
	var cstr string 
	cstr = strconv.FormatInt(int64(num1),10)
	fmt.Printf("\ncstr的类型  %T;cstrr=%v;",cstr,cstr)

	cstr = strconv.FormatFloat(float64(num2),'f',5,64)
	fmt.Printf("\ncstr的类型  %T;cstrr=%v;",cstr,cstr)

	cstr = strconv.FormatBool(b)
	fmt.Printf("\ncstr的类型  %T;cstrr=%v;",cstr,cstr)

	// 其他:strconv包中有一个函数Itoa,可以将int 转string
	var num3  int64= 1254
	cstr = strconv.Itoa(int(num3)) 
	fmt.Printf("\n cstr的类型:%T ; cstr = %v",cstr,cstr)
}

2.5.2 string转基本数据类型

package main
import (
	"fmt"
	"strconv"
)

func main(){
	var str string = "true"
	var b bool
	//strconv.ParseBool 会返回两个值   func ParseBool(str string) (value bool, err error)
	// 可以用下划线_ 忽略 返回的第二个值error
	b , _= strconv.ParseBool(str)
	fmt.Printf("b的类型 %T,b= %v",b,b)

	// func ParseInt(s string, base int, bitSize int) (i int64, err error)
	// base指定进制
	// bitSize指定结果必须能无溢出赋值的整数类型 ,0、8、16、32、64 分别代表 int、int8、int16、int32、int64
	var str2 string  = "12365"
	var i int64
	i,_ = strconv.ParseInt(str2,10,64)
	fmt.Printf("\ni的类型 %T,i= %v",i,i)


	// func ParseFloat(s string, bitSize int) (f float64, err error)
	var str3 string = "88.888"
	var f float64
	f ,_ = strconv.ParseFloat(str3,64)
	fmt.Printf("\nf的类型 %T,f= %v",f,f)
}

2.5.3 注意事项

在将string类型转成基本数据类型时，要确保string类型能够转成有效的数据

2.6 指针

2.6.1 获取变量的地址

package main
import(
	"fmt"
)

func main(){
	var i int  = 10
	var i2 int  = 11
	fmt.Println(i)
	fmt.Println("i的地址=",&i)
	fmt.Println("i2的地址=",&i2)
}

2.6.2 指针

指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值

package main
import(
	"fmt"
)

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

	// ptr是一个指针变量，
	// ptr的类型是*int
	// ptr本身的值是&i
	var ptr *int = &i
	fmt.Printf("ptr = %v",ptr)

	// 获取指针类型所指向的值，使用 *,   *ptr 获取ptr指向的值
	fmt.Println("\nptr的值",*ptr)
}

	// 需求：获取一个变量num的地址，并显示到终端
	// 将num的地址赋给指针ptr，并通过ptr去修改num的值
	var num int =10
	var ptr *int = &num
	*ptr = 11
	fmt.Println("num的值：",num)

2.7 标识符的命名规范

（1）标识符由26个英文字母大小写，0~9，_组成

（2）数字不可以开头

（3）严格区分大小写

（4）标识符不能包含空格

（5）_ 本身在Go中是一个特殊的标识符，称为空标识符，可以代表任何其他的标识符，但是它对应的值会背忽略（如忽略某个返回值）

（6） 不能以系统保留关键字作为标识符，比如break，if等

（7）如果变量名、函数名、常量名首字母大写，则可以被其他的包访问，如果首字母小写，则只能在本包中使用（简单来说，就是首字母大写是公有的，首字母小写是私有的）

2.8 go mod init

2.9 运算符

运算符是一种特殊的符号，用以标识数据的运算、赋值和比较

（1）算数运算符

（2）赋值运算符

（3）比较运算符

（4）逻辑运算符

（5）位运算符

（6）其他运算符

2.9.1 算数运算符

// 算数运算符： +  -  *   /   %取模   ++自增  --自减
func main(){
	
	// 如果参与除运算的都是整数，结果只会保留整数部分，去掉小数部分
	fmt.Println(10/4)
	// 如果需要保留小数部分，需要有浮点数参与运算
	fmt.Println(10/4.0)

	// % 的运算   公式  a % b = a - a/b *b
	fmt.Println("10%3=",10 % 3)   // 1 
	fmt.Println("-10%3=",-10 % 3)  // -1
	fmt.Println("10%-3=",10 % -3)  // 1
	fmt.Println("-10%-3=",-10 % -3)  //  -1
}

2.9.2 关系运算符

（1）关系运算符的结果都是bool型，要么是true，要么是false

（2）关系表达式经常用在 if结构的条件中或循环结构的条件中

2.9.3 逻辑运算符

用于连接多个条件，最终结果是一个bool值

&&： 逻辑与 （短路与） ；

||： 逻辑或 （短路或） ；

！：逻辑非

2.9.4 赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量

= ： 简单的赋值运算符

+= ： 相加后再赋值

-= ： 相减后再赋值

*= ： 相乘后再赋值

/= ： 想除后再赋值

%= ： 求余后再赋值

func main(){
	// 有两个变量，a和b，要求将其进行交换，但是不允许使用中间变量
	var a int = 10
	var b int = 8

	a = a + b
	b = a - b // b = a+b -b
	a = a - b // a + b - a -b + b
	fmt.Println(a)
	fmt.Println(b)
}

2.9.5 其他运算符

& ：返回变量存储地址

*：取指针变量

func main(){
	a := 100
	fmt.Println ("a 的地址是",&a)

	var ptr *int  = &a;
	fmt.Println("ptr 指向的变量是：",*ptr)
}

2.10 键盘输入语句

func Scanln(a ...interface{}) (n int, err error)

func Scanf(str string, format string, a ...interface{}) (n int, err error)

func main(){
	// 1、scanln
	//    声明需要的变量
	var name string
	var age int
	var sal float32
	var ispass bool
	fmt.Println("请输入姓名")
	fmt.Scanln(&name)
	fmt.Println("请输入年龄")
	fmt.Scanln(&age)
	fmt.Println("请输入薪水")
	fmt.Scanln(&sal)
	fmt.Println("请输入结果")
	fmt.Scanln(&ispass)

	fmt.Println("姓名：",name)
	fmt.Println("年龄：",age)
	fmt.Println("薪水：",sal)
	fmt.Println("结果：",ispass)

	// 方式二：fmt.scanf,可以按指定格式输入
	fmt.Println("请输入你的姓名，年龄，薪水，是否通过考试，空格隔开")
	fmt.Scanf("%s %d %f %t",&name,&age,&sal,&ispass)
	fmt.Println("姓名：",name)
	fmt.Println("年龄：",age)
	fmt.Println("薪水：",sal)
	fmt.Println("结果：",ispass)
}

2.11 原码、反码、补码

（1）二进制的最高位是符号位：0 表示整数，1表示复数

（2）正数的原码、反码、补码都一样

（3） 负数的反码 = 它的原码符号位不变，其他位取反

（4）负数的补码 = 它的反码 + 1

（5） 0 的反码、补码都是0

（6）在计算机运算的时候，都是以补码的方式来运算的

2.12 位运算

& ：按位与 （两位全为1，结果为1，否则为0）

| ： 按位或（两位有一个为1，结果为1，否则为0）

^ ：按位异或（两为一个为0，一个为1，结果为1，否则为0）