数据类型
布尔类型
a. var b bool 和 var b bool = true 和 var b = false
b. 操作符 == 和 !=
c. 取反操作符： !b
d. && 和 || 操作符
e. 格式化输出占位符: %t
package main import "fmt" func boolTest(){ var a bool = true var b bool //bool类型不给定值 默认false fmt.Println(a,b) // == 和 != fmt.Println(a == true, b== false, a != true) // 取反 ！ fmt.Printf("a取反 %t", !a) /* &&(都相同是才为true) || (有一个为true则结果就为true) */ if a == true && b == true{ fmt.Println("right") }else{ fmt.Println("no right") } if a == true && b == true{ fmt.Println("right") }else{ fmt.Println("no right") } // 格式化输出 用Printf %t fmt.Printf("a的值为:%t", a) /* true false true true false a取反 falseno right no right a的值为:true */ } func main(){ boolTest() }
整数和浮点型
a. int8、int16、int32、int64
b. uint8、uint16、uint32、uint64
c. int 和 uint，和操作系统平台相关
d. float32 和 float64浮点类型
e. 所有整数 初始化为0，所有浮点数初始化为0.0，布尔类型初始化为false
package main import "fmt" func boolTest(){ var a bool = true var b bool //bool类型不给定值 默认false fmt.Println(a,b) // == 和 != fmt.Println(a == true, b== false, a != true) // 取反 ！ fmt.Printf("a取反 %t", !a) /* &&(都相同是才为true) || (有一个为true则结果就为true) */ if a == true && b == true{ fmt.Println("right") }else{ fmt.Println("no right") } if a == true && b == true{ fmt.Println("right") }else{ fmt.Println("no right") } // 格式化输出 用Printf %t fmt.Printf("a的值为:%t", a) /* true false true true false a取反 falseno right no right a的值为:true */ } func intTest(){ var a1 int8 = 124 // -127-128 var a2 int = 885555555 fmt.Println(a1,a2) var a3 int // a3 =a1 不同的数据类型不能赋值 这样写 不对 应该 把 a1转为int类型 a3 = int(a1) fmt.Println(a3) var a4 uint8 = 100 // 无符号 0-128 fmt.Println(a4) /* 124 885555555 124 100 */ } func floatTest(){ var i float32 var j float64 = 258.336 var n float64 fmt.Println(i,j,n) } func main(){ //boolTest() // intTest() floatTest() /* 0 258.336 0 */ }
a. Go是强类型语言，不同类型相加以及赋值是不允许的
b. 那怎么样才能实现，不同类型相加呢？ 强转
c. 输出占位符：整数%d，%x十六进制，%f浮点数
字符串类型
a. var str string
b. var str string = “hello world”
c. 字符串输出占位符%s
d. 万能输出占位符: %v
字符串的两种 表示方法
a. 双引号， “”，可以包含控制字符
b. 反引号 ``所有字符都是原样输出
package main import “fmt” func main() { var str = “hello world ” var str2 = `hello ` fmt.Println(“str=“, str) fmt.Println(“str2=“, str2) }
字符串常用操作
a. 长度：len(str) b. 拼接：+，fmt.Sprintf c. 分割：strings.Split d. 包含： strings.Contains e. 前缀或后缀判断：strings.HasPrefix, strings.HasSuffix f. 字符串出现的位置: strings.Index(), strings.LastIndex() g. join操作： strings.Join(a[]string, sep string)
package main import ( "fmt" "strings" ) func jbyf() { var a string = "hello" var b = "world" c := "hello world " fmt.Println(a, b, c) var d = "an c" // 有特殊字符 则转义 fmt.Println(d) d = `an c` // 原样输出 fmt.Println(d) } func commonMethod() { aa := "lol is bad, but i like play lol" // 长度 aLen := len(aa) fmt.Printf("aa的长度:%d ", aLen) //aa的长度:31 // 字符串拼接 aaStr := "hello" + "world" fmt.Println(aaStr) // helloworld bbStr := fmt.Sprintf("%s-%s", "hello", "china") // hello-china fmt.Println(bbStr) // 字符串分割 cc := "i-n-j" dd := strings.Split(cc, "-") fmt.Println(dd) // [i n j] fmt.Println(dd[1]) // n // 包含 if strings.Contains(aa, "lol") { fmt.Println("aa is contains lol") } else { fmt.Println("aa is not contains lol") } // 前缀和后缀判断 if strings.HasPrefix(aa, "lol") { fmt.Println("aa is start lol") } else { fmt.Println("aa is not start lol") } if strings.HasSuffix(aa, "lol") { fmt.Println("aa is end lol") } else { fmt.Println("aa is not end lol") } // 自字符串出现的位置 fmt.Println(strings.Index(aa, "lol")) fmt.Println(strings.LastIndex(aa, "lol")) // Join 操作 var strArr [] string = [] string{"aa", "bb", "cc"} fmt.Println(strings.Join(strArr, "*")) } func main() { // jbyf() commonMethod() }
操作符
a. 逻辑操作符， == 、 != 、<、<=、>=
b. 算数操作符， +、-、* 、 /
go的基本结构
package main import "fmt" func main(){ fmt.Println("hello world") }
1. 任何一个代码文件隶属于⼀个包 2. import 关键字，引用其他包： import(“fmt”) import(“os”) 通常习惯写成： import ( “fmt” “os” )
3. 开发可执行程序，package main，
并且有且只有一个main入口函数
4. 包中函数调用：
a. 同一个包中函数，直接用函数名调用
b. 不同包中函数，通过包名+点+ 函数名 进行 调用
5. 包访问控制规则：
a. 大写意味着这个函数/变量是可导出的
b. 小写意味着这个函数/变量是私有的，
包外部不能访问
字符串原理解析
1. 字符串底层就是一个byte数组，所以可以和[]byte类型互相转换
2. 字符串中的字符是不能修改的，那怎么修改呢
3. 字符串是由byte字节组成，所以字符串的长度是byte字节的长度
4. rune类型用来表示utf8字符，一个rune字符由1个或多个byte组成
package main import "fmt" func main() { var aa = "hello 世界" fmt.Printf("aa[0]=%c len(aa)=%d ", aa[0], len(aa)) // aa[0]=h len(aa)=12 字节的长度 一个中文占3个字节 for index, str := range aa { fmt.Printf("aa[%d]=%c ", index, str) } /* aa[0]=h aa[1]=e aa[2]=l aa[3]=l aa[4]=o aa[5]= aa[6]=世 aa[9]=界 */ // 修改字符串 var bb []byte bb = []byte(aa) fmt.Println(bb) // [104 101 108 108 111 32 228 184 150 231 149 140] bb[0] = 'H' aa = string(bb) fmt.Println(aa) // Hello 世界 fmt.Printf("aa的长度:%d ", len(aa)) // 12 var cc []rune cc = []rune(aa) fmt.Println(cc) // fmt.Printf("aa的长度:%d", len(aa))
fmt.Printf("cc的长度:%d
", len(cc)) // 8
fmt.Printf("aa的长度:%d
", len(aa)) // 12
fmt.Printf("aa[7] = %c
", aa[7]) // aa[7] = ¸
fmt.Printf("cc[7] = %c
", cc[7]) // cc[7] = 界
}
字符串练习
练习1：写一个程序，对英问字符串进行逆序。
练习2：写一个程序，对包含中文的字符串进行逆序。
练习3：写一个程序，判断一个字符串是否是回文
package main import "fmt" // 写一个程序，对英问字符串进行逆序。 func ewreverse() string { var aa = "hello world" var bb []byte bb = []byte(aa) for i := 0; i < len(aa)/2; i++ { tem := bb[len(aa)-i-1] bb[len(bb)-i-1] = bb[i] bb[i] = tem } aa = string(bb) return aa } // 写一个程序，对包含中问的字符串进行逆序。 func zwreverse() string { var aa = "hello 世界" var bb []rune bb = []rune(aa) for i := 0; i < len(bb)/2; i++ { tem := bb[len(bb)-i-1] bb[len(bb)-i-1] = bb[i] bb[i] = tem } aa = string(bb) return aa } //写一个程序，判断一个字符串是否是回文 (正序和倒序一样) func testHuiwen() bool { var aa = "上海自来水来自海上" var bb []rune bb = []rune(aa) for i := 0; i < len(bb)/2; i++ { tem := bb[len(bb)-i-1] bb[len(bb)-i-1] = bb[i] bb[i] = tem } cc := string(bb) return cc == aa } func main() { // aa := ewreverse() // aa := zwreverse() aa := testHuiwen() fmt.Printf("aa=%t", aa) }