基本类型

bool

整数：byte(相当于uint8), rune(相当于int32), int/uint ,int8/uint8 ,int16/uint16 ,int32/uint32 ,int64/uint64

浮点数: float32 ,float64, complex64 ,complex128

array（值类型）、slice、map、chan（引用类型）

条件循环语句

if 、switch

if用法注意点

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10
 
   /* 使用 if 语句判断布尔表达式 */
   if a < 20 {
       /* 如果条件为 true 则执行以下语句 */
       fmt.Printf("a 小于 20\n" )
   }
   fmt.Printf("a 的值为 : %d\n", a)
}

switch用法注意点

Go 语言 switch 语句 | 菜鸟教程

switch简单demo

package main

import "fmt"

func main() {
    var grade string = "B"
    var marks int = 90

    switch marks {
    case 90:
        grade = "A"
    case 80:
        grade = "B"
    case 50, 60, 70:
        grade = "C"
    default:
        grade = "D"
    }

    switch {
    case grade == "A":
        fmt.Println("优秀")
    default:
        fmt.Println("懒得写了")
    }
    fmt.Println(grade)
}

switch判断interface的类型

package main

import "fmt"

func main() {
    var x interface{}
    x = "你好"

    switch i := x.(type) {
    case nil:
        fmt.Println("nil")
    case int:
        fmt.Printf("x is an integer: %d\n", i)
    case string:
        fmt.Printf("x is a string: %s\n", i)
    default:
        fmt.Println("x is of unknown type")
    }
}

fallthrough加在后面可以不加判断强制执行后面的case

package main

import "fmt"

func main() {

    switch {
    case false:
        fmt.Println("1、case 条件语句为 false")
        //fallthrough
    case true:
        fmt.Println("2、case 条件语句为 true")
        fallthrough
    case false:
        fmt.Println("3、case 条件语句为 false")
        fallthrough
    case true:
        fmt.Println("4、case 条件语句为 true")
        //fallthrough
    case true:
        fmt.Println("5、case 条件语句为 false")
        fallthrough
    default:
        fmt.Println("6、默认 case")
    }
}

string

string、rune、byte之间的关系

参考链接：https://www.cnblogs.com/cheyunhua/p/16007219.html

理解go中rune数据类型 - 知乎

首先查看官方包的定义

可以看出byte区分字节值和uint8，rune区分字符值和int32

// byte is an alias for uint8 and is equivalent to uint8 in all ways. It is
// used, by convention, to distinguish byte values from 8-bit unsigned
// integer values.
type byte = uint8

// rune is an alias for int32 and is equivalent to int32 in all ways. It is
// used, by convention, to distinguish character values from integer values.
type rune = int32

UTF-8 是 Unicode 的一种实现方式，是一种针对 Unicode 可变长度的字符编码，它定义了字符串具体以何种方式存储在内存中。UFT-8 使用 1 ~ 4 为每个字符编码。

rune对应于int32，也就是这个unicode码点

byte对应于原始字节（8位所以0~255），也就是原始字节

go中的string类型采用UTF-8编码，这是一种可变长的 Unicode 字符编码方案，几乎可以表示世界任何字符。

统计字节数：len

统计Unicode字符数：utf8.RuneCountInString()

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    a := "Go语言"

    fmt.Println("字节数：", len(a))
    //utf8计算unicode字符数
    fmt.Println("Unicode字符数：", utf8.RuneCountInString(a))
    fmt.Println("[]Rune：", len([]rune(a)))

    // 遍历字符串中的字符 char为rune类型
    fmt.Println("遍历字符串中的字符：")
    for _, char := range a {
        //测试当前rune类型
        fmt.Printf("%T %c\n", char, char)
    }
    fmt.Println()
}

字符串之间比较

Strings.Compare包返回-1，0，1分别< ，== ，>

常用其他方法

package main

import (
    "fmt"
    "strings"
)

func main() {
    name := "go语言爱好者-l"
    //是否包含
    contain := strings.Contains(name, "爱好")
    fmt.Println(contain)

    //出现次数
    count := strings.Count(name, "g")
    fmt.Println(count)

    //以sep分割
    s := strings.Split(name, "-")
    fmt.Println(s)

    //前后缀
    goHead := strings.HasPrefix(name, "go语言")
    lEnd := strings.HasSuffix(name, "l")
    fmt.Println(goHead, lEnd)

    //查询字串出现位置,注意是byte的索引
    index := strings.Index(name, "爱好者") //8
    fmt.Println(index)

    //索引输出rune
    //for key, val := range name {
    //    fmt.Println(key, "--->", val)
    //}

    //索引输出byte,更细节，具体看当时文档 string rune byte之间的关系
    //for i := 0; i < len(name); i++ {
    //    fmt.Println(i, "-->", name[i])
    //}

    //索引到rune
    indexRune := strings.IndexRune(name, 35328)
    fmt.Println(indexRune)

    //替换,-1则替换所有
    fmt.Println(strings.Replace(name, "go", "java", -1))

    //大小写转换
    fmt.Println(strings.ToUpper("go"))
    fmt.Println(strings.ToLower("JAVA"))

    //去掉前后的符合,其他的用到了自己查询
    fmt.Println(strings.Trim(" 你好，啊 ", " "))
}