最近因为又报了那边的青训,后端方向的,应该是全程使用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)
}
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 i int
j:=i//j也是一个int
i:=43//int
i:=2.323//float64
i=0.3232+0.5i//complex128
package main
import "fmt"
const Pi = 3.14
func main (){
const world = "世界"
fmt.Println("hello",world)
fmt.Println(Pi)
}
func main (){
sum:=0
for i:=0;i<10;i++{
sum+=i
}
fmt Println(sum)
}
sum:=1//初始化
for ;sum<100 ;{
sum+=sum
}
sum := 1
for sum < 1000 {
sum += sum
}
func main (){
for{ }
}
func sqrt (x float64)string{
if x<0 {
return 0
}
}
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))
}
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的case语句从上到下依次执行,直到匹配成功停止
switch i{
case 0
case f()
}//在i=0时,f()不会被调用
func main (){
defer fmt.Println("world")
fmt.Println("hello")
}//输出结果为 hello world
推迟的函数调用会被压入一个栈中。当外层函数返回时,被推迟的函数会按照后进先出的顺序调用