Go语言笔记

最新推荐文章于 2024-04-25 09:45:05 发布

VIP文章 smilelk

最新推荐文章于 2024-04-25 09:45:05 发布

阅读量360

点赞数

分类专栏：学习笔记文章标签： golang go 编程语言

本文链接：https://blog.csdn.net/smilelk/article/details/109406070

版权

Go语言笔记

一、变量、常量以及其他语言的差异

1.编写测试程序

源码文件以_test结尾： xxx_test.go
测试方法名以Test开头：func TestXXX(t *testing.T){...}

2.变量赋值

var a int =1
把两个赋值语句放在一起

var (
	a int =1
	b int =1
    b =1
)

go具有类型推断能力，给变量赋值的话，把类型删掉也是可以的。

a:=1

通常，前两种情况用于声明变量使用，后续再给它赋值（全局或者外部的情况下）

3.与其他语言的差异

赋值可以进行自动类型推断
在一个赋值语句中可以对多个变量进行同时赋值

func TestExchange(t *testing.T){
   
	a,b=b,a
}

交换两个变量

4.常量定义

快速设置连续值

const(
	Monday=iota+1
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
	Sunday
)

const(
	Open=1<<iota
	Close
	Pending
)

对一些比特位常量进行连续赋值，每一位代表每一种状态，第一位比特位为1时，其他位为0时，表示Open;第二位为1，其他位为0时，表示Close;第三位为1，其他位为0，表示Pending。

二、数据类型

1.基本数据类型

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

2.与其他语言的差异

Go语言不允许隐式类型转换
别名和原有类型也不能进行隐式类型转换
不支持指针运算
string是值类型，其默认的初始化值为空字符串，而不是nil

三、运算符

Go语言没有前置的++，–

~~（++a）~~
用==比较数组

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

位运算符

&^ 按位清零

1 &^ 0 --1
1 &^ 1 --0
0 &^ 1 --0
0 &^ 0 --0

对于左右两个操作数来说，只要右边的操作数的位上为1，那么无论左边的操作数对应位上为1还是0，结果都为1，若右边操作数的位上为0，则左边操作数是什么结果就是什么。

四、条件和循环

1.循环

Go语言仅支持循环关键字for

代码示例

while条件循环用go表示

n:=0
for n<5 {
   
	n++
	fmt.Println(n)
}
//无限循环
n:=0
for {
   
...
}

2.条件

if条件

if condition{
   
//...
}else{
   
//...
}

if condition-1{
   
//...
}else if condition-2{
   
//...
}else{
   
//...
}

condition表达式结果必须为布尔值
支持变量赋值：

if var declaration; condition{
   
//code to be executed if condition is true
}

switch条件

与其他编程语言的差异：

条件表达式不限制为常量或者整数
单个case中，可以出现多个结果选项，使用逗号分隔
与c相反，Go不需要用break来明确退出一个case
可以不设定switch之后的条件表达式，这样，整个switch结构与多个if…else…的逻辑作用等同。

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

for i:=0;i<5;i++{
   
	switch {
   
		case i%2==0:
			t.Log("Even")
		case i%2==1:
			t.Log("Odd")
		default:
			t.Log("unknow")
	}
}

五、数组

1.数组的声明

var a [3]int 声明并初始化为默认零值
b := [3]int{1,2,3} 声明同时初始化
c := [2][2]int{ {1,2},{3,4}} 多维数组初始化

func TestArrayInit(t *testing.T)  {
   
	var arr [3]int
	arr1 := [4]int{
   1,2,3,4}
	arr3 := [...]int{
   1,3,4,5}
	t.Log(arr[1],arr[2])
	t.Log(arr1,arr3)
	for _, e :=range arr3 {
   
		t.Log(e)
	}
}

2.数组截取

a[开始索引(包含)，结束索引(不包含)]

a := [...]int{
   1,2,3,4,5}
a[1:2] //2
a[1:3] //2,3
a[1:] //2,3,4,5
a[:3] //1,2,3

!!!Go语言不支持负数的索引

3.切片内部结构

在这里插入图片描述

func TestSliceInit(t *testing.T)  {
   
	var s0 []int
	t.Log(len(s0),cap(s0))
	s1:=[]int{
   1,2,3,4}
	t.Log(len(s1),cap(s1))
}
// 0 0
// 4 4

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

在这里插入图片描述

六、Map声明、元素访问及遍历

1. Map声明

m := map[string]int{"one":1,"two":2,"three":3}
m1 := map[string]int{}
m1["one"]=1
m2 := make(map[string]int,10)

func TestInitMap(t *testing.T)  {
   
	m1:=map[int]int{
   1:1,2:4,3:9}
	t.Log(m1[2]) //4
	t.Logf("len m1=%d",len(m1)) //len m1=3
	m2:=map[int]int{
   }
	m2[4]=16
	t.Logf("len m2=%d",len(m2)) //len m2=1
	m3:=make(map[int]int,10)
	t.Logf("len m3=%d",len(m3)) //len m3=0
}

func TestAccessNotExistingKey(t *testing.T)  {
   
	m1 := map[int]int{
   }
	t.Log(m1[1]) //0
	m1[2]=0
	t.Log(m1[2]) //0
	if v,ok:=m1[3];ok{
   
		t.Logf("Key 3's value is %d",v)
	}else {
   
		t.Log("Key 3 is not existing.")//Key 3 is not existing.
	}
}

2. Map元素的访问

在访问的Key不存在时，仍会返回零值，不能通过返回nil来判断元素是否存在

3. Map与工厂模式

Map的value可以是一个方法

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](2),m[2](2),m[3](2)) //2,4,8
}

4.实现Set

Go的内置集合中没有Set实现，可以map[type]bool

对于set：

元素的唯一性
基本操作：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)//3 is not existing
	}
	mySet[3]=true
	t.Log(len(mySet))//2
	delete(mySet,1)
	n=1
	if mySet[n] {
   
		t.Logf("%d is existing",n)
	}else {
   
		t.Logf("%d is not existing",n)//1 is not existing
	}
}

七、字符串

1.与其他编程语言的差异

string是数据类型，不是引用或指针类型
string是只读的byte slice, len函数计算它所包含的byte数
string的byte数组可以存放任何数据

func TestString(t *testing.T)  {
   
	var s string
	t.Log(s) // 
	s="hello"
	t.Log(len(s)) //5
	s="\xE4\xB8\xA5"
	t.Log(s) //严
	t.Log(len(s)) //3
    s="中"
	t.Log(len(s)) //3
	c:= []rune(s)
	t.Log(len(c)) //1
	t.Logf("中 unicode %x",c[0]) //中 unicode 4e2d
	t.Logf("中 UTF8 %x",s) //中 UTF8 e4b8ad
}

2.常用字符串函数

strings包

func TestStringFn(t *testing.T)  {
	s:="A,B,C"
	parts := strings.Split(s,",")
	for _,part:=range parts{
		t.Log(part)//A,B,C
	}
}

strconv包

func TestConv(t *testing.T){
   
	s:= strconv.Itoa(10)
	t.Log("str"+s) //str10
	if i,err:=strconv.Atoi("10");err==nil{
   
		t.Log(10+i) //20
	}
}

八、Go语言的函数

1.与其他编程语言的区别

可以有多个返回值
所有的参数都是值传递
函数可以作为变量的值
函数可以作为参数的返回值

func returnMultiValues() (int,int) {
   
	return rand.Intn(10), rand.Intn(20)
}

func timeSpent(inner func(op int) int) func(op int

最低0.47元/天解锁文章

smilelk

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Go语言笔记

Go语言笔记一、变量、常量以及其他语言的差异1.编写测试程序源码文件以_test结尾： xxx_test.go测试方法名以Test开头：func TestXXX(t *testing.T){...}2.变量赋值var a int =1把两个赋值语句放在一起var ( a int =1 b int =1 b =1)go具有类型推断能力，给变量赋值的话，把类型删掉也是可以的。a:=1通常，前两种情况用于声明变量使用，后续再给它赋值（全局或者外部的
复制链接

扫一扫