[摘]Go 语言简介(上)— 语法

作者:陈皓

偏偏待你对C语言,Unix,Python有少数基础,我相信您会当30分钟左右念了并针对性Go语言有局部初始了解之。

图片 1

Hello World

文件名 hello.go
1
2
3
4
5
6
7
package main //声明本文件的package名
 
import "fmt" //import语言的fmt库——用于输出
 
func main() {
    fmt.Println("hello world")
}

 

运行

卿得出零星种运行方式,

解释执行(实际是编译成a.out再执行)
1
2
$go run hello.go
hello world
编译执行
1
2
3
4
5
6
7
$go build hello.go
 
$ls
hello hello.go
 
$./hello
hello world

自己的package

你可以应用GOPATH环境变量,或是使用相对路径来import你协调的package。

Go的清规戒律是这样的:

1)每当import中,你得用相对路径,如 ./或 ../ 来引用你的package

2)要没有采用相对路径,那么,go会去摸索$GOPATH/src/目录。

使用相对路径
1
2
import "./haoel"  //import当前目录里haoel子目录里的所有的go文件
使用GOPATH路径
1
2
import "haoel"  //import 环境变量 $GOPATH/src/haoel子目录里的所有的go文件

fmt输出格式

fmt包和libc里之那堆用printf, scanf,fprintf,fscanf
很一般。下面的事物对C程序员不见面生。

在意:Println不支持,Printf才支撑%式的输出:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main
 
import "fmt"
import "math"
 
func main() {
    fmt.Println("hello world")
 
    fmt.Printf("%t\n", 1==2)
    fmt.Printf("二进制:%b\n", 255)
    fmt.Printf("八进制:%o\n", 255)
    fmt.Printf("十六进制:%X\n", 255)
    fmt.Printf("十进制:%d\n", 255)
    fmt.Printf("浮点数:%f\n", math.Pi)
    fmt.Printf("字符串:%s\n", "hello world")
}

自,也可采取要\n\t\r这样的同C语言一样的控制字符

变量和常量

变量的扬言很像 javascript,使用
var关键字。注意:go是静态类型的言语,下面是代码:

1
2
3
4
5
6
7
8
//声明初始化一个变量
var  x int = 100
var str string = "hello world"</pre>
//声明初始化多个变量
var  i, j, k int = 1, 2, 3
 
//不用指明类型,通过初始化值来推导
var b = true //bool型

还有一样种概念变量的法(这被自己想开了Pascal语言,但全无同等)

1
2
x := 100 //等价于 var x int = 100;

常量很粗略,使用const关键字:

1
2
const s string = "hello world"
const pi float32 = 3.1415926

数组

直接看代码(注意其中的for语句,和C很相似吧,就是没有括号了)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
func main() {
    var a [5]int
    fmt.Println("array a:", a)
 
    a[1] = 10
    a[3] = 30
    fmt.Println("assign:", a)
 
    fmt.Println("len:", len(a))
 
    b := [5]int{1, 2, 3, 4, 5}
    fmt.Println("init:", b)
 
    var c [2][3]int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            c[i][j] = i + j
        }
    }
    fmt.Println("2d: ", c)
}

运作结果:

1
2
3
4
5
6
array a: [0 0 0 0 0]
assign: [0 10 0 30 0]
len: 5
init: [1 2 3 4 5]
2d:  [[0 1 2] [1 2 3]]

几度组的切片操作

这个很Python了。

1
2
3
4
5
6
7
8
9
10
11
a := [5]int{1, 2, 3, 4, 5}
 
b := a[2:4] // a[2] 和 a[3],但不包括a[4]
fmt.Println(b)
 
b = a[:4] // 从 a[0]到a[4],但不包括a[4]
fmt.Println(b)
 
b = a[2:] // 从 a[2]到a[4],且包括a[2]
fmt.Println(b)

分段循环语句

if语句

小心:if 语句没有圆括号,而一定用出花括号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//if 语句
if x % 2 == 0 {
    //...
}
//if - else
if x % 2 == 0 {
    //偶数...
} else {
    //奇数...
}
 
//多分支
if num < 0 {
    //负数
} else if num == 0 {
    //零
} else {
    //正数
}

switch 语句

专注:switch语句没有break,还可以运用逗号case多只价

1
2
3
4
5
6
7
8
9
10
11
12
switch i {
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    case 4,5,6:
        fmt.Println("four, five, six")
    default:
        fmt.Println("invalid value!")
}

for 语句

眼前你曾经展现了了,下面还来瞧for的老三种样式:(注意:Go语言中尚无while)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//经典的for语句 init; condition; post
for i := 0; i<10; i++{
     fmt.Println(i)
}
 
//精简的for语句 condition
i := 1
for i<10 {
    fmt.Println(i)
    i++
}
 
//死循环的for语句 相当于for(;;)
i :=1
for {
    if i>10 {
        break
    }
    i++
}

至于分号

自打地方的代码我们可以看代码里没有分号。其实,及C一样,Go的专业的语法使用分号来终止语句。和C不同的是,这些分公司由词法分析器在扫描源代码过程遭到采取简单的规则自动插入分号,因此输入源代码多数时分就未待分号了

规则是这么的:如果在一个新行前方的末段一个标志是一个标识符(包括诸如intfloat64这样的单词)、一个主干的如数值这样的字、或以下标记中之一个时,会自行插入分号:

break continue fallthrough return ++ -- ) }

常备Go程序仅于for循环语词被使分号,以这来分别初始化器、条件和增量单元。如果您于一行中写多独话,也得为此分号分开。

注意无论是任何时刻,你还无应当拿一个控制结构((ifforswitchselect)的缪大括号在下一行。如果这么做,将会晤在大括号的前敌插入一个分公司,这或致出现非思只要之结果

map

map在别的语言里或被哈希表或受dict,下面是暨map的连锁操作的代码,代码很易懂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
func main(){
    m := make(map[string]int) //使用make创建一个空的map
 
    m["one"] = 1
    m["two"] = 2
    m["three"] = 3
 
    fmt.Println(m) //输出 map[three:3 two:2 one:1] (顺序在运行时可能不一样)
    fmt.Println(len(m)) //输出 3
 
    v := m["two"] //从map里取值
    fmt.Println(v) // 输出 2
 
    delete(m, "two")
    fmt.Println(m) //输出 map[three:3 one:1]
 
    m1 := map[string]int{"one": 1, "two": 2, "three": 3}
    fmt.Println(m1) //输出 map[two:2 three:3 one:1] (顺序在运行时可能不一样)
 
    for key, val := range m1{
        fmt.Printf("%s => %d \n", key, val)
        /*输出:(顺序在运行时可能不一样)
            three => 3
            one => 1
            two => 2*/
    }
}

指针

Go语言一样来指针,看代码

1
2
3
4
5
6
7
8
9
10
11
12
13
var i int = 1
var pInt *int = &i
//输出:i=1     pInt=0xf8400371b0       *pInt=1
fmt.Printf("i=%d\tpInt=%p\t*pInt=%d\n", i, pInt, *pInt)
 
*pInt = 2
//输出:i=2     pInt=0xf8400371b0       *pInt=2
fmt.Printf("i=%d\tpInt=%p\t*pInt=%d\n", i, pInt, *pInt)
 
i = 3
//输出:i=3     pInt=0xf8400371b0       *pInt=3
fmt.Printf("i=%d\tpInt=%p\t*pInt=%d\n", i, pInt, *pInt)

Go有两独分配内存的机制,分别是内建的函数new和make。他们所开的从不同,所下到之种类为不同,这或许勾混淆,但规则却甚简短。

内存分配

new
是一个分配内存的内建函数,但不同为外语言中同名的new所作的工作,她只有是用内存清零,而无是初始化内存。new(T)为一个项目为T的新品类分配了价值为零星之囤积空间并赶回其地址,也不怕是一个列为*T的价值。用Go的术语来说,就是其回到了一个针对性新分配的类为T的零值的指针

make(T,args)函数的目的和new(T)今非昔比。它只是用于创造切片、map和chan(消息管道),并回路T(不是*T)的一个让初始化了底(不是)实例。这种差异之出现是由当时三栽档次实质上是针对在采取前要开展初始化的数据结构的援。例如,切片是一个怀有三桩内容的描述符,包括对数据(在一个数组内部)的指针、长度及容量,在当时三起内容被初始化之前,切片值为nil。对于片、映射和信道,make初始化了彼里面的数据结构并预备了将以的价值。如:

脚的代码分配了一个整型数组,长度也10,容量也100,并返回前10个数组的切片

1
make([]int, 10, 100)

以下示例说明了newmake的不同。

1
2
3
4
5
6
7
8
9
10
11
12
13
var p *[]int = new([]int)   // 为切片结构分配内存;*p == nil;很少使用
var v  []int = make([]int, 10) // 切片v现在是对一个新的有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]

函数

老实巴交说,我本着Go语言这种扭曲声明变量类型以及函数返回值的做法有些遗憾(保持同C一样的未得以为?
呵呵)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main
import "fmt"
 
func max(a int, b int) int { //注意参数和返回值是怎么声明的
 
    if a > b {
        return a
    }
    return b
}
 
func main(){
    fmt.Println(max(4, 5))
}

函数返回多只价

Go中很多Package 都见面回两单价值,一个凡例行值,一个是荒谬,如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package main
import "fmt"
 
func main(){
    v, e := multi_ret("one")
    fmt.Println(v,e) //输出 1 true
 
    v, e = multi_ret("four")
    fmt.Println(v,e) //输出 0 false
 
    //通常的用法(注意分号后有e)
    if v, e = multi_ret("four"); e {
        // 正常返回
    }else{
        // 出错返回
    }
}
 
func multi_ret(key string) (int, bool){
    m := map[string]int{"one": 1, "two": 2, "three": 3}
 
    var err bool
    var val int
 
    val, err = m[key]
 
    return val, err
}

函数不定参数

事例十分懂得了,我就算非多说了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func sum(nums ...int) {
    fmt.Print(nums, " "//输出如 [1, 2, 3] 之类的数组
    total := 0
    for _, num := range nums { //要的是值而不是下标
        total += num
    }
    fmt.Println(total)
}
func main() {
    sum(1, 2)
    sum(1, 2, 3)
 
    //传数组
    nums := []int{1, 2, 3, 4}
    sum(nums...)
}

函数闭包

nextNum这个函数返回了一个匿名函数,这个匿名函数记住了nextNum中i+j的价值,并改变了i,j的值,于是形成了一个闭包的用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func nextNum() func() int {
    i,j := 1,1
    return func() int {
        var tmp = i+j
        i, j = j, tmp
        return tmp
    }
}
//main函数中是对nextNum的调用,其主要是打出下一个斐波拉契数
func main(){
    nextNumFunc := nextNum()
    for i:=0; i<10; i++ {
        fmt.Println(nextNumFunc())
    }
}

函数的递归

暨c基本是一律的

1
2
3
4
5
6
7
8
9
10
func fact(n int) int {
    if n == 0 {
        return 1
    }
    return n * fact(n-1)
}
 
func main() {
    fmt.Println(fact(7))
}

结构体

Go的结构体和C的大多一样,不过在初始化时有些不雷同,Go支持带动名字的初始化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
type Person struct {
    name string
    age  int
    email string
}
 
func main() {
    //初始化
    person := Person{"Tom", 30, "tom@gmail.com"}
    person = Person{name:"Tom", age: 30, email:"tom@gmail.com"}
 
    fmt.Println(person) //输出 {Tom 30 tom@gmail.com}
 
    pPerson := &person
 
    fmt.Println(pPerson) //输出 &{Tom 30 tom@gmail.com}
 
    pPerson.age = 40
    person.name = "Jerry"
    fmt.Println(person) //输出 {Jerry 40 tom@gmail.com}
}

结构体方法

未多说了,看代码吧。

专注:Go语言中没有public, protected,
private的要字,所以,若果你想给一个方式可以给别的包访问的话语,你用将此法的第一个假名大写。这是一模一样种约定

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
type rect struct {
    width, height int
}
 
func (r *rect) area() int { //求面积
    return r.width * r.height
}
 
func (r *rect) perimeter() int{ //求周长
    return 2*(r.width + r.height)
}
 
func main() {
    r := rect{width: 10, height: 15}
 
    fmt.Println("面积: ", r.area())
    fmt.Println("周长: ", r.perimeter())
 
    rp := &r
    fmt.Println("面积: ", rp.area())
    fmt.Println("周长: ", rp.perimeter())
}

接口及多态

接口意味着多态,下面是一个经文的事例,不用多说了,自己扣代码吧。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//---------- 接 口 --------//
type shape interface {
    area() float64 //计算面积
    perimeter() float64 //计算周长
}
 
//--------- 长方形 ----------//
type rect struct {
    width, height float64
}
 
func (r *rect) area() float64 { //面积
    return r.width * r.height
}
 
func (r *rect) perimeter() float64 { //周长
    return 2*(r.width + r.height)
}
 
//----------- 圆  形 ----------//
type circle struct {
    radius float64
}
 
func (c *circle) area() float64 { //面积
    return math.Pi * c.radius * c.radius
}
 
func (c *circle) perimeter() float64 { //周长
    return 2 * math.Pi * c.radius
}
 
// ----------- 接口的使用 -----------//
func interface_test() {
    r := rect {width:2.9, height:4.8}
    c := circle {radius:4.3}
 
    s := []shape{&r, &c} //通过指针实现
 
    for _, sh := range s {
        fmt.Println(sh)
        fmt.Println(sh.area())
        fmt.Println(sh.perimeter())
    }
}

错误处理 – Error接口

函数错误返回可能是C/C++时极被人纠结的东西的,Go的多值返回可以吃咱重新便于的返错误,其得以于返一个正常的返回值之外,还会随随便便地回到一个详细的错描述。通常状态下,错误的门类是error,它来一个内建的接口。

1
2
3
type error interface {
    Error() string
}

要看个示范吧:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package main
 
import "fmt"
import "errors"
 
//自定义的出错结构
type myError struct {
    arg  int
    errMsg string
}
//实现Error接口
func (e *myError) Error() string {
    return fmt.Sprintf("%d - %s", e.arg, e.errMsg)
}
 
//两种出错
func error_test(arg int) (int, error) {
    if arg < 0  {
         return -1, errors.New("Bad Arguments - negtive!")
     }else if arg >256 {
        return -1, &myError{arg, "Bad Arguments - too large!"}
    }
    return arg*arg, nil
}
 
//相关的测试
func main() {
    for _, i := range []int{-1, 4, 1000} {
        if r, e := error_test(i); e != nil {
            fmt.Println("failed:", e)
        } else {
            fmt.Println("success:", r)
        }
    }
}

程序运行后输出:

1
2
3
failed: Bad Arguments - negtive!
success: 16
failed: 1000 - Bad Arguments - too large!

错误处理 – Defer

下的次对每一个熟识C语言的总人口来说都不陌生(有资源泄露的题目),C++用RAII来缓解这种题材。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func CopyFile(dstName, srcName string) (written int64, err error) {
    src, err := os.Open(srcName)
    if err != nil {
        return
    }
 
    dst, err := os.Create(dstName)
    if err != nil {
        return
    }
 
    written, err = io.Copy(dst, src)
    dst.Close()
    src.Close()
    return
}

Go语言引入了Defer来确保那些受打开的文本能够给关门。如下所示:(这种解决方法还是比优雅的)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func CopyFile(dstName, srcName string) (written int64, err error) {
    src, err := os.Open(srcName)
    if err != nil {
        return
    }
    defer src.Close()
 
    dst, err := os.Create(dstName)
    if err != nil {
        return
    }
    defer dst.Close()
 
    return io.Copy(dst, src)
}

Go的defer语句预设一个函数调用(延期的函数),该调用在函数执行defer返回时立刻运行。该法显得不同健康,但可是处理上述情形非常管用,无论函数怎样返回,都须开展资源自由。

咱们再度来拘禁一个defer函数的言传身教:

1
2
3
for i := 0; i < 5; i++ {
    defer fmt.Printf("%d ", i)
}

深受延迟的函数以后进先出(LIFO)的顺行执行,因此上述代码在回去时将打印4 3
2 1 0。

总之,我个人认为defer的函数行为有点蹊跷,我现在还不曾了将懂。

错误处理 – Panic/Recover

对不可恢复的错误,Go提供了一个内建的panic函数,它用开创一个运转时误并设程序停止(相当强力)。该函数收取一个肆意档次(往往是字符串)作为序死亡时要打印的物。当编译器在函数的结尾处检查到一个panic时,就会见终止进行正规的return语词检查。

下面的仅仅是一个示范。实际的库函数应避免panic。如果问题可忍受,最好是给事情继续下去而不是停整个程序。

1
2
3
4
5
6
7
var user = os.Getenv("USER")
 
func init() {
    if user == "" {
        panic("no value for $USER")
    }
}

当panic被调用时,它将即刻停下当前函数的尽并初步逐级解开函数堆栈,同时运转有被defer的函数。如果这种解开达到堆栈的头,程序就算去世了。但是,也得以应用内建的recover函数来更得到Go程的控制权并恢复正常的履。
对recover的调用会通知解开堆栈并回到传递及panic的参量。由于单独于松期间运行的代码处在被defer的函数之内,recover仅于给推移的函数内部才是立竿见影的。

君可概括地掌握也recover就是用来捕捉Painc的,防止程序一下子尽管昂立掉了。

下是一个例程,很简短了,不讲了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
func g(i int) {
    if i>1 {
        fmt.Println("Panic!")
        panic(fmt.Sprintf("%v", i))
    }
 
}
 
func f() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered in f", r)
        }
    }()
 
    for i := 0; i < 4; i++ {
        fmt.Println("Calling g with ", i)
        g(i)
        fmt.Println("Returned normally from g.")
     }
}
 
func main() {
    f()
    fmt.Println("Returned normally from f.")
}

运行结果如下:(我们得看来Painc后的for循环就没有往生执行了,但是main的次第还以为生活动)

1
2
3
4
5
6
7
8
Calling g with  0
Returned normally from g.
Calling g with  1
Returned normally from g.
Calling g with  2
Panic!
Recovered in f 2
Returned normally from f.

乃习以为常这种编程方式吗?我看多少奇怪。呵呵。

哼了,上面是凡平等Go语言相关的编程语法的牵线,我无事不管巨细,只是让您了解一下Go语言是加上什么样的。当然,这尚从未竣工,请期待下篇——Go语言的特色

(转载本站文章呼吁注明作者及出处 酷壳 –
CoolShell.cn ,请不用于其他商业用途)