Go Go教程 2019-04-29 09:56:28 16 0 0

Go 语言开发工具

LiteIDE

LiteIDE 是一款开源、跨平台的轻量级 Go 语言集成开发环境（IDE）。

支持的操作系统

Windows x86 (32-bit or 64-bit)
Linux x86 (32-bit or 64-bit)

下载地址：http://sourceforge.net/projects/liteide/files/

源码地址：https://github.com/visualfc/liteide

Eclipse

Eclipse 也是非常常用的开发利器，以下介绍如何使用 Eclipse 来编写 Go 程序。

1.4.eclipse1

Eclipse 编辑 Go 的主界面

首先下载并安装好 Eclipse
下载 goclipse 插件 https://github.com/GoClipse/goclipse/blob/latest/documentation/Installation.md#installation
下载 gocode，用于 go 的代码补全提示
gocode 的 github 地址：
```
https://github.com/nsf/gocode
```
在 Windows下要安装 git，通常用 msysgit。
再在 cmd 下安装：
```
go get -u github.com/nsf/gocode
```
也可以下载代码，直接用 go build 来编译，会生成 gocode.exe
下载 MinGW 并按要求装好
配置插件
Windows->Reference->Go
(1)、配置 Go 的编译器
设置 Go 的一些基础信息
(2)、配置 Gocode（可选，代码补全），设置 Gocode 路径为之前生成的 gocode.exe 文件
设置 gocode 信息
(3)、配置 GDB（可选，做调试用），设置 GDB 路径为 MingW 安装目录下的 gdb.exe 文件
设置 GDB 信息
测试是否成功
新建一个 go 工程，再建立一个 hello.go。如下图：
新建项目编辑文件
调试如下（要在 console 中用输入命令来调试）：
图 1.16 调试 Go 程序

更多

Go 并发

Go Go教程 2019-04-29 09:55:52 9 0 0

Go 并发

Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。

goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。

goroutine 语法格式：

go 函数名( 参数列表 )

例如：

go f(x, y, z)

开启一个新的 goroutine:

f(x, y, z)

Go 允许使用 go 语句开启一个新的运行期线程，即 goroutine，以一个不同的、新创建的 goroutine 来执行一个函数。同一个程序中的所有 goroutine 共享同一个地址空间。

实例

package main

import (
  "fmt"
  "time"
)

func say(s string) {
  for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
  }
}

func main() {
  go say("world")
say("hello")
}

执行以上代码，你会看到输出的 hello 和 world 是没有固定先后顺序。因为它们是两个 goroutine 在执行：

world
hello
hello
world
world
hello
hello
world
world
hello

通道（channel）

通道（channel）是用来传递数据的一个数据结构。

通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。

ch <- v    // 把 v 发送到通道 ch
v := <-ch  // 从 ch 接收数据
           // 并把值赋给 v

声明一个通道很简单，我们使用chan关键字即可，通道在使用前必须先创建：

ch := make(chan int)

注意：默认情况下，通道是不带缓冲区的。发送端发送数据，同时必须又接收端相应的接收数据。

以下实例通过两个 goroutine 来计算数字之和，在 goroutine 完成计算后，它会计算两个结果的和：

实例

package main

import "

更多

Go 错误处理

Go Go教程 2019-04-29 09:54:57 9 0 0

Go 错误处理

Go 语言通过内置的错误接口提供了非常简单的错误处理机制。

error类型是一个接口类型，这是它的定义：

type error interface {
    Error() string
}

我们可以在编码中通过实现 error 接口类型来生成错误信息。

函数通常在最后的返回值中返回错误信息。使用errors.New 可返回一个错误信息：

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
    // 实现
}

在下面的例子中，我们在调用Sqrt的时候传递的一个负数，然后就得到了non-nil的error对象，将此对象与nil比较，结果为true，所以fmt.Println(fmt包在处理error时会调用Error方法)被调用，以输出错误，请看下面调用的示例代码：

result, err:= Sqrt(-1)

if err != nil {
   fmt.Println(err)
}

实例

package main

import (
  "fmt"
)

// 定义一个 DivideError 结构
type DivideError struct {
dividee int
divider int
}

// 实现 `error` 接口
func (de *DivideError) Error() string {
strFormat := `
Cannot proceed, the divider is zero.
dividee: %d
divider: 0
`
  return fmt.Sprintf(strFormat, de.dividee)
}

// 定义 `int` 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
  if varDivider == 0 {
dData := DivideError{
dividee: varDividee,

更多

Go 语言接口

Go Go教程 2019-04-29 09:54:14 17 0 0

Go 语言接口

Go 语言提供了另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。

实例

/* 定义接口 */
type interface_name interface {
method_name1 [return_type]
method_name2 [return_type]
method_name3 [return_type]
...
method_namen [return_type]
}

/* 定义结构体 */
type struct_name struct {
/* variables */
}

/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
/* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
/* 方法实现*/
}

实例

package main

import (
"fmt"
)

type Phone interface {
call()
}

type NokiaPhone struct {
}

func (nokiaPhone NokiaPhone) call() {
fmt.Println("I am Nokia, I can call you!")
}

type IPhone struct {
}

func (iPhone IPhone) call() {
fmt.Println("I am iPhone, I can call you!")
}

func main() {
var phone Phone

phone = new(NokiaPhone)
phone.call()

phone = new(IPhone)
phone.call()

}

在上面的例子中，我们定义了一个接口Phone，接口里面有一个方法call()。然后我们在main函数里面定义了一个Phone类型变量，并分别为之赋值为NokiaPhone和IPhone。然后调用call()方法，输出结果如下：

I am Nokia, I can call

更多

Go 语言类型转换

Go Go教程 2019-04-29 09:53:22 28 0 0

Go 语言类型转换

类型转换用于将一种数据类型的变量转换为另外一种类型的变量。Go 语言类型转换基本格式如下：

type_name(expression)

type_name 为类型，expression 为表达式。

实例

以下实例中将整型转化为浮点型，并计算结果，将结果赋值给浮点型变量：

实例

package main

import "fmt"

func main() {
var sum int = 17
var count int = 5
var mean float32

mean = float32(sum)/float32(count)
fmt.Printf("mean 的值为: %f\n",mean)
}

以上实例执行输出结果为：

mean 的值为: 3.400000

更多

Go 语言递归函数

Go Go教程 2019-04-29 09:53:00 14 0 0

Go 语言递归函数

递归，就是在运行的过程中调用自己。

语法格式如下：

func recursion() {
recursion() /* 函数调用自身 */
}

func main() {
recursion()
}

Go 语言支持递归。但我们在使用递归时，开发者需要设置退出条件，否则递归将陷入无限循环中。

递归函数对于解决数学上的问题是非常有用的，就像计算阶乘，生成斐波那契数列等。

阶乘

以下实例通过 Go 语言的递归函数实例阶乘：

实例

package main

import "fmt"

func Factorial(n uint64)(result uint64) {
  if (n > 0) {
result = n * Factorial(n-1)
  return result
  }
  return 1
}

func main() {
  var i int = 15
fmt.Printf("%d 的阶乘是 %d\n", i, Factorial(uint64(i)))
}

以上实例执行输出结果为：

15 的阶乘是 1307674368000

斐波那契数列

以下实例通过 Go 语言的递归函数实现斐波那契数列：

实例

package main

import "fmt"

func fibonacci(n int) int {
  if n < 2 {
return n
  }
  return fibonacci(n-2) + fibonacci(n-1)
}

func main() {
  var i int
  for i = 0; i < 10; i++ {
fmt.Printf("%d\t", fibonacci(i))
  }
}

以上实例执行输出结果为：

0    1    1    2    3    5    8    13    21    34

-------------------------------------

斐波纳契数列以如下被以递归的方法定义：F0=0，F1=1，Fn=F(n-1)+F(n-2)（n>=2，n∈N*）。
在这里的:
```
return fibonacci(n-2) + fibonacci(n-1)
```
是指的 n-2 是 n 前面第二项的值，而不是 n-2=x 的值，那么 n-1 也与此同理。
slepox

更多

Go 语言Map(集合)

Go Go教程 2019-04-29 09:52:16 9 0 0

Go 语言Map(集合)

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

定义 Map

可以使用内建函数 make 也可以使用 map 关键字来定义 Map:

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对

实例

下面实例演示了创建和使用map:

实例

package main

import "fmt"

func main() {
  var countryCapitalMap map[string]string /*创建集合 */
countryCapitalMap = make(map[string]string)

  /* map插入key - value对,各个国家对应的首都 */
countryCapitalMap [ "France" ] = "Paris"
countryCapitalMap [ "Italy" ] = "罗马"
countryCapitalMap [ "Japan" ] = "东京"
countryCapitalMap [ "India " ] = "新德里"

  /*使用键输出地图值 */
  for country := range countryCapitalMap {
fmt.Println(country, "首都是", countryCapitalMap [country])
  }

  /*查看元素在集合中是否存在 */
capital, ok := countryCapitalMap [ "美国" ] /*如果确定是真实的,则存在,否则不存在 */
  /*fmt.Println(capital) */
  /

更多

Go 语言范围(Range)

Go Go教程 2019-04-29 09:51:47 13 0 0

Go 语言范围(Range)

Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对的 key 值。

实例

package main
import "fmt"
func main() {
  //这是我们使用range去求一个slice的和。使用数组跟这个很类似
nums := []int{2, 3, 4}
sum := 0
  for _, num := range nums {
sum += num
  }
fmt.Println("sum:", sum)
  //在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
  for i, num := range nums {
  if num == 3 {
fmt.Println("index:", i)
  }
  }
  //range也可以用在map的键值对上。
kvs := map[string]string{"a": "apple", "b": "banana"}
  for k, v := range kvs {
fmt.Printf("%s -> %s\n", k, v)
  }
  //range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
  for i, c := range "go" {
fmt.Println(i, c)
  }
}

以上实例运行输出结果为：

sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111

---------------------------------

Go Range 简单循环：

package main

import "fmt"

func main(){
    nums := []int{1,2,3,4};
    length := 0;
    for range

更多

Go 语言切片(Slice)

Go Go教程 2019-04-29 09:50:49 23 0 0

Go 语言切片(Slice)

Go 语言切片是对数组的抽象。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

定义切片

你可以声明一个未指定大小的数组来定义切片：

var identifier []type

切片不需要说明长度。

或使用make()函数来创建切片:

var slice1 []type = make([]type, len)

也可以简写为

slice1 := make([]type, len)

也可以指定容量，其中capacity为可选参数。

make([]T, length, capacity)

这里 len 是数组的长度并且也是切片的初始长度。

切片初始化

s :=[] int {1,2,3 }

直接初始化切片，[]表示是切片类型，{1,2,3}初始化值依次是1,2,3.其cap=len=3

s := arr[:]

初始化切片s,是数组arr的引用

s := arr[startIndex:endIndex]

将arr中从下标startIndex到endIndex-1 下的元素创建为一个新的切片

s := arr[startIndex:]

缺省endIndex时将表示一直到arr的最后一个元素

s := arr[:endIndex]

缺省startIndex时将表示从arr的第一个元素开始

s1 := s[startIndex:endIndex]

通过切片s初始化切片s1

s :=make([]int,len,cap)

通过内置函数make()初始化切片s,[]int 标识为其元素类型为int的切片

len() 和 cap() 函数

切片是可索引的，并且可以由 len() 方法获取长度。

切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

以下为具体实例：

实例

package main

import "fmt"

func main() {
var numbers = make([]int,3,5)

printSlice(numbers)
}

func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

以上实例运行输出结果为:

len=3

更多

Go 语言结构体

Go Go教程 2019-04-29 09:49:42 25 0 0

Go 语言结构体

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

结构体表示一项记录，比如保存图书馆的书籍记录，每本书有以下属性：

Title ：标题
Author ：作者
Subject：学科
ID：书籍ID

定义结构体

结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体有中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：

variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

实例如下：

实例

package main

import "fmt"

type Books struct {
title string
author string
subject string
book_id int
}

func main() {

  // 创建一个新的结构体
fmt.Println(Books{"Go 语言", "www.istudy.wang", "Go 语言教程", 6495407})

  // 也可以使用 key => value 格式
fmt.Println(Books{title: "Go 语言", author: "www.istudy.wang", subject: "Go 语言教程", book_id: 6495407})

  // 忽略的字段为 0 或空
fmt.Println(Books{title: "Go 语言", author: "www.istudy.wang"})
}

输出结果为：

{Go 语言 www.istudy.wang Go 语言教程

更多

Arthur's Blog

标签 - Go

Go 语言开发工具

LiteIDE

支持的 操作系统

Eclipse

Go 并发

实例

通道（channel）

实例

Go 错误处理

实例

实例

Go 语言接口

实例

实例

实例

实例

Go 语言类型转换

实例

实例

Go 语言递归函数

阶乘

实例

斐波那契数列

实例

Go 语言Map(集合)

定义 Map

实例

实例

Go 语言范围(Range)

实例

实例

Go 语言切片(Slice)

定义切片

切片初始化

len() 和 cap() 函数

实例

Go 语言结构体

定义结构体

实例

导航

最近发布

友情链接

支持的操作系统