Go——基础（1）
最近因为又报了那边的青训，后端方向的，应该是全程使用Go语言的，所以把暑假整理的笔记拿来复习一下。然后这次应该不会全程参与，主要是探索一下自己适不适合后端的工作，就先这样吧，然后下面是笔记。
包、变量和函数
包
包名与导入路径的最后一个元素一致
导入
分组导入：
import (
"math"
"fmt"
)
也可以编写多个导入
import "math"
import "fmt"导出名
- 如果一个名字以大写字母开头，就是已导出的
- 不以大写字母开头，就是未导出的
- ==在导入一个包时，只能引用其中已导出的名字==
import (
"math"
"fmt"
)
func main(){
fmt.println(math.pi)
}是运行错误的，需要将pi改为Pi函数
- 函数可以没有参数也可以接受多个参数
- 注意==类型在变量名之后==
package main
import "fmt"
func add(x int ,y int) int {
return x+y
}
func main (){
fmt.Println(add(23,42))
} - 当连续两个或多个函数的已命名形参类型相同时，除最后一个类型以外，其他都可以省略
func (x,y int)int {
}多值返回
函数可以返回任意数量的返回值
例：swap函数返回了两个字符串
package main
import "fmt"
func swap(x,y string)(string string){//返回值也写两个
return y,x
}
func main (){
a,b:=swap("world""hello")
fmt Println(a,b)
}命名返回
- Go的返回值可以被命名，它们会视作定义在函数顶部的变量
- 没有参数的return语句返回==已命名==的返回值，也就是直接返回
- 适用于==短函数==中，在长的函数中会影响可读性
package main
import "fmt"
func split(sum int)(x,y int){
x=sum*4/9
y=sum-x
return
}
func main (){
fmt Println(split(12))
}变量
var语句用于声明一个变量列表，跟函数参数一样，==类型放在最后==
var c,python,java bool
func main (){
var i int
fmt.Println(i,c,python,java)
}//输出结果是0，false,false,false 应该是默认初值变量的初始化
- 变量声明可以包含初始值
- 如果初始值已经存在，就可以省略类型；变量会从初始值中获得类型
var x,y int = 1,2
//初始值已存在省略类型：
func main() {
var c, python, java = true, false, "no!"
fmt.Println(i, j, c, python, java)
}短变量声明
在函数中，==”:=”==可以在类型明确的地方代替var
不能在函数外使用
func main (){
var x,y int =1,2
k:=3
c,python,java:=true,"no",false
fmt.Println(x,y,k,c,python,java)
}基本类型
Go的基本类型
bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte//uint8的别名
rune//int32的别名，表示一个Unicode节点
float32 float64
complex64 complex128和导入语句一样，变量声明也可以==分组==为一个==语法块==
package main
import(
"fmt"
"math/cmplx"
)
var(
x bool = false
y uint64 =1<<64-1
z complex128=cmplx.Sqrt(-5+12i)
)
func main (){
fmt.Println("Type:%T,value:%v",x,x)
fmt.Println("Type:%T,value:%v",y,y)
fmt.Println("Type:%T,value:%v",z,z)
}零值
没有明确初始值的变量声明会被赋予零值
零值：数据类型为0，bool类型为false，字符串为” “（空字符串）
var i int
var j bool类型转换
表达式T(v)，将值v转换为类型T
例：数值转换
var i int
var f float64=float64(i)类型推导
- 在声明一个变量但不指定类型时（:=语法或var=表达式语法），变量的类型由右值推导得出
- 当右值声明了类型时，新变量的类型与其相同：
var i int
j:=i//j也是一个int- 当右边包含未指明类型的数值常量时，新变量的类型就可能是int，float64或complex128了，这取决于常量的精度
i:=43//int
i:=2.323//float64
i=0.3232+0.5i//complex128常量
- 常量的声明与变量类似，但要使用==const==关键字
- 常量可以是：数值，字符串，布尔值，字符
- 常量不能用:=声明
package main
import "fmt"
const Pi = 3.14
func main (){
const world = "世界"
fmt.Println("hello",world)
fmt.Println(Pi)
}数值常量
- 数值常量是高精度的值
- 一个没指定类型的常量由上下文决定其类型
流程控制语句：for，if，else，switch和defer
for
- Go只有一种循环结构：即for循环
- 基本的for循环由三部分组成，中间用分号隔开
- 初始化语句：在第一次迭代前执行
- 条件表达式：在每次迭代前求值
- 后置语句：在每次迭代的结尾执行
- 一旦条件表达句的布尔值为false，循环终止
- 和c不同，Go的for循环不用小括号，但{ }是必须的
func main (){
sum:=0
for i:=0;i<10;i++{
sum+=i
}
fmt Println(sum)
}- 初始化语句和后置语句是可选的
sum:=1//初始化
for ;sum<100 ;{
sum+=sum
}- 上述语句可以省略分号，因为C中的while就是Go的for
sum := 1
for sum < 1000 {
sum += sum
}- 无线循环：如果省略循环条件，该循环就不会结束，因此无限循环可以写的很紧凑
func main (){
for{ }
}if
- 与for类型，不用小括号，大括号是必须的
func sqrt (x float64)string{
if x<0 {
return 0
}
}- if的简短语句：与for一样，if语句可以在条件表达式前执行一个简单语句（相当于for的初始化语句），该语句声明变量的作用域仅在if语句之内
- 上述的简单语句的作用域包含if对应的else块
- 练习：用牛顿法实现平方根函数
package main
import (
"fmt"
)
func Sqrt(x float64) float64 {
z:=1.0
for ;z<=10;z++{
z -= (z*z - x) / (2*z)
fmt.Println(z)
}
return z
}
func main() {
fmt.Println(Sqrt(2))
}
Switch
- switch 是编写一连串if-else的简便方法，它运行第一个值等于条件表达式的case语句
- Switch的case无需为常量，也不必为整数
- Go自动提供了每个case后面所需的break语句，除非以
fallthrough语句结束，否则分支会自动终止。
import (
"fmt"
"runtime"
)
func main() {
fmt.Print("Go runs on ")
switch os := runtime.GOOS; os {
case "darwin":
fmt.Println("OS X.")
case "linux":
fmt.Println("Linux.")
default:
fmt.Printf("%s.\n", os)
}
}
switch 的求值顺序
switch的case语句从上到下依次执行，直到匹配成功停止
switch i{
case 0
case f()
}//在i=0时，f()不会被调用没有条件的switch
- 没有条件的switch即switch true
- 这种形式可以将一长串if-then-else写的更加清晰
defer
- 功能：将函数推迟到外层函数返回之后执行
- 推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用
func main (){
defer fmt.Println("world")
fmt.Println("hello")
}//输出结果为 hello world defer 栈
推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用
本文参与 腾讯云自媒体分享计划，分享自作者个人站点/博客。
原始发表：2023-01-10，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录