SisMaker
/
goUtils
1
0
Forka 0
Codice Problemi 0 Pull Requests 0 Projects 0 Rilasci 0 Wiki Attività
Sfoglia il codice sorgente

部分提交

v1
AICells 5 anni fa
parent
3ff3bdba1c
commit
d3dce2178d
20 ha cambiato i file con 902 aggiunte e 0 eliminazioni
Visualizzazione separata
Opzioni Diff
Mostra statistiche Scarica il file Patch Scarica il file Diff
  1. +6
    -0
      .gitignore
  2. +23
    -0
      src/docs/Go语言变量作用域.md
  3. +39
    -0
      src/docs/go语言函数.md
  4. +15
    -0
      src/docs/go语言切片.md
  5. +318
    -0
      src/docs/go语言基础.md
  6. +64
    -0
      src/docs/go语言循环语句.md
  7. +23
    -0
      src/docs/go语言指针.md
  8. +25
    -0
      src/docs/go语言数组.md
  9. +76
    -0
      src/docs/go语言条件语句.md
  10. +33
    -0
      src/docs/go语言结构体.md
  11. +88
    -0
      src/docs/go语言运算符.md
  12. +19
    -0
      src/learn/addrOp.go
  13. +23
    -0
      src/learn/ariOp.go
  14. +17
    -0
      src/learn/assOp.go
  15. +14
    -0
      src/learn/bitOp.go
  16. +26
    -0
      src/learn/constVar.go
  17. +6
    -0
      src/learn/hello.go
  18. +18
    -0
      src/learn/mulVar.go
  19. +39
    -0
      src/learn/structs.go
  20. +30
    -0
      src/learn/var.go

+ 6
- 0
.gitignore Vedi File

@ -5,6 +5,12 @@
*.so
*.dylib
# idea
.idea
#bin
bin
# Test binary, built with `go test -c`
*.test

+ 23
- 0
src/docs/Go语言变量作用域.md Vedi File

@ -0,0 +1,23 @@
# Go 语言变量作用域
作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。
Go 语言中变量可以在三个地方声明：
函数内定义的变量称为局部变量
函数外定义的变量称为全局变量
函数定义中的变量称为形式参数
接下来让我们具体了解局部变量、全局变量和形式参数。
## 局部变量
在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。
以下实例中 main() 函数使用了局部变量 a, b, c：
## 全局变量
在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。
## 形式参数
形式参数会作为函数的局部变量来使用
## 初始化局部和全局变量
不同类型的局部和全局变量默认值为：
数据类型 初始化默认值
int 0
float32 0
pointer nil

+ 39
- 0
src/docs/go语言函数.md Vedi File

@ -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 语言使用的是值传递，即在调用过程中不会影响到实际参数。
函数用法
函数用法 描述
函数作为另外一个函数的实参 函数定义后可作为另外一个函数的实参数传入
闭包 闭包是匿名函数，可在动态编程中使用
方法 方法就是一个包含了接受者的函数

+ 15
- 0
src/docs/go语言切片.md Vedi File

@ -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是数组的长度并且也是切片的初始长度

+ 318
- 0
src/docs/go语言基础.md Vedi File

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

+ 64
- 0
src/docs/go语言循环语句.md Vedi File

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

+ 23
- 0
src/docs/go语言指针.md Vedi File

@ -0,0 +1,23 @@
#Go 语言指针
Go 语言中指针是很容易学习的，Go 语言中使用指针可以更简单的执行一些任务。
接下来让我们来一步步学习 Go 语言指针。
我们都知道，变量是一种使用方便的占位符，用于引用计算机内存地址。
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。
# 什么是指针
一个指针变量指向了一个值的内存地址。
类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：
var var_name *var-type
# 如何使用指针
指针使用流程：
定义指针变量。
为指针变量赋值。
访问指针变量中指向地址的值。
在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。
# Go 空指针
当一个指针被定义后没有分配到任何变量时，它的值为 nil。
nil 指针也称为空指针。
nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。
一个指针变量通常缩写为 ptr。

+ 25
- 0
src/docs/go语言数组.md Vedi File

@ -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
## 访问数组元素

+ 76
- 0
src/docs/go语言条件语句.md Vedi File

@ -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 没有三目运算符，所以不支持 ?: 形式的条件判断。

+ 33
- 0
src/docs/go语言结构体.md Vedi File

@ -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

+ 88
- 0
src/docs/go语言运算符.md Vedi File

@ -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 ||
当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。

+ 19
- 0
src/learn/addrOp.go Vedi File

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

+ 23
- 0
src/learn/ariOp.go Vedi File

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

+ 17
- 0
src/learn/assOp.go Vedi File

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

+ 14
- 0
src/learn/bitOp.go Vedi File

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

+ 26
- 0
src/learn/constVar.go Vedi File

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

+ 6
- 0
src/learn/hello.go Vedi File

@ -0,0 +1,6 @@
package learn
import "fmt"
func main(){
fmt.Println("hello world!")
}

+ 18
- 0
src/learn/mulVar.go Vedi File

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

+ 39
- 0
src/learn/structs.go Vedi File

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

+ 30
- 0
src/learn/var.go Vedi File

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

Scrivi Anteprima
Caricamento…
Annulla
Salva