Golang 通关初级(1)
来源:互联网 发布:电商软件营销方案 编辑:程序博客网 时间:2024/04/30 17:57
- 原文
- Hello 世界
- 包
- 导入
- 导出名
- 函数
- 多值返回
- 命名返回值
- 变量
- 变量的初始化
- 短变量声明
- 基本类型
- 零值
- 类型转换
- 类型推导
- 常量
- 数值常量
- for
- if
- switch
- defer
原文
https://tour.golang.org/welcome/1
Hello, 世界
package mainimport "fmt"func main() { fmt.Println("Hello, 世界")}
输出:
Hello, 世界
包
每个 Go 程序都是由包构成的。
程序从 main 包开始运行。
本程序通过导入路径 “fmt” 和 “math/rand” 来使用这两个包。
按照约定,包名与导入路径的最后一个元素一致。例如,"math/rand"
包中的源码均以 package rand 语句开始。
package mainimport ( "fmt" "math/rand")func main() { fmt.Println("My favorite number is", rand.Intn(10))}
输出:
My favorite number is 1
导入
此代码用圆括号组合了导入,这是“分组”形式的导入语句。
当然你也可以编写多个导入语句,例如:
import "fmt"import "math"
不过使用分组导入语句是更好的形式。
package mainimport( "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 mainimport ( "fmt" "math")func main() { fmt.Println(math.Pi)}
输出:
3.141592653589793
函数
函数可以没有参数或接受多个参数。
在本例中, add 接受两个 int 类型的参数。
注意类型在变量名 之后 。
package mainimport "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 mainimport ( "fmt" )func main(){ fmt.Println(add(5, 15))}func add(a, b int) int{ return a + b }
输出:
20
多值返回
函数可以返回任意数量的返回值。
swap 函数返回了两个字符串。
package mainimport "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 mainimport( "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 mainimport ( "fmt")var a, b intfunc main() { var c bool fmt.Println(a, b, c)}
输出:
0 0 false
变量的初始化
变量声明可以包含初始值,每个变量对应一个。
如果初始化值已存在,则可以省略类型;变量会从初始值中获得类型。
package mainimport ( "fmt")var a int = 100func main() { var i, b, d, e = 1, false, true, 3.9 fmt.Println(a, i, b, d, e)}
输出:
100 1 false true 3.9
短变量声明
在函数中,简洁赋值语句 := 可在类型明确的地方代替 var 声明。
函数外的每个语句都必须以关键字开始( var 、 func 等等), 因此 := 结构不能在函数外使用。
package mainimport ( "fmt")func main() { var a, b int = 10, 22 c, d, e := 12, false, 33.22 fmt.Println(a, b, c, d, e)}
输出:
10 22 12 false 33.22
基本类型
Go 的基本类型有:
boolstringint int8 int16 int32 int64uint uint8 uint16 uint32 uint64 uintptrbyte // uint8 的别名rune // int32 的别名 // 表示一个 Unicode 码点float32 float64complex64 complex128
本例展示了几种类型的变量。 同导入语句一样,变量声明也可以“分组”成一个语法块。
int 、 uint 和 uintptr 在 32 位系统上通常为 32 位宽,在 64 位系统上则为 64 位宽。 当你需要一个整数值时应使用 int 类型,除非你有特殊的理由使用固定大小或无符号的整数类型。
package mainimport ( "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 ,
布尔类型为 false ,
字符串为 “” (空字符串)。
package mainimport ( "fmt")func main() { var a int var b bool var c string var d float64 fmt.Printf("%v, %v, %q, %v\n", a, b, c, d)}
输出:
0, false, "", 0
类型转换
表达式 T(v) 将值 v 转换为类型 T 。
一些关于数值的转换:
var i int = 42var f float64 = float64(i)var u uint = uint(f)
或者,更加简单的形式:
i := 42f := float64(i)u := uint(f)
与 C 不同的是,Go 在不同类型的项之间赋值时需要显式转换。 试着移除例子中 float64 或 int 的转换看看会发生什么。
package mainimport ( "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 intj := i // j 也是一个 int
不过当右边包含未指明类型的数值常量时,新变量的类型就可能是 int 、 float64 或 complex128 了,这取决于常量的精度:
i := 42 // intf := 3.142 // float64g := 0.867 + 0.5i // complex128
package mainimport ( "fmt")func main() { a := 12 b := true c := "xxx" d := 12.222 fmt.Printf(" a %T\n b %T\n c %T \n d %T \n", a, b, c, d)}
输出:
a int b bool c string d float64
常量
常量的声明与变量类似,只不过是使用 const 关键字。
常量可以是字符、字符串、布尔值或数值。
常量不能用 := 语法声明。
package mainimport ( "fmt")const ( f = 12i)func main() { const ( a = 2 b = 3.12 c = true d = "sssss" ) fmt.Println(a, b, c, d, f)}
输出:
2 3.12 true sssss (0+12i)
数值常量
数值常量是高精度的 值 。
一个未指定类型的常量由上下文来决定其类型。
( int 类型最大可以存储一个 64 位的整数,有时会更小。)
(int
可以存放最大64位的整数,根据平台不同有时会更少。)
package mainimport "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))}
输出:
210.21.2676506002282295e+29
再尝试一下输出 needInt(Big) :
报错:
# command-line-arguments.\compile33.go:22: constant 1267650600228229401496703205376 overflows int
for
Go 只有一种循环结构: for 循环。
基本的 for 循环由三部分组成,它们用分号隔开:
初始化语句:在第一次迭代前执行
条件表达式:在每次迭代前求值
后置语句:在每次迭代的结尾执行
初始化语句通常为一句短变量声明,该变量声明仅在 for 语句的作用域中可见。
注意:和 C、Java、JavaScript 之类的语言不同,Go 的 for 语句后面没有小括号,大括号 { } 则是必须的。
package mainimport ( "fmt")func main() { var b int for i := 0; i < 8; i++ { fmt.Printf("i = %v, b++\n", i) b++ } fmt.Printf("b = %v\n", 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 mainimport "fmt"func main() { sum := 1 for ; sum < 1000; { sum += sum } fmt.Println(sum)}
输出:
1024
for 也是 Go 中的 “while”
此时你可以去掉分号:C 的 while 在 Go 中叫做 for:
package mainimport ( "fmt")func main() { var b int for b < 9 { b++ } fmt.Printf("b = %v\n", b)}
输出:
b = 9
无限循环
如果省略循环条件,该循环就不会结束,因此无限循环可以写得很紧凑。
package mainfunc main() { for { }}
if
Go 的 if 语句与 for 循环类似,表达式外无需小括号 ( ) ,而大括号 { } 则是必须的。
package mainimport ( "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 的简短语句
同 for 一样, if 语句可以在条件表达式前执行一个简单的语句。
该语句声明的变量作用域仅在 if 之内。
package mainimport ( "fmt" "math")func main() { fmt.Println(sqrt(2, 3, 10)) fmt.Println(sqrt(4, 5, 10))}func sqrt(a, b, c float64) float64 { if d := math.Pow(a, b); d < c { return d } return c}
输出:
810
if 和 else
在 if 的简短语句中声明的变量同样可以在任何对应的 else 块中使用。
package mainimport ( "fmt" "math")func main() { fmt.Println(sqrt(2, 3, 10)) fmt.Println(sqrt(2, 4, 11))}func sqrt(a, b, c float64) float64 { if d := math.Pow(a, b); d < c { return d } else { fmt.Printf("%g >= %g\n", d, c) } // 这里开始就不能使用 d 了 return c}
输出:
816 >= 1111
switch
除非以 fallthrough 语句结束,否则分支会自动终止。Go里面switch默认相当于每个case最后带有break,匹配成功后不会自动向下执行其他case,而是跳出整个switch, 但是可以使用fallthrough强制执行后面的case代码。
package mainimport ( "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) }}
输出:
WWWWOS X.
switch 的求值顺序
switch 的 case 语句从上到下顺次执行,直到匹配成功时停止。
(例如,
switch i {
case 0:
case f():
}
在 i==0 时 f 不会被调用。)
package mainimport ( "fmt" "time")func main() { fmt.Println("When is Saturday?") today := time.Now().Weekday() fmt.Printf("Today is %v\nSaturday 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 TuesdaySaturday is Too far away.
没有条件的 switch
没有条件的 switch 同 switch true 一样。
这种形式能将一长串 if-then-else 写得更加清晰。
package mainimport ( "fmt" "time")func main() { t := time.Now().Hour() fmt.Printf("Time now is %v\n", t) switch { case t < 12: fmt.Println("Good morning.") case t < 17: fmt.Println("Good afternoon.") default: fmt.Println("Good evening.") }}
输出:
Time now is 16Good afternoon.
defer
defer 语句会将函数推迟到外层函数返回之后执行。
推迟调用的函数其参数会立即求值,但直到外层函数返回前该函数都不会被调用。
package mainimport ( "fmt")func main() { defer sqrt(9) fmt.Println("9 * 9: ")}func sqrt(x float64) { fmt.Println(x * x)}
输出:
9 * 9: 81
defer 栈
推迟的函数调用会被压入一个栈中。 当外层函数返回时,被推迟的函数会按照后进先出的顺序调用。
更多关于 defer 语句的信息, 请阅读此博文。
package mainimport "fmt"func main() { fmt.Println("counting") for i := 0; i < 10; i++ { defer fmt.Println(i) } fmt.Println("done")}
输出:
countingdone9876543210
- Golang 通关初级(1)
- Golang 通关初级(1)
- Golang 通关初级(1)
- Golang 通关初级(1)
- Golang 通关初级(2)
- Golang 通关初级(3)
- Golang通关初级(4)
- Golang 通关初级(2)
- Golang 通关初级(2)
- Golang 通关初级(2)
- Golang 通关初级(3)
- Golang通关初级(4)
- Golang初级系列教程-Struct
- Golang初级系列教程-接口
- rosalind-生物信息算法通关(python)(1)
- [Golang]Golang编程杂记(1)
- Golang初级系列教程-安装配置
- Golang初级系列教程-常见错误
- RangeError: index out of range
- CSS的position
- 深入浅出iOS事件机制
- Android 获取手机传感器信息
- Android仿QQ邮箱下拉刷新动画(三个小球围绕中心转动)
- Golang 通关初级(1)
- 面试题:“你能不能谈谈,java GC是在什么时候,对什么东西,做了什么事情?”
- GibbsLDA utils.h分析
- 关闭TV的效果
- golang 中 reflect 简单用法
- 使用pthreads实现真正的PHP多线程(需PHP5.3以上版本)
- github操作分享
- 浏览器调试教程-chrome
- JDK多版本下如何设置jdk 1.8为默认jdk