Goland安全开发第二节
一、基础语法-初识函数、基本类型
package main
import "fmt"
func main() {
fmt.Println("Hello Go!")
}
上述是一个简单的go代码
Package
包是 Go 语⾔的基本组成单元，通常使⽤单个的⼩写单词命名，⼀个 Go 程序本质上就是⼀组包的集合。所有 Go 代码都有⾃⼰⾪属的包。main 包在 Go 中是⼀个特殊的包，整个 Go 程序中仅允许存在⼀个名为 main 的包。
函数
Go 语⾔中，函数名的⾸字母决定了其可见性。如果函数名的⾸字母⼤写，那么该函数是导出的，可以在包外部使⽤；如果⾸字⺟⼩写，那么该函数是未导出的，只能在包内部使⽤。
基本类型
字符串型-string
单引号和双引号的区别
单引号
⽤途：⽤于表示字符（rune）类型。
类型：字符类型在Go中是rune，它是int32的别名，可以表示⼀个Unicode码点
双引号
⽤途：⽤于表示字符串（string）类型。
类型：字符串类型在Go中是string，它是⼀个字符序列，可以包含零个或多个字符
数字Number
var a int // 有符号整型
var b uint // 无符号整型
var c uint32 // 32位无符号整型
布尔型Booleans
fmt.Println(true && true) // true
fmt.Println(true && false) // false
fmt.Println(true || true) // true
fmt.Println(true || false) // true
fmt.Println(!true) // false
变量声明
变量声明
var s1 string
s1 = "schneidr"
简短声明
S2 := "schneider" // := 是声明并且赋值
一次声明多个变量
var s3, s4 string
或者s3, s4 := "schneider","schneider1"
匿名变量
_,s5 := "1","2"
注释
//单行注释
/*多行
注释*/
fmt.Println与print
print是go中自带的，用于简单的调试，输出时不会换行
fmt.println是fmt库中的，输出格式更加灵活，输出时会换行
运算符
算数运算符
加法
a := 7 + 7
减法
a := 7 - 7
乘法
a := 7 * 7
除法
a := 7 / 7
取模
a := 7 % 7
赋值运算符
=（赋值）
a = 5 //将5赋值给a
+=（加赋值）
a := 5
a =+ 3 //等价于a = a +3 ,结果是8
-=（减赋值）
a := 5
a -= 3 //等价于a = a * 3 ,结果是 15
*=（乘赋值）
a := 5
a *= 3 // 等价于a = a * 3，结果是15
/= (除赋值)
a := 6
a /= 3 / / 等价于a = a / 3，结果是2
%= (取模赋值)
a := 5
a %= 3 // 等价于a = a % 3，结果是2
关系运算符
== （等于）
a := 5
b := 5
fmt.Println(a == b) // 结果是true
!=（不等于）
a := 5
b := 3
fmt.Println(a != b) // 结果是true
<（⼩于）
a := 3
b := 5
fmt.Println(a < b) // 结果是true
<=（⼩于等于）
a := 5
b := 5
fmt.Println(a <= b) // 结果是true
'>'（⼤于）
a := 5
b := 3
fmt.Println(a > b) // 结果是true
（⼤于等于）
a := 5
b := 5
fmt.Println(a >= b) // 结果是true
逻辑运算符
&&（逻辑与）
a := true
b := false
fmt.Println(a && b) // 结果是false
||（逻辑或）
a := true
b := falsefmt.Println(a || b) // 结果是true
!（逻辑⾮）
a := true
fmt.Println(!a) // 结果是false
位运算符
&（按位与）
a := 5 // 0101
b := 3 // 0011
fmt.Println(a & b) // 结果是1（0001）
|（按位或）
a := 5 // 0101
b := 3 // 0011
fmt.Println(a | b) // 结果是7（0111）
^（按位异或）
a := 5 // 0101
b := 3 // 0011
fmt.Println(a ^ b) // 结果是6（0110）
如果两个数的对应位只有⼀个是 1，那么结果位为 1。
如果两个数的对应位都是 1 或都是 0，那么结果位为 0。
<<（左移） 保留0
a := 1 // 0001
fmt.Println(a << 2) // 结果是4（0100）
》》(右移）不保留0
a := 4 // 0100
fmt.Println(a >> 2) // 结果是1（0001）
复合赋值运算符
&=（按位与赋值）
a := 5 // 0101
a &= 3 // 结果是1（0001）
|=（按位或赋值）
a := 5 // 0101
a |= 3 // 结果是7（0111）
^=（按位异或赋值）
a := 5 // 0101
a ^= 3 // 结果是6（0110）
其它运算符
++（⾃增）
a := 5
a++ // 结果是6
--（⾃减）
a := 5
a-- // 结果是4
:=（短变量声明）
a := 5 // 声明并初始化变量a
<-（通道操作符）
ch := make(chan int)
go func() {
ch <- 5 // 发送值到通道
}()
a := <-ch // 从通道接收值
fmt.Println(a) // 结果是5
分组和分隔符
( 和 )（小括号）
a := (5 + 3) * 2 // ⼩括号⽤于改变运算优先级
[ 和 ]（中括号）
arr := [3]int{1, 2, 3} // 定义数组
fmt.Println(arr[0]) // 访问数组元素，结果是1
{ 和 }（大括号）
func main() {
fmt.Println("Hello, World!")
}
,（逗号）
a, b := 1, 2 // 多变量声明
;（分号）
// 在Go语言中编译器会自动在每行代码的末尾添加分号，这就是隐式，下面是显式
a := 5; b := 3; fmt.Println(a + b)
...（省略号）
省略号允许你创建一个函数，该函数可以接受任意数量的参数。这些参数在函数内部被表示为一个切片
func sum(nums ...int) int {
sum := 0
for _, num := range nums {
sum += num
}
return sum
}
调用这个函数时，可以传递任意数量的整数参数
fmt.Println(sum(1, 2, 3)) // 输出 6
fmt.Println(sum(1, 2, 3, 4, 5)) // 输出 15
在切片操作中，省略号可以表示从当前位置到切片的末尾
s := []int{1, 2, 3, 4, 5}
sub := s[1:] // 从索引1到切片末尾，结果是 [2, 3, 4, 5]
如果开始索引省略，那么默认从切片的开始位置切片
sub := s[:3] // 从切片开始到索引3（不包括索引3），结果是 [1, 2, 3]
如果开始和结束索引都省略，那么就是原始切片的一个副本
sub := s[:] // 整个切片的副本，结果是 [1, 2, 3, 4, 5]
.（点号）
fmt.Println("Hello, World!") // 调⽤包中的函数
快捷键
Ctrl+B 转到声明
Ctrl+p 查看这个函数可以接收什么内容
.var 快速⽣成变量名
shift+空格 下⼀⾏
坑
创建项⽬记得⽤英⽂，不能⽤中⽂创建项⽬
⽆法相互调⽤，看看是不是mod包错了