一、变量定义
使用关键字var定义变量：
1、var[变量名][变量类型]
例如：var a int(未给变量赋初始值则变量会有默认值，当前变量默认值为0)
2、var[变量名][变量类型]=[变量值]----例如：var a int = 1
3、var [变量名],[变量名],... [变量类型] = [变量值],[变量值],...
例如：var a, b, c int = 1, 2, 3(同时定义多个变量并赋值时必须保证每个变量都赋值)
4、var[变量名],[变量名],[变量名],...=[变量值],[变量值],[变量值]...
例如：var a, b, c = 1, "hh", false
(未定义变量类型时，可以同时定义多个不同类型的变量;go语言编译器能根据变量值自动推断出变量类型)
5、var (
[变量名] = [变量值]
[变量名] = [变量值]
...
)
使用“:=”定义变量
[变量名]:=[变量值]
例如：a := 1(符号":="定义变量的方式只能在函数内使用，函数外必须有关键字开头)
var (
name = "猪猪"
age = 18
phone = 12345678
)
func variableDefaultValue() {
var a int
var b string
fmt.Printf("%d,%q\n", a, b)
}
func variableInit() {
var a, b = 1, "test"
println(a, b)
}
func variableMultiple() {
a, b, c := 1, 2, 3
println(a, b, c)
}
go语言中定义的变量必须被使用，在函数外定义的变量称为：包内变量
二、 内建变量类型
bool 、 string
(u)int 、(u)int8 、(u)int16 、(u)int32、(u)int64、uintptr(指针)--- 加u即无符号整数
byte 、rune
float32、float64、complex64(实数float32、虚数float32) 、complex128(实数float64、虚数float64)
- 强制类型转换
func demo() {
a, b := 3, 4
var c int
c = int(math.Sqrt(float64(a*a + b*b)))
println(c)
}
- 变量要点
1、变量类型写在变量名之后
2、编译器可推测变量类型
3、没有char,只有rune
4、原生支持复数类型
三、 常量与枚举
/**
*常量和枚举
*使用关键字const定义常量，和定义变量基本相同
*枚举类型：
* 普通枚举
* 自增值枚举
*/
func constDemo() {
//定义常量
const a = 1
const b, c = 4, 5
const project = "golang"
println(a, b, c, project)
const (
language = "golang"
code = 01
)
println(language, code)
//普通枚举
const (
java = 01
golang = 02
scala = 03
)
println(java, golang, scala)
//自增值枚举
const (
lua = iota
spark
python
)
println(lua,spark,python)
}
四、条件语句
/**
* 条件语句
* if [表达式] {}else{}
* switch [表达式(可忽略)]
*
*/
func demo(code int) string {
a := "hello"
c := "go"
d := a + c
e := "hello" + "go"
if d == e {
fmt.Println(true)
} else {
fmt.Println(false)
}
if b := "hello"; a == b {
fmt.Println(true)
} else {
fmt.Println(false)
}
switch {
case code == 1:
return "春天"
case code == 2:
return "夏天"
case code == 3:
return "秋天"
case code == 4:
return "冬天"
default:
panic("code wrong")
}
}
- 总结
1、if 语句的条件不需要()
2、if 的条件里可以赋值
3、if 的条件里赋值的变量作用域就在这个if语句里
4、switch 语句会自动break，除非使用fallthrough
5、switch后可以没有表达式
五、循环
package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
func main() {
sum := 0
for i := 1; i <= 10; i++ {
sum += i
}
fmt.Println(sum)
fmt.Println(convertToBin(10),
convertToBin(32832),
convertToBin(8),
)
printFile("test.txt")
forever()
}
/**
* 省略初始条件 相当于while
*/
func convertToBin(n int) string {
res := ""
for ; n > 0; n /= 2 {
lsb := n % 2
//strconv.Itoa(lsb) 转为字符串
res = strconv.Itoa(lsb) + res
}
return res
}
/**
* 没有初始条件和递增值
*/
func printFile(filename string) {
file, err := os.Open(filename)
if err != nil {
panic(err)
}
scanner := bufio.NewScanner(file)
for scanner.Scan() {
fmt.Println(scanner.Text())
}
}
/**
* 无限循环
*/
func forever() {
for {
fmt.Println("123")
}
}
- 总结
1、for 循环的条件里不需要括号
2、for 的条件里可以省略初始条件，结束条件，递增表达式
3、没有while循环
六、函数
package main
import (
"fmt"
"math"
"reflect"
"runtime"
)
func calculate(a, b int, opt string) (int, error) {
switch opt {
case "+":
return a + b, nil
case "-":
return a - b, nil
case "*":
return a * b, nil
case "/":
consult, _ := div(a, b)
return consult, nil
default:
return 0, fmt.Errorf("unsupported opt: %s", opt)
}
}
func apply(op func(int, int) int, a, b int) int {
//通过反射获取函数名称
pointer := reflect.ValueOf(op).Pointer()
funcName := runtime.FuncForPC(pointer).Name()
fmt.Printf("Calling function %s with args (%d, %d)\n", funcName, a, b)
return op(a, b)
}
/**
* 计算两数的商和余数 并返回
*/
func div(a, b int) (consult, remainder int) {
return a / b, a % b
}
/**
* a 的 b次方
*/
func pow(a, b int) int {
return int(math.Pow(float64(a), float64(b)))
}
func sum(nums ...int) int {
sum := 0
for i := range nums {
sum += nums[i]
}
return sum
}
func main() {
res, err := calculate(7, 6, "X")
if err != nil {
fmt.Println(err)
} else {
fmt.Println(res)
}
if res, err := calculate(1, 3, "X"); err != nil {
fmt.Println("error:", err)
} else {
fmt.Println(res)
}
fmt.Println(calculate(5, 8, "/"))
fmt.Println(div(10, 7))
fmt.Println(apply(pow, 2, 3))
fmt.Println(apply(func(a int, b int) int {
return int(math.Pow(float64(a), float64(b)))
}, 2, 3))
fmt.Println(sum(1,4,5,6,3))
}
- 总结
1、函数可以返回多个值并可以起名字
2、仅用于非常简单的函数
3、对于调用者来说没有区别
4、函数可作为参数
5、没有默认参数，可选参数
七、指针
func swap(a, b *int) {
*b, *a = *a, *b
}
func main() {
a, b := 3, 4
swap(&a, &b)
fmt.Println(a, b)
}
- 总结
1、指针不能运算
2、只有值传递一种方式
八、数组
package main
import "fmt"
func arrays(arr [5]int) {
arr[0] = 10
for i := range arr{
fmt.Println(arr[i])
}
}
func main() {
//定义数组的方式
//数量写在类型前
var arr1 [3]int
arr2 := [5]int{1, 2, 3, 4, 5}
arr3 := [...]int{1, 3, 6, 4}
fmt.Println(arr1, arr2, arr3)
//遍历数组
//方式一
for i := 1; i < len(arr2); i++ {
fmt.Println(arr2[i])
}
fmt.Println("--------------------------")
//方式二
for i := range arr2{
fmt.Println(arr2[i])
}
fmt.Println("--------------------------")
//方式三，获取值和下标
for i,v := range arr2{
fmt.Println(i,v)
}
fmt.Println("arrays------------------------")
arrays(arr2)
fmt.Println("arr2----------------")
fmt.Print(arr2)
}
- range关键字
1、意义明确
2、任何地方都能通过'_'省略变量
3、可以同时获取下标和值
- 数组是值类型
1、[10] int 和 [20] int 是不同类型
2、调用 func f(arr [10] int ) 会拷贝数组
3、在go 语言中一般不直接使用数组
九、Slice（切片）---- 相当于java的list
image.png
Slice的实现
package main
import "fmt"
func updateVal(arr []int) {
arr[0] = 10
}
func main() {
array := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
fmt.Println("array[2:6] = ", array[2:6])
fmt.Println("array[2:] = ", array[2:])
fmt.Println("array[:6] = ", array[:6])
fmt.Println("array[:] = ", array[:])
fmt.Println("update array before : ", array)
updateVal(array[:])
fmt.Println("update array after: ", array)
s1 := array[1:5] //[1 2 3 4]
fmt.Println("s1 = array[1:5] = ", s1)
s2 := s1[3:5]
fmt.Println("s2 = ", s2)
fmt.Println("-------------------------------")
fmt.Printf("s1=%v, len(s1)=%d, cap(s1)=%d\n", s1, len(s1), cap(s1)) //cap(s1) = [1, 2, 3, 4, 5, 6, 7]
fmt.Printf("s2=%v, len(s2)=%d, cap(s2)=%d\n", s2, len(s2), cap(s2)) //cap(s2) = [4, 5, 6, 7]
}
1、Slice本身没有数据，是对底层array的一个view
2、Slice可以向后扩展，不可以向前扩展
3、s[i] 不可以超越 len(s) , 向后扩展不可以超越底层数组cap(s)
-
切片的操作
1、向Slice添加元素时，如果超越cap，系统会重新分配更大的底层数组
2、由于值传递的关系，必须接收append的返回值 例如 s = append(s,val)
package main
import "fmt"
func printSlice(s []int) {
fmt.Printf("%v, len=%d, cap=%d\n", s, len(s), cap(s))
}
func main() {
var s []int //zero val for slice is nil
for i := 0; i < 10; i++ {
printSlice(s)
s = append(s, 2*i+1)
}
fmt.Println(s)
s1 := []int{2, 4, 6, 8}
printSlice(s1)
s2 := make([]int, 10)
s3 := make([]int, 8, 16)
fmt.Println(s2)
fmt.Println(s3)
fmt.Println("Slice copy")
copy(s2, s1)
printSlice(s2)
fmt.Println("Slice delete")
s2 = append(s2[:3],s2[4:]...)
printSlice(s2)
fmt.Println("popping from front")
front := s2[0]
s2 = s2[1:]
fmt.Println(front)
printSlice(s2)
fmt.Println("popping from back")
back := s2[len(s2)-1]
s2 = s2[:len(s2)-1]
fmt.Println(back)
printSlice(s2)
}
十、Map
-
定义
变量名 [key type] value type {}
例如：
m := map [string] string {
"name": "hhh",
"age": "18",
}
-
复合map
map[K1]map[K2]V
package main
import "fmt"
func main() {
fmt.Println("定义map------------------------------------------")
//定义map
//方式一 m == nil 变量名称为m key为string类型 value为string类型
var m map[string]string
fmt.Println("m = ", m)
//方式二
m2 := map[string]string{
"course": "golang",
"article": "map",
"test": "delete",
}
fmt.Println("m2 = ", m2)
//方式三 m3 == empty map
m3 := make(map[int]string)
fmt.Println("m3=", m3)
fmt.Println("遍历map-------------------------")
//遍历map
for k, v := range m2 {
fmt.Println("m2 的key和val: ", k, v)
}
for k := range m2 {
fmt.Println("m2 的key: ", k)
}
for value := range m2 {
fmt.Println("m2 的val: ", value)
}
fmt.Println("根据key获取元素----------------------------")
//根据key值获取元素
val := m2["course"]
fmt.Println(val)
fmt.Println("判断map中的元素是否存在-----------------------------")
//判断map中的元素是否存在
val2, ok := m2["course"]
fmt.Println(val2, ok)
if val3, ok := m2["course"]; ok {
fmt.Println(val3)
} else {
fmt.Println("val is not exist")
}
fmt.Println("根据Key删除元素-----------------------")
//根据Key删除元素
fmt.Println("删除m2的元素前：",m2)
delete(m2, "test")
fmt.Println("删除m2的元素后：",m2)
}
- 总结
1、map是无序的
2、key不存在时，获得value类型的初始值
3、map使用哈希表，必须可以比较相等
4、除了slice，map，function的内建类型都可以作为key
5、Struct类型不包含上述字段，也可作为key
十一、字符和字符串
- rune
（相当于go的char）
1、使用range 遍历pos,rune对
2、使用utf8.RuneCountInString获得字符数量
3、使用len获得字节长度
4、使用[]byte获得字节
