基本程序结构

条件和循环

n:=0
for n<5{
    n++
    fmt.Println(n)
}

无限循环

n:=0
for{
n++
fmt.Println(n)
}

switch与其它语言的区别
1.条件表达式不限制为常量或者证书；
2.单个case中，可以出现多个结果选项，使用逗号分隔；
3.与C语言等规则相反，go语言不需要用break来明确退出一个case；
4.可以不设定 switch之后的条件表达式，在此种情况下，整个switch结构与多个if else 的逻辑作用相同

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("unknown")


        }
    }

常用集合

数组和切片

var a [3]int//声明并初始化为默认值0
a[0]=1

b:=[3]int{1,2,3}//声明同时初始化
c:=[2][2]int{{1,2},{3,4}}//多维数组初始化

数组的初始化与遍历

import "testing"

func TestArrayInit(t *testing.T){
    var arr[3]int//初始化默认结果为0
    arr1:=[4]int{1,2,3,4}//
    arr2:=[...]int{1,3,4,5}
    t.Log(arr[1],arr[2])
    t.Log(arr1[1],arr2[1])
}
func TestArrayTravel(t *testing.T){
    arr3 := [...]int{1,2,3,4,5}
    for i:=0;i<len(arr3);i++{
        t.Log(arr3[i])
    }
    for idx,e:=range arr3{
        t.Log(idx,e)
    }

}

数组截取
a[开始索引(包含)，结束索引(不包含)]
a:=[...]int{1，2，3，4，5，60}
a[1:2]//2
a[1:3]//2，3
a[1:len(a)]//2 3 4 5
a[1:]//2，3，4，5,60
a[:3]//1,2,3
```

切片内部结构

切片内部是一个结构体

func TestSliceGrowing(t *testing.T){
    s:=[]int{}
    for i:=0;i<10;i++{
        s = append(s, i)
        t.Log(len(s),cap(s))
    }
}

=== RUN TestSliceGrowing
--- PASS: TestSliceGrowing (0.00s)
slice_test.go:24: 1 1
slice_test.go:24: 2 2
slice_test.go:24: 3 4
slice_test.go:24: 4 4
slice_test.go:24: 5 8
slice_test.go:24: 6 8
slice_test.go:24: 7 8
slice_test.go:24: 8 8
slice_test.go:24: 9 16
slice_test.go:24: 10 16
PASS

共享连续存储控件

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

}

=== RUN TestSliceShareMemory
--- PASS: TestSliceShareMemory (0.00s)
slice_test.go:30: [Apr May Jun] 3 9
slice_test.go:32: [Jun Jul Aug] 3 7
PASS

数组 vs 切片
1.容量是否可伸缩
数组不可伸缩
2.是否可以进行比较
数组长度相同可以比较，slice 只能与nil进行比较 不可以比较两个slice

Map声明 元素访问及遍历

m:=map[string]int{"one":1,"two":2,"three":3}
m1:=map[string]int{}
m1["one"]=1
m2:=make(map[string]int, 10/Initial Capacity/)//为什么不初始化len？

判断map里面的值是否存在

func TestAccessNotExistingKey(t *testing.T){
    m1:=map[int]int{}
    t.Log(m1[1])
    m1[2]=0
    t.Log(m1[2])
    m1[3]=0
    if v,ok:=m1[3];ok{
        t.Log("key 3 is ",v)
    }else{
        t.Log("key 3 is not existing")

    }
}

map 元素的访问

与其他主要编程语言的差异
在访问key不存在时， 仍然会返回零值，不能通过返回nil来判断元素是否存在
if v,ok:=m["four"];ok{
t.log("four",v)
}
else{
t.Log("Not existing")
}

map元素的遍历

m:=map[string]int{"one":1,"two":2,"three":3}

for k,v :range m{
t.Log(k,v)
}

func TestTravelMap(t*testing.T){
    m:=map[string]int{"one":1,"two":2,"three":3}
    for k,v:=range m{
        t.Log(k,v)
    }
}

Map 与工厂模式，在go语言中实现工厂模式

map与工厂模式

• Map的value可以是一个方法
• 与Go的Dock type接口方式一起，可以方便的实现单一方法对象的工厂模式

//value是一个方法
package _map

import "testing"

func TestMapWithFunVlaue(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](2),m[2](2),m[3](2))

}

实现Set
Go的内置集合中没有set实现，可以map[type]bool
1.元素的唯一性
2.基本操作

• 添加元素
• 判断元素是否存在
• 删除元素
• 元素个数

func TestMapForSet(t*testing.T){
    mySet:=map[int]bool{}
    mySet[1]=true
    n:=1
    if mySet[n]{
        t.Logf("%d is existing",n)
    }else{
        t.Logf("%d is not existing",n)
    }
    mySet[3]=true
    delete(mySet,1)
    n=1
    if mySet[n]{
        t.Logf("%d is existing",n)
    }else{
        t.Logf("%d is not existing",n)
    }
}

字符串

与其它主要编成语言的差异
1.string 是数据类型，不是引用类型或者指针类型
2.string是只读的byte slice len函数可以计算它所包含的byte数
3.string的byte数组可以存放任何数据

Unicode 与UTF8
1.Unicode是一种字符集（code point）
2.UTF8是unicode的存储实现（转换为字节序列的规则）
编码与存储
字符 "中"
Unicode 0x4E2D
UTF-8 0xE4B8AD
string/[]byte [0xE4,0xB8,0xAD]
常用的字符串函数

go 基本语法 条件与循环

原文：https://www.cnblogs.com/simp/p/12386067.html