一等公民 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("字符串是空")
    }
}
  • 算术运算符
运算符 描述 示例
+ 相加 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)
    }
}

Add a Comment

电子邮件地址不会被公开。 必填项已用*标注