From d3dce2178d7b553b9b8335d77da8d840b90027c5 Mon Sep 17 00:00:00 2001 From: AICells <1713699517@qq.com> Date: Tue, 12 May 2020 23:02:15 +0800 Subject: [PATCH] =?UTF-8?q?=E9=83=A8=E5=88=86=E6=8F=90=E4=BA=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 6 + src/docs/Go语言变量作用域.md | 23 ++ src/docs/go语言函数.md | 39 ++++ src/docs/go语言切片.md | 15 ++ src/docs/go语言基础.md | 318 ++++++++++++++++++++++++++++ src/docs/go语言循环语句.md | 64 ++++++ src/docs/go语言指针.md | 23 ++ src/docs/go语言数组.md | 25 +++ src/docs/go语言条件语句.md | 76 +++++++ src/docs/go语言结构体.md | 33 +++ src/docs/go语言运算符.md | 88 ++++++++ src/learn/addrOp.go | 19 ++ src/learn/ariOp.go | 23 ++ src/learn/assOp.go | 17 ++ src/learn/bitOp.go | 14 ++ src/learn/constVar.go | 26 +++ src/learn/hello.go | 6 + src/learn/mulVar.go | 18 ++ src/learn/structs.go | 39 ++++ src/learn/var.go | 30 +++ 20 files changed, 902 insertions(+) create mode 100644 src/docs/Go语言变量作用域.md create mode 100644 src/docs/go语言函数.md create mode 100644 src/docs/go语言切片.md create mode 100644 src/docs/go语言基础.md create mode 100644 src/docs/go语言循环语句.md create mode 100644 src/docs/go语言指针.md create mode 100644 src/docs/go语言数组.md create mode 100644 src/docs/go语言条件语句.md create mode 100644 src/docs/go语言结构体.md create mode 100644 src/docs/go语言运算符.md create mode 100644 src/learn/addrOp.go create mode 100644 src/learn/ariOp.go create mode 100644 src/learn/assOp.go create mode 100644 src/learn/bitOp.go create mode 100644 src/learn/constVar.go create mode 100644 src/learn/hello.go create mode 100644 src/learn/mulVar.go create mode 100644 src/learn/structs.go create mode 100644 src/learn/var.go diff --git a/.gitignore b/.gitignore index 66fd13c..193fc34 100644 --- a/.gitignore +++ b/.gitignore @@ -5,6 +5,12 @@ *.so *.dylib +# idea +.idea + +#bin +bin + # Test binary, built with `go test -c` *.test diff --git a/src/docs/Go语言变量作用域.md b/src/docs/Go语言变量作用域.md new file mode 100644 index 0000000..ffb597b --- /dev/null +++ b/src/docs/Go语言变量作用域.md @@ -0,0 +1,23 @@ +# Go 语言变量作用域 + 作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。 + Go 语言中变量可以在三个地方声明： + 函数内定义的变量称为局部变量 + 函数外定义的变量称为全局变量 + 函数定义中的变量称为形式参数 + 接下来让我们具体了解局部变量、全局变量和形式参数。 +## 局部变量 + 在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。 + 以下实例中 main() 函数使用了局部变量 a, b, c： + +## 全局变量 + 在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。 + +## 形式参数 + 形式参数会作为函数的局部变量来使用 + +## 初始化局部和全局变量 + 不同类型的局部和全局变量默认值为： + 数据类型 初始化默认值 + int 0 + float32 0 + pointer nil \ No newline at end of file diff --git a/src/docs/go语言函数.md b/src/docs/go语言函数.md new file mode 100644 index 0000000..62da4dc --- /dev/null +++ b/src/docs/go语言函数.md @@ -0,0 +1,39 @@ +# Go语言函数 + 函数时基本的代码块 用于执行一个任务 + Go语言 最少有个main()函数 + 你可以用过函数来划分不同的功能 逻辑上每个函数执行的是知道的任务 + 函数声明告诉了编译器函数的名称 返回类型和参数 + Go语言标准库提供了多种可动用的内置函数 例如 len()函数可以接受不同参数类型的并返回该类型的长度 + 如果传入的是字符串则返返回字符串的长度 如果传入的是数组 则返回数组的元素个数 + +# 函数定义格式 + func function_name([参数列表]) [返回类型]{ + 函数体 + } + + 函数定义解析： + func：函数由 func 开始声明 + function_name：函数名称，函数名和参数列表一起构成了函数签名。 + parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。 + return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。 + 函数体：函数定义的代码集合。 + +## 函数参数 + 函数如果使用参数，该变量可称为函数的形参。 + + 形参就像定义在函数体内的局部变量。 + + 调用函数，可以通过两种方式来传递参数： + + 传递类型 描述 + 值传递 值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。 + 引用传递 引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。 + 默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。 + + 函数用法 + 函数用法 描述 + 函数作为另外一个函数的实参 函数定义后可作为另外一个函数的实参数传入 + 闭包 闭包是匿名函数，可在动态编程中使用 + 方法 方法就是一个包含了接受者的函数 + + \ No newline at end of file diff --git a/src/docs/go语言切片.md b/src/docs/go语言切片.md new file mode 100644 index 0000000..9b8f6e6 --- /dev/null +++ b/src/docs/go语言切片.md @@ -0,0 +1,15 @@ +# Go语言切片 + Go语言切片是对数组的抽象 + Go数组的长度不可改变 在特定场景中这样的集合就不在适用 而切片即使一个长度不固定 可以最佳元素 追加是可能使切片容量增大 + +## 定义切片 + 你可以声明一个未指定大小的数组来定义切片 + var identifier []type + 切片不需要说明长度 + 也可以使用make()函数来创建切片 + var slice1 []type = make([]type, len) + 也可以简写 + clice1 := make([]type, len) + 也可以指定容量， 其中capacity为可选参数 + make([]T, length, capacity) + 这里len是数组的长度并且也是切片的初始长度 \ No newline at end of file diff --git a/src/docs/go语言基础.md b/src/docs/go语言基础.md new file mode 100644 index 0000000..cb5dc10 --- /dev/null +++ b/src/docs/go语言基础.md @@ -0,0 +1,318 @@ +# Go语言结构 + go语言的基础组成有一下几个部分组成 + 包声明 指明文件属于哪个包 其中package main表示一个可独立执行的程序 每个go应用程序都包含一个名为main的包 + 引入包 告诉go编译器这个程序需要引入的包或其他元素 + 函数 + 变量 + 语句&表达式 + 注释 // 单行注释 /* .. */(不可嵌套)多行注释 + + 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用 + （客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的， + 但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。 + +# 关于包 + 关于包，根据本地测试得出以下几点： + + 文件名与包名没有直接关系，不一定要将文件名与包名定成同一个。 + 文件夹名与包名没有直接关系，并非需要一致。 + 同一个文件夹下的文件只能有一个包名，否则编译报错。 + +# go语言基础语法 +## Go标记 + Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。如以下 GO 语句由 6 个标记组成： + +## 行分割符 + 在 Go 程序中，一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾，因为这些工作都将由 Go 编译器自动完成。 + 如果你打算将多个语句写在同一行，它们则必须使用 ; 人为区分，但在实际开发中我们并不鼓励这种做法。 + +## 注释 + 注释不会被编译，每一个包应该有相关注释。 + 单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾。 + +## 标识符 + 标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A~Z和a~z)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。 + 以下是有效的标识符： + mahesh kumar abc move_name a_123 + myname50 _temp j a23b9 retVal + +## 字符串连接 + Go语言的字符串可以通过 + 实现 + +## 关键字 + 下面列举了 Go 代码中会使用到的 25 个关键字或保留字： + + break default func interface select + case defer go map struct + chan else goto package switch + const fallthrough if range type + continue for import return var + 除了以上介绍的这些关键字，Go 语言还有 36 个预定义标识符： + + append bool byte cap close complex complex64 complex128 uint16 + copy false float32 float64 imag int int8 int16 uint32 + int32 int64 iota len make new nil panic uint64 + print println real recover string true uint uint8 uintptr + 程序一般由关键字、常量、变量、运算符、类型和函数组成。 + + 程序中可能会使用到这些分隔符：括号 ()，中括号 [] 和大括号 {}。 + + 程序中可能会使用到这些标点符号：.、,、;、: 和 …。 + +## Go语言的空格 + Go 语言中变量的声明必须使用空格隔开，如： + var age int; + 语句中适当使用空格能让程序更易阅读。 + 无空格： + fruit=apples+oranges; + 在变量与运算符间加入空格，程序看起来更加美观，如： + fruit = apples + oranges; + +# Go语言数据类型 + 在 Go 编程语言中，数据类型用于声明函数和变量。 + 数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。 + Go 语言按类别有以下几种数据类型： + 序号 类型和描述 + 1 布尔型 + 布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。 + 2 数字类型 + 整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。 + 3 字符串类型: + 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。 + 4 派生类型: + 包括： + (a) 指针类型（Pointer） + (b) 数组类型 + (c) 结构化类型(struct) + (d) Channel 类型 + (e) 函数类型 + (f) 切片类型 + (g) 接口类型（interface） + (h) Map 类型 + + + 数字类型 + Go 也有基于架构的类型，例如：int、uint 和 uintptr。 + + 序号 类型和描述 + 1 uint8 + 无符号 8 位整型 (0 到 255) + 2 uint16 + 无符号 16 位整型 (0 到 65535) + 3 uint32 + 无符号 32 位整型 (0 到 4294967295) + 4 uint64 + 无符号 64 位整型 (0 到 18446744073709551615) + 5 int8 + 有符号 8 位整型 (-128 到 127) + 6 int16 + 有符号 16 位整型 (-32768 到 32767) + 7 int32 + 有符号 32 位整型 (-2147483648 到 2147483647) + 8 int64 + 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807) + + 浮点型 + 序号 类型和描述 + 1 float32 + IEEE-754 32位浮点型数 + 2 float64 + IEEE-754 64位浮点型数 + 3 complex64 + 32 位实数和虚数 + 4 complex128 + 64 位实数和虚数 + + 其他数字类型 + 以下列出了其他更多的数字类型： + + 序号 类型和描述 + 1 byte + 类似 uint8 + 2 rune + 类似 int32 + 3 uint + 32 或 64 位 + 4 int + 与 uint 一样大小 + 5 uintptr + 无符号整型，用于存放一个指针 + +# Go语言变量 + 变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。 + 变量可以通过变量名访问。 + Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。 + 声明变量的一般形式是使用 var 关键字： + var identifier type + 可以一次声明多个变量： + var identifier1, identifier2 type + +## 变量声明 + 第一种，指定变量类型，如果没有初始化，则变量默认为零值。 零值就是变量没有做初始化时系统默认设置的值。 + var v_name v_type + v_name = value + var v_name v_type = value + + 数值类型（包括complex64/128）为 0 + 布尔类型为 false + 字符串为 ""（空字符串） + 以下几种类型为 nil： + var a *int + var a []int + var a map[string] int + var a chan int + var a func(string) int + var a error // error 是接口 + + 第二种，根据值自行判定变量类型。 + var v_name = value + + 第三种，省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误，格式： + v_name := value + IE + var intVal int + intVal :=1 // 这时候会产生编译错误 + intVal,intVal1 := 1,2 // 此时不会产生编译错误，因为有声明新的变量， + 注意：：：：因为 := 是一个声明语句 + + +## 多变量声明 + //类型相同多个变量, 非全局变量 + var vname1, vname2, vname3 type + vname1, vname2, vname3 = v1, v2, v3 + var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断 + vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误 + // 这种因式分解关键字的写法一般用于声明全局变量 + var ( + vname1 v_type1 + vname2 v_type2 + ) + +## 值类型和引用类型 + 所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值： + 当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝： + 你可以通过 &i 来获取变量 i 的内存地址，例如：0xf840000040（每次的地址都可能不一样）。值类型的变量的值存储在栈中。 + 内存地址会根据机器的不同而有所不同，甚至相同的程序在不同的机器上执行后也会有不同的内存地址。因为每台机器可能有不同的存储器布局，并且位置分配也可能不同。 + 更复杂的数据通常会需要使用多个字，这些数据一般使用引用类型保存。 + 一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个字所在的位置。 + 这个内存地址为称之为指针，这个指针实际上也被存在另外的某一个字中。 + 同一个引用类型的指针指向的多个字可以是在连续的内存地址中（内存布局是连续的），这也是计算效率最高的一种存储形式；也可以将这些字分散存放在内存中，每个字都指示了下一个字所在的内存地址。 + 当使用赋值语句 r2 = r1 时，只有引用（地址）被复制。 + 如果 r1 的值被改变了，那么这个值的所有引用都会指向被修改后的内容，在这个例子中，r2 也会受到影响。 + +## 简短形式，使用 := 赋值操作符 + 我们知道可以在变量的初始化时省略变量的类型而由系统自动推断，声明语句写上 var 关键字其实是显得有些多余了，因此我们可以将它们简写为 a := 50 或 b := false。 + a 和 b 的类型（int 和 bool）将由编译器自动推断。 + 这是使用变量的首选形式，但是它只能被用在函数体内，而不可以用于全局变量的声明与赋值。使用操作符 := 可以高效地创建一个新的变量，称之为初始化声明。 + 注意事项 + 如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，例如：a := 20 就是不被允许的，编译器会提示错误 no new variables on left side of :=，但是 a = 20 是可以的，因为这是给相同的变量赋予一个新的值。 + + 如果你在定义变量 a 之前使用它，则会得到编译错误 undefined: a。 + + 如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，例如下面这个例子当中的变量 a： + + 实例 + package main + + import "fmt" + + func main() { + var a string = "abc" + fmt.Println("hello, world") + } + 尝试编译这段代码将得到错误 a declared and not used。 + + 此外，单纯地给 a 赋值也是不够的，这个值必须被使用，所以使用 + + fmt.Println("hello, world", a) + 会移除错误。 + + 但是全局变量是允许声明但不使用。 同一类型的多个变量可以声明在同一行，如： + + var a, b, c int + 多变量可以在同一行进行赋值，如： + + var a, b int + var c string + a, b, c = 5, 7, "abc" + 上面这行假设了变量 a，b 和 c 都已经被声明，否则的话应该这样使用： + + a, b, c := 5, 7, "abc" + 右边的这些值以相同的顺序赋值给左边的变量，所以 a 的值是 5， b 的值是 7，c 的值是 "abc"。 + + 这被称为 并行 或 同时 赋值。 + + 如果你想要交换两个变量的值，则可以简单地使用 a, b = b, a，两个变量的类型必须是相同。 + + 空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。 + + _ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。 + + 并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)。 + +# Go语言常量 + 常量是一个简单值的标识符，在程序运行时，不会被修改的量。 + + 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。 + + 常量的定义格式： + + const identifier [type] = value + 你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。 + + 显式类型定义： const b string = "abc" + 隐式类型定义： const b = "abc" + 多个相同类型的声明可以简写为： + + const c_name1, c_name2 = value1, value2 + + 常量还可以用作枚举： + + const ( + Unknown = 0 + Female = 1 + Male = 2 + ) + 数字 0、1 和 2 分别代表未知性别、女性和男性。 + + 常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过： + +## iota + iota，特殊常量，可以认为是一个可以被编译器修改的常量。 + iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。 + iota 可以被用作枚举值： + const ( + a = iota + b = iota + c = iota + ) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/docs/go语言循环语句.md b/src/docs/go语言循环语句.md new file mode 100644 index 0000000..58ce678 --- /dev/null +++ b/src/docs/go语言循环语句.md @@ -0,0 +1,64 @@ +# Go 语言循环语句 + 在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。 + + 以下为大多编程语言循环程序的流程图： + + Go 语言提供了以下几种类型循环处理语句： + + 循环类型 描述 + for 循环 重复执行语句块 + for init; condition; post { } + init： 一般为赋值表达式，给控制变量赋初值； + condition： 关系表达式或逻辑表达式，循环控制条件； + post： 一般为赋值表达式，给控制变量增量或减量。 + for condition { } + for { } + 循环嵌套 在 for 循环中嵌套一个或多个 for 循环 + 以下为 Go 语言嵌套循环的格式： + + for [condition | ( init; condition; increment ) | Range] + { + for [condition | ( init; condition; increment ) | Range] + { + statement(s); + } + statement(s); + } + 循环控制语句 + 循环控制语句可以控制循环体内语句的执行过程。 + + GO 语言支持以下几种循环控制语句： + + 控制语句 描述 + break 语句 经常用于中断当前 for 循环或跳出 switch 语句 + Go 语言中 break 语句用于以下两方面： + 用于循环语句中跳出循环，并开始执行循环之后的语句。 + break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。 + 在多重循环中，可以用标号 label 标出想 break 的循环。 + continue 语句 跳过当前循环的剩余语句，然后继续进行下一轮循环。 + Go 语言的 continue 语句 有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。 + for 循环中，执行 continue 语句会触发 for 增量语句的执行。 + 在多重循环中，可以用标号 label 标出想 continue 的循环。 + goto 语句 将控制转移到被标记的语句。 + Go 语言的 goto 语句可以无条件地转移到过程中指定的行。 + goto 语句通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。 + 但是，在结构化程序设计中一般不主张使用 goto 语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。 + 语法 + goto 语法格式如下： + goto label; + .. + . + label: statement; + 无限循环 + 如果循环中条件语句永远不为 false 则会进行无限循环，我们可以通过 for 循环语句中只设置一个条件表达式来执行无限循环： + + 实例 + package main + + import "fmt" + + func main() { + for true { + fmt.Printf("这是无限循环。\n"); + } + } \ No newline at end of file diff --git a/src/docs/go语言指针.md b/src/docs/go语言指针.md new file mode 100644 index 0000000..5e84475 --- /dev/null +++ b/src/docs/go语言指针.md @@ -0,0 +1,23 @@ +#Go 语言指针 + Go 语言中指针是很容易学习的，Go 语言中使用指针可以更简单的执行一些任务。 + 接下来让我们来一步步学习 Go 语言指针。 + 我们都知道，变量是一种使用方便的占位符，用于引用计算机内存地址。 + Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。 + +# 什么是指针 + 一个指针变量指向了一个值的内存地址。 + 类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下： + var var_name *var-type + +# 如何使用指针 + 指针使用流程： + 定义指针变量。 + 为指针变量赋值。 + 访问指针变量中指向地址的值。 + 在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。 + +# Go 空指针 + 当一个指针被定义后没有分配到任何变量时，它的值为 nil。 + nil 指针也称为空指针。 + nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。 + 一个指针变量通常缩写为 ptr。 \ No newline at end of file diff --git a/src/docs/go语言数组.md b/src/docs/go语言数组.md new file mode 100644 index 0000000..1f93c24 --- /dev/null +++ b/src/docs/go语言数组.md @@ -0,0 +1,25 @@ +# Go 语言数组 + Go 语言提供了数组类型的数据结构。 + 数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。 + 相对于去声明 number0, number1, ..., number99 的变量，使用数组形式 numbers[0], numbers[1] ..., numbers[99] 更加方便且易于扩展。 + 数组元素可以通过索引（位置）来读取（或者修改），索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推。 + +## 声明数组 + Go 语言数组声明需要指定元素类型及元素个数，语法格式如下： + var variable_name [SIZE] variable_type + 以上为一维数组的定义方式。例如以下定义了数组 balance 长度为 10 类型为 float32： + var balance [10] float32 + +## 初始化数组 + var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 56.0} + 初始化数组中 {} 中的元素个数不能大于 [] 中的数字。 + 如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小： + var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0} + 该实例与上面的实例是一样的，虽然没有设置数组的大小。 + balance[4] = 50.0 + +## 访问数组元素 + + + + \ No newline at end of file diff --git a/src/docs/go语言条件语句.md b/src/docs/go语言条件语句.md new file mode 100644 index 0000000..508e312 --- /dev/null +++ b/src/docs/go语言条件语句.md @@ -0,0 +1,76 @@ +# Go 语言条件语句 + 条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。 + + 下图展示了程序语言中条件语句的结构： + + Go 语言条件语句 + Go 语言提供了以下几种条件判断语句： + + 语句 描述 + if 语句 if 语句 由一个布尔表达式后紧跟一个或多个语句组成。 + if 布尔表达式 { + /* 在布尔表达式为 true 时执行 */ + } + + if...else 语句 if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。 + if 布尔表达式 { + /* 在布尔表达式为 true 时执行 */ + } else { + /* 在布尔表达式为 false 时执行 */ + } + if 嵌套语句 你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。 + if 布尔表达式 1 { + /* 在布尔表达式 1 为 true 时执行 */ + if 布尔表达式 2 { + /* 在布尔表达式 2 为 true 时执行 */ + } + } + switch 语句 switch 语句用于基于不同条件执行不同动作。 + switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。 + + switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。 + + switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。 + + 语法 + Go 编程语言中 switch 语句的语法如下： + + switch var1 { + case val1: + ... + case val2: + ... + default: + ... + } + 变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。 + + 您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。 + select 语句 select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。 + select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。 + + select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。 + + 语法 + Go 编程语言中 select 语句的语法如下： + + select { + case communication clause : + statement(s); + case communication clause : + statement(s); + /* 你可以定义任意数量的 case */ + default : /* 可选 */ + statement(s); + } + 以下描述了 select 语句的语法： + + 每个 case 都必须是一个通信 + 所有 channel 表达式都会被求值 + 所有被发送的表达式都会被求值 + 如果任意某个通信可以进行，它就执行，其他被忽略。 + 如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。 + 否则： + 如果有 default 子句，则执行该语句。 + 如果没有 default 子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值。 + 注意：Go 没有三目运算符，所以不支持 ?: 形式的条件判断。 \ No newline at end of file diff --git a/src/docs/go语言结构体.md b/src/docs/go语言结构体.md new file mode 100644 index 0000000..a28bd50 --- /dev/null +++ b/src/docs/go语言结构体.md @@ -0,0 +1,33 @@ +# Go 语言结构体 + Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。 + 结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。 + +## 定义结构体 + 结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下： + + type struct_variable_type struct { + member definition + member definition + ... + member definition + } + 一旦定义了结构体类型，它就能用于变量的声明，语法格式如下： + + variable_name := structure_variable_type {value1, value2...valuen} + 或 + variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen} + +## 访问结构体成员 + 如果要访问结构体成员，需要使用点号 . 操作符，格式为： + 结构体.成员名" + +## 结构体指针 + 你可以定义指向结构体的指针类似于其他指针变量，格式如下： + + var struct_pointer *Books + 以上定义的指针变量可以存储结构体变量的地址。查看结构体变量地址，可以将 & 符号放置于结构体变量前： + + struct_pointer = &Book1 + 使用结构体指针访问结构体成员，使用 "." 操作符： + + struct_pointer.title \ No newline at end of file diff --git a/src/docs/go语言运算符.md b/src/docs/go语言运算符.md new file mode 100644 index 0000000..6b804fc --- /dev/null +++ b/src/docs/go语言运算符.md @@ -0,0 +1,88 @@ +#Go 语言运算符 + Go语言内置的运算符有 + 算术运算符 + 关系运算符 + 逻辑运算符 + 位运算符 + 赋值运算符 + 其他运算符 + + +## 算术运算符 + + 相加 A + B 输出结果 30 + - 相减 A - B 输出结果 -10 + * 相乘 A * B 输出结果 200 + / 相除 B / A 输出结果 2 + % 求余 B % A 输出结果 0 + ++ 自增 A++ 输出结果 11 + -- 自减 A-- 输出结果 9 + 如果想除法得到小数 将其中一个数转为浮点数再相除就行 + + 注意：：：： Go 的自增，自减只能作为表达式使用，而不能用于赋值语句。 + a++ // 这是允许的，类似 a = a + 1,结果与 a++ 相同 + a-- //与 a++ 相似 + a = a++ // 这是不允许的，会出现变异错误 syntax error: unexpected ++ at end of statement + +## 关系运算符 + 下表列出了所有Go语言的关系运算符。假定 A 值为 10，B 值为 20。 + + 运算符 描述 实例 + == 检查两个值是否相等，如果相等返回 True 否则返回 False。 (A == B) 为 False + != 检查两个值是否不相等，如果不相等返回 True 否则返回 False。 (A != B) 为 True + > 检查左边值是否大于右边值，如果是返回 True 否则返回 False。 (A > B) 为 False + < 检查左边值是否小于右边值，如果是返回 True 否则返回 False。 (A < B) 为 True + >= 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。 (A >= B) 为 False + <= 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。 (A <= B) 为 True + +## 逻辑运算符 + 下表列出了所有Go语言的逻辑运算符。假定 A 值为 True，B 值为 False。 + + 运算符 描述 实例 + && 逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。 (A && B) 为 False + || 逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。 (A || B) 为 True + ! 逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。 + +## 位运算符 + Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13： + + 运算符 描述 实例 + & 按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。 (A & B) 结果为 12, 二进制为 0000 1100 + | 按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或 (A | B) 结果为 61, 二进制为 0011 1101 + ^ 按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 (A ^ B) 结果为 49, 二进制为 0011 0001 + << 左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 A << 2 结果为 240 ，二进制为 1111 0000 + >> 右移运算符">>"是双目运算符。右移n位就是除以2的n次方。 其功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。 + +## 赋值运算符 + 下表列出了所有Go语言的赋值运算符。 + + 运算符 描述 实例 + = 简单的赋值运算符，将一个表达式的值赋给一个左值 C = A + B 将 A + B 表达式结果赋值给 C + += 相加后再赋值 C += A 等于 C = C + A + -= 相减后再赋值 C -= A 等于 C = C - A + *= 相乘后再赋值 C *= A 等于 C = C * A + /= 相除后再赋值 C /= A 等于 C = C / A + %= 求余后再赋值 C %= A 等于 C = C % A + <<= 左移后赋值 C <<= 2 等于 C = C << 2 + >>= 右移后赋值 C >>= 2 等于 C = C >> 2 + &= 按位与后赋值 C &= 2 等于 C = C & 2 + ^= 按位异或后赋值 C ^= 2 等于 C = C ^ 2 + |= 按位或后赋值 C |= 2 等于 C = C | 2 + +## 其他运算符 + 运算符 描述 实例 + & 返回变量存储地址 &a; 将给出变量的实际地址。 + * 指针变量。 *a; 是一个指针变量 + + +## 运算符优先级 + 有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低： + + 优先级 运算符 + 5 * / % << >> & &^ + 4 + - | ^ + 3 == != < <= > >= + 2 && + 1 || + 当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。 + + \ No newline at end of file diff --git a/src/learn/addrOp.go b/src/learn/addrOp.go new file mode 100644 index 0000000..64b1304 --- /dev/null +++ b/src/learn/addrOp.go @@ -0,0 +1,19 @@ +package main + +import "fmt" + +func main(){ + var a int = 4 + var b int32 + var c float32 + var ptr *int + + fmt.Printf("第一行 -a 变量类型为 %T\n", a) + fmt.Printf("第二行 -b 变量类型为 %T\n", b) + fmt.Printf("第三行 -c 变量类型为 %T\n", c) + + ptr = &a + fmt.Printf("a的值为 %d \n",a) + fmt.Printf("ptr为 %d\n", *ptr) + fmt.Printf("ptr %d\n", ptr) +} \ No newline at end of file diff --git a/src/learn/ariOp.go b/src/learn/ariOp.go new file mode 100644 index 0000000..afc4e38 --- /dev/null +++ b/src/learn/ariOp.go @@ -0,0 +1,23 @@ +package main + +import "fmt" + +func main() { + var a int = 21 + var b int = 10 + var c int + c = a + b + fmt.Printf("第 1111 c 的值 %d \n", c) + c = a - b + fmt.Printf("第 2222 c 的值 %d \n", c) + c = a * b + fmt.Printf("第 3333 c 的值 %d \n", c) + c = a*1.0 / b + fmt.Printf("第 4444 c 的值 %d \n", c) + c = a % b + fmt.Printf("第 5555 c 的值 %d \n", c) + a++ + fmt.Printf("第 6666 c 的值 %d \n", a) + a-- + fmt.Printf("第 7777 c 的值 %d \n", a) +} diff --git a/src/learn/assOp.go b/src/learn/assOp.go new file mode 100644 index 0000000..365ace2 --- /dev/null +++ b/src/learn/assOp.go @@ -0,0 +1,17 @@ +package main + +func main() { + var a int = 21 + var c int + c = a + c += a + c -= a + c *= a + c /= a + c = 200 + c <<= 2 + c >>= 2 + c &= 2 + c ^= 2 + c |= 2 +} diff --git a/src/learn/bitOp.go b/src/learn/bitOp.go new file mode 100644 index 0000000..2bb6b33 --- /dev/null +++ b/src/learn/bitOp.go @@ -0,0 +1,14 @@ +package main + +func main() { + var a uint = 60 + var b uint = 13 + var c uint = 0 + + c = a & b + c = a | b + c = a ^ b + c = a << 2 + c = a >> 2 + c *= 1 +} diff --git a/src/learn/constVar.go b/src/learn/constVar.go new file mode 100644 index 0000000..903021b --- /dev/null +++ b/src/learn/constVar.go @@ -0,0 +1,26 @@ +package main + +import ( + "fmt" + "unsafe" +) + +const( + a1 = "abc" + b1 = len(a1) + c1 = unsafe.Sizeof(a1) +) + +func main() { + const LENGTH int = 10 + const WIDTH int = 5 + var area int + const a, b, c = 1, false, "str" //多重赋值 + + area = LENGTH * WIDTH + fmt.Printf("面积为 : %d", area) + println() + println(a, b, c) + + println(a1, b1, c1) +} diff --git a/src/learn/hello.go b/src/learn/hello.go new file mode 100644 index 0000000..0cbc2b2 --- /dev/null +++ b/src/learn/hello.go @@ -0,0 +1,6 @@ +package learn +import "fmt" + +func main(){ + fmt.Println("hello world!") +} diff --git a/src/learn/mulVar.go b/src/learn/mulVar.go new file mode 100644 index 0000000..684b914 --- /dev/null +++ b/src/learn/mulVar.go @@ -0,0 +1,18 @@ +package main + +var x, y int +var ( // 这种因式分解关键字的写法一般用于声明全局变量 + a int + b bool +) + +var c, d int = 1, 2 +var e, f = 123, "hello" + +//这种不带声明格式的只能在函数体中出现 +//g, h := 123, "hello" + +func main(){ + g, h := 123, "hello" + println(x, y, a, b, c, d, e, f, g, h) +} \ No newline at end of file diff --git a/src/learn/structs.go b/src/learn/structs.go new file mode 100644 index 0000000..d00e864 --- /dev/null +++ b/src/learn/structs.go @@ -0,0 +1,39 @@ +package main + +import "fmt" + +type Books struct{ + title string + author string + subject string + book_id int +} + +func main(){ + var Book1 Books + var Book2 Books + + Book1.title = "Go 语言" + Book1.author = "www.runoob.com" + Book1.subject = "Go 语言教程" + Book1.book_id = 45646 + + Book2.title = "Python 教程" + Book2.author = "wwww.runoob.com" + Book2.subject = "python 语言教程" + Book2.book_id = 464513 + + /* 打印 Book1 信息 */ + fmt.Printf( "Book 1 title : %s\n", Book1.title) + fmt.Printf( "Book 1 author : %s\n", Book1.author) + fmt.Printf( "Book 1 subject : %s\n", Book1.subject) + fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id) + + /* 打印 Book2 信息 */ + fmt.Printf( "Book 2 title : %s\n", Book2.title) + fmt.Printf( "Book 2 author : %s\n", Book2.author) + fmt.Printf( "Book 2 subject : %s\n", Book2.subject) + fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id) + + +} diff --git a/src/learn/var.go b/src/learn/var.go new file mode 100644 index 0000000..06631bb --- /dev/null +++ b/src/learn/var.go @@ -0,0 +1,30 @@ +package main +import "fmt" +func main() { + + // 声明一个变量并初始化 + var a = "RUNOOB" + fmt.Println(a) + + // 没有初始化就为零值 + var n int + fmt.Println(n) + + // bool 零值为 false + var c bool + fmt.Println(c) + + var i int + var f float64 + var b bool + var s string + fmt.Printf("%v %v %v %q\n", i, f, b, s) + + var a1 *int + var a2 []int + var a3 map[string] int + var a4 chan int + var a5 func(string) int + var a6 error // error 是接口 + fmt.Printf("%v %v %v %v %v %v\n", a1, a2, a3, a4, a5, a6) +}