【Go】Go语言学习笔记

变量

标准声明

var 变量名 变量类型
复制代码

举个栗子🌰

var age int
var name string
var isOk bool
复制代码

批量声明

var (
    变量名 类型
    变量名 类型
    变量名 类型
)
复制代码

举个栗子🌰

var (
    age int
    name string
    isOk bool
)
复制代码

变量的初始化

Go语言声明变量的时候，每个变量其实会被初始化成该类型的默认值。

0空字符串falsenil

var 变量名 类型 = 表达式
复制代码

举个栗子🌰

var name string = "张三"
var age int = 18
var isOk bool = true
复制代码

或者还可以这样

var name, age, isOk = "张三", 12, true
复制代码

类型推导

有时候可以选择性省略变量的类型，编译器会根据等号右边的值来推导变量的类型来完成初始化。

举个栗子🌰

var name = "张三"
var age = 12
var isOk = true
复制代码

短变量声明

函数内部:=

举个栗子🌰

package main
import "fmt"
var m = 100 // 全局声明变量m
func main() {
    n := 10
    m := 200 // 局部声明变量m
    fmt.Println(m,n)
}
复制代码

匿名变量

_

举个栗子🌰

func foo() (int, string) {
    return 12, "张三"
}
func main() {
    age,_ := foo()
    _,name := foo()
    fmt.Println(name, age)
}
复制代码

注意事项

1. 函数外的每个语句都必须以关键字开始（var、const、func等）
2. := 不能在函数外使用
3. _多用于占位，表示忽略

常量

const

const HOME_ADDRESS = "我滴家在东北~松花江上昂昂"
const MY_GENDER = "男"
复制代码

多个常量可以一起声明：

const (
    HOME_ADDRESS = "我滴家在东北~松花江上昂昂"
    MY_GENDER = "男"
)
复制代码

const同时声明常量的时候，如果省略了值，则表示和上面一行的值相同：

const (
    HOME_ADDRESS = "我滴家在东北~松花江上昂昂"
    HIS_HOME_ADDRESS
    MY_GENDER = "男"
    HIS_GENDER
)
复制代码

HIS_HOME_ADDRESS我滴家在东北~松花江上昂昂HIS_GENDER男

iota

常量计数器，JavaScript中没有。

iota

iotaiota

举个栗子🌰

const (
    n1 = iota
    n2
    n3
    n4
    n5
)
fmt.Println(n1,n2,n3,n4,n5) // 0 1 2 3 4
复制代码

常见的iota示例

_

const (
    n1 = iota
    _
    n2
    _
    n3
    n4
)
fmt.Println(n1,n3,n4,n5) // 0 2 4 5
复制代码

iota

const (
   n1 = iota //0
   n2 = 1000 // 1000
   n3
   n4 = 9999 // 9999
   n5 = iota // 4
   n6 // 5
)
const n7 = iota
fmt.Println(n1,n2,n3,n4,n5,n6,n7)
复制代码

n3n3n5iotan6n5iotaiotan7iota0

整型

浮点型

复数

布尔值

字符串

字符串转义

举个栗子🌰

package main 
import "fmt"
func main() {
    fmt.Println("str := \"c:\\code\\day01\\main.go")
}
复制代码

多行字符串

反引号

s1 := `第一行
第二行
第三行
`
复制代码

字符串常用操作

举个栗子🌰

// ----------- len ------------
s1 := "abcd"
fmt.Println(len(s1)) // 4
// ----------- + ------------
s1 := "ab"
s2 := "cd"
s3 := s1 + s2
fmt.Println(s3) // abcd
// ----------- strings.Split ------------
参数1：待分割的字符串
参数2：分割符
返回值：返回一个字符串切片
s1 := "u&me&she&he"
s1_slice := strings.split(s1, "&")
fmt.Println("result:", s1_slice) // [u me she he]
fmt.Println("len:", len(s1_slice)) // 4
fmt.Println("cap:", cap(s1_slice)) // 4
注意事项：
    1. 字符串中不包含分隔符时，将原字符串转换成一个len&cap为1的字符串切片。 // [ u&me&she&he ] len:1 cap:1
    2. 当分隔符是空字符串时，将每个字符切割成一个单独的元素。//[u & m e & s h e & h e] len:1 cap:1
   
// ----------- strings.Contains ------------
s1 := "u&me&he&she"
s2 := "me"
s3 := "haha"
fmt.Println(strings.Contains(s1, s2)) // true
fmt.Println(strings.Contains(s1, s3)) // false
// ----------- strings.HasPrefix, HasSuffix ------------
参数1：待检测的字符串
参数2：指定的前缀/后缀
返回值：返回一个布尔值
s1 := "goodday.png"
fmt.Println(strings.HasPrefix(s1, "goodday")) // true
fmt.Println(strings.HasPrefix(s1, "goodday")) // true
fmt.Println(strings.HasSuffix(s1, "png")) // true
fmt.Println(strings.HasSuffix(s1, "jpg")) // false
// ----------- strings.Index, LastIndex ------------
s1 := "abcd"
fmt.Println(strings.Index(s1, "a")) // 0
fmt.Println(strings.Index(s1, "b")) // 3
fmt.Println(strings.Index(s1, "e")) // -1
// ----------- strings.Join ------------
s := []string{"11", "12", "13"}
res := strings.Join(s, "|")
fmt.Println(res) // 11|12|13
复制代码

byte和rune类型

Go语言的字符有两种：

byteASCII码runeUTF-8rune

s := "hello啊！树哥"
for i := 0; i < len(s); i++ {
    fmt.Println("%v(%c)", s[i], s[i])
}
fmt.Println()
for _, r := range s{
   fmt.Printf("%v(%c)", r, r)
}
复制代码

获取字符串的长度

如果想拿到一个字符串的真实长度，可以通过一下两种办法：

fmt.Println(len([]rune(s))) //9
fmt.Println(len(utf8.RuneCountInString(s))) // 9
复制代码

修改字符串

runebytestring

s1 := "helloa!shugge!"
byteS1 := []byte(s1)
byteS1[0] = 'w'
fmt.Println(string(byteS1)) // welloa!shugge!
s2 := "hello啊！树哥！"
runeS2 := []rune(s2)
runeS2[7] = '涛'
fmt.Println(string(runeS2)) // hello啊！涛哥！
复制代码

''""

关于字符编码

编码解码字符集

ASCII码非ASCII码GB 类GB2312GBKUnicodeUnicodeUTF-32UTF-16UTF-8

类型转换

Go语言中只有强制类型转换，没有隐式类型转换。

强制类型转换的基本语法如下：

T(表达式)
复制代码

T

数据类型练习题

fmt.Printf()%T

s := "hello树先生"
n := 12
b := true
f := 3.1415
fmt.Printf("%v：%T", n,n)
fmt.Println()
fmt.Printf("%v：%T", b,b)
fmt.Println()
fmt.Printf("%v：%T", f,f)
fmt.Println()
fmt.Printf("%v：%T", s,s)
还有两种获取变量和类型的方法
1. reflect.Typeof(s)
2. reflect.Typeof(s).Name()
关于Printf
1.%T 打印变量的类型
2.%v 以默认的方式打印变量的值
复制代码

"hello！树先生！"

// 我的解法，因为Go默认使用 UTF-8解码，所以一个中文字符是3
str := "hello!树先生!"
runeStr := []rune(str)
count := 0
for _, r := range runeStr {
   if len(string(r)) >= 3 {
      count++
   }
}
fmt.Printf("str中汉字有%v个", count)
// 一个好的解法
// unicode 包提供了一些测试Unicode码点属性的数据和函数.
// Is 返回该符文是否在指定范围的表中。
// Han 汉字的表范围
str := "hello!树先生!"
count := 0
for _,item := range str {
   if unicode.Is(unicode.Han, item) {
      count++
   }
}
fmt.Printf("str中汉字有%v个", count)