0x01程序结构

标识符

Go语言标识符是用于标识变量、函数或任何用户自定义项目的名称。

标识符有两种:

用户定义的标识符，作为程序实体。一般来说同一个代码块中，不运行出现同名的程序实体，调用其他包中的实体需要指定包标识符，例如: fmt.Println。
预定义标识符，在Go语言源代码中声明，例如数据类型: bool、byte、int; 内建函数名: append、cap、close等。

关键字

关键字也叫保留字，这些保留字不能作为常量、变量或任何其他标识符名称。

Go的关键字相比其他语言来说还算非常少的了，一共只有25个。

包导入与声明：import、package。
程序实体声明与定义：var、type、func、interface、map、 struct、chan、const。
流程控制：if、continue、for、return、go、case、goto、 switch、select、else、break、default、defer、fallthrough、 range。

字面量

通俗的说就是用来表示值的，例如const b int = 10，这里的b是常量，10为字面量。

分隔符

用于分隔其他元素，例如() {} [] . , ; : ......,程序代码都是通过语句来实现结构化的，但是Go语言不需要以;结尾，Go语言编译器会自动完成。

运算符

运算符	说明
\|\|	或
&&	与
!	非
==	相等判断
!=	不等判断
<	小于判断
>	大于判断
<=	小于等于判断
>=	大于等于判断
+	求和
-	求差
*	乘积
/	求商
\|	按位或
^	按位异或
%	求余
<<	按位左移
>>	按位右移
&	按位与
&^	按位清楚

优先级

运算符	优先级
* / % << >> & &^	最高
+ - \| ^	较高
== != < <= > >=	中
&&	较低
\|\|	最低

如果出现相同优先级的运算符，则从左到右运算。所有运算符均收到括号的影响。

注释

Go语言可以使用//单行注释，也可也使用/* */来多行注释，这与其他大多编程语言并无差异。

常量

常量使用关键字const定义，常量的定义格式为: const 标识符 [类型] = value，例如const Pi float32 = 3.1415926536。这里的类型是可以忽略的，因为Go语言编译器可以判断值的类型。

变量

变量声明的格式是: var 标识符类型。

例如:

var a int
var b bool
var a,b int
//也可以通过如下方式进行批量定义
var(
	a,b int
	c bool
	str string
)

很有趣的一个点就是，如果想要交换两个变量的值，可以直接使用a,b=b,a，不再需要使用Temp变量去充当中间商hhhh。

变量的声明不仅可以通过var来定义，还可以直接在使用的时候通过:=定义并赋值，例如: a := 1。

注意:

:=方式不能用于全局变量的声明和赋值
同一个代码块内不能多次声明同一个变量
函数体内属于独立代码块，可以再次声明变量a，可以改变变量的类型，并且定义只在函数内部生效
局部变量声明了就必须使用，全局变量可以声明了不被使用

在使用某个函数的时候，往往会出现多个返回值，但我们只需要其中的一个返回值，则可以使用_占位。

package main

import "fmt"

func main() {
	fmt.Println("Who are U?")
	Name, Age, _ := GetInfo()//用_匿名变量来接收Hobby的值
	fmt.Println("I am " + Name + ",and I am " + Age + "years old")
}

func GetInfo() (Name string, Age string, Hobby string) {
	return "Le1aaaaa", "20", "Security"
}

init函数

init函数执行优先级比main函数高，一个源文件只能有一个init函数。

package main

import (
   "fmt"
   "math"
)

var Pi float64

func init() {
   Pi = 4 * math.Atan(1)
}

func main() {
   DPi := Pi * Pi
   fmt.Println(Pi, DPi)
}
//3.141592653589793 9.869604401089358

0x02基础数据类型

整型

整型的表示

package main

import "fmt"

var value1 int32 //全局声明
func main() {
   value2 := 64 //函数内部声明
   fmt.Println("value2:" + fmt.Sprint(value2))

}

整型的运算

package main

import "fmt"

func main() {
   x, y := 2, 4
   if x == y {
      fmt.Println("x等于y")
   } else {
      fmt.Println("x不等于y")
   }
}

运算	例子	结果
x<<y，左移(x乘以2的y次方)	1<<2	4
x>>y，右移(x除以2的y次方)	12>>2	3
x ^ y，异或	1^2	3
x & y，与	1&2	0
x \| y，或	\|2	2
^x，取反	^2	-3

浮点型

浮点型的表示

package main

import (
   "fmt"
   "reflect"
)

func main() {
   var value1 float64
   value1 = 1    //不管是否有小数点，value1都是浮点型
   value2 := 2   //如果没有小数点，则会被推导为整型
   value3 := 3.0 //如果有小数点，value3会被推导为浮点型
   // v := value1 + value2 //编译失败，因为类型不同
   v := value1 + value3
   fmt.Println(value1, value2, value3, v)
   fmt.Println("v的类型是: ", reflect.TypeOf(v))
}

浮点数的运算

package main

import "fmt"

func main() {
   var value1 float64
   value1 = 1
   value2 := 1.00000000000000000000001
   if value1 == value2 {
      fmt.Println("相等")
   }
}
//相等，因为精度限制在小数点后15位

字符与字符串

字符串的表示

package main

import "fmt"

var value1 float64

func main() {
   s := "aA你2"
   fmt.Println("字符串长度:", len(s))
   for i := 0; i < len(s); i++ {
      fmt.Println(s[i])
   }
   s = "你好, " 
   t := s
   s += "世界。" //字符串可以连接，但原字符串不会改变
   fmt.Println(s)//你好, 世界。
   fmt.Println(t)//你好, 

}

解释字符串

该类字符串使用""括起来，其中的相关转义字符将会被替换。

非解释字符串

该类字符串使用反引号括起来，可以跨行，并且会直接把引号内的所有内容直接输出。

package main

import "fmt"

func main() {
	str1 := `苟利国家生死以\n
			岂因祸福避趋之`
	str2 := "今天天气\n真好"
	fmt.Println(str1)
	fmt.Println(str2)
}

/*苟利国家生死以\n
		岂因祸福避趋之
今天天气
真好*/

遍历字符串

第一种方式输出了乱码，原因是使用的len()方法是不能用来遍历字符串的，因为Go使用UTF-8来保存字符串，所以每个字符由多个字节组成，只输出其中的一个字节是无法显示为一个完整字符的。所以需要使用range方法。

package main

import "fmt"

//遍历字符串
func main() {
   s := "我是中国人"
   for i := 0; i < len(s); i++ {
      fmt.Printf("%c", s[i])
   }
   fmt.Printf("\n")
   for _, v := range s {
      fmt.Printf("%c", v)
   }
   fmt.Println("\n")
}
/*
ææ¯ä¸å½äºº
我是中国人
*/

字符串修改

Go语言字符串不能修改，也就不能使用s[i]的方法来修改字符串中的UTF-8编码。但是可以把字符串赋予给新的变量中，一般使用[]byte或者[]rune类型。如果修改字节，则转化为[]byte类型，如果修改字符，则转化为[]rune类型。

package main

import "fmt"

//修改字符串 byte[]类型
func main() {
   s := "Hello 世界!"
   b := []byte(s)
   b[5] = ','
   fmt.Printf("%s\n", s) //s的值不会被修改
   fmt.Printf("%s\n", b) //修改后的数据
   /*
   Hello 世界!
   Hello,世界!
   */
}

package main

import "fmt"

//修改字符串 []rune
func main() {
   s := "我爱世界"
   b := []rune(s)
   b[2] = '中'
   b[3] = '国'
   fmt.Printf("%s\n", s)
   fmt.Printf("%s\n", string(b))
   /*我爱世界
   我爱中国*/
}

strings包

这是一个处理字符串的包

包含判断

package main

import (
	"fmt"
	"strings"
)

//包含判断
func main() {
	a := "I am Le1aaaaa"
	fmt.Printf("%t\n", strings.HasPrefix(a, "I"))        //判断字符串a 是否以I开头
	fmt.Printf("%t\n", strings.HasSuffix(a, "Le1aaaaa")) //判断字符串a 是否以Le1aaaaa结尾
	fmt.Printf("%t\n", strings.Contains(a, "am"))        //判断字符串a 中是否存在am
	/*
		true
		true
		true
	*/
}

索引

strings.IndexRune(s,str string) int 用于Ascii编码

strings.LastIndex(s,str string) int 用于非Ascii编码

替换

一共有4个参数，其中第一个为原字符串，第二个表示需要被替换的子字符串，第三个表示替换内容，第四个则表示匹配到第几个，如果把上面的n改为数字-1，则表示匹配所有。

package main

import (
   "fmt"
   "strings"
)

//字符串替换
func main() {
   str := "你好世界，这个世界真好!"
   fmt.Println(strings.Replace(str, "世界", "地球", 1))
   //你好地球，这个世界真好!
}

出现频率

strings.Count()

package main

import (
   "fmt"
   "strings"
)

//统计字符串中字符出现的频率
func main() {
   a := "I am Le1aaaaa"
   fmt.Println("a出现了: " + fmt.Sprint(strings.Count(a, "a")) + "次!")
}

字符串总数

package main

import (
   "fmt"
   "unicode/utf8"
)

//统计字符串数量
func main() {
   s := "我爱中国"
   fmt.Printf("%d\n", len([]rune(s)))//4
   fmt.Println(utf8.RuneCountInString(s))//4
}

大小写转换

strings.ToLower(s)

strings.ToUpper(s)

package main

import (
   "fmt"
   "strings"
)

//大小写转换
func main() {
   s := "I am Le1aaaaa,and I am 21"
   fmt.Println(strings.ToLower(s)) //转化为小写
   fmt.Println(strings.ToUpper(s)) //转化为大写
   /*
      i am le1aaaaa,and i am 21
      I AM LE1AAAAA,AND I AM 21
   */
}

修剪

strings.Trim("今天天气真好","今天")//天气真好

分割

strings.Split("a,b,c",",")//以逗号，来分割，得到["a","b","c"]

布尔型

布尔类型的表示

v:=true直接表示或者 v:=(1==2)自动推导。go语言只有true和false,不能用0 1表示。

Le1a的菜园坝

Golang学习笔记

0x01程序结构

标识符

关键字

字面量

分隔符

运算符

注释

常量

变量

init函数

0x02基础数据类型

整型

浮点型

字符与字符串

strings包

布尔型

Rome反序列化链分析