基本类型
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用法注意点
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
首先查看官方包的定义
可以看出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 = int32UTF-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(" 你好，啊 ", " "))
}
