数据类型
布尔类型
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\n\n”
var str2 = `hello \n \n \n`
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\nc" // 有特殊字符 则转义
fmt.Println(d)
d = `an\nc` // 原样输出
fmt.Println(d)
}
func commonMethod() {
aa := "lol is bad, but i like play lol"
// 长度
aLen := len(aa)
fmt.Printf("aa的长度:%d\n", 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\n", aa[0], len(aa)) // aa[0]=h len(aa)=12 字节的长度 一个中文占3个字节
for index, str := range aa {
fmt.Printf("aa[%d]=%c\n", 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\n", len(aa)) // 12
var cc []rune
cc = []rune(aa)
fmt.Println(cc) // fmt.Printf("aa的长度:%d", len(aa))
fmt.Printf("cc的长度:%d\n", len(cc)) // 8
fmt.Printf("aa的长度:%d\n", len(aa)) // 12
fmt.Printf("aa[7] = %c\n", aa[7]) // aa[7] = ¸
fmt.Printf("cc[7] = %c\n", 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)
}