一等公民 Golang

aicken_wang · · 994 次点击 · · 开始浏览

这是一个创建于的文章，其中的信息可能已经有所发展或是发生改变。

第一次，站长亲自招 Gopher 了>>>

下载安装Go语言

https://golang.org/doc/install

https://golang.google.cn/dl/

安装IDE

Atom:https://atom.io + package:go-plus

若没有设置环境变量使用

Unix上默认为 $HOME/go

Windows上默认为 %USERPROFILE%/go

Mac 上 GOPATH 通过修改~/.bash_profile来设置

package main //包 ，表明代码所在的模块（包） /* //只有25个关键字 1.必须是main 包：package main 2.必须是main 方法：func main() 3. 文件名不一定是main.go */ /* 退出返回值 与其他主要编程语言的差异 Go中main 函数不支持任何返回值 通过os.Exit来返回状态 */ import "fmt" //引入代码依赖 //功能实现 func main() { fmt.Print("hello world") os.Exit(0) }

直接运行使用 go run hello.go

编译生成二进制 go build hello.go

package main /* 获取命令行参数 与其他主要编程语言的差异 main 函数不支持传入参数 func main(arg []string) 不支持 X 在程序中通过os.Args获取命令行参数 */ import ( "fmt" "os" ) func main() { fmt.Println(os.Args) if len(os.Args)>1 { fmt.Println("hello world cmd: ",os.Args[1]) } fmt.Print("hello world") os.Exit(0) }

编写测试程序

//源码文件以 _test结尾：xxx_test.go //测试方法名以Test开头：func TestXXX(t *testing.T){ ... } 大写是包外可以访问 package try_test import "testing" func TestFirstTry(t *testing.T){ t.Log("My First try!") }

package fib import ( "fmt" "testing" ) //全局变量声明 //var a int func TestFibList(t *testing.T) { //a = 1 //全局变量赋值 //定义变量方法一 //var a int = 1 //var b int = 1 //定义变量方法二 //var( // a int = 1 // b int = 1 //) // 自动推断变量类型 a := 1 b := 1 fmt.Print(a) for i :=0; i<5; i++ { // fmt.Print(" ", b) t.Log(" ", b) tmp := a a = b b = tmp + a } fmt.Println() } func TestSwap(t *testing.T) { a := 1 b := 2 // tmp := a // a = b // b = tmp // 对多个变量赋值 a, b = b, a t.Log(a, b) }

// 常量定义 // 与其他主要编程语言的差异 // 快速设置连续值 package constant_test import "testing" const ( Monday = iota +1 Tuesday Wednesday Thursday Friday Saturday Sunday ) const ( Open = 1 << iota Close ) func TestConstantTry(t *testing.T) { t.Log(Monday, Tuesday) } func TestConstantTryBin(t *testing.T) { a := 7 //0111 t.Log( a&Open == Open, a&Close == Close) }

// 基本数据类型 bool string int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr byte //alias for uint8 rune //alias for int32,represents a Unicode code point float32 float64 complex64 complex128 // 类型转换 // 与其他主要编程语言的差异 // 1.Go语言不允许隐式类型转换 // 2.别名和原有类型也不能进行隐式类型转换

package type_test import "testing" type MyInt int64 // 声明一个int64 的别名MyInt func TestImplicit(t *testing.T) { var a int = 1 var b int64 b = int64(a) //显示转换 // b = a //Err 不能隐式转换 var c MyInt //c = b //Err 同类型的别名也不能隐式转换 严格 c = MyInt(b) t.Log(a, b, c) }

//类型的预定义值 1.math.MaxInt64 2.math.MaxFloat64 3.math.MaxUint32 //指针类型 与其他主要编程语言的差异 1.不支持指针运算 2.string是值类型，其默认的初始化值为空字符串，而不是nil

package type_test import ( "testing" ) type MyInt int64 // 声明一个int64 的别名MyInt func TestImplicit(t *testing.T) { var a int = 1 var b int64 b = int64(a) //显示转换 // b = a //Err 不能隐式转换 var c MyInt //c = b //Err 同类型的别名也不能隐式转换 严格 c = MyInt(b) t.Log(a, b, c) } func TestPoint(t *testing.T) { a :=1 aPtr := &a // aPtr = aPtr + 1 //Err 不支持运算 t.Log(a, aPtr) t.Logf(" %T %T", a, aPtr) } func TestString(t *testing.T) { var s string //string是值类型默认是空字符串 t.Log("*" + s +"*") t.Log(len(s)) if s == ""{ t.Log("字符串是空") } }

算术运算符

运算符	描述	示例
+	相加	A := 10 B := 10 ==> A + B 输出结果 20
-	相减	A - B 输出结果 0
*	相乘	A * B 输出结果 100
/	相除	B / A 输出结果 1
%	求余	B % A 输出结果 0
++	自增	A++ 输出结果 11
--	自减	A-- 输出结果 9

Go语言没有前置的 ++， --；（++a） Err

比较运算符

运算符	描述	示例
==	检查两个值是否相等，如果相等返回True,否则返回False
!>	检查两个值是否不相等，如果不相等返回True ,否则返回False
>	检查左边值是否大于右边值，如果是返回True，否则返回False
<	检查左边值是否小于右边值，如果是返回True 否则返回False
>=	检查左边值是否大于等于右边值，如果是返回True 否则返回False
<=	检查左边值是否小于等于右边值，如果是返回True 否则返回False

用 == 比较数组
- 相同维数且含有相同个数元素的数组才可以比较
- 每个元素都相同才相等

逻辑运算符（ && 、 || 、！）

位运算符（&、 | 、^ 、<< 、>>）

位运算符 与其他主要编程语言的差异 &^ 按位清零 1 &^ 0 -- 1 1 &^ 1 -- 0 0 &^ 1 -- 0 0 &^ 0 -- 0

package operator_test import ( "fmt" "testing" ) func TestCompareArray(t *testing.T) { a := [...]int{1,2,3,4} b := [...]int{1,2,3,4} //c := [...]int{1,2,3,4,5} // t.Log(a == b) //t.Log(c) //t.Log( a == c) } /* 循环 Go 语言仅支持循环关键字 for for j :=7; j <=9; j++ */ func TestForLoop(t *testing.T) { for j := 0; j <= 10; j++ { t.Log("执行第" ,j , "次") } } /* while 条件循环 while (n < 5) */ func TestWhileLoop(t *testing.T){ n := 0 for n < 5 { n++ fmt.Println(n) } } /* while 条件循环 while (true) */ func TestForLoop(t *testing.T){ //n := 0 //for { // n++ // fmt.Print("死循环") //} }

if 条件

与其他主要编程语言差异

1.condition表达式结果必须为bool 布尔值

2.支持变量赋值

if var declaration; condition{

//code

}

switch 条件

1.条件表达式不限制为常量或者整数

2.单个case中，可以出现多个结果选项，使用逗号分隔

3.与C语言等规则相反，Go语言不需要用break 来明确退出一个case;

4.可以不设定switch之后的条件表达式，在这种情况下，整个switch结构与多个if else 的逻辑作用等同

switch os := runtime.GOOS;os{

case "xxx":

default:

}

func TestSwitchMultiCase(t *testing.T) { for i :=0; i <5; i++ { switch i { case 0, 2: t.Log("Even") case 1,3: t.Log("Odd") default: t.Log("it is not 0-3") } } } func TestSwitchCaseCondition(t *testing.T) { for i :=0; i <5; i++ { switch { case i%2 == 0: t.Log("Even") case i%2 == 1: t.Log("Odd") default: t.Log("不会走这个分支") } } }

package slice_test import "testing" func TestSliceInit(t *testing.T) { var s0 []int t.Log(len(s0), cap(s0)) s0 = append(s0, 1) t.Log(len(s0), cap(s0)) //方式二 s1 := []int{1, 2, 3, 4} t.Log(len(s1), cap(s1)) //方式三 //[]type ,len,cap 其中len 个元素会被初始化为默认零值，未初始化元素不可以访问 s2 := make([]int, 3, 5) t.Log(len(s2), cap(s2)) s2 = append(s2, 1) t.Log(s2[0], s2[1],s2[2] ,s2[3]) } /** 切片共享存储结构 */ func TestSliceGrowing(t *testing.T) { s := []int{} for i := 0; i < 10; i++ { s = append(s, i) t.Log(len(s),cap(s)) } } func TestSliceShareMemory(t *testing.T) { year := []string{"Jan", "Feb", "Mar", "Apr", "May","Jun", "Jul","Aug","Sep","Oct","Nov","Dec"} Q2 := year[3:6] t.Log(Q2, len(Q2),cap(Q2)) summer := year[5 :8] t.Log(summer,len(summer), cap(summer)) summer[0] = "UnKnow" t.Log(Q2) t.Log(year) } /* 数组 vs 切片 1.容量是否可伸缩 2.是否可以进行比较 结论： 数组不可伸缩 ，可比较 切片可伸缩，不可比较 */

package string_test import ( "testing" "unsafe" ) /* 字符串 与其他主要编程语言的差异 1.string 是数据类型，不是引用或指针类型 2. string是只读 byte slice ,len 函数是它所包含的byte数 3.string的byte数组可以存放任何数据 */ func TestString(t *testing.T){ var s string t.Log(s) //初始化默认零值"" s = "hello" t.Log(len(s)) //s[1] = "3" //string是不可变byte slice s ="\347\216\213" //可以存储任何二进制数据 t.Log(s) s = "中China" t.Log(len(s)) // byte数 c :=[]rune(s) t.Log("rune size:",unsafe.Sizeof(c[0])) t.Logf("中 Unicode %x", c[0]) t.Logf("中 UTF %x",s) }

package map_and_factory_test import ( "testing" ) /* Map 与工厂模式 Map的value 可以是一个方法 与Go的 Dock type接口方式一起，可以方便的实现单一方法对象的工厂模式 */ func TestMapWithFunValue(t *testing.T) { m := map[int]func(op int)int{} m[1] = func(op int) int { return op } m[2] = func(op int) int { return op * op } m[3] = func(op int) int { return op * op * op } t.Log(m[1](1), m[2](2), m[3](2)) } /* 实现 Set Go 的内置集合中没有Set的实现 ，可以map[type]bool 1.元素的唯一性 2.基本操作 1）添加元素 2）判断元素是否存在 3）删除元素 4）元素个数 */ func TestMapForSet(t *testing.T) { mySet := map[int]bool{} mySet[1] = true n := 3 if mySet[n] { t.Logf("%d is existing", n) } else { t.Logf(" %d is not existing", n) } t.Log(len(mySet)) delete(mySet,1) t.Log(len(mySet)) n = 1 if mySet[n] { t.Logf("%d is existing", n) } else { t.Logf(" %d is not existing", n) } }

package string_test import ( "strconv" "strings" "testing" ) func TestStringFn(t *testing.T) { t.Log("test") s :="A, B, C" parts := strings.Split(s, ",") for _, part := range parts{ t.Log(part) } t.Log(strings.Join(parts, "-")) } func TestStringToNum(t *testing.T) { s :=strconv.Itoa(10) t.Log("str " + s) if i, err :=strconv.Atoi("10");err == nil { t.Log(10 + i) } }

package string_test import ( "testing" "unsafe" ) /* 字符串 与其他主要编程语言的差异 1.string 是数据类型，不是引用或指针类型 2. string是只读 byte slice ,len 函数是它所包含的byte数 3.string的byte数组可以存放任何数据 */ func TestString(t *testing.T){ var s string t.Log(s) //初始化默认零值"" s = "hello" t.Log(len(s)) //s[1] = "3" //string是不可变byte slice s = "\347\216\213"//可以存储任何二进制数据 t.Log(s) s = "中" t.Log(len(s)) // byte数 c :=[]rune(s) t.Log("rune size:",unsafe.Sizeof(c[0])) t.Logf("中 Unicode %x", c[0]) t.Logf("中 UTF %x",s) } /* strings 包 https://golang.org/pkg/strings/ strconv 包 https://golang.org/pkg/strconv/ */ func TestStringToRune(t *testing.T) { s := "中华人民共和国" for _, c := range s { t.Logf(" %[1]c %[1]d",c) } }

有疑问加站长微信联系（非本文作者）