一等公民 Golang

下载安装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("字符串是空")
    }
}

• 算术运算符

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