GoLang (3)

控制语句

for

Go 只有一种循环结构—— for 循环。

基本的 for 循环除了没有了 ( ) 之外(甚至强制不能使用它们),看起来跟 C 或者 Java 中做的一样,而 { } 是必须的。

package main

import “fmt”

func main() {
sum := 0
for i := 0; i < 10; i++ {
sum += i
}
fmt.Println(sum)
}

for 可以是 Go 的 “while”

基于其前置后置可以为空可以省略分号:C 的 while 在 Go 中叫做 for

sum := 0

for sum<100{

sum += 1

}

死循环

如果省略了循环条件,循环就不会结束,因此可以用更简洁地形式表达死循环。

func main() {
for {
}
}

if

if 语句除了没有了 ( ) 之外(甚至强制不能使用它们),看起来跟 C 或者 Java 中的一样,而 { } 是必须的。

sum := 1
if sum < 2 {
sum = sum + 1
}
fmt.Printf(“%v”, sum)

 

if 的便捷语句 (带else的一个示例)

for 一样, if 语句可以在条件之前执行一个简单的语句。

由这个语句定义的变量的作用域仅在 if 范围之内。

package main

import (
“fmt”
“math”
)

func main() {
sum := 2
if sq := math.Sqrt(float64(sum)); sq < 2 {
sum = sum + 1
} else {
sum = sum + 2
}
fmt.Printf(“%v”, sum)
}

switch

除非以 fallthrough 语句结束,否则分支会自动终止。(注意与c的区别)

func main() {

fmt.Print(“Go runs on “)
switch os := runtime.GOOS; os {
case “darwin”:
fmt.Println(“OS X.”)
case “linux”:
fmt.Println(“Linux.”)
default:
// freebsd, openbsd,
// plan9, windows…
fmt.Printf(“%s.”, os)
}
}

 

没有条件的 switch

没有条件的 switch 同 switch true 一样。

这一构造使得可以用更清晰的形式来编写长的 if-then-else 链。

 

defer

defer 语句会延迟函数的执行直到上层函数返回。

延迟调用的参数会立刻生成,但是在上层函数返回前函数都不会被调用。

package main

import “fmt”

func main() {
defer fmt.Println(“world”)

fmt.Println(“hello”)
}

输出结果:hellow  world

defer 栈

延迟的函数调用被压入一个栈中。当函数返回时, 会按照后进先出的顺序调用被延迟的函数调用。

 

 

 

GoLang(2)

基础

 

每个 Go 程序都是由包组成的。

程序运行的入口是包 main

看下程序。

package main

import (
“fmt”
“math/rand”
“time”
)

func main() {
fmt.Printf(“hello, ching, it’s %s \n”, time.Now())
fmt.Printf(“%d\n”, rand.Intn(10))
}

我们由package main 定义了程序入口,并通过import(“fmt”  “math/rand”  “time”)引入了三个包。

按照惯例,包名与导入路径的最后一个目录一致。例如,"math/rand" 包由package rand 语句开始

导出名

在导入了一个包之后,就可以用其导出的名称来调用它。

在 Go 中,首字母大写的名称是被导出的。

FooFOO 都是被导出的名称。名称 foo 是不会被导出的。

执行下面这段代码。然后将 math.Pi 改名为 math.pi 再试着执行一下。(是不是就会报错~?)

package main

import (
“fmt”
“math”
)

func main() {
fmt.Println(math.Pi)
}

函数

函数可以没有参数或接受多个参数。

在这个例子中, add 接受两个 int 类型的参数。

注意类型在变量名 之后

package main

import “fmt”

func add(x int, y int) int {
return x + y
}

func main() {
fmt.Println(add(42, 13))
}

当两个或多个连续的函数命名参数是同一类型,则除了最后一个类型之外,其他都可以省略。

在这个例子中 ,

x int, y int

可以被缩写为

x, y int

多值返回

函数可以返回任意数量的返回值。

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)
}

命名返回值

Go 的返回值可以被命名,并且像变量那样使用。

返回值的名称应当具有一定的意义,可以作为文档使用。

没有参数的 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))
}

build一下,可以看到conlose打印了7 和 10, 分别是x和y

变量

package main

import “fmt”

var c, python, java bool

func main() {
var i int
fmt.Println(i, c, python, java)
}

var 语句定义了一个变量的列表;跟函数的参数列表一样,类型在后面。

就像在这个例子中看到的一样, var 语句可以定义在包或函数级别。

初始化变量

这里提供两种方式:

1. 在初始化时顺便包含初始值,如:

var i, j int = 1, 2

2.直接用值来初始化, 根据初始化的值来识别类型,如:

var i, j, bol = 1, 2, bool

短声明变量

在函数中, := 简洁赋值语句在明确类型的地方,可以用于替代 var 定义。

k := 3   <==> var k int = 3

:= 结构不能使用在函数外,函数外的每个语句都必须以关键字开始( varfunc 、等等)。

变量的基本类型

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // uint8 的别名

rune // int32 的别名
     // 代表一个Unicode码

float32 float64

complex64 complex128

一个示例:

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)
}

零值

变量在定义时没有明确的初始化时会赋值为 零值

零值是:

  • 数值类型为 0
  • 布尔类型为 false
  • 字符串为 "" (空字符串)。

类型转换

表达式 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)

类型推导

在定义一个变量但不指定其类型时(使用没有类型的 var:= 语句), 变量的类型由右值推导得出。

当右值定义了类型时,新变量的类型与其相同:

var i int
j := i // j 也是一个 int

常量

常量的定义与变量类似,只不过使用 const 关键字。

常量可以是字符、字符串、布尔或数字类型的值。

常量不能使用 := 语法定义。EGS:

const Pi = 3.14

const World = “世界”

const Truth = true

常量的类型由指定的值来决定

一个未指定类型的常量由上下文来决定其类型。

 

 

GoLang (1)

一、mac下安装go

下载golang安装包

下载地址:

http://www.golangtc.com/download
我的选择是:go1.4.darwin-amd64-osx10.8.pkg  go1.4 Mac OS X (x86 64-bit) PKG installer

双击安装就成,会在/usr/local/go下

二、设置环境变量

创建目录下的go文件夹:为了我学习的方便,我选择了放在桌面上..原谅我

/Users/qing/Desktop/go

下面的东西放到.bash_rc(也可能是.bash_profile或者.zshrc)
export GOROOT=/usr/local/go

export GOPATH=/Users/qing/Desktop/go

export PATH=$PATH:$GOROOT/bin

三、使环境变量配置生效
source ~/.bash_profile
四、 开发ide - sublime text 2
我之前装过了,就不多说。
关键说下设置sublime的build

为Sublime Text2添加Go语言的Build

Tools -> Build System -> New Build System

输入如下代码:

{
“cmd” : [ “/usr/local/go/bin/go” ,  “run” ,  “$file” ],
“file_regex” :  “^(…*?):([0-9]*):?([0-9]*)” ,
“working_dir” :  “${file_path}” ,
“selector” :  “source.go”
}

然后选择Build存放的文件夹:go

然后Command + B  就有输出了。

五、安装GoSublime

1 . 打开sublime,按ctrl+` 出现sublime console

https://packagecontrol.io/installation

根据sublime的版本,复制相应代码进console, 回车

2. 重启sublime,command+shift+p 出现panel,输入package control: install package

然后等待一下,会看见panel出现新的内容,然后输入GoSublime,安装,重启sublime,再次在sublime中码go时,就会有代码提示咯~

六、第一个go程序

package main

import(
“fmt”
)
func main(){
fmt.Printf(“hello ching\n”)
}

在sublime下按command + b 就可以看到编译后的结果,也可以选择去到工作路径下,go build first.go 编译成可执行文件。双击运行看下结果,ok , done