整形分为两大类 有符号与无符号
按长度划分：
其中: uint8 是byte类型 int16对应C语言中的short型 int64对应C语言中的long型。
注意：在使用Int 和 uint 类型时，不能假定它是32位或64位的整形，而是考虑 int和uint可能在不同平台上的差异。
注意事项: 获取对象的长度的内建 len() 函数返回的长度可以根据不同平台的字节长度进行变化。实际使用中，切片或map的元素数量等
都可以用 int 来表示。 在涉及到二进制传输，读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用int 和 uint。
Go1.13版本之后引入了数字字面量语法，这样便于开发者以二进制，八进制或十六进制浮点数的格式定义数字。
我们可以借助fmt函数来将一个整数以不同进制形式展示。
package main
import "fmt"
func main(){
// 十进制
var a int = 10
fmt.Printf("%d \n",a) //10
fmt.Printf("%b \n",a) // 1010 占位符%b表示二进制
// 八进制 以o开头
var b int = o77
fmt.Printf("%o \n",b) //77
//十六进制 以0x开头
var c int = 0xff
fmt.Printf("%x \n",c) //ff
fmt.Printf("%X \n",c) //FF
}
Go支持两种浮点数: float32 和 float64
打印浮点数时，可以使用 fmt 包配合动词 %f，代码如下:
package main
import (
"fmt"
"math"
)
func main(){
fmt.Printf("%f\n",math.Pi)
fmt.Printf("%.2f\n",math.Pi)
}
Go中 以bool类型进行声明布尔数据类型
注意:
Go语言里的字符串的内部实现使用 UTF-8编码。字符串的值为 双引号(") 中的内容。可以在Go的源码中直接添加非
ASCII码字符，例如:
s1 := "hello" s2 := "你好"
Go的字符串常见转义符包含回车，换行，单双引号，制表符等
例子：打印一个windows平台的文件路径:
package main
import (
"fmt"
)
func main() {
fmt.Println("str := \"c:\\Code\\lesson1\\go.exe\"")
}
Go中要定义一个多行字符串时，就必须使用 反引号 字符:
s1 := ` my name is zzp
my age is 18
hello world
`
fmt.Println(s1)
示例:
1. strings.Split
package main
import (
"fmt"
"strings"
)
func main() {
name := "周1泽1平"
a := strings.Split(name, "1")
fmt.Println(a)
}
//结果: [周 泽 平] 类型:[]string
2.len(str)
package main
import (
"fmt"
)
func main() {
name := "周1泽1平"
a := len(name)
fmt.Println(a)
}
// 结果: 11
//注意: 中文字符 3个字节 数字英文字母 1个字节
3. + 或 fmt.Sprintf
package main
import (
"fmt"
)
func main() {
name := "zhou"
l_name := "s686"
username := name + l_name
fmt.Println(username)
}
//结果: zhous686
package main
import (
"fmt"
)
func main() {
name := "zhou"
l_name := "s686"
username := fmt.Sprintf("%v%v", name, l_name)
fmt.Println(username)
}
//结果: zhous686
4.strings.Contains
package main
import (
"fmt"
"strings"
)
func main() {
name := "zhous686"
is_con := strings.Contains(name, "zhou")
fmt.Println(is_con)
is_con1 := strings.Contains(name, "wj")
fmt.Println(is_con1)
}
//结果: is_con true
// is_con1 false
5. strings.HasPrefix, strings.HasSuffix
package main
import (
"fmt"
"strings"
)
func main() {
name := "zhous686"
is_con := strings.HasPrefix(name, "zhou")
fmt.Println(is_con)
is_con1 := strings.HasSuffix(name, "86")
fmt.Println(is_con1)
}
//结果: is_con true // is_con1 false
6. strings.Index()，strings.LastIndex() （这两个是一个意思）
package main
import (
"fmt"
"strings"
)
func main() {
name := "zhous686"
f_idx := strings.Index(name, "zhou")
fmt.Println(f_idx)
l_idx := strings.LastIndex(name, "zhou")
fmt.Println(l_idx)
}
//结果: f_idx =0 l_idx =0
7.strings.Join(a[]string,sep string)
Todo:..............
组成每个字符串的元素叫做"字符"，可以通过遍历或者单个获取字符串元素获得字符。字符用单引号(‘)包裹起来，如:
var a := ‘中‘ var b := ‘x‘
Go语言的字符有以下两种:
当需要处理中文，日文或者其他复合字符时，则需要用到 rune 类型。rune类型实际是一个 int32
Go使用了特殊的rune类型来处理 Unicode,让基于Unicode的文本处理更为方便，也可以使用byte型默认字符串处理，性能
和扩展性都有照顾。
package main
import (
"fmt"
)
func traversalString() {
s := "hello沙河"
for i := 0; i < len(s); i++ {
fmt.Printf("%v(%c)", s[i], s[i])
}
fmt.Println()
for _, r := range s {
fmt.Printf("%v(%c)", r, r)
}
fmt.Println()
}
func main() {
traversalString()
}
//结果:
104(h)101(e)108(l)108(l)111(o)230(æ)178(²)153()230(æ)178(²)179(³)
104(h)101(e)108(l)108(l)111(o)27801(沙)27827(河)
因为UTF8编码下一个中文汉字由3~4个字节组成，所以我们不能简单的按照字节去遍历一个包含中文的字符串，否则就会出现上面输出中第一行结果。
字符串底层是一个byte数组，所以可以和 []byte 类型相互转换。字符串是不能修改的 字符串是由byte字节组成,所以字符串的长度是byte字节的长度。rune类型
用来表示 utf8 字符，一个rune字符由一个或多个byte组成。
要修改字符串，需要先将其转换成 []rune 或 []byte,完成后再转换为 string。无论哪种转换，都会重新分配内存，并赋值字节数组。
func changeString() {
s1 := "big"
// 强制类型转换
byteS1 := []byte(s1)
byteS1[0] = ‘p‘
fmt.Println(string(byteS1))
s2 := "白萝卜"
runeS2 := []rune(s2)
runeS2[0] = ‘红‘
fmt.Println(string(runeS2))
}
Go语言中只有强制类型转换，没有隐式类型转换。该语法只能再两个类型之间支持相互转换的时候使用。
强制类型转换的基本语法如下:
T (表达式)
其中，T表示要转换的类型。
例子：
func sqrtDemo() {
var a, b = 3, 4
var c int
// math.Sqrt()接收的参数是float64类型，需要强制转换
c = int(math.Sqrt(float64(a*a + b*b)))
fmt.Println(c)
}
原文：https://www.cnblogs.com/zhukaijian/p/12879950.html