简年1:笨办法学 Golang(1)

作者: 左蓝 | 来源:发表于2017-01-20 23:39 被阅读389次

顺便蹭下活动,反正也是日更。这个鸡年我在简书写Golang,笑哭。

这个系列受 Python 界那本著名的《笨办法学 Python》(Learn Python the Hard Way)启发,尝试从练习和例子入手学习 Go 语言。

本文为系列第一篇,主要介绍 Go 语言的最基础的语法(部分例题来自 Go by Example)。Go 语言环境安装就不说了。

1. Hello World

这是我们的第一个 Go 语言程序。
下面是一个 Hello World 程序的全部代码。

package main
// 软件包 fmt 实现 I/O 格式化,功能类似于 C 的 printf 和 scanf。
import "fmt"
// main 函数,程序入口。
func main() {
    fmt.Println("hello world")
}

点击运行,如果打不开请翻墙。

我们可以直接使用 go run 命令运行这个文件:

$ go run hello-world.go
hello world

或者使用 go build 命令把源文件

$ go build hello-world.go
$ ls
hello-world hello-world.go

编译成二进制执行文件,然后就可以直接执行了。这样,下次就不需要使用 Go 语言的环境来执行源程序,而是可以脱离 Go 语言开发环境成为一个独立的程序。例如下面,你可以把 hello-world 文件移动到其他主流 Linux 发行版运行,即便那系统没有 Go 语言环境也可以运行。

$ ./hello-world
hello world

练习

  1. 下面哪个可以输出“hello world”?
    A.
package main
import "fmt"
func main() {
    fmt.Print("hello")
    fmt.Print(" world")
}

B.

package main
import "fmt"
func main()
{
    fmt.Print("hello")
    fmt.Print(" world")
}

C.

package main
import "fmt"
func main()
{
    fmt.Println("hello")
    fmt.Print(" world")
}

D.

package hello
import "fmt"
func hello() {
    fmt.Print("hello")
    fmt.Print(" world")
}

2. Values

Go 有各种值类型,包括 strings, integers, floats, booleans 等等。
下面是一些很基础的例子。

package main

import "fmt"

func main() {

    // 字符串,可以使用“+”符号把两个值连到一起。
    fmt.Println("go" + "lang")

    // 整数和浮点数。
    fmt.Println("1+1 =", 1+1)
    fmt.Println("7.0/3.0 =", 7.0/3.0)

    // 布尔值,支持常见的布尔运算符。
    fmt.Println(true && false)
    fmt.Println(true || false)
    fmt.Println(!true)
}

点击运行,如果打不开请翻墙。

直接在本地运行:

$ go run values.go
golang
1+1 = 2
7.0/3.0 = 2.3333333333333335
false
true
false

练习

  1. 下列哪行代码不可以通过编译?
package main
import "fmt"
func main() {
    // A
    fmt.Println("go" + "lang")
    // B
    fmt.Println("相加:", 1 + 1)
    // C
    fmt.Println("相除", 7.0000000000000001 / 3)
    // D
    fmt.Println("真假:", 0 || 1)
}

3. Variables

Go语言里面定义变量有多种方式。

//定义一个名称为“varName”,类型为"type"的变量,变量类型放在变量名后面
var varName type

//定义三个类型都是“type”的变量
var vname1, vname2, vname3 type

//初始化“varName”的变量为“value”值,类型是“type”
var varName type = value

/*
    定义三个类型都是"type"的变量,并且分别初始化为相应的值
    vname1为v1,vname2为v2,vname3为v3
*/
// 这是第一种写法
var vname1, vname2, vname3 type = v1, v2, v3

// 直接忽略类型声明,Go会根据其相应值的类型来帮你初始化它们
var vname1, vname2, vname3 = v1, v2, v3

// 再简单点,直接把var都去掉
vname1, vname2, vname3 := v1, v2, v3

/*
    :=这个符号直接取代了var和type,这种形式叫做简短声明。
    不过它有一个限制,那就是它只能用在函数内部;
    在函数外部使用则会无法编译通过,所以一般用var方式来定义全局变量。
*/

// 还可以这样
var (
    v1 = 1
    v2 = 2
    v3 = 3
)

注意:

  • _(下划线)是个特殊的变量名,任何赋予它的值都会被丢弃。
  • Go对于已声明但未使用的变量会在编译阶段报错
  • 变量除了可以在全局声明中初始化,也可以在 init 函数中初始化。这是一类非常特殊的函数,它不能够被人为调用,而是在每个包完成初始化后自动执行,并且执行优先级比 main 函数高。每一个源文件都可以包含且只包含一个 init 函数。初始化总是以单线程执行,并且按照包的依赖关系顺序执行。

类型转换:

var n int16 = 34
var m int32
m = int32(n)

Example

package main

import "fmt"

func main() {
    // var 定义一个或者多个变量。
    var a string = "initial"
    fmt.Println(a)
    // 你可以在一行定义多个变量。
    var b, c int = 1, 2
    fmt.Println(b, c)
    // Go语言会自动推断变量类型。
    var d = true
    fmt.Println(d)
    // 没有初始化声明的变量默认值是0。例如,一个没有初始化的int类型的值为0。
    var e int
    fmt.Println(e)
    // 为了省事,Go语言提供了 := 这样的语法,它包含了定义和初始化。下面就是一个例子,下面语句中等同为:var f string = "short"
    f := "short"
    fmt.Println(f)
}

4. Constants

const Pi = 3.1415926
//如果需要,也可以明确指定常量的类型:
const Pi float32 = 3.1415926
//甚至还可以这样
const (
    数字, 字符串, 布尔值 = 1, "你好世界", true
)

使用某个类型作为枚举常量的类型:

type Color int
const (
    RED Color = iota // 0
    ORANGE // 1
    YELLOW // 2
    GREEN // 3
    BLUE // 4
    INDIGO // 5
    VIOLET // 6
)

需要注意的一点是,这些类型的变量之间不允许互相赋值或操作,不然会在编译时引起编译器报错。

如下的代码会产生错误:

var a int8
var b int32
c:=a + b
// 编译报错:invalid operation: a + b (mismatched types int8 and int32)

另外,尽管int的长度是32 bit, 但int 与 int32并不可以互用。

Example

package main

import "fmt"
import "math"

const declares a constant value.
const s string = "constant"

func main() {
    fmt.Println(s)
    // 常量可以在任意地方定义,但是初始化后便不能修改。
    const n = 500000000
    // 常量的值可以是一个不含变量的表达式
    const d = 3e20 / n
    fmt.Println(d)
    // 常量同样可以隐式声明类型,即交由Go编译器判断类型,你可以使用下面的方式强制类型转换一个常量。
    fmt.Println(int64(d))
    // Go允许不同类型的数字常量运算,结果按照最后一个运算法则变化例如原本n是整型,经过Sin()函数转变,运算结果会变成一个浮点型。
    fmt.Println(math.Sin(n))
}

相关文章

网友评论

    本文标题:简年1:笨办法学 Golang(1)

    本文链接:https://www.haomeiwen.com/subject/nntwbttx.html