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

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

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

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

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)
}
复制代码

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

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

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

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

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

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)
复制代码

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
复制代码

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
复制代码

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啊！涛哥！
复制代码

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 以默认的方式打印变量的值
复制代码

// 我的解法，因为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)