Go-语言基础

linux安装Go环境

1
2
3
4
5
6
7
8
9
10
11
12
yum install mercurial
yum install git
yum install gcc
wget https://golang.google.cn/dlc/具体包名
tar -zxvf go1.2.linux-amd64.tar.gz
vim /etc/profile
//配置GO 全局变量
//Gopath是个人Go目录地址
//Goroot是Go安装地址
export GOROOT=/usr/local/go
export PATH=$GOROOT/bin:$PATH
export GOPATH=/usr/zibu/go

Go语法格式一览

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//当前程序的包名
package main
//导入其他包
import "fmt"
//常量定义
const PI = 3.14
//全局变量的声明和赋值
var name = "this a var "
//一般类型声明
type newType int;
//结构的声明
type newStruct struct {}
//接口的申明
type golang interface {}
//main函数作为程序入口点启动
func main(){
fmt.Println("hello zibu")
}

Go 程序是通过 package 来组织的。

只有 package 名称为 main 的包可以包含 main 函数。

一个可执行程序有且仅有一个 main 包。

通过 import 关键字来导入其他非 main 包。

1
2
3
4
5
6
7
8
//通过 import 关键字单个导入
import "fmt"
import "io"
//同时导入多个:
import {
"fmt",
"io"
}

使用 . 调用:

1
2
3
4
5
6
7
8
9
10
11
12
package 别名:
// 为fmt起别名为fmt2
import fmt2 "fmt"
// 调用的时候只需要Println(),而不需要fmt.Println()


//省略调用(不建议使用):
//前面加个点表示省略调用,那么调用该模块里面的函数,可以不用写模块名称了
import . "fmt"
func main (){
Println("hello,world")
}

const :常量

var: 函数体外部使用var关键字来进行全局变量的声明和赋值

type:使用type来声明结构(struct)和接口(interface)

func :声明函数

可见性规则

Go语言中,使用大小写来决定该常量、变量、类型、接口、结构或函数是否可以被外部包所调用。

函数名首字母小写即为 private :

1
func getId() {}

函数名首字母大写即为 public :

1
func Printf() {}

Go语言数据类型

1
2
3
4
5
var isBool bool = true			//bool类型 默认false
var isInt int = 1 //int类型
var isFloat32 float32 = 1.1 //float32
var isFloat64 float64 = 1.1 //float64
//1.9版本对于数字类型 无需声明 系统自动识别

GO语言变量

1
2
3
var v_name v_type    //默认声明 给与一个默认初始值
var v_name = v_value //自动根据赋值判定数据类型
v_name := v_value //省略var的语法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var x, y int
var ( // 这种因式分解关键字的写法一般用于声明全局变量
a int
b bool
)

var c, d int = 1, "zibu"

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"

func main(){
g, h := 123, "hello"
println(x, y, a, b, g, h)
}

值类型:int,float,bool,string等类型,使用 = 赋值时,是深度copy

使用**&i** 来获取i变量的内存地址,复杂数据一般使用引用类型,引用类型的赋值是地址复制,即浅拷贝。

Go语言常量

const:上文中已经介绍 就不赘述

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

在每一个const关键字出现时,被重置为0,然后再下一个const出现之前,每出现一次iota,其所代表的数字会自动增加1。

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
package main

import "fmt"

func main() {
const (
a = iota //0
b //1
c //2
d = "ha" //独立值,iota += 1
e //"ha" iota += 1
f = 100 //iota +=1
g //100 iota +=1
h = iota //7,恢复计数
i //8
)
fmt.Println(a,b,c,d,e,f,g,h,i)
}
//0 1 2 ha ha 100 100 7 8

import "fmt"
const (
i=1<<iota
j=3<<iota
k
l
)

func main() {
fmt.Println("i=",i)
fmt.Println("j=",j)
fmt.Println("k=",k)
fmt.Println("l=",l)
}
/*i= 1
j= 6
k= 12
l= 24*/
1
2
3
a = "hello"
unsafe.Sizeof(a)
//输出结果为:16

字符串类型在 go 里是个结构, 包含指向底层数组的指针和长度,这两部分每部分都是 8 个字节,所以字符串类型大小为 16 个字节。

Go语言运算符

  • 算数运算符 + - * / % ++ –
  • 关系运算符 == != > < >= <=
  • 逻辑运算符 && || !
  • 位运算符 &(位与) |(位或) ^(位异或) <<(左移运算符) >>(右移运算符)
  • 赋值运算符 = += -= *= /= %= <<= >>= &= ^= |=
  • 其他运算符 &返回变量存储地址 *指针变量

Go语言条件语句

  • if else
  • switch
1
2
3
4
5
6
7
 switch marks {//marks可以为任何类型
case 90: grade = "A"//成员需要是相同类型
case 80: grade = "B"
case 50,60,70 : grade = "C"
default: grade = "D"
}
//不需要使用break 默认break

Go语言循环语句

  • for
  • break
  • continue
  • goto :不建议使用

Go语言函数

Go语言最少有个main()函数

Go语言变量作用域

  • 局部变量 //局部变量与全局变量重名,局部变量覆盖全局变量
  • 全局变量
  • 形式参数 //函数的局部变量

Go语言数组

1
2
3
4
var varName [size] varType //Go的类型声明都是如此 与Java相反
var 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}//也可以不设置数组长度
var a = [5][2]int{ {0,0}, {1,2}, {2,4}, {3,6},{4,8}}//初始化二维数组

Go语言指针

1
2
3
4
5
6
7
8
9
10
11
12
13
func main() {
var a int= 20 /* 声明实际变量 */
var ip *int /* 声明指针变量 */
ip = &a /* 指针变量的存储地址 */
fmt.Printf("a 变量的地址是: %x\n", &a )/* 指针变量的存储地址 */

fmt.Printf("ip 变量储存的指针地址: %x\n", ip ) /* 指针变量的存储地址 */

fmt.Printf("*ip 变量的值: %d\n", *ip ) /* 使用指针访问值 */
}
/*a 变量的地址是: 20818a220
ip 变量储存的指针地址: 20818a220
*ip 变量的值: 20*/

空指针为:nil

Go语言结构体

1
2
3
4
5
6
7
8
type struct_variable_type struct {
member definition;
member definition;
...
member definition;
}//定义一个结构体
variable_name := structure_variable_type {value1, value2...valuen}//创建结构体变量,并赋值
fmt.Printf(variable_name.value1)//访问子元素

结构体指针

1
2
3
var struct_pointer *Books	//定义结构体指针
struct_pointer = &Book1 //指针变量 存储结构体变量地址
struct_pointer.title //结构体指针访问结构体成员 使用.操作符

Go语言切片

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

Go数组的长度不可改变,在特定场景中需要一个变长的集合,既为切片

Go数组的传递是值传递,而非

切片实际的存储是 *array length capacity 指向数组的指针 长度 容量

1
2
3
4
5
6
7
8
9
10
var identifier []type	//声明一个未制定大小的数组来定义切片
var slice1 []int = make([]int,length)//声明一个制定长度的切片
slice2:=make([]int,length,capacity) //增加容量声明,容量是容器的大小,长度是数据的长度,容量>=数据

fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)//使用len() cap()函数获取切片长度和容量

/* 创建切片 numbers1 是之前切片的两倍容量*/
numbers1 := make([]int, len(numbers), (cap(numbers))*2)
/* 拷贝 numbers 的内容到 numbers1 */
copy(numbers1,numbers)

Go 语言范围(Range)

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

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
package main
import "fmt"
func main() {
//这是我们使用range去求一个slice的和。使用数组跟这个很类似
//使用range将传入index和值变量,由于该例子无需序号则施工空白符“_”省略。
nums := []int{2, 3, 4}
sum := 0
for _, num := range nums {
sum += num
}
//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语言Map(集合)

Map:无序的键值对的集合,通过key来快速检索数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/* 声明变量,默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

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

func main() {
/* 创建map */
countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}
/* 遍历map */
for country := range countryCapitalMap {
fmt.Println(country, "首都是", countryCapitalMap [ country ])
}
/*删除元素*/
delete(countryCapitalMap, "France")
}

Go语言递归函数

阶乘:注意设置退出条件 否则将死循环

1
2
3
4
5
6
7
8
9
10
11
12
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)))
}

斐波那契数列

1
2
3
4
5
6
7
8
9
10
11
12
13
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))
}
}

Go语言类型转换

1
2
3
4
5
6
type_name(expression) 	//类型转换格式
var sum int = 17
var count int = 5
var mean float32

mean = float32(sum)/float32(count)

Go错误处理

http://www.runoob.com/go/go-error-handling.html

相关引用

Go语言教程——菜鸟教程