go学习笔记
学习资料
Go语言官网（需要FQ）：https://golang.org/
go 中文社区：https://studygolang.com
go中文在线文档 ： https://studygolang.com/pkdoc
把程序类比作商场
1） 入口， go有且只有一个函数入口函数，main
liteide, 直接进入图形编译，一个文件夹里的文件只能有一个main函数
2） 干活 ，调用函数
go bulid xxx.go
getyyInfo
go语言安装环境：
Go安装包下载网站：http:www.golangtc.com/download
有zip压缩版和msi安装两个版本下载（这里使用smi安装版，比较方便）
运行smi文件，千万不要在安装路径中出现中文，一路Next
由于使用msi安装文件，所以Go语言环境变量已经自动设置好了。
打开Windows中的命令提示符（cmd.exe)执行命令：
go version
查看G安装信息：go env
2）Go语言环境测试
3）LiteIDE安装
LiteIDE 是一款简单，开源，跨平台的go IDE。
官网: http://liteide.org/cn/
发行版本下载地址：https://sourceforge.net/projects/liteide/files
package main
import "fmt"
//有参无返回值函数的定义， 普通参数列表
//定义函数时,在函数名后面()定义的参数叫形参
//参数传递，只能有实参传递给形参，不能反过来，单向传递
func MyFunc01(a int) {
fmt.Println("a = ", a)
}
func MyFunc02(a int, b int) {
fmt.Println("a =%d, b = %d\n", a, b)
}
func MyFunc03(a, b int) {
fmt.Println("a = %d, b = %d\n", a, b)
}
func MyFunc04(a int, b string, c float64) {
fmt.Println("")
}
func main() {
//有参无返回值函数调用： 函数名（所需参数）
//调用函数传递的参数叫实参
}
package main
import "fmt"
func MyFun01(a int, b int) { //固定参数
}
//...int类型这样的类型， ...type不定参数类型
func MyFun02(args ...int) { //传递的实参可以是0或者多个
fmt.Println("len(args) =", len(args)) //获取用户传递参数的个数
for i := 0; i < len(args); i++ {
fmt.Println("args[%d] =%d\n", i, args[i])
}
fmt.Println("==================================")
//返回两个值， 第一个是下标，第二个是下标对应的参数
for i := 0; i < len(args); i++ {
fmt.Println("args[%d] =%d\n", i, args[i])
}
}
fun MyFunc03(a int, args ...int){
}
func main() {
MyFun02()
fmt.Println("+++++++++++++++++++++++")
MyFun02(1)
fmt.Println("+++++++++++++++++++++++")
MyFun02(1, 2, 3)
}
package main
import (
"fmt"
)
func main() {
//变量，程序运行期间，可以改变的量
//1.声明格式 var变量名 类型
//2.只是声明没有初始化，默认值是0
//3、同一个{}里 声明的变量名是唯一的
var a int
fmt.Println("a =", a)
//4.可以同时声明多个变量
// var a, b int
a = 10 //给变量赋值
fmt.Println("a =", a)
//2.变量的初始化，声明变量时，同时赋值
var b int = 10 //初始化，声明变量时，同时赋值（一步到位）
b = 20 //赋值,先声明 ，后赋值
fmt.Println("b=", b)
//3.自动推到类型，必须初始化，通过初始化的值确定类型（常用）
c := 30
//%T打印变量所属的类型
fmt.Printf("c type is %T\n", c)
}
package main
import "fmt"
func main() {
//赋值，赋值前，必须声明变量
var a int
a = 10 //赋值，可以使用N次
a = 20
a = 30
fmt.Println("a =", a)
// :=, 自动推到类型，先声明b，再给b赋值为20
//自动推导，同一个变量只能使用一次，用于初始化那次
b := 20
fmt.Println("b =", b)
//b := 30 //前面已经有变量b，不能再新建一个b
b = 30 //只是赋值是可以的
fmt.Println("b2 =", b)
}
package main
import "fmt"
func main() {
a := 10
//一段一段处理, 自动加换行
fmt.Println("a =", a)
//格式化输出，把a的内容放在%d的位置
// "a = 10\n" 这个字符串输出到屏幕, "\n" 代表换行符
fmt.Println("a = %d\n", a)
b := 20
c := 30
fmt.Println("a=", a, ", b=", b, ", c=", c)
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}
package main
import (
"fmt"
)
//go函数可以返回多个值
func test() (a, b, c int) {
return 1, 2, 3
}
func main() {
// a := 10
// b := 20
// c := 30
a, b := 10, 20
//交换2个变量的值
var tmp int
tmp = a
a = b
b = tmp
fmt.Printf("a = %d, b = %d\n", a, b)
// i := 10
// j := 20
i, j := 10, 20
i, j = j, i
fmt.Printf("i = %d, j = %d\n", i, j)
i = 10
j = 20
//_匿名变量，丢弃数据不处理，_匿名变量配合函数返回使用，才有优势
tmp, _ = i, j
fmt.Println("tmp =", tmp)
var c, d, e int
c, d, e = test() //return 1, 2, 3
fmt.Printf("c = %d, d = %d, e = %d", c, d, e)
_, d, _ = test()
fmt.Printf("d = %d\n", d)
}
package main
import "fmt"
func main() {
//变量：程序运行期间，可以改变的量， 变量生命需要var
//常量：程序运行期间， 不可改变的量， 常量生命需要 const
const a int = 10
//a = 20 //err, 常量不允许修改
fmt.Println("a =", a)
const b = 11 //没有使用
fmt.Printf("b type is %T\n", b)
fmt.Println("b =", b)
}
package main
import (
"fmt"
)
func main() {
//不同类型变量的定义（声明）
// var a int
// var b float64
var (
a int
b float64
)
a, b = 10, 3.14
fmt.Println("a =", a)
fmt.Println("b =", b)
// const i int = 10
// const j float64 = 3.14
// const (
// i int = 10
// j float64 = 3.14
// )
//自动推导类型
const (
i = 10
j = 3.14
)
fmt.Println("i =", i)
fmt.Println("j =", j)
}
package main
import "fmt"
func main() {
//1.iota 常量自动生成器，每隔一行，自动累加1
//2.iota 给常量赋值使用
const (
a = iota
b = iota
c = iota
)
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
//3.iota遇到const, 重置为0
const d = iota
fmt.Printf("d = %d\n", d)
//4.可以只写一个iota
const (
a1 = iota
b1
c1
)
fmt.Printf("a1 = %d, b1 = %d, c1 = %d", a1, b1, c1)
//5.如果是同一行，值都一样
const (
i = iota
j1, j2, j3 = iota, iota, iota
k = iota
)
fmt.Printf("i = %d, j1 = %d, j2 = %d, j3 = %d, k = %d\n", i, j1, j2, j3, k)
}
package main
import "fmt"
func main() {
//1.声明变量 没有初始化 默认0值为false
var a bool
fmt.Println("a0 = ", a)
a = true
fmt.Println("a = ", a)
//2.自动推导类型
var b = false
fmt.Println("b = ", b)
c := false
fmt.Println("c =", c)
}
package main
import "fmt"
func main() {
//声明变量
var f1 float32
f1 = 3.14
fmt.Println("f1 =", f1)
//自动推导类型
f2 := 3.14
fmt.Printf("f2 type is %T\n", f2) //f2 type is float64
//float64 存储小数比float32更准确
}
package main
import "fmt"
func main() {
//字符类型 ascii码
// 97 = a
var ch byte //声明字符类型
ch = 97
fmt.Println("ch =", ch)
//格式化输出， %c以字符方式打印，%d以整型方式打印
fmt.Println("%c, %d\n", ch, ch)
//大写转小写，小写转大写，大小写相差32， 小写大
fmt.Printf("大写: %d, 小写: %d\n, 'A', 'a'")
fmt.Printf("大写转小写: %c\n", 'A'+32)
fmt.Printf("小写转大写: %c\n", 'a'-32)
//'\' 以反斜杠开头的字符是转义字符, ' \n' 代表换行
fmt.Printf("hello go%c", '\n')
fmt.Printf("hello itcast")
}
package main
import "fmt"
func main() {
var str1 string //声明变量
str1 = "abc"
fmt.Println("str1 =", str1)
//自动推导类型
str2 := "mike"
fmt.Printf("str2 类型是 %T\n", str2)
//内建函数 len() 可以测字符串的长度，有多少个字符
fmt.Println("len(str2) =", len(str2))
}
package main
import "fmt"
func main() {
var ch byte
var str string
//字符
//1. 单引号
//2. 字符, 往往都只有一个字符，转义字符除外 '\n'
ch = 'a'
fmt.Println("ch =", ch)
//字符串
//1.双引号
//2.字符串有一个或多个字符组成
//3.字符串都是隐藏了一个结束符， '\0'
str = "a" //由'a'和'\0' 组成了一个字符串
fmt.Println("str =", str)
str = "hello go"
//只想操作字符串的木个字符，从0开始操作
fmt.Printf("str[0] = %c, str[1] =%c\n", str[0], str[1])
}
package main
import "fmt"
func main() {
var t complex128
t = 2.1 + 3.14i
fmt.Println("t =", t)
//自动推导类型
t2 := 3.3 + 3.14i
fmt.Println("t2 type is %T\n", t2)
//通过内建函数，取实部和虚部
fmt.Println("real(t2) =", real(t2), ", imag(t2) =", imag(t2))
}
package main
import "fmt"
func main() {
a := 10
b := "abc"
c := 'a'
d := 3.14
//%T操作变量所属类型
fmt.Printf("%T, %T, %T, %T\n", a, b, c, d)
//%d 整型格式
//%s 字符串格式
//%c 字符格式
//%f 浮点型格式
fmt.Printf("a = %d, b = %s, c = %c, d = %f\n", a, b, c, d)
//%v 自动匹配格式输出
fmt.Printf("a = %v, b = %v, c = %v, d = %v\n", a, b, c, d)
}
package main
import "fmt"
func main() {
var a int //声明变量
fmt.Printf("请输入变量a: ")
//阻塞等待用户的输入
// fmt.Scanf("%d", &a) //别忘了
fmt.Scan(&a)
fmt.Println("a =", a)
}
package main
import "fmt"
func main() {
//这种不能转换的类型，叫做兼容类型
var flag bool
flag = true
fmt.Printf("flag = %t\n", flag)
//bool 类型不能转换为int
fmt.Printf("flag = %d\n", flag)
//0就是假， 非0就是真
//整型也不能转换为bool
//flag = bool(1)
var ch byte
ch = 'a' //字符类型本质上就是整型
var t int
t = int(ch)
fmt.Println("t = ", t)
}
package main
import "fmt"
func main() {
//给int64起一个别名叫bight
type bigint int64
var a bigint //等价于var a int64
fmt.Printf("a type is %T\n", a)
type (
long int64
char byte
)
var b long
var ch char = 'a'
fmt.Printf("b = %d, ch = %c\n", b, ch)
}
package main
import "fmt"
func main() {
//给int64起一个别名叫bight
type bigint int64
var a bigint //等价于var a int64
fmt.Printf("a type is %T\n", a)
type (
long int64
char byte
)
var b long
var ch char = 'a'
fmt.Printf("b = %d, ch = %c\n", b, ch)
}
浙公网安备 33010602011771号