Go语言开发工具LiteIDE的安装
下载
下载网址： https://www.cr173.com/soft/44819.html
网上多数讲的下载地址，已失链： http://golangtc.com/download/liteide
下载成功得到一个压缩包： liteidex37.4.qt4.8.5.zip
安装
压缩包中有两个文件夹： liteide、liteide_win64
根据你安装的Go版本是32位还64位选择对应的文件夹释放到Go安装文件夹下，我的安装在文件夹： d:\go。
运行
然后在D:\Go\liteide\bin里找到 liteide.exe，双击运行。右键点击在任务栏里的“八卦”图标，把它锁定在任务里，或者创建一个桌面快捷方式也可以。
界面
我安装的是X37.4版本：
LiteIDE的使用
文件菜单中“新建”，或者快捷键Ctrl+N新建一个代码，复制以下代码段框中的几行代码，另存为一个源文件helloworld.go。
hello world
万能的hello world，不管学什么语言总要遇到它
1. package main 2. 3. import "fmt" 4. 5. func main() { 6. fmt.Println("hello world") 7. }
解读
1. package main
每个Go源代码文件的开头都是一个package声明，表示该Go代码所属的包。
包是Go语言里最基本的分发单位，也是工程管理中依赖关系的体现。
要生成Go可执行程序，必须建立一个名字为main的包。
2. import "fmt"
在包声明之后是import语句，用于导入该程序所依赖的包。
和python一样用import导入，但库名要用引号包括；类似C/C++的include语句。
3. func main()
包main中必须包含一个名为main()的函数（Go可执行程序的执行起点）。
Go语言的main()函数不能带参数，也不能定义返回值。
命令行传入的参数在os.Args变量中保存，如果需要支持命令行开关，可使用flag包。
4. fmt.Println("hello world")
Println()函数，需要导入该函数所属的fmt包。
执行
编译菜单中FileRun，或者使用快捷键 Alt+F6或Alt+Shift+R。
由fmt.Println()输出： hello world。
Go语法基础入门
输出 Print
三种基本形式：带换行、不带换行、使用格式符
1. fmt.Println("string") 2. fmt.Print("string") 3. fmt.Printf("Name: %s, Age: %d\n", "Hann", 48)
与python对比：内置函数不用导入包
print('string') print('string', end='') print('Name: %s, Age: %d'%('Hann',48)) #python 另有两种方法： print('Name: {}, Age: {}'.format('Hann', 48)) name,age = 'Hann',48 print(f'Name: {name}, Age: {age}')
注释
与C/C++相同，使用 // 或 /* */
1. // 单行注释 2. 3. /* 4. 多行注释 5. */
Python 则使用井号 # 或者三连引号 """ ... """ 、 ''' ... '''
标识符、关键字
标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A~Z和a~z)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。
这些规则，基本上所有语言都是如此。
Go 语言有 25 个关键字（或称为保留字）：
Go 语言有 36 个预定义标识符：
Python 只有30来个关键字，上表的标识符也有类似的但没有这么多类型标识符。
程序一般由关键字、常量、变量、运算符、类型和函数组成。
数据类型
布尔型
布尔型的值只可以是常量 true 或者 false，字母全部小写，其格式化符：%t。
Go和Python都是大小写敏感的编程语言，Python使用的布尔值首字母要大写。
数字型
#有符号整数 int8（-128 -> 127） int16（-32768 -> 32767） int32（-2,147,483,648 -> 2,147,483,647） int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807） #无符号整数 uint8（0 -> 255） uint16（0 -> 65,535） uint32（0 -> 4,294,967,295） uint64（0 -> 18,446,744,073,709,551,615） #浮点型 float32（IEEE-754 32位浮点型数） float64（IEEE-754 64位浮点型数） #无float类型 #复数，格式化符：%v Go 拥有以下复数类型： complex64 (32 位实数和虚数) complex128 (64 位实数和虚数) 复数与python基本相同，只是两者的虚数单位不同，Go用的是 i ，python用的是 j 。 Go语言的数字类型比较接近C/C++，不如Python只有int, float, complex来的方便。
变量声明
Go语言引入关键字var，而类型信息放在变量名之后，示例如下：
var v1 int var v2 string var v3 [10]int // 数组 var v4 []int // 数组切片 var c1 complex64 = 3 + 23i fmt.Printf("The value is: %v", c1) // 输出： 3 + 23i //函数内部可以隐式声明变量，使用 := ，不需要var 和 类型 InternalVariable := 6
这一点比Python严格，Python直接赋值即声明，没有声明关键字，且不强制要指定类型。
1）整型的零值为 0，浮点型的零值为 0.0。
2）int 和 uint 在 32 位操作系统上均使用4字节，在 64 位操作系统上均使用8字节。
3）uintptr 的长度被设定为足够存放一个指针即可。
4）整型的零值为 0，浮点型的零值为 0.0。
5）int 型是计算最快的一种类型。
6）尽可能地使用 float64，因为 math 包中所有有关数学运算的函数都会要求接收这个类型。
7）Go 是强类型语言，不会进行隐式转换.。所以Go 中不允许不同类型之间的混合使用，但允许常量之间的混合使用。
字符型
字符不是 Go 语言的一个类型，字符只是整数的特殊用例：
1）byte 类型是 uint8的别名：
1. var ch byte = 'A' 2. var ch byte = 65 3. var ch byte = '\x41' // \x 总是紧跟着长度为 2 的 16 进制数 4. /* 以上三行代码等价 */
2） rune 是 int32 的别名。
Unicode 至少占用 2 个字节，所以Go使用 int16 或者 int 类型来表示。如果需要使用到 4 字节，则会加上 \U 前缀；前缀 \u 则总是紧跟着长度为 4 的 16 进制数，前缀 \U紧跟着长度为 8 的 16 进制数。
var ch int = '\u0041' var ch2 int = '\u03B2' var ch3 int = '\U00101234' fmt.Printf("%d - %d - %d\n", ch, ch2, ch3) // integer fmt.Printf("%c - %c - %c\n", ch, ch2, ch3) // character fmt.Printf("%X - %X - %X\n", ch, ch2, ch3) // UTF-8 bytes fmt.Printf("%U - %U - %U", ch, ch2, ch3) // UTF-8 code point
对Python来说也没字符类型一说，它可以看作长度为1的字符串。
字符串类型
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
1）字符串是 UTF-8 字符的一个序列（当字符为 ASCII 码时则占用 1 个字节，其它字符根据需要占用 2-4 个字节）
2）字符串在Go语言内存模型中用一个2字长的数据结构表示。它包含一个指向字符串存储数据的指针和一个长度数据。
派生类型
(a) 指针类型（Pointer）
(b) 数组类型
(c) 结构类型 （struct）
(d) Channel 类型
(e) 函数类型
(f) 切片类型
(g) 接口类型（interface）
(h) Map 类型
这些类型大多是python所没有的，可以找到数组、结构、函数、切片、Map等相近的用法。
零值 nil
Go任何类型在未初始化时都对应一个零值：布尔类型是false，整型是0，字符串是""，而指针，函数，interface，slice，channel和map的零值都是nil。
可以把 nil 看作相当于Python的None。
常量
常量是一个简单值的标识符，在程序运行时，不会被修改的量。
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
常量的定义格式： const identifier [type] = value
可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。
显式类型定义： const b string = "abc"
隐式类型定义： const b = "abc"
Python没有常量关键字const的，就是不能被重定义的或值不变的“变量”。
运算符
运算符用于在程序运行时执行数学或逻辑运算。Go 语言内置的运算符有：
算术运算符
+、-、*、/ 、% 加减乘除、取余
++、-- 有和C/C++一样的自增减运算，但只有后增后减，没先自增先自减；
即只有 i++, j--；没有++i, --j；且不能有自增后赋值： a=i++，这是不允许的。
也没有Python的整除//，和C/C++一样用数据类型来分辨这“两种”运算。
package main import "fmt" func main() { fmt.Printf("%d", 5/2) fmt.Println() fmt.Printf("%f", 5/2.0) } /* 2 2.500000 */
关系运算符
==、!=、>、<、>=、<= 这些和Python的都相同。
逻辑运算符
&&、||、! 对应Python的 and、 or、 not 运算。
位运算符
&、|、^ 、<<、>> 和Python相同：“与、或、异或”及左、右位移。
按位取反运算： Go直接用^符号，Python则用~符号。
即： Go语言中，^ 作一元运算符时即按位取反，作二元运算符时即按位异或。
Go语言还特有一个“与非”运算： &^，相当于与运算和非运算的“连写”。
赋值运算符
=、+=、-=、*=、/=、%=、<<=、>>=、&=、^=、|= 差不多的，略。
其他运算符
*a 指针变量a
&a 返回变量a的存储地址
这两个运算和C/C++中的用法相同，Python是没有指针的。
控制语句
条件语句
if 语句：
package main import "fmt" func main() { var a int = 3 if a < 23 { fmt.Printf("a 小于 23\n") } fmt.Printf("a 的值为 : %d\n", a) }
if-else语句：
1. if 布尔表达式 { 2. /* 在布尔表达式为 true 时执行 */ 3. } else { 4. /* 在布尔表达式为 false 时执行 */ 5. }
if- else if-else语句:
package main import "fmt" func main() { var age int = 23 if age == 25 { fmt.Println("true") } else if age < 25 { fmt.Println("too small") } else { fmt.Println("too big") } }
Go的条件语句中else 位置不能新起一行，必须紧跟在右括号后面。
与Python对比，else要另起一行，且Python有关键字elif：
a = 3 if a<23: ...... if a<23: ...... else: ...... if a<5: ...... elif a<10: ...... else: ......
注意：Go没有三目操作符a=b>c?b:c，Python中即 a=b if b>c else c。
开关语句(选择、分支)
switch-case-default语句：
switch var1 { case val1: ... case val2: ... default: ... }
package main import "fmt" func main() { var grade string = "" var marks int = 65 switch marks / 10 { case 9, 10: grade = "A" case 8: grade = "B" case 6, 7: grade = "C" default: grade = "D" } fmt.Printf("你的等级是 %s\n", grade) }
Python最新版本3.10.0才开始启用 match - case 开关语句，之前的版本只能使用 if... elif... elif... elif... else... 代替。
相对于C/C++分支结构中，Go语言不支持如下像C/C++一样的写法：
package main import "fmt" func main() { var grade string = "未定义" var marks int = 65 switch marks / 10 { case 9: case 10: grade = "A" case 8: grade = "B" case 6: case 7: grade = "C" default: grade = "D" } fmt.Printf("你的等级是 %s\n", grade) } /* Out: 你的等级是 未定义 */
fallthrough
使用fallthrough就可以解决程序要依次执行多个case代码的问题。
package main import "fmt" func main() { var grade string = "未定义" var marks int = 92 switch marks / 10 { case 9: fallthrough case 10: grade = "A" case 8: grade = "B" case 6: fallthrough case 7: grade = "C" default: grade = "D" } fmt.Printf("你的等级是 %s\n", grade) }
另外Go还有一种开关结构语句，因为要用到新类型channel，保留暂时先不讨论：
select-case-default语句
select { case clause1: statement(s1) case clsuse2: statement(s2) default: statement(s3) }
循环语句
Go 只有for循环语句，没有while语句。但比Python有更多种形态：
和 C 语言的 for 一样：
for init; condition; post { }
和 C 的 while 一样：
for condition { }
和 C 的 for(;;) 一样：
for { }
和 Python 的 for i in range(n)差不多：
这种格式可以对字符串、数组、切片等进行迭代输出元素。
for key, value := range oldMap {
newMap[key] = value
}
循环实例
实例1:累加1+2+3+...+100
package main import "fmt" func main() { sum := 0 for i := 0; i <= 100; i++ { sum += i } fmt.Println(sum) // 以下写法就和 While 形式一样，只是关键字没换而已 sum = 0 i := 1 for i <= 100 { sum += i i++ } fmt.Println(sum) }
实例2:100以内的素数
package main import "fmt" func main() { // var prime,c int //定义变量不使用也会报错 var prime int var flag bool prime = 1 //while(prime<100) { //Go语言没有while for prime < 100 { //这种形式就似while语句，没用这个关键字而已 prime++ flag = true for tmp := 2; tmp < prime; tmp++ { if prime%tmp == 0 { flag = false } } if flag == true { fmt.Println(prime, "是素数") } } } /* 2 是素数 3 是素数 5 是素数 7 是素数 11 是素数 13 是素数 17 是素数 19 是素数 23 是素数 29 是素数 31 是素数 37 是素数 41 是素数 43 是素数 47 是素数 53 是素数 59 是素数 61 是素数 67 是素数 71 是素数 73 是素数 79 是素数 83 是素数 89 是素数 97 是素数 */
continue语句
continue 忽略当前循环体内的剩下代码，提前进入下一轮循环。
用法与Python及其它语言的完全相同，略。
break 语句
break 可以提前退出当前循环，用法与Python及其它语言的基本相同；
但是Go语言中用个跳转到指定标签的功能，可以同时跳出多层循环。
注：标签一定要放在循环之前，如下示例：
package main import "fmt" func main() { count := 1 Label1: for { count++ for { break Label1 count++ } } fmt.Println(count) // Out: 2 }
goto 语句
goto 可以无条件地转移到过程中指定的行（指定标签所在行之后）
注：大多数程序员都不待见这个goto语句，结构化程序设计中一般不主张使用goto语句。
比如，从主程序跳入子程序是绝对禁止的，或者从循环、结构等外部直接跳转到其内部。
Python 语言中没用goto语句，省得有了乱来瞎用。
