go语言入门_go { 不能单独放在一行

安装就不说了，网上都有。

 

入门

package main
 
import "fmt"
 
func main() {
	fmt.Println("Hello, World!")
}

 

让我们来看下以上程序的各个部分：

1. 第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。

2. 下一行 import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。

3. 下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。

4. 下一行 /*...*/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。

5. 下一行 fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。
   使用 fmt.Print("hello, world\n") 可以得到相同的结果。
   Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。

6. 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。

注意

需要注意的是 { 不能单独放在一行，所以以下代码在运行时会产生错误：

package main
 
import "fmt"
 
func main()  
{  // 错误，{ 不能在单独的行上
    fmt.Println("Hello, World!")
}

左括号不能单独一行，因为在go语言一行代表一个语句结束

 

Go语言变量

Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。

声明变量的一般形式是使用 var 关键字，可以一次声明多个变量：

package main
import "fmt"
func main() {
    var a string = "Runoob"
    fmt.Println(a)
 
    var b, c int = 1, 2
    fmt.Println(b, c)
}

 

变量声明

第一种，指定变量类型，如果没有初始化，则变量默认为零值。

零值就是变量没有做初始化时系统默认设置的值。

package main
import "fmt"
func main() {
 
    // 声明一个变量并初始化
    var a = "RUNOOB"
    fmt.Println(a)
 
    // 没有初始化就为零值
    var b int
    fmt.Println(b)
 
    // bool 零值为 false
    var c bool
    fmt.Println(c)
}

• 数值类型（包括complex64/128）为 0

• 布尔类型为 false

• 字符串为 ""（空字符串）

• 以下几种类型为 nil：

var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口

第二种，根据值自行判定变量类型。

package main
import "fmt"
func main() {
    var d = true
    fmt.Println(d)
}

第三种，省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误，格式：

package main
import "fmt"
func main() {
    f := "Runoob" // var f string = "Runoob"
 
    fmt.Println(f)
}

或者可以带个新的变量，比如：

package main
 
func main() {
	var intVal int
 
	intVal :=1 // 这时候会产生编译错误
 
	intVal,intVal1 := 1,2 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句
}

全局变量声明

package main
 
var (  // 这种因式分解关键字的写法一般用于声明全局变量
    a int
    b bool
)
 
func main(){
    println(a, b)
}

常量池

package main
 
import "fmt"
 
const (
	LENGTH int = 10
	WIDTH  int = 5
)
 
func main() {
	var area int
	const a, b, c = 1, false, "str" //多重赋值
 
	area = LENGTH * WIDTH
	fmt.Printf("面积为 : %d", area)
	println()
	println(a, b, c)
}

常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：

package main
 
import "unsafe"
const (
	a = "abc"
	b = len(a)
	c = unsafe.Sizeof(a)
)
 
func main(){
	println(a, b, c)
}

 

iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

iota 可以被用作枚举值：

const (
    a = iota
    b = iota
    c = iota
)

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

const (
    a = iota
    b
    c
)

实际用法

package main
 
const (
	a = iota
	b
	c
	d = "ha"
	e
	f = 100
	g
	h = iota
	i
)
 
func main(){
	println(a, b, c, d, e, f, g, h, i)
}

 

运算符

运算符跟Java差不多，所以说明下特殊的即可

 

 

 

 

package main
 
import "fmt"
 
func main(){
	var a int = 4
	var b int32
	var c float32
	var ptr *int
 
	fmt.Printf("第一行a变量类型为 = %T\n", a)
	fmt.Printf("第二行b变量类型为 = %T\n", b)
	fmt.Printf("第三行c变量类型为 = %T\n", c)
 
	/*  & 和 * 运算符实例 */
	ptr = &a     /* 'ptr' 包含了 'a' 变量的地址 */
	fmt.Printf("a 的值为  %d\n", a)
	fmt.Printf("*ptr 为 %d\n", *ptr)
 
}

 

Go 语言条件语句

这个注意go没有三元表达式即可

 

返回函数

go函数可以返回多个值

package main
 
import "fmt"
 
func swap(x, y string) (string, string)  {
	return y, x
}
 
func main(){
	a, b := swap("Google", "baidu")
	fmt.Println(a, b)
}

 

数组

例如以下定义了数组 balance 长度为 10 类型为 float32：

var balance [10] float32
 
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
 
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果数组长度不确定，可以使用 ... 代替数组的长度，编译器会根据元素个数自行推断数组的长度：

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果设置了数组的长度，我们还可以通过指定下标来初始化元素：

//  将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}

 

指针

package main
 
import "fmt"
 
func main() {
	var a int = 10
 
	fmt.Printf("变量的地址: %x\n", &a  )
}

 

什么是指针

一个指针变量指向了一个值的内存地址。类似于变量和常量，在使用指针前你需要声明指针。

var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */

如何使用指针

指针使用流程：

• 定义指针变量。
• 为指针变量赋值。
• 访问指针变量中指向地址的值。

package main
 
import "fmt"
 
func main() {
	var a int = 20
	var ip *int
 
	ip = &a
 
	fmt.Printf("变量的地址: %x\n", &a  )
 
	fmt.Printf("ip变量的存储地址： %x\n", ip)
 
	fmt.Printf("*ip 变量的的值: %d\n", *ip)
}

 

结构体（就是类）

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

package main
 
import "fmt"
 
type Books struct {
	title string
	author string
	subject string
	book_id int
}
 
func main() {
	// 创建一个新的结构体
	fmt.Println(Books{
		"Go 语言",
		"www.runoob.com",
		"Go 语言教程",
		6495407,
	})
 
	// 也可以使用  key：value 格式
	fmt.Println(Books{
		title: "Go 语言",
		author: "www.runoob.com",
		subject: "Go 语言教程",
		book_id: 6495407,
	})
 
	// 忽略字段为0或空,得看默认值
	fmt.Println(Books{
		title: "Go 语言",
		author: "www.runoob.com",
	})
}

 

如果要访问结构体成员，需要使用点号 . 操作符，或者传入整个结构体

package main
 
import "fmt"
 
type Books struct {
	title string
	author string
	subject string
	book_id int
}
 
func main() {
	var Book1 Books
	/* book 1 描述 */
	Book1.title = "Go 语言"
	Book1.author = "www.runoob.com"
	Book1.subject = "Go 语言教程"
	Book1.book_id = 6495407
 
	// 可以用点
	fmt.Printf( "Book 1 title : %s\n", Book1.title)
	/* 打印 Book1 信息 */
	printBook(Book1)
}
 
func printBook( book Books ) {
	fmt.Printf( "Book title : %s\n", book.title)
	fmt.Printf( "Book author : %s\n", book.author)
	fmt.Printf( "Book subject : %s\n", book.subject)
	fmt.Printf( "Book book_id : %d\n", book.book_id)
}

 

指针形式，修改上方代码

 

语言切片(Slice)

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

package main
 
import "fmt"
 
func main() {
	/* 创建切片 */
	numbers := []int{0,1,2,3,4,5,6,7,8}
	printSlice(numbers)
 
	/* 打印原始切片 */
	fmt.Println("numbers ==", numbers)
 
	/* 打印子切片从索引1(包含) 到索引4(不包含)*/
	fmt.Println("numbers[1:4] ==", numbers[1:4])
 
	/* 默认下限为 0*/
	fmt.Println("numbers[:3] ==", numbers[:3])
 
	/* 默认上限为 len(s)*/
	fmt.Println("numbers[4:] ==", numbers[4:])
 
	numbers1 := make([]int,0,5)
	printSlice(numbers1)
 
	/* 打印子切片从索引  0(包含) 到索引 2(不包含) */
	number2 := numbers[:2]
	printSlice(number2)
 
	/* 打印子切片从索引 2(包含) 到索引 5(不包含) */
	number3 := numbers[2:5]
	printSlice(number3)
 
}
 
func printSlice(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

 

append() 和 copy() 函数

如果想增加切片的容量，我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来。

package main
 
import "fmt"
 
func main() {
	var numbers []int
	printSlice(numbers)
 
	/* 允许追加空切片 */
	numbers = append(numbers, 0)
	printSlice(numbers)
 
	/* 向切片添加一个元素 */
	numbers = append(numbers, 1)
	printSlice(numbers)
 
	/* 同时添加多个元素 */
	numbers = append(numbers, 2,3,4)
	printSlice(numbers)
 
	/* 创建切片 numbers1 是之前切片的两倍容量*/
	numbers1 := make([]int, len(numbers), (cap(numbers))*2)
 
	/* 拷贝 numbers 的内容到 numbers1 */
	copy(numbers1,numbers)
	printSlice(numbers1)
}
 
func printSlice(x []int){
	fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

 

语言范围(Range)

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

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

 

Map(集合)

package main
 
import "fmt"
 
func main() {
	/* 创建集合,声明变量，默认 map 是 nil */
	// var countryCapitalMap map[string]string
 
	/* 使用 make 函数 */
	countryCapitalMap := make(map[string]string)
 
	countryCapitalMap ["France"] = "巴黎"
	countryCapitalMap ["Italy"] = "罗马"
 
	for country := range countryCapitalMap {
		fmt.Println(country, "首都是", countryCapitalMap [country])
	}
 
	// 查看元素是否在集合中存在
	capital, ok := countryCapitalMap["American"]
	if ok {
		fmt.Println("American 的首都是", capital)
	} else {
		fmt.Println("American 的首都不存在")
	}
}

 

delete() 函数

package main
 
import "fmt"
 
func main() {
	/* 创建集合,声明变量，默认 map 是 nil */
	// var countryCapitalMap map[string]string
 
	/* 使用 make 函数 */
	countryCapitalMap := make(map[string]string)
 
	countryCapitalMap ["France"] = "巴黎"
	countryCapitalMap ["Italy"] = "罗马"
 
	for country := range countryCapitalMap {
		fmt.Println(country, "首都是", countryCapitalMap [country])
	}
 
	delete(countryCapitalMap, "France")
	fmt.Println("法国巴黎被删除了")
 
	for country := range countryCapitalMap {
		fmt.Println(country, "首都是", countryCapitalMap [country])
	}
}

 

递归函数

package main
 
import "fmt"
 
func main() {
	i := int64(15)
	fmt.Printf("%d 的阶乘是 %d\n", i, Factorial(i))
}
 
func Factorial(n int64)(result int64)  {
	if n > 0 {
		result = n * Factorial(n-1)
		return result
	}
	return 1
}

 

类型转换

package main
import "fmt"
 
func main() {  
    var a int64 = 3
    var b int32
    b = int32(a)
    fmt.Printf("b 为 : %d", b)
}

 

接口

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

 

错误处理

package main
 
import "fmt"
 
type DivideErroe struct {
	dividee int
	divider int
}
 
// 实现error接口
func (de *DivideErroe) Error() string {
	strFormat := `
	Cannot proceed, the divider is zero
	dividee: %d
	divider: 0
`
	return fmt.Sprintf(strFormat, de.dividee)
}
 
// 定义 int 类型除法运算的函数
func Divide(varDividee , varDivider int) (result int, errorMsg string) {
	if varDivider == 0 {
		dData := DivideErroe{
			dividee: varDividee,
			divider: varDivider,
		}
		errorMsg = dData.Error()
		return
	} else {
		return varDividee / varDivider, ""
	}
}
 
func main() {
	// 正常情况
	if result, errorMsg := Divide(100, 10); errorMsg == "" {
		fmt.Println("100/10= " , result)
	}
	// 除数为0
	if _, errorMsg := Divide(100, 0); errorMsg !="" {
		fmt.Println("100/0= " , errorMsg)
	}
}

其中有个语法糖需要解释下

if result, errorMsg := Divide(100, 10); errorMsg == "" {
    fmt.Println("100/10 = ", result)
}
 
 
// 等价于
 
result, errorMsg := Divide(100,10)
if errorMsg == ""{
    fmt.Println("100/10 = ", result)
}

 

说到异常，Go有 panic 和 recover

panic异常一旦被引发就会导致程序崩溃。
所以Go语言提供了专用于“拦截”运行时panic的内建函数—recover。
它可以使当前程序从panic的状态中恢复，重新获得流程控制权，并返回panic value。
在未发生panic时调用recover，recover会返回nil。

注意：recover只有在defer调用的函数中有效。

func testb(x int) {
    defer func() {
        // recover()
        // fmt.Println(recover())
        if err := recover(); err != nil {
            fmt.Println("err 是：", err)
        }
    }()
    var a [10]int
    a[x] = 123
}

 

并发

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

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

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 在执行

 

通道（channel）

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

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

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

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

ch := make(chan int)

 

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

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

package main
 
import "fmt"
 
func sum(s []int, c chan int)  {
	sum := 0
	for _, v := range s{
		sum += v
	}
	c <- sum  // 把 sum 发送到通道c
}
 
func main() {
	s := []int{7, 2, 8, -9, 4, 0}
	c := make(chan int)
	go sum(s[:len(s)/2], c)
	go sum(s[len(s)/2:], c)
	x, y := <-c, <-c
	fmt.Println(x, y, x+y)
}

通道缓冲区

通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小：

ch := make(chan int, 100)

带缓冲区的通道允许发送端的数据发送和接收端的数据获取处于异步状态，就是说发送端发送的数据可以放在缓冲区里面，可以等待接收端去获取数据，而不是立刻需要接收端去获取数据。

不过由于缓冲区的大小是有限的，所以还是必须有接收端来接收数据的，否则缓冲区一满，数据发送端就无法再发送数据了。

注意：如果通道不带缓冲，发送方会阻塞直到接收方从通道中接收了值。如果通道带缓冲，发送方则会阻塞直到发送的值被拷贝到缓冲区内；如果缓冲区已满，则意味着需要等待直到某个接收方获取到一个值。接收方在有值可以接收之前会一直阻塞。

 

关于并发查缺补漏

package main
import (
    "fmt"
    "time"
)
func say(s string) {
    for i := 0; i < 5; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s, (i+1)*100)
    }
}
func say2(s string) {
    for i := 0; i < 5; i++ {
        time.Sleep(150 * time.Millisecond)
        fmt.Println(s, (i+1)*150)
    }
}
func main() {
    go say2("world")
    say("hello")
}

问题来了，say2 只执行了 3 次，而不是设想的 5 次，为什么呢？

原来，在 goroutine 还没来得及跑完 5 次的时候，主函数已经退出了。

我们要想办法阻止主函数的结束，要等待 goroutine 执行完成之后，再退出主函数：

package main
 
import (
	"fmt"
	"time"
)
 
func say(s string) {
	for i := 0; i < 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s, (i+1)*100)
	}
}
func say2(s string, ch chan int) {
	for i := 0; i < 5; i++ {
		time.Sleep(150 * time.Millisecond)
		fmt.Println(s, (i+1)*150)
	}
	ch <- 0
	close(ch)
}
 
func main() {
	ch := make(chan int)
	go say2("world", ch)
	say("hello")
	fmt.Println(<-ch)
}

 

我们引入一个信道，默认的，信道的存消息和取消息都是阻塞的，在 goroutine 中执行完成后给信道一个值 0，则主函数会一直等待信道中的值，一旦信道有值，主函数才会结束。

package main
 
import "fmt"
 
func main() {
    ch := make(chan int, 2)
 
    ch <- 1
    a := <-ch
    ch <- 2
    ch <- 3
 
    fmt.Println(<-ch)
    fmt.Println(<-ch)
    fmt.Println(a)
}

通道遵循先进先出原则。

不带缓冲区的通道在向通道发送值时，必须及时接收，且必须一次接收完成。

而带缓冲区的通道则会以缓冲区满而阻塞，直到先塞发送到通道的值被从通道中接收才可以继续往通道传值。就像往水管里推小钢珠一样，如果钢珠塞满没有从另一头放出，那么这一头就没法再往里塞，是一个道理。例如上面的例子，最多只能让同时在通道中停放2个值，想多传值，就需要把前面的值提前从通道中接收出去。

因此，上面的输出结果为：