其他相关笔记: [[派蒙bot开发环境配置]] [[Golang 常用标准库]]

什么是Go语言
#

Go 语言被设计成一门应用于搭载 Web 服务器，存储集群或类似用途的巨型中央服务器的系统编程语言。

环境安装
#

Go语言的基础构成
#

包声明
引入包
函数
变量
语句 & 表达式
注释

package main //包声明  
  
import "fmt" //引入包  
  
func main() { //main函数  
   // 可执行程序必须包含的函数  
   //单行注释  
   /*多行注释*/  
   var A int = 10               //声明变量  
   fmt.Println(A)               //Go中声明变量必须使用  
   fmt.Println("Hello, World!") //语句  
}

Hello,World!
#

使用Go语言输出 Hello,World!

package main  //包声明  main ,任何可执行的Go程序必须的包  
  
import "fmt"  //引入fmt包  
  
func main() {  //main函数 ,每个可执行程序必须包含  
   //单行注释  
   /*多行注释*/  
   /* 这是我的第一个简单的程序 */   fmt.Println("Hello, World!")  //语句  
}

Go语言基础语法
#

Go 标记
#

Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。

比如 fmt.Println("Hello, World!") ,fmt , println ,"Hello,World!" 和括号以及点都是Go标记。

行分隔符
#

在Go程序中，一行代表一行语句的结束，每个语句不需要像C，JAVA一样加分号 ; 结尾。

fmt.Println("Hello, World!")
fmt.Print("Hello,Go!")

package main  

import "fmt"

func main() { 
	fmt.Println("Hello, World!") 
	fmt.Print("Hello,Go!")
}

输出结果:

变量的声明
#

Go语言中声明变量必须使用 var 关键字，而且声明的变量必须使用。

有两种方式来声明变量，

1.指定类型变量的声明

格式： var 变量名变量类型

此方式声明是有默认值的

2,根据值自判断的变量声明

格式： var 变量名 = 值

此方法声明，必须赋值

package main

import "fmt"

func main() {

	var A string = "123"  //指定类型的变量
	var B string=  "987"  //指定类型为字符串的名为 B的变量
	var C = 100  //自判断变量的声明
	var D = true

	fmt.Println(A)  //输出
	fmt.Println(B)
	fmt.Println(C)
	fmt.Println(D)
}

输出结果：

包的引入
#

Go语言引入包需要使用 import 关键字，引用格式为 import " 包名 " ,调用格式为 包名.方法名() 或 包名.变量名 .引入的包和变量一样，一经引用，必须使用。

package main  //包声明  main ,任何Go程序必须的包

import "fmt"  //引入fmt包
import "math"  //引入math包

func main() {  //main函数 ,每个可执行程序必须包含

fmt.Print(math.Pi)  //调用math包的变量Pi

}

注意：一个可执行程序有且仅有一个 main 包。

在Go语言中也可以使用 fmt.Sprint 来格式化字符串

package main

import "fmt"

func main() {

var A string = "123"
var B string=  "987"
// fmt.Sprint格式化字符串，并赋值给新字符串
var C string   =  fmt.Sprint(A,B) 
fmt.Print(C)
}

输出结果为：

注释
#

注释不会被编译，每一个包应该有相关注释。

单行注释是最常见的注释形式， // 开头是单行注释。多行注释也叫块注释，以 /* 开头，并以 */ 结尾。

//单行注释
/*多行
注释*/

标识符
#

标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A~~Z和a~~z)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。

数据类型
#

布尔类型
#

值只有 ture 和 false ，声明方式 var B bool ，默认值为 false

和 JAVA 不同的是，JAVA使用 Boolean 关键字来表示布尔值，Go 语言用 bool 来表示，注意区分

数字类型
#

整数类型
#

整数

int 类型，有正负之分。

int8   //有符号 8 位整型,取值 -128 到 127
int16 //有符号 16 位整型,取值 -32768 到 32767
int32 //有符号 32 位整型,取值 -2147483648 到 2147483647
int64 //有符号 64 位整型,取值 -9223372036854775808 到 9223372036854775807

无符号整数

int 前面加个u (unsigned) ,变成无符号整数 uint (unsigned integer),无符号整数一定是正整数。

和有符号整数一样，也是有各种位数的

uint8   //无符号 8 位整型,取值 0 到 255
uint16 //无符号 16 位整型,取值 0 到 65535
uint32 //无符号 32 位整型,取值 0 到 4294967295
uint64 //无符号 64 位整型,取值 0 到 18446744073709551615

浮点型
#

float32 和 float64 IEEE754标准

Go语言的浮点型没有float ,有 float32 和 float64 ，无 double 类型

float32  //32位浮点型数
float64 //64位浮点型数

字符串类型
#

string ,一串固定长度的字符连接起来的字符序列。

使用双引号 " "，或者反引号` `来创建。

在JAVA中，字符串类型是 String 第一个字母是大写，Go语言中，第一个字母小写

package main

import "fmt"

func main() {

var A string = "A" //定义字符串
var B string = `B`

fmt.Println("var A = " , A )  //输出
fmt.Println(`var B = ` , B )
}

输出结果：

合并字符串

使用加号来合并字符串

package main

import "fmt"

func main() {

var A string = "A"
var B string = `B`
var str string = A + B

fmt.Println("var A = " , A )
fmt.Println(`var B = ` , B )
fmt.Println("var str1 = " , str )
}

输出结果:

fmt包中的 Sprintf来合并字符串

格式 : fmt.Sprintf(格式化样式, 参数列表)

**格式化样式：**字符串形式，格式化符号以 % 开头， %s 字符串格式，%d 十进制的整数格式。
**参数列表：**多个参数以逗号分隔，个数必须与格式化样式中的个数一一对应，否则运行时会报错。

package main

import "fmt"

func main() {

var A = "123"
var B = "123"

        //fmt包中的Sprint方法格式化输出
var str = fmt.Sprintf("A = %s , B = %s",A , B)  

fmt.Println( "var str :" ,str )

}

输出结果:

派生类型
#

指针类型（Pointer）
数组类型 (Arrayllist)
结构化类型(struct)
通道类型 (Channel)
函数类型(Fanc)
切片类型
接口类型（interface）
Map 类型相关笔记: [[Golang派生类型]]

注意
#

Go语言中在不同数据类型之间赋值时需要显式的转换，不像其他如php,java可自动转换。

比如下面这个例子:

会出现类型不匹配的报错。

需要强制转换一下:

package main

import "fmt"

func main() {

var A int8 = 10

var B float32 = 0.5

var C = float32(A) + B  //将 int强制转换为 float32

fmt.Println(C)
}

输出结果:

而在JAVA中不会出现这个问题。

变量
#

声明变量
#

在Go语言中,使用var关键字声明变量，且变量一旦声明，必须使用。

这里和JAVA中不同，需要注意。

声明格式

var Name Type //声明变量的格式

var ：变量声明关键字

Name : 变量名字

Type : 变量类型

//声明变量
package main

import "fmt"

func main() {

var A string = "Hello,Go" //声明名为 A 的整数变量

fmt.Println(A)  //输出
}

输出结果：

批量声明变量
#

在Go中，可以使用 var + ()来实现批量声明变量的操作。

声明格式：

//批量声明变量
var (
Name string 
Sex string 
Age int 
)

类型推断
#

在Go中有一种很方便的声明变量或者常量的方式，就是类型推断

声明格式：

var Name = value

var : 变量声明关键字

Name : 变量名

value : 初始化值

//类型推断
package main

import "fmt"

func main() {
var Name = "たかみ ちか"  

fmt.Println(Name)  //输出

 }

输出结果:

变量的初始化
#

Go语言中声明变量，会自动进行初始化操作，并且赋默认值。

int类型默认值为0,string类型默认值为""，bool类型默认值为false

//变量初始化
var (
Name string  = "Takami Chika"
Sex string = "female"
Age int = 16
)

批量初始化
#

一次性可以初始化多个变量，中间用逗号隔开变量和值

//批量初始化
var A ,B , C = 1, 2, 3

短变量声明
#

在函数内部，可以使用短变量来更为快速地声明变量。

//短变量声明
package main

import "fmt"

func main() {

Name := "短变量"  //短变量声明

fmt.Println(Name)  //输出

 }

短变量只能在函数内部声明，无法在函数外部声明

匿名变量
#

如果接收到多个变量，而有一些变量暂时使用不到，可以使用下划线 _ 来声明匿名变量来代替变量名称。

匿名变量声明后，传入的任何值将会被抛弃，且不能在后续的代码中使用。

var _ = "" 
var Name,_ = "KSM" , 123

常量
#

在编译时就确定的值，运行后无法改变。

声明常量
#

在Go语言中，使用 const 关键字来定义常量

const Name Type = value

const : 常量定义关键字

Name : 常量名

Type : 常量数据类型 , 因为有类型推断，也可以不用写数据类型

value ：常量值

Go中的常量，在定义时就必须要赋初值，且后续无法修改。（比JAVA方便了不少）

JAVA 中的常量 : private static final int A = 100;
Go 中的常量 : const A = 100

//常量
package main

import "fmt"

func main() {

const Name string = "CYaRon!"
fmt.Println(Name)

}

输出结果:

当然，常量也是可以批量定义和初始化的

package main

import "fmt"

func main() {

const Name string = "CYaRon!"
fmt.Println(Name)

const (
A = "A"
B = 10
)

const C, D, E = 1,2,3
}

IOTA
#

关键字iota
#

iota可以理解为一个可以被编译器修改的变量，初始值为0，调用一次增加1，遇到下一个const关键字重置为0。

package main

import "fmt"

func main() {

const (
A = iota  //0
B = iota  //类似 JAVA 中的 i++
C = iota
D = iota
E = iota  //4
)
fmt.Println("const A = " ,A)
fmt.Println("const E =",E)
const (  //iota被重置
F = iota  //0
G= iota  //1
)
fmt.Println("const F = ",F)
fmt.Println("const G = ",G)
}

输出结果:

使用 `_` (下划线)来跳过某些值
#

package main

import "fmt"

func main() {

const (
A = iota  //0
B = iota //1
_        //2
D = iota //3
E = iota //4
)
fmt.Println("const A = " ,A)
fmt.Println("const E =",E)
}

运行结果:

iota中间插队
#

在iota中间，如果被别的常量打断，iota 会被覆盖掉，不再继续自增。但是用另一个 iota 接一下，又会继续自增。

被打断有iota接

package main

import "fmt"

func main() {

const (
A = iota  //0
B = iota //1
C = 100
D = iota //3
E = 100
F = iota  //5
G         //6
)
fmt.Println("const A = " , A )
fmt.Println("const D = " , D )

fmt.Println("const G = " , G )
}

输出结果：

被打断没有iota来接

package main

import "fmt"

func main() {

const (
A = iota  //0
B = iota //1
C = 100
D = iota //3
E = 100
F         //100
G         //100
)
fmt.Println("const A = " , A )
fmt.Println("const D = " , D )
fmt.Println("const E = " , E )
fmt.Println("const G = " , G )
}

输出结果:

运算符
#

算数运算符
#

符号	描述
+	相加
-	相减
*	相乘
/	相处
%	取余

在Go语言中，自增 ( ++ ) 和自减 ( -- ) 算单独的语句，不属于运算符。

package main

import "fmt"

func main() {

var A = 100
var B = 10

fmt.Println("A+B : " ,A + B)
fmt.Println("A-B : " ,A - B)
fmt.Println("A*B : " ,A * B)
fmt.Println("A/B : " ,A / B)
fmt.Println("A%B : " ,A % B)

}

输出结果:

关系运算符
#

运算符	描述
==	检查两个值是否相等，如果相等返回 True, 否则返回 False。
!=	检查两个值是否不相等，如果不相等返回 True, 否则返回 False。
>	检查左边值是否大于右边值，如果是返回 True, 否则返回 False。
>=	检查左边值是否大于等于右边值，如果是返回 True ,否则返回 False。
<	检查左边值是否小于右边值，如果是返回 True ,否则返回 False。
<=	检查左边值是否小于等于右边值，如果是返回 True, 否则返回 False。

package main

import "fmt"

func main() {
var Bool bool  //定义布尔值 Bool
var A = 10
var B = 100
var C = 10

Bool = A==B
fmt.Println("A == B: " , Bool)  // false
Bool = A!=B
fmt.Println("A != B: " , Bool)  //true

Bool = A > C
fmt.Println("A > C: " , Bool)  //false
Bool = A < B
fmt.Println("A < B: " , Bool) //true

Bool = A <= B
fmt.Println("A <= B: " , Bool) //true
Bool = A >= C
fmt.Println("A >= C: " , Bool) //true
}

输出结果:

逻辑运算符
#

运算符	描述
&&	逻辑 AND 运算符。如果两边的操作数都是 True，则为 True，否则为 False。
\|\|	逻辑 OR 运算符。如果两边的操作数有一个 True，则为 True，否则为 Fal
!	逻辑 NOT 运算符。如果条件为 True，则为 False，否则为 True

package main

import "fmt"

func main() {
var S bool

var A = true
var B = false

S = A && B
fmt.Println("A && B: " , S)
S = A  B
fmt.Println("A  B: " , S)
S = !A
fmt.Println("!A: " , S)

}

输出结果:

位运算符
#

运算符	描述
&	参与运算的两数各对应的二进位相与。（两位均为1才为1）
\|	参与运算的两数各对应的二进位相或。（两位有一个为1就为1）
^	参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。（两位不一样则为1）
«	左移n位就是乘以2的n次方。“a«b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
»	右移n位就是除以2的n次方。“a»b”是把a的各二进位全部右移b位。

位运算符的概念可以参考这篇教程来更好的理解： C 运算符

package main

import "fmt"

func main() {

var A  = 15 //1111
var B = 10 // 1010
var C uint = 1 //1

Y := A & B
fmt.Println("A & B: " , Y)  //1010 = 10
Y = A  B
fmt.Println("A  B: " , Y) //1111 = 5
Y = A ^ B
fmt.Println("A ^ B: " , Y) //0101 = 5
Y = A << C
fmt.Println("A << C: " , Y)//11110 = 30
Y = A >> C
fmt.Println("A >> C: " , Y)//0111 = 7

}

输出结果:

赋值运算符
#

运算符	描述
=	简单的赋值运算符，将一个表达式的值赋给一个左值
+=	相加后再赋值
-=	相减后再赋值
*=	相乘后再赋值
/=	相除后再赋值
%=	求余后再赋值
«=	左移后赋值
»=	右移后赋值
&=	按位与后赋值
l=	按位或后赋值
^=	按位异或后赋值

package main

import "fmt"

func main() {

var R = 20
fmt.Println("var R = 20")
R += 1
fmt.Println("R += 1: ",R)  // R = R + 1
R -= 1
fmt.Println("R -= 1: ",R)  // R = R - 1
fmt.Println("++++++++++++++++")

var A = 10
fmt.Println("var A = 10")
A *= 2
fmt.Println("A *= 2: ",A) // A = A * 2
A /= 4  //a = 20/4
fmt.Println("A /= 4: ",A)  // A = A / 4
A %= 10  //5%10
fmt.Println("A %= 10: ",A)// A = A % 10
fmt.Println("++++++++++++++++")

var G = 15  //1111
fmt.Println("var G = 15")
G <<= 1
fmt.Println("G <<= 1: ",G)  // 1111 ---> 11110 , 11110 = 30
G >>= 1
fmt.Println("G >>= 1: ",G) // 1111  ---> 01111 , 01111 = 15
fmt.Println("++++++++++++++++")

var E = 10  // 1010
E &= 10
fmt.Println("E &= 10: ",E)  //1010 & 1010 ---> 1010 , 1010 = 10
E = 15
fmt.Println("E = 10: ",E)  //1010 % 1111 ---> 1111 , 1111 = 15
E ^= 10
fmt.Println("E ^= 10: ",E)  //1010 ^ 1010 ---> 0101 , 0101 = 5

}

输出结果:

条件判断语句
#

if - else 语句
#

语法格式:

if (布尔表达式){   //布尔值为true执行花括号内语句

语句1

}
else {  //布尔值为false执行else内语句

语句2

}

package main

import "fmt"

func main() {

var A = 2

if (A == 10){  //2 != 10结果为false,执行else内的语句

fmt.Println("A = 10")

}else {
fmt.Println("A = ",A)
}

}

输出结果:

if嵌套语句
#

在 if 内添加if语句，实现嵌套效果.

语法格式：

if (布尔表达式){

语句1

if(B  == 4) {

语句1.1
}

}

package main

import "fmt"

func main() {

var B = 4

if (B > 2){  // 4 > 2 执行语句1

fmt.Println("B > 2")  //语句1

if(B  == 4) {  //B = 4 ,执行语句1.1

fmt.Println("B = 4" )  //语句1.1
		}
	}
}

运行结果:

if-else if-if 语句
#

单纯是if else是不够用的，所以Go语言还有else if语句。可以搭配if ，else使用

func main() {


var A = 10

if (A == 5){
fmt.Println("A = 5")
}else if (A == 10) {
fmt.Println("A = 10")
}else{
fmt.Println("A != 5 && A != 10")
}
}

输出结果:

switch语句
#

switch用来执行不同条件的不同动作，switch包含case的分支，swicth会从上到下一次判断各个case分支。case都是唯一的，而且自带一个break效果，一旦执行一个case就不会执行后面的case，如果需要执行后面的case,需要加 fallthrough .

fallthrough 要放在要第一个执行的case内

default代表如果没有可执行的 case ，则会执行 default下的语句。

case中值的数据类型必须和switch中的数据类型相同, 多个值也可以写在一个case中, 但要用逗号隔开

格式 :

switch Var {
    case var1:
        //语句1
    case var2:
        //语句2
    default:
        //语句3
}

package main

import "fmt"

func main() {

var A = 4

var B = 2

var C = A

var D = 4

switch C {  //判断

case A:
fmt.Println("A = " , A)
fallthrough   // D 和 A都为4，如果不加fallthrough只能执行A 的case

case B:
fmt.Println("B = " , B)

case D:
fmt.Println("D = " , D)

default:
fmt.Println("C = " , C)

}

}

输出结果:

条件循环语句
#

for关键字
#

在Go语言中去除了while ,do - while 循环,变得更加简洁了。

格式:

for 控制变量(赋值表达式); 循环条件(逻辑表达式\关系表达式);控制变量控制(自增\自减){
        //语句
}

其中控制变量控制是可以选择性添加的，不添加就实现了while循环

package main

import "fmt"

func main() {

var A = 0
for i := 0; i < 10; i++{
A = A + i
}
fmt.Println( "A = ",A)

}

运行结果:

for range 语句
#

for range语句有着类似迭代器操作(遍历数组，字符串等)，返回 (索引, 值) 或 (键, 值)

特点:

数组，切片返回格式为\[**索引**,**值**\]
map返回键和值
通道(channel)只返回通道（channel）内的值

格式:

for (索引名\键名),(值) := range (range的对象) {
      //语句
}

字符串会转为ASCII码输出，如果需要显示字符则需要 string()转为字符串类型

package main

import "fmt"

func main() {

var String = "ABCDEFG"

for index,value := range String{

        //index:索引 , value:for range出来的值
fmt.Println("index:",index,",Value:",string(value),"ASCII:",value)

	}
}

输出结果:

流程控制语句
#

Continue
#

跳过当前循环，进入下一循环

package main

import "fmt"

func main() {

for i := 0;i < 3;i++{
fmt.Println("i =  = = ",i)
for n := 0;n < 5;n++{
if (n < 2){
continue
}
fmt.Println("n =",n)
}

}

}

输出结果:

Break
#

终止当前循环,或者跳出switch语句

在多重循环中，可以用标号 label 标出想 break 的循环。

package main

import "fmt"

func main() {

for i := 0;i < 3;i++{
fmt.Println("i =  = = ",i)
for n := 0;n < 5;n++{
if (n < 2){
break
}
fmt.Println("n =",n)
}

}

}

输出结果：

break + label 跳出指定循环

package main

import "fmt"

func main() {
label1:
for i := 0; i < 3; i++ {
for n := 0; n < 3; n++ {
break label1  //跳出最外层循环（label1）
fmt.Println("循环2")
}
fmt.Println("循环1")
fmt.Println("---------------")
}

}

输出结果:

Goto
#

无条件地转移到过程中指定的行。

格式 :

goto label;
..
.
label: statement;

使用Goto语句来跳出双层循环.
#

未使用Goto：

package main

import "fmt"

func main() {

for i := 0; i < 3; i++ {
for n := 0; n < 3; n++ {
fmt.Println("循环2")
//goto label
}
fmt.Println("循环1")
fmt.Println("---------------")
}

//label:
//fmt.Println("label")
}

输出结果,可见break只能跳出所在的循环，无法跳出双层循环。

循环 2
循环1
---------------
循环 2
循环1
---------------
循环2
循环1
---------------

使用Goto语句:

package main

import "fmt"

func main() {

for i := 0; i < 3; i++ {
for n := 0; n < 3; n++ {
fmt.Println("循环2")
goto label  //跳到名为label的代码处
}
fmt.Println("循环1")
fmt.Println("---------------")
}

label:
fmt.Println("label")
}

输出结果：

循环2
label

函数
#

何为函数
#

函数是基本的代码块，用于执行一个任务。

Go 语言最少有个 main() 函数。

你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。

函数声明告诉了编译器函数的名称，返回类型，和参数。

函数的定义和调用
#

函数定义
#

Go语言定义函数的语法：

func function_name( [parameter list] ) [return_types] {
   函数体

   [return return_Numbers]
}

func ：定义函数的关键字

function_name : 函数名

parameter list : 参数列表，需要传入的参数和参数类型，根据需要选择可以不设置。

return_types ：返回值类型，返回一系列的值，根据需要选择可以不设置。

函数体：函数定义的代码集合。

func PrintHello() { //打印Hello的函数

var String = "Hello"
fmt.Println(String)

}

函数调用
#

当创建函数时，你定义了函数需要做什么，通过调用该函数来执行指定任务。

package main

import "fmt"

func main() {
PrintHello()  //调用PrintHello函数

fmt.Println(PrintHelloWorld()) //调用PrintHelloWorld函数


        fmt.Println(Add(10, 10))  //调用求和函数
}

func PrintHello() { //PrinrHello函数，无参，无返回值

var String = "Hello"
fmt.Println(String)


}

func PrintHelloWorld() string { //PrintHelloWorld函数，无参，有返回值

var String = "Hello,World!"
return String

}

func Add(X int, Y int) int {  //求和函数，有参，有返回值
Res := X + Y
return Res
}

运行结果：

HeTTo
Hetto ,WorTd!
20

函数类型
#

使用Type关键字可以定义函数类型。

在Go语言中,type可以定义任何自定义的类型。

package main

import "fmt"

func main() {
type T1 func(int, int) int  //使用type关键字，定义T1类型
var F T1 = Add  //声明T1类型的变量F ，将Add函数赋给F
f1 := F(1, 4)
fmt.Println(f1)

var F2 T1 = subtract
f2 := F2(10, 40)
fmt.Println(f2)

fmt.Println(f1 + f2)

}

func Add(X int, Y int) int {  //Add函数
Res := X + Y
return Res
}

func subtract(X int, Y int) int {  //subtract函数
Res := X - Y
return Res
}

输出结果：

5
-30
-25

高阶函数
#

函数作为参数
#

package main

import "fmt"

func main() {
PrintHello("Sam", SayHello)

}

func SayHello(name string) string {
var Hello string = name + " Hello"
fmt.Println("func SayHello: ", Hello)
return Hello
}

func PrintHello(name string, f func(string2 string) string) {
fmt.Println("func PrintHello: ", name, f(name))
}

输出结果：

函数作为返回值
#

package main

import (
"fmt"
"strconv"
)

func main() {
fmt.Println(Add(10, 20))

}

func Add(x int, y int) string {
var Res = x + y
return ToString(Res)
}

func ToString(z int) string {
var Res = strconv.Itoa(z)  //使用 strconv.Itoa()将整型数字转为字符串数字
return Res
}

其他
#

strconv.Itoa() 和 string()的区别

string()是直接整数类型的数字转为ASCII码值等于该整形数字的字符。

而strconv.Itoa() 是转换成对应的字符串类型的数字。

package main

import (
"fmt"
"strconv"
)

func main() {

var Number = 40

fmt.Println(Number)
fmt.Printf("%T\n", Number)
fmt.Println("------------------")

fmt.Println(string(Number))
fmt.Printf("%T\n", string(Number))

fmt.Println("------------------")

fmt.Println(strconv.Itoa(Number))
fmt.Printf("%T\n", strconv.Itoa(Number))

}

输出结果：

匿名函数
#

Go语言中的函数无法实现函数的嵌套，但是可以通过匿名函数来实现相似的效果。

匿名函数效果类似Python中的lamda

格式:

func(参数列表) 返回值 { 
    函数体
}

package main

import "fmt"

func main() {
Add := func(X int, Y int) int { //匿名函数
return X + Y
}

A := Add(1, 2) //调用匿名函数
fmt.Println("var A =", A) //输出
}

输出结果：

var A = 3

作者

Xenolies

Keep On Keeping On

什么是Go语言#

环境安装#

Go语言的基础构成#

Hello,World!#

Go语言基础语法#

Go 标记#

行分隔符#

变量的声明#

包的引入#

注释#

标识符#

数据类型#

布尔类型#

数字类型#

整数类型#

浮点型#

字符串类型#

派生类型#

注意#

变量#

声明变量#

批量声明变量#

类型推断#

变量的初始化#

批量初始化#

短变量声明#

匿名变量#

常量#

声明常量#

IOTA#

关键字iota#

使用 _ (下划线)来跳过某些值#

iota中间插队#

运算符#

算数运算符#

关系运算符#

逻辑运算符#

位运算符#

赋值运算符#

条件判断语句#

if - else 语句#

if嵌套语句#

if-else if-if 语句#

switch语句#

条件循环语句#

for关键字#

for range 语句#

流程控制语句#

Continue#

Break#

Goto#

使用Goto语句来跳出双层循环.#

函数#

何为函数#

函数的定义和调用#

函数定义#

函数调用#

函数类型#

高阶函数#

函数作为参数#

函数作为返回值#

其他#

匿名函数#

什么是Go语言
#

环境安装
#

Go语言的基础构成
#

Hello,World!
#

Go语言基础语法
#

Go 标记
#

行分隔符
#

变量的声明
#

包的引入
#

注释
#

标识符
#

数据类型
#

布尔类型
#

数字类型
#

整数类型
#

浮点型
#

字符串类型
#

派生类型
#

注意
#

变量
#

声明变量
#

批量声明变量
#

类型推断
#

变量的初始化
#

批量初始化
#

短变量声明
#

匿名变量
#

常量
#

声明常量
#

IOTA
#

关键字iota
#

使用 `_` (下划线)来跳过某些值
#

iota中间插队
#

运算符
#

算数运算符
#

关系运算符
#

逻辑运算符
#

位运算符
#

赋值运算符
#

条件判断语句
#

if - else 语句
#

if嵌套语句
#

if-else if-if 语句
#

switch语句
#

条件循环语句
#

for关键字
#

for range 语句
#

流程控制语句
#

Continue
#

Break
#

Goto
#

使用Goto语句来跳出双层循环.
#

函数
#

何为函数
#

函数的定义和调用
#

函数定义
#

函数调用
#

函数类型
#

高阶函数
#

函数作为参数
#

函数作为返回值
#

其他
#

匿名函数
#