标识符与关键字
标识符
在编程语言中标识符就是程序员定义的具有特殊意义的词。
关键字
关键字是指编程语言中预先定义好的具有特殊意义的字。
变量的来历
变量的类型
变量的声明
标准声明
声明变量
var str string;声明变量类型
package main
// 批量声明
import "fmt"
var (name string
age int
isOk bool)
func main(){
name = "小王"
age = 14
isOk = true
// Go语言中变量声明必须使用，不使用就编译不过去
fmt.Printf("name:%s",name)
fmt.Println();
fmt.Print(isOk)
fmt.Println();
fmt.Println(age)
}变量声明赋值(代码段)
// 声明变量同时赋值
var baby string = "yan"
fmt.Println(baby)
// 类型推导（根据值的判断类型）
var s2 = "heiheihei"
fmt.Println(s2)
s3 := "heiheihei"
fmt.Println()
fmt.Print(s3)
fmt.Println()常量
定义了常量之后就不可以修改
在程序运行期间不会改变的量
常量使用
package main
// 常量
const pi = 3
func main (){
}常量默认声明
// 如果批量声明常量是，如果某一行没有赋值，默认就和上一行一致
const (
n1 = 100
n2
n3
)iota
iota 是go语言的常量计数器，只能在在常量的表达式中使用。
iota在const关键字出现时将被重置为0.const中每新增一行常量将使iota计数增加一次。使用iota能简化定义，在定义枚举时很有用。
const (
s1 = iota
s2
s3
s4
)
func main (){
fmt.Println("s1:",s1)
fmt.Println("s2:",s2)
fmt.Println("s3:",s3)
}Go语言之基本数据类型
常见数据类型
整型
整形分为以下两个大类：无符号和有符号
特殊类型
unint
int
uintptr 无符号整形，用于存放一个指针
八进制&十六进制
Go语言中无法直接定义，关于八进制和十六进制。
o 开头的就是八进制
0x开头的就是 16进制
浮点型
package main
import "fmt"
import "math"
func main(){
f1 := 12.45
fmt.Printf("%f\n",f1);
const f2 = math.MaxFloat32; // 最大的数
fmt.Printf("%f\n",f2);
f3 := 1.123456
fmt.Printf("%T\n",f3) // 默认Go 语言中的小数是float64类型
f4 := float32(1,234532)
fmt.Printf("%T\n",f4)
f5 = f4 // float32类型的值不能直接赋值给float64类型的变量
}复数
complex64 和complex128
var c1 complex64
c1 = 1+ 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)复数有实部和虚部，complex64的实部和虚部为33位，complex的实部和虚部为64位
布尔值
Go语言中以 bool 类型进行声明布尔型数据，布尔型数据只有true和false两个
package main
import "fmt"
// bool 默认是false
var (v bool)
func main(){
fmt.Println(v);
}1.布尔值类型变量的默认值为false
2.Go语言中不允许将整型强制转换为布尔型
3.布尔型无法参与数值运算，也无法与其他类型转换
字符串类型
Go语言中的字符串已原生数据类型出现，使用字符串就像其他原生数据类型一样。
Go语言里面的字符串的内部事项使用UTF-8b编码。字符串的职位双引号中内容，可以在Go语言的源码里面加入ASCII码字符，例如：
s1 = "hello"
s3="你好"
// 字节 ： 1 字节 = 8bit
1 个字符 “A” = 1 个字节
// 1个utf8编码的汉字‘沙’= 一般占3个字节字符串如何拼接
name : = "hello"
w: = "world"
fmt.Println(ss);
ss1 := fmt.Sprintf("%s%s",name,world)
fmt.PrintF("%s%s",name,world)
fmt.Println(ss1)
ret := strings.Split(ss,"\\")
fmt.Println(ret)字符串的方法
Split 按字符分割成新的数组
Contains 字符串是否包含某个字符
HasPrefix 字符串以什么开头
HasSuffix 字符串以什么结尾
name := "hello";
world :="world!";
ss := name + world
fmt.Println(ss)
ss1 := fmt.Sprintf("%s%s",name,world)
fmt.Println(ss1)
ret := strings.Split(ss,"\\")
fmt.Println(ret)
ret1 := strings.Contains(ss1,"world")
fmt.Println(ret1)
ret2 := strings.HasPrefix(ss1,"hello")
fmt.Println(ret2)
ret3 := strings.HasSuffix(ss1,"world")
fmt.Println(ret3)
ret4 := strings.Index(ss1,"or")
fmt.Println(ret4)
ret5 := strings.LastIndex(ss1,"or")
fmt.Println(ret5)
// ret6 := strings.Join(ss1," ")
// fmt.Println(ret6)
helloworld!
helloworld!
[helloworld!]
true
true
false
6
6字符串修改及类型转换
byte 和 rune类型
Go语言中为处理非ASCII码类型的字符 定义了行的rune类型
package main
import "fmt"
func main(){
s:= "bsx"
// len() 求得是byte字节的数量
n := len(s) // 求得字符串s的长度，把长度保存到变量n中
fmt.Println(n);
// fmt.Println(n)
// for i := 0; i < len(s); i ++{
// fmt.Println(s[i])
// fmt.Printf("%c\n",s[i])// %c：字符
// }
for _,c :=range s{ // 字符串中拿出具体的字符
fmt.Printf("%c\n",c)// %c: 具体字符
}
}Go语言的字符有以下两种：
uint8类型，或者叫byte类型，代表了ASCII码的一个字符。
runt类型，代表一个UTF-8字符
当需要处理中文、日文或者其他复合字符是，则需要用到rune类型，rune类型实际上是一个int32位
Go使用了特殊的rune类型来处理Unicode，让基于Unicode的文本处理更为方便，也可以使用byte类型进行默认处理，性能和扩展性都有照顾
for i := 0; i < len(s); i ++{
fmt.Println(s[i])
fmt.Printf("%c\n",s[i])// %c：字符
}
for _,c :=range s{ // 字符串中拿出具体的字符
fmt.Printf("%c\n",c)// %c: 具体字符
}修改字符串
要修改字符创，需要先件其转换为[]rune或者[]byte，完成后再转换为string.无论哪种转换，都会重新分配内存，并复制字节 数组
package main
func main(){
s2 := "白萝卜"; // '白', '萝','卜'
s3 := []rune(s2);// 把字符串强制转换为一个rune切片
s3 [0] = '红';
fmt.Println(string(s3))// 把切片强制转换为字符串
}
// 这里的单引号和双引号是不同的
// 单引号是 int32位
// 双引号是string类型
