尚硅谷Go语言总结

金盏花

已于 2022-02-28 20:58:04 修改

阅读量690

点赞数

文章标签： golang 开发语言后端

于 2022-01-15 15:23:29 首次发布

本文链接：https://blog.csdn.net/qq_39817758/article/details/122510740

版权

在这里插入图片描述
一、变量
1.变量的含义
变量占内存中的存储空间；变量=变量类型+变量名+值
2.变量的使用
三步骤：声明、初始化、赋值
（1）单变量的三种使用方式：

//第一种
var i int
i = 10
// 第二种：类型自动推导
var i = 20
// 第三种
i := 20
//或者
var i int = 10

（2）多变量的两种使用方式`

// 第一种
var i = 1
var j = 2 
var k = 3
或者
var(
	i = 1
	j = 2
	k = 3
)
// 第二种
i,j,k := 1,2,3

3.数据的基本类型
数据类型占据不同大小的存储空间
包括：基本数据类型（数值型、字符型、字符串型、布尔型）和复杂数据类型（数组、map等等）

3.1 整型
整型包括：有符号和无符号，int 和uint 所占空间的大小和计算机的位数有关
注意：bit(位)是计算机最小的最小存储单元；byte是计算机基本的存储单位 1字节 = 1byte = 8 bit
（1）分类
无符号：unit、int8（1字节）、int16（2字节）、int32（4字节）、int64（8字节） —>范围是（0~2^(bit位数)-1）
有符号：int、int8（1字节）、int16（2字节）、int32（4字节）、int64 （8字节）（最高位是符号位，0\1）–>范围是(-2^{(bit位数-1)~2}(bit位数-1)-1)
byte类型 = uint8 类型
注意： unit和int : 32位系统是4字节、64位系统是8字节
在不赋值的情况下默认为 int 类型
3.2 小数类型
包括：单精度 float32 和双精度 float64；存储方式 = 浮点数 + 指数位 + 尾数 ; 浮点数都是有符号的，默认是float64
（1）浮点数的两种表示方式
. 表示：7.82 、.82(0.82)
科学计数法：7.82E2 、7.82E-2(0.0782)
3.3 字符类型
字符本质上是整型，一个数字代表一个字符，一般情况下用byte 存储（ASCII 码的0-255：比如 0-9 a-z A-Z）超出8 bit 一般用 int存储 ;
英文一般是 1字节、汉字一般是3字节
字符用单引号（’‘）表示，输出字符需要用 %c ，否则输出的是整数；’\n‘用 \ 表示转义字符，它的%c 的表现形式就是换行
字符串是由一系列的字节表示，由字符组成；Go语言的编码方式是utf-8 ;字符类型可以进行运算
注意：字符类型的存储和读取本质
存储：字符–>码值–二进制–存储
读取：二进制–码值–字符–读取
3.4 字符串类型 string
(1) 字符串是一连串的字符组成；go 语言中的字符串不可变，因此不可以修改
（2）用双引号（转义后的）或者反引号（可表示特殊字符）括号
（3）“+ ”字符串连接
3.5 布尔类型 bool
(1) 占用1字节，只能取值 true 或者 false
注意：各种数据类型的默认值
整型、浮点型 0 布尔型 false 字符串型 “”
3.6 各种数据类型的转换
数据之间的强制转换：不管是运算计算还是函数的参数要求，都需要类型匹配
3.6.1 基本数据类型之间的转换
（1）Go中，必须显式转换 T（v）：数据类型（变量），不存在强制转换；变得是数值，数据类型不变
(2) 若超出数值范围，溢出处理
3.6.2 基本数据类类型和 string 之间的转换
三种方式：
（1）fmt.Sprintf():格式化转换
注意：Go 语言的格式化输出：注意两个区别
fmt.Sprintf(格式化样式, 参数列表…) ：转换格式，返回一个字符串
fmt.Printf() : 打印输出
Printf 知识点
Sprintf 知识点
（1）%v %b %o %d %x %X : 原数值、二进制、八进制、十进值、小写的十六进制、大写的十六进制输出
（2）%f %c %t %T :浮点数、单个字符、布尔类型、数据类型输出
格式化转换
（2）方式二：strconv 包中的函数
函数1 ： Format 系列函数–>包括 FormatBool()、FormatInt()、FormatUint()、FormatFloat() 将基本类型转换为字符串
func FormatBool(b bool) string
func FormatInt(i int64, base int) string --> base 代表几进制
func FormatUint(i uint64, base int) string
func FormatFloat(f float64, fmt byte, prec, bitSize int) string --> 分别代表进制表示、精度、来源位数
函数2：Parse 系列函数–>将字符串转换为指定类型的值，包括 ParseBool()、ParseFloat()、ParseInt()、ParseUint()
func ParseBool(str string) (value bool, err error) --> str只能是 1、0、t、f、T、F、true、false、True、False、TRUE、FALSE ； err 中nil (零值或空值)只能赋值给指针或接口
func ParseInt(s string, base int, bitSize int) (i int64, err error) base 进制；bitSize 位数且不溢出；err:若有语法错误，则返回
func ParseUint(s string, base int, bitSize int) (n uint64, err error)
func ParseFloat(s string, bitSize int) (f float64, err error) bitSize 代表返回的位数
注意：将字符串转为基本类型必须转换为有效的数值，否则将返回默认值。
4、复杂数据类型–指针
基本数据类型: 内存地址中存放着数值
&i,取地址； ptr *int = &i–>指针类型； &ptr 就是指针类型所在的地址，*ptr就是指针类型所指地址的数值中的数值，可以修改—> 通过修改 *ptr来修改地址中存放的数值
注意：
*（1）值类型都有对应的指针类型 数据类型值类型有: int\float\bool\string\数组\结构体系列等
(2) 值类型(栈区) 和引用类型（堆区）的区别值类型本身存储的是一个变量值；引用类型存储的是一个地址，地址对应的是变量值
引用类型包括：指针、Map、切片Slice、管道chan、接口interface
5、标识符
名字：变量、常量名称、函数名称
命名规则：
（1）以26个大小写字母命名、0-9、_ch哦你给图
(2) 不以数字开头，不能和保留字冲突
（3）区分大小写
（4）_不单独以下划线命名，go中有表示占位的作用
（5）一般采取驼峰命名的方法：xxxYyyZzz，并且取有意义的名
go中没有Public 、private ，大写字母命名首字母所以的包都可以访问，小写字母首字母开头只有在本包中可以使用

6、保留字和预定义的标识符保留字和标识符

第四章运算符

一、运算符的分类
1）算数运算符：+ - + - * / % ++ – (正负加减乘除取模自增自减) 注意：自增自减只能独立使用（单独一行），不可以给其他变量赋值；只能放在变量名之后；/运算，若是除数被除数都是整数，那么结果也是整数、若是有一个是浮点数，那么结果也是浮点数；取模%运算，凡是被除数上有负号的，结果都是负数，除数上有负号的，结果都是正数，否则正常计算
2）关系运算符 == ！= > < >= <= (等于、不等于、大于、小于、大于等于、小于等于) 注意：结果都是布尔bool类型
3）赋值运算符 = += -= *= /= %= -->二进制相关 <<= >>= &= |= ^= 注意：赋值运算符的运算规则都是从右往左
4）逻辑运算符 && || ！（短路与、短路或、非）注意：结果是一个布尔型；&& || 参与两边运算的是布尔类型
go 语言中没有三目运算
运算符号的优先级别：
括号、++ – -->单目–> 算术–>移位–>关系–> 位运算–> 逻辑运算–> 赋值运算–> 逗号
在这里插入图片描述
二、键盘输入

scanln 和 scanf 的区别
1）scanln 是按照输入一行空格，继续输入
2）sacnf 按照指定的格式输入按空格输入，在循环中可能会出现跳跃次数
//先定义，后输入
fmt.Scanf（"%d  %s...",&age,&name）  //注意！！！！！    格式化用空格隔开
fmt.Scanln(&name)

三、进制
二进制、八进制（0开头）、十进值、十六进制（0x\0X开头）
注意：各个进制之间的转换（以二进制为媒介）

-------------------------------注意：负数的移动位置还没有看-------------------------------------------------

第五章程序流程控制

一、三种结构
1）顺序结构
2）分支结构
3）循环结构
二、三种结构
2.1 顺序结构
从上往下执行，后边使用到的变量前边要定义过
2.2 分支结构

三种：单分支、双分支、多分支：这三种分直都是一次执行其中的一路分支

//单分支
if  条件表达式 {
	执行体
}
注意：
1）必须有{}
2）条件表达式一般没有  （）
3）条件表达体这块可以定义变量，并执行表达判断，用分号隔开；if 中当不满足条件时，该分支可能没有走到，因此该分支定义的变量后边不能直接使用（无定义错误）

//双分支
if　条件表达式｛
	执行体1
｝else{
	执行体2
}
注意：
1）else 必须和} 在一行，和{  在一行 不能换行
2）若条件表表达式有多个选项  可以用（）括起来表示一个选择

//多分支
if　条件表达式1｛
	执行体1
｝ else if 条件表达式2{
	执行体2
} else if 条件表达式3{
	执行体3
}..else{
	执行体N
}
注意：
1）最后的else   可有可无
2）多分支最选择其中一个，分支不能重复；只要执行了其中的一条分支，下边不继续执行了，（范围选择上的问题）
3）if  后边的条件表达式不能是 赋值语句  比如： b = true  编译错误
注意： 可以使用嵌套循环，一般不超过两层

//switch 分支循环
switch 表达式 {
	case 情况1，情况2，...:
		执行体
	case 情况1，情况2，...:
		执行体
	case 情况1，情况2，...:
		执行体
	...
	default:
	 执行体
}
注意：
1）case 的执行体后不用写break ，因为匹配到一种情况就直接选择，否则直接 用 default；default不是必须的
2)一般表达式实现计算出数值，然后再和 case 里边的值比较；switch/case 后边一般是 表达式、常量、有返回值的函数

//switch 使用情况1 switch 后边不带表达式，类似于 if-else 
switch 中的穿透 fallthrough //switch 中没有break fallthrough 默认穿透一层，如果上一层匹配，穿透一层就是下边直接的条件，否则按照原始的 条件分支选择顺序

注意： switch 和 if 比较
1）但数值不多：常数、浮点数、字符串等 用switch 表示范围 一般用 if

2.3 循环结构

//for 循环
for 循环变量初始化；判断条件；循环条件迭代{
	循环体
}

//第二种 用法，初始化写在前边
循环变量初始化
for 循环条件{
	循环体
	循环变量的迭代
}

//第三种  类似于死循环，但是条件都是写在里边了
for ;;{
}

循环变量初始化
for {
	//循环条件
	if--else{
	//配合 break 使用跳出循环
	}
	 循环变量迭代
}

//使用  for-range 遍历字符串 ，有index 和 value
	//从第二个位置上开始，遍历字符串
	var str  string = "hello,yage" 
	for index, value := range str{
		fmt.Printf("%d %c", index,value)
	}

注意: 
1）对于传统的字符串的遍历 ，对于汉字的遍历是不可行的，汉字占三个字节，但是按照1个字节的方式遍历的；可以通过对字符串切片的方式实现遍历
2）for - range 是可以遍历汉字字符串的

//切片的方式实现遍历汉字字符串
	//遍历字符串
	var str  string = "hello,雅阁" 
	str2 := []rune(str)
	for i := 0; i < len(str2);i++{
		fmt.Printf("%c", str2[i])
	}

注意：go 语言中 没有  do while  和  while 语法，但是可以通过 for来实现
//while 循环
循环变量初始化
for{
	if (循环条件，配合break使用)
	循环体
	循环变量迭代
}
 
 //do- while 循环
循环变量初始化
for{
	循环体
	循环变量迭代
	if{
	循环条件的判断
	}
}

//例子
	i := 0;
	for {
		fmt.Println("hello,world")
		i++
		if i > 9{
			break
		}
	}
	
	注意 ：多重循环，内层循环和外层循环的搭配使用  m*n

注意：以API为准，学习每个api 要看懂参数含义和用法，scanf 就是如此

生成指定位数的随机数

//方式一：利用系统时间指定生成随机数
func Seed(seed int64)
rand.Seed(time.Now().Unix())  // 初始种子，初始器不一样随机数产生的也不一样；time.Now().Unix() 获取当前时间，因此每一次都不一样
	for i:=0; i<10; i++ {
		fmt.Print(rand.Intn(10), " ")
	}
    fmt.Println(rand.Int())       // int随机值，返回值为int

    fmt.Println(rand.Intn(100))   // [0,100)的随机值，返回值为int

    fmt.Println(rand.Int31())     // 31位int随机值，返回值为int32

    fmt.Println(rand.Int31n(100)) // [0,100)的随机值，返回值为int32

    fmt.Println(rand.Float32())   // 32位float随机值，返回值为float32

    fmt.Println(rand.Float64())   // 64位float随机值，返回值为float64

关于终止程序或者跳转程序

// continue break goto tuturn 
1)continue break 表示跳出本层循环和终止本层循环；
2）continue break label 后边加上label 跳出、跳过固定的某层循环；一般情况下就是跳出最近的循环，也就是一层
3） goto label 表示 跳到固定的地方，一般不用
4）return 返回本函数或方法，不往下执行；如果是在main函数中，表示终止程序

第六章函数、包和错误处理

一、函数
1、函数概念

（1）函数功能：减少代码冗余、便于维护
（2）函数的概念：完成某一功能的代码的集合
		函数分为：系统函数和自定义函数

2、函数语法

func 函数名 （形参列表）（返回值列表）{
	执行语句
	return 返回值列表
	}

举例:

package main
import "fmt"



//函数
func test (n1 float64, n2 float64, n3 byte)(float64){
	res  := 0.0  //默认返回类型
	switch n3 {
		case '+':
			res = n1 + n2
		case '-':
			res = n1 - n2
		case '*':
			res = n1 * n2
		case '/':
			res = n1 / n2
		default:
			fmt.Println("输入错误")
	}
	return res
}


//主函数
var name string = "yage"
//name = "yge"
func main() {
	//函数的递调用
	//n1 := test(10)
	res := test(1.0, 2.0, '/')
	fmt.Println("res = ",res)
}

3、函数的调用机制
基本数据类型一般在栈区
注意

1、调用函数时，会在栈区分配新的空间，和原来的空间区分开；空间互相独立，不会混淆

二、包
-------------------------注意此处没有实现方法----------------------------------
1、包的含义和功能
（1）功能
每个程序都是一个包，go是以包的形式管理项目文件目录

1、管理同名的函数、变量等标识符
2、控制函数、变量的访问范围、即作用域
3、当程序的文件比较多时，便于管理项目文件

（2）包的语法

//1、打包
pakage 包名
//2、引入包
//方式1
import "包的路径"
//方式2
import (
	"包的路径1"
	"包的路径2"
)

注意：

1、一个文件对应一个包，包名和文件名一样，一般为写
2、当一个文件要使用其他文件的函数和变量时，要先引入其他文件对应的包；引入包，从src下边开始就行，编译器自动从src下边开始
3、为了其他包访问到本包，函数名应该大写，类似于pubilc；若是函数名称小写，那么类似于private

访问其他包的函数/变量的语法

包名.函数名

注意

1、当包名过长时，可以给其起别名；起别名后，原来的名字就不能使用了
2、编译可执行程序，包名为main；编译自定义库，包名可以自定义

金盏花

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
尚硅谷Go语言总结

一、变量变量的含义变量占内存中的存储空间；变量=变量类型+变量名+值2.变量的使用三步骤：声明、赋值、使用（1）单变量的三种使用方式：//第一种var i inti = 10// 第二种：类型自动推导var i = 20// 第三种i := 20（2）多变量的两种使用方式`// 第一种var i = 1var j = 2 var k = 3或者var( i = 1 j = 2 k = 3)// 第二种i,j,k := 1,2,3...
复制链接

扫一扫