Java转Go初步学习（基础篇）
Go基础
Go关键字
break default func interface select（选择不同类型的通讯）
case defer go map(引⽤类型，字典)struct
chan else goto package switch
const(常量)fallthrough if range（⽤于读取slice、map、channel数据）type（声明⾃定义类型）
continue for import return var(变量)
⼤写字母开头的变量是可导出的，也就是其它包可以读取的，是公有变量；⼩写字母开头的就是不可导出的，是私有变量。
⼤写字母开头的函数也是⼀样，相当于class中的带public关键词的公有函数；⼩写字母开头的就是有private关键词的私有函数。make & new
new⽤于各种类型的内存分配。[new分配返回的是指针，即类型*T]
new返回指针。 （它返回了⼀个指针，指向新分配的类型T的零值。）
new(T) 为类型T分配⼀⽚内存，初始化为0并且返回类型为*T的内存地址，适⽤于任意类型。对于结构体，new(T)相当于&T{}。
make⽤于内建类型（map、slice 和channel）的内存分配。[make返回引⽤，即T]
make返回初始化后的（⾮零）值。 （指向数据结构的引⽤在使⽤前必须被初始化。）
make(T) 也是⽤于内存分配的，但是和new不同，它只适⽤于3种内建的引⽤类型：切⽚、map和channel，⽽且它返回的类型就是这三个类型本⾝，⽽不是他们的指针类型，因为这三种类型就是引⽤类型，所以就没有必要返回他们的指针了。
// 为切⽚结构分配内存；p为指向切⽚的指针；*p == nil；很少使⽤。
var p *[]int=new([]int)
// 切⽚v现在是对⼀个新的有10个整数的数组的引⽤。
var v []int=make([]int,10)
// 不必要地使问题复杂化：
var p *[]int=new([]int)
fmt.Println(p)// 输出：&[]
*p =make([]int,10,10)
fmt.Println(p)// 输出：&[0 0 0 0 0 0 0 0 0 0]
fmt.Println((*p)[2])// 输出：0
// 习惯⽤法:
v :=make([]int,10)
fmt.Println(v)// 输出：[0 0 0 0 0 0 0 0 0 0]
包、变量、和函数
包（package main）
每个 Go 程序都是由包构成的。
程序从 main 包开始运⾏。
在 Go 中，如果⼀个名字以⼤写字母开头，那么它就是已导出的。
package （在我们的例⼦中是package main）这⼀⾏告诉我们当前⽂件属于哪个包，⽽包名main则告诉我们它是⼀个可独⽴运⾏的
GOPATH/pkg/包，它在编译后会产⽣可执⾏⽂件。除了main包之外，其它的包最后都会⽣成*.a⽂件（也就是包⽂件）并放置在
GOOS_$GOARCH中
函数
函数可以返回任意数量的返回值。
当连续两个或多个函数的已命名形参类型相同时，除最后⼀个类型以外，其它都可以省略。
没有参数的 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(17))
}
变量（var）
var 语句⽤于声明⼀个变量列表，跟函数的参数列表⼀样，类型在最后。
如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型。
在函数中，简洁赋值语句 := 可在类型明确的地⽅代替 var 声明。
func main(){
var i, j int=1,2
k :=3
c, python, java :=true,false,"no!"
fmt.Println(i, j, k, c, python, java)
}
基本类型
int, uint 和 uintptr 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽。 当你需要⼀个整数值时应使⽤ int 类型，除⾮你有特殊的理由使⽤固定⼤⼩或⽆符号的整数类型。
bool
string
int int8int16int32int64
uint uint8uint16uint32uint64uintptr
byte// uint8 的别名
rune// int32 的别名
// 表⽰⼀个 Unicode 码点
float32float64
complex64complex128
类型转换
表达式 T(v) 将值 v 转换为类型 T。
i :=42
f :=float64(i)
u :=uint(f)
类型推导
在声明⼀个变量⽽不指定其类型时（即使⽤不带类型的 := 语法或 var = 表达式语法），变量的类型由右值推导得出。
i :=42// int
f :=3.142// float64
g :=0.867+0.5i// complex128
常量 (const)
常量可以是字符、字符串、布尔值或数值。
常量不能⽤ := 语法声明。
流程控制语句 for if/else switch defer
Go中流程控制分三⼤类：条件判断，循环控制和⽆条件跳转。
goto
⽤goto跳转到必须在当前函数内定义的标签。
func myFunc(){
i :=0
Here://这⾏的第⼀个词，以冒号结束作为标签
println(i)
i++
goto Here  //跳转到Here去
}
循环语句：for
它既可以⽤来循环读取数据，⼜可以当作while来控制逻辑，还能迭代操作。
sum :=0
// 循环读取数
for i :=0; i <10; i++{
sum += i
}
fmt.Println(sum)
在循环⾥⾯有两个关键操作break和continue ,break操作是跳出当前循环，continue是跳过本次循环。当嵌套过深的时候，break可以配合标签使⽤，即跳转⾄标签所指定的位置
while实现（for xxx {…}）
如果省略循环条件，该循环为⽆限循环
sum :=1
for sum <1000{
sum += sum
}
for配合range可以⽤于读取slice和map
可以使⽤_来丢弃不需要的返回值
for k,v:=range map{
fmt.Println("map's key:",k)
fmt.Println("map's val:",v)
}
if
Go 的 if 语句与 for 循环类似，表达式外⽆需⼩括号 ( ) ，⽽⼤括号 { } 则是必须的。
同 for ⼀样， if 语句可以在条件表达式前执⾏⼀个简单的语句。
在 if 的简短语句中声明的变量同样可以在任何对应的 else 块中使⽤。
func pow(x, n, lim float64)float64{
if v := math.Pow(x, n); v < lim {
return v
}else{
fmt.Printf("%g >= %g\n", v, lim)
}
// 这⾥开始就不能使⽤ v 了
return lim
}
循环与函数
python转java代码func Sqrt(x float64)float64{
der :=0.00001
temp :=float64(1)
z := x
for math.Abs(z - temp)>= der {
temp = z
z =(z + x / z)/2// 题中计算⽅式演变⽽来的公式
}
return z
}
func main(){
fmt.Println(Sqrt(2))
fmt.Println(math.Sqrt(2))
}
switch
Go ⾃动提供了在这些语⾔中每个 case 后⾯所需的 break 语句。 除⾮以 fallthrough 语句结束，否则分⽀会⾃动终⽌。
没有条件的 switch 同 switch true ⼀样。
注意：switch语句没有break，但可以使⽤逗号case多个值。
func main(){
fmt.Print("Go runs on ")
switch os := runtime.GOOS; os {
case"darwin":
fmt.Println("OS X.")
case"linux","Unix":
fmt.Println("Linux.")
default:
fmt.Printf("%s.\n", os)
}
}
延迟defer (在defer后指定的函数会在函数退出前调⽤)
defer 语句会将函数推迟到外层函数返回之后执⾏。
推迟调⽤的函数其参数会⽴即求值，但直到外层函数返回前该函数都不会被调⽤。
推迟的函数调⽤会被压⼊⼀个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调⽤。
func main(){
fmt.Println("counting")
for i :=0; i <10; i++{
defer fmt.Println(i)
}
fmt.Println("done")
}
其他类型
指针
指针保存了值的内存地址。
类型 *T 是指向 T 类型值的指针。其零值为 nil。
var p *int
& 操作符会⽣成⼀个指向其操作数的指针。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。