Android还没搞完又要来搞Go了，基础学习笔记，直接代码了.
ch1 第一个程序入门
package main
import (
"fmt"
"os"
)
/**
应用程序入口
必须是main包:package main
必须是main方法:func main()
文件名不一定是main.go
在hello文件夹下一样可以执行
Go中main函数不支持任何返回值
通过os.Exit来返回状态
通过os.Args获取命令行参数
*/
func main() {
fmt.Println(os.Args)
if len(os.Args)>1{
fmt.Println("Hello World",os.Args[1])
}
//os.Exit(0)
os.Exit(-1)
}
ch2
package try_test
import "testing"
/**
1. 源码⽂件以 _test 结尾： xxx_test.go
2. 测试⽅法名以 Test 开头： func TestXXX(t *testing.T) {…}
参数为t *testing.T的指针
*/
func TestFirstTry(t *testing.T) {
t.Log("My first test")
}
斐波纳挈数列
package fib
import (
"testing"
)
func TestFibList(t *testing.T) {
//var a int = 1
//var b int = 1
//var(
// a int =1
// b =1
//)
a := 1
b := 1
//fmt.Println(a,"")
t.Log(a)
for i := 0; i < 5; i++ {
//fmt.Println("",b)
t.Log(b)
tmp := a
a = b
b = tmp + a
}
//fmt.Println()
}
/**
go 中可以直接交换值
*/
func TestFibList2(t *testing.T) {
a, b := 0, 1
t.Log(b)
for i := 0; i < 5; i++ {
a, b = b, a+b
t.Log(b)
}
}
常量
package constant_test
import "testing"
/**
go 连续常量赋值及按比特位连续赋值
*/
const (
Monday = iota + 1
Tuesday
Wednesday
)
/**
常量按比特位赋值,第一位为1,第二位为1..
*/
const (
Readable = 1 << iota
Writable
Executable
)
func TestConstantTry(t *testing.T) {
t.Log(Monday, Tuesday)
}
func TestConstantTry1(t *testing.T) {
a:=1 //0001
t.Log(a&Readable==Readable,a&Writable==Writable,a&Executable==Executable)
}
ch3
类型装换
package type_test
import "testing"
/**
go的基本数据类型
隐式类型转换
*/
//定义自己的类型
type MyInt int64
func TestImplicit(t *testing.T) {
//隐式类型转换报错
var a int32 = 1
var b int64
//b = a
//t.Log(a, b)
//别名也无法进行隐式类型转换 只能使用显示类型转换 c=MyInt(b)
b = int64(a)
var c MyInt
//c = b
c = MyInt(b)
t.Log(a, b, c)
}
/**
go 指针
*/
func TestPoint(t *testing.T) {
a := 1
aPtr := &a
//go指针不能进行运算
//aPtr = aPtr + 1
t.Log(a, aPtr)
t.Logf("%T %T", a, aPtr)
}
/**
go 中初始化string时为空字符串
*/
func TestString(t *testing.T) {
//go 中空判断为nil
var s string
//判断空字符传为
if s==""{
t.Log(s)
}
t.Log("*"+s+"*")
t.Log(len(s))
}
ch4
按位操作
package operator_test
import "testing"
/**
在go中 数组长度一致可以直接==比较
*/
func TestCompareArray(t *testing.T) {
a := [...]int{1, 2, 3, 4}
b := [...]int{1, 2, 3, 5}
//c:=[...]int{1,2,3,4,5}
d := [...]int{1, 2, 3, 4}
e := [...]int{1, 3, 2, 4}
t.Log(a == b)
//长度不同无法比较
//t.Log(a==c)
t.Log(a == d)
//长度相同,内容相同,顺序不同 返回false
t.Log(a == e)
}
/**
&^ 按位清零运算符
当右侧数为1时返回0
当右侧数为0时返回左侧数
1 &^ 0 -- 1
1 &^ 1 -- 0
0 &^ 1 -- 0
0 &^ 0 -- 0
*/
const (
Readable = 1 << iota
Writable
Executable
)
func TestBitClear(t *testing.T) {
a:=7 //0111
a = a&^Readable
t.Log(a)
t.Log(a&Readable==Readable,a&Writable==Writable,a&Executable==Executable)
}
ch5
循环与条件
package condition__test
import "testing"
/**
go的条件语句中 必须是boolen值
函数支持多返回值
*/
func TestIfMultiSec(t *testing.T) {
if a := 1 == 1; a {
t.Log("1=1")
}
//多返回值处理
//if v, err := someFunc(); err == nil {
// t.Log("2==2")
//} else {
// t.Log("1==1")
//}
}
/**
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("It is not 0-3")
}
}
}
func TestSwitchCaseCondition1(t *testing.T) {
for i := 0; i < 5; i++ {
switch {
case i&1 == 0:
t.Log("EVEN")
case i&1 == 1:
t.Log("ODD")
default:
t.Log("It is not 0-3")
}
}
}
package loop__test
import "testing"
/**
循环
*/
func TestWhileLoop(t *testing.T) {
//条件循环
n := 0;
for n < 5 {
t.Log(n)
n++
}
//无限循环
for {
t.Log(n)
}
}
ch6
数组与分片
package array_test
import "testing"
/**
var a [3]int //声明并初始化为默认零值
a[0] = 1
b := [3]int{1, 2, 3} //声明同时初始化
c := [2][2]int{{1, 2}, {3, 4}} //多维数组初始化
*/
func TestArrayInit(t *testing.T) {
var arr [4] int
arr1 := [4] int{1, 2, 3, 5}
arr3 := [...]int{1, 2, 3, 4}
arr[1] = 5
t.Log(arr[1], arr[2])
t.Log(arr1, arr3)
}
/**
遍历数组
*/
func TestArrayTravel(t *testing.T) {
arr3 := [...]int{1, 2, 3, 4}
for i := 0; i < len(arr3); i++ {
t.Log(arr3[i])
}
for idx/*索引*/, e/*元素*/ := range arr3 {
t.Log(idx, e)
}
//当不需要返回索引时,需要用下划线占位
for _,e:=range arr3{
t.Log(e)
}
}
/**
数组截取
a[开始索引(包含), 结束索引(不包含)]
a := [...]int{1, 2, 3, 4, 5}
a[1:2] //2
a[1:3] //2,3
a[1:len(a)] //2,3,4,5
a[1:] //2,3,4,5
a[:3] //1,2,3
*/
func TestArraySection(t *testing.T) {
arr3:=[...]int{1,2,3,4,5}
arr3_sec :=arr3[:3]
t.Log(arr3_sec)
//go中不支持从后向前取值
//arr3_sec1 :=arr3[:-1]
}
package slice_test
import "testing"
/**
切片,类似可变长的数组
内部结构:
ptr *Elem指针,指向一个连续空间数组
len int:元素的个数
cap int:内部数组的容量
*/
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))
//使用make初始化数组,第一个参数为类型,第二为长度len,第三个为容量cap
s2 := make([]int, 3, 5)
t.Log(len(s2), cap(s2))
//此时报错 index out of range [3] with length 3
//t.Log(s2[0],s2[1],s2[2],s2[3],s2[4])
t.Log(s2[0], s2[1], s2[2])
//追加一个元素,len是初始化元素的个数,cap是容量大小
s2 = append(s2, 1)
t.Log(s2[0], s2[1], s2[2], s2[3])
t.Log(len(s2), cap(s2))
}
/**
切片的扩容效果,cap增长因子是*2
cap:capacity
*/
func TestSliceGrowing(t *testing.T) {
s := []int{}
for i := 0; i < 10; i++ {
//数组append的时候需要重新赋值,cap在增长后会赋值
s = append(s, i)
t.Log(len(s), cap(s))
}
}
/**
切片共享存储结构
*/
func TestSliceShareMemory(t *testing.T) {
year := []string{"Jan", "Feb", "Mar", "Apr", "Mar", "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)
}
/**
数组 vs. 切⽚
1. 容量是否可伸缩
2. 是否可以进⾏⽐较
切片不能比较只能判断是否为nil
*/
func TestSliceComparing(t *testing.T) {
a := []int{1, 2, 3, 4}
b := []int{1, 2, 3, 4}
// invalid operation: a == b (slice can only be compared to nil)
//if a == b {
// t.Log("equal")
//}
}