Golang 通关初级（1）
原文https://tour.golang.org/welcome/1 Hello， 世界package main
import "fmt"
func main() {
fmt.Println("Hello,世界")
}
输出： Hello,世界 包每个 Go 程序都是由包构成的。 程序从 main 包开始运行。 本程序通过导入路径 “fmt” 和 “math/rand” 来使用这两个包。 按照约定，包名与导入路径的最后一个元素一致。例如， package main
import ( "fmt" "math/rand" ) func main() { fmt.Println("My favorite number is",rand.Intn(10)) }
输出： My favorite number is 1
导入此代码用圆括号组合了导入，这是“分组”形式的导入语句。 当然你也可以编写多个导入语句，例如： import "fmt"
import "math"
不过使用分组导入语句是更好的形式。 package main
import( "fmt" "math" ) func main(){ fmt.Printf("xxxx %g n===",math.Sqrt(25)) }
输出： xxxx 5 ===
导出名在 Go 中，如果一个名字以大写字母开头，那么它就是已导出的。 例如， Pizza 就是个已导出名， Pi 也同样，它导出自 math 包。 pizza 和 pi 并未以大写字母开头，所以它们是未导出的。 在导入一个包时，你只能引用其中已导出的名字。任何“未导出”的名字在该包外均无法访问。 执行代码，观察错误输出。 然后将 math.pi 改名为 math.Pi 再试着执行一次。 package main
import ( "fmt" "math" ) func main() { fmt.Println(math.Pi) }
输出： 3.141592653589793 函数函数可以没有参数或接受多个参数。 在本例中， add 接受两个 int 类型的参数。 注意类型在变量名 之后 。 package main
import "fmt"
func add(x int,y int) int {
return x + y
}
func main() {
fmt.Println(add(42, 13))
}
输出： 55 当连续两个或多个函数的已命名形参类型相同时，除最后一个类型以外，其它都可以省略。 在本例中， x int,y int
被缩写为 x,y int
package main
import (
"fmt"
)
func main(){
fmt.Println(add(5, 15))
}
func add(a,b int) int{
return a + b
}
输出： 20 多值返回函数可以返回任意数量的返回值。 swap 函数返回了两个字符串。 package main
import "fmt"
func swap(x,y string) (string,string) {
return y,x
}
func main() {
a,b := swap("hello","world")
fmt.Println(a,b)
}
输出： world hello 命名返回值Go 的返回值可被命名，它们会被视作定义在函数顶部的变量。 返回值的名称应当具有一定的意义，它可以作为文档使用。 没有参数的 return 语句返回已命名的返回值。也就是 直接返回语句应当仅用在下面这样的短函数中。在长的函数中它们会影响代码的可读性。 package main
import(
"fmt"
)
func main(){
fmt.Println(show(22, 14))
}
func show(a,b int) (x,y int){
x = a + b
y = a - b
return
}
输出： 36 8 变量var 语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后。 就像在这个例子中看到的一样， var 语句可以出现在包或函数级别。 package main
import (
"fmt"
)
var a,b int
func main() {
var c bool
fmt.Println(a,b,c)
}
输出： 0 0 false
变量的初始化变量声明可以包含初始值，每个变量对应一个。 如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型。 package main
import (
"fmt"
)
var a int = 100
func main() {
var i,d,e = 1,false,true, 3.9
fmt.Println(a,i,e)
}
输出: 100 1 false true 3.9
短变量声明在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。 函数外的每个语句都必须以关键字开始（ var 、 func 等等）， 因此 := 结构不能在函数外使用。 package main
import (
"fmt"
)
func main() {
var a,b int = 10, 22
c,e := 12, 33.22
fmt.Println(a,c,e)
}
输出： 10 22 12 false 33.22
基本类型Go 的基本类型有： bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8 的别名
rune // int32 的别名
// 表示一个 Unicode 码点
float32 float64
complex64 complex128
本例展示了几种类型的变量。 同导入语句一样，变量声明也可以“分组”成一个语法块。 int 、 uint 和 uintptr 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽。 当你需要一个整数值时应使用 int 类型，除非你有特殊的理由使用固定大小或无符号的整数类型。 package main
import (
"fmt"
"math/cmplx"
)
var (
ToBe bool = false
MaxInt uint64 = 1<<64 - 1
z complex128 = cmplx.Sqrt(-5 + 12i)
)
func main() {
const f = "%T(%v)n"
fmt.Printf(f,ToBe,ToBe)
fmt.Printf(f,MaxInt,MaxInt)
fmt.Printf(f,z,z)
}
输出： bool(false)
uint64(18446744073709551615)
complex128((2+3i))
零值没有明确初始值的变量声明会被赋予它们的 零值 。 零值是： 数值类型为 0 ， package main
import (
"fmt"
)
func main() {
var a int
var b bool
var c string
var d float64
fmt.Printf("%v,%v,%q,%vn",a,d)
}
输出： 0,false,"",0
类型转换表达式 T(v) 将值 v 转换为类型 T 。 一些关于数值的转换： var i int = 42
var f float64 = float64(i)
var u uint = uint(f)
或者，更加简单的形式： i := 42
f := float64(i)
u := uint(f)
与 C 不同的是，Go 在不同类型的项之间赋值时需要显式转换。 试着移除例子中 float64 或 int 的转换看看会发生什么。 package main
import (
"fmt"
"math"
)
func main() {
var x,y int = 3, 6
f := float64(math.Sqrt(float64(x*x + y*y)))
var g int = int(f)
fmt.Println(x,y,f,g)
}
输出： 3 6 6.708203932499369 6 类型推导在声明一个变量而不指定其类型时（即使用不带类型的 := 语法 或 var = 表达式语法）， 变量的类型由右值推导得出。 当右值声明了类型时，新变量的类型与其相同： var i int
j := i // j 也是一个 int
不过当右边包含未指明类型的数值常量时，新变量的类型就可能是 int 、 float64 或 complex128 了，这取决于常量的精度： i := 42 // int
f := 3.142 // float64
g := 0.867 + 0.5i // complex128
package main
import (
"fmt"
)
func main() {
a := 12
b := true
c := "xxx"
d := 12.222
fmt.Printf(" a %Tn b %Tn c %T n d %T n",d)
}
输出： a int
b bool
c string
d float64
常量常量的声明与变量类似，只不过是使用 const 关键字。 常量可以是字符、字符串、布尔值或数值。 常量不能用 := 语法声明。 package main
import (
"fmt"
)
const (
f = 12i
)
func main() {
const (
a = 2
b = 3.12
c = true
d = "sssss"
)
fmt.Println(a,f)
}
输出： 2 3.12 true sssss (0+12i)
数值常量数值常量是高精度的 值 。 一个未指定类型的常量由上下文来决定其类型。 （ int 类型最大可以存储一个 64 位的整数，有时会更小。） （ package main
import "fmt"
const (
// Create a huge number by shifting a 1 bit left 100 places.
// In other words,the binary number that is 1 followed by 100 zeroes.
Big = 1 << 100
// Shift it right again 99 places,so we end up with 1<<1,or 2.
Small = Big >> 99
)
func needInt(x int) int { return x*10 + 1 }
func needFloat(x float64) float64 {
return x * 0.1
}
func main() {
fmt.Println(needInt(Small))
fmt.Println(needFloat(Small))
fmt.Println(needFloat(Big))
}
输出： 21 0.2 1.2676506002282295e+29 再尝试一下输出 needInt(Big) : # command-line-arguments
.compile33.go:22: constant 1267650600228229401496703205376 overflows int
forGo 只有一种循环结构： for 循环。 基本的 for 循环由三部分组成，它们用分号隔开： 初始化语句：在第一次迭代前执行 注意：和 C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面没有小括号，大括号 { } 则是必须的。 package main
import (
"fmt"
)
func main() {
var b int
for i := 0; i < 8; i++ {
fmt.Printf("i = %v,b++n",i)
b++
}
fmt.Printf("b = %vn",b)
}
输出： i = 0,b++
i = 1,b++
i = 2,b++
i = 3,b++
i = 4,b++
i = 5,b++
i = 6,b++
i = 7,b++
b = 8
初始化语句和后置语句是可选的： package main
import "fmt"
func main() {
sum := 1
for ; sum < 1000; {
sum += sum
}
fmt.Println(sum)
}
输出： 1024 for 也是 Go 中的 “while” package main
import (
"fmt"
)
func main() {
var b int
for b < 9 {
b++
}
fmt.Printf("b = %vn",b)
}
输出： b = 9
无限循环 package main func main() {
for {
}
}
ifGo 的 if 语句与 for 循环类似，表达式外无需小括号 ( ) ，而大括号 { } 则是必须的。 package main
import (
"fmt"
"math"
)
func main() {
fmt.Println(sqrt(-4),sqrt(9))
}
func sqrt(x float64) string {
if x < 0 {
return sqrt(-x) + "i"
}
return fmt.Sprint(math.Sqrt(x))
}
输出： 2i 3
if 的简短语句 该语句声明的变量作用域仅在 if 之内。 package main
import (
"fmt"
"math"
)
func main() {
fmt.Println(sqrt(2, 3, 10))
fmt.Println(sqrt(4, 5, 10))
}
func sqrt(a,c float64) float64 {
if d := math.Pow(a,b); d < c {
return d
}
return c
}
输出： 8 10 if 和 else package main
import (
"fmt"
"math"
)
func main() {
fmt.Println(sqrt(2, 10))
fmt.Println(sqrt(2, 4, 11))
}
func sqrt(a,b); d < c {
return d
} else {
fmt.Printf("%g >= %gn",c)
}
// 这里开始就不能使用 d 了
return c
}
输出： 8 16 >= 11 11
switch除非以 fallthrough 语句结束，否则分支会自动终止。Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch,但是可以使用fallthrough强制执行后面的case代码。 package main
import (
"fmt"
"runtime"
)
func main() {
switch a := runtime.GOOS; a {
case "windows":
fmt.Println("Windows")
fallthrough
case "darwin":
fmt.Println("OS X.")
case "linux":
fmt.Println("Linux.")
default:
// freebsd,openbsd,
// plan9...
fmt.Printf("%s.n",a)
}
}
输出： WWWW OS X. switch 的求值顺序 （例如， switch i { package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("When is Saturday?")
today := time.Now().Weekday()
fmt.Printf("Today is %vnSaturday is ",today)
switch time.Saturday {
case today + 0:
fmt.Println("Is Today")
case today + 1:
fmt.Println("Is Tomorrow")
case today + 2:
fmt.Println("In Two Days")
case today + 3:
fmt.Println("In Three Days")
default:
fmt.Println("Too far away.")
}
}
输出： When is Saturday?
Today is Tuesday
Saturday is Too far away.
没有条件的 switch 这种形式能将一长串 if-then-else 写得更加清晰。 package main
import (
"fmt"
"time"
)
func main() { t := time.Now().Hour() fmt.Printf("Time now is %vn",t) switch { case t < 12: fmt.Println("Good morning.") case t < 17: fmt.Println("Good afternoon.") default: fmt.Println("Good evening.") }
}
输出： Time now is 16
Good afternoon.
deferdefer 语句会将函数推迟到外层函数返回之后执行。 推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。 package main
import ( "fmt" ) func main() { defer sqrt(9) fmt.Println("9 * 9: ") } func sqrt(x float64) { fmt.Println(x * x) }
输出： 9 * 9: 81 defer 栈 更多关于 defer 语句的信息， 请阅读此博文。 package main
import "fmt"
func main() {
fmt.Println("counting")
for i := 0; i < 10; i++ {
defer fmt.Println(i)
}
fmt.Println("done")
}
输出： counting
done
9
8
7
6
5
4
3
2
1
0 （编辑：李大同） 【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容! |