金泉网做网站电话,老薛主机 wordpress,个人网站做微擎,网站SEM优化如何做变量声明:批量声明变量:变量赋值: 声明变量同时为变量赋值可以在变量声明时为其赋值go中赋值时的编译器会自动根据等号右侧的数据类型自动推导变量的类型使用 : 进行赋值匿名变量 常量常量计数器iota1. 使用场景2. 基本用法3. 简化语法4. 自定义增量5. 复杂使用go的类似枚举 使…变量声明:批量声明变量:变量赋值: 声明变量同时为变量赋值可以在变量声明时为其赋值go中赋值时的编译器会自动根据等号右侧的数据类型自动推导变量的类型使用 : 进行赋值匿名变量 常量常量计数器iota1. 使用场景2. 基本用法3. 简化语法4. 自定义增量5. 复杂使用go的类似枚举 使用 const 和 iota 定义枚举 使用 map 实现枚举附加Galang(二) 基本数据类型字符串 字符串转义符多行字符串常用字符串操作 byte 和 rune 类型 修改字符串 类型转换 基本语法 流程控制1. 条件语句if 语句switch 语句2. 循环语句基本的 for 循环for 循环与条件无限循环for range 循环 用于遍历数组、切片、字符串、映射map等数据结构。3. 跳转语句break 语句continue 语句goto 语句 变量声明:
变量的声明以 var 关键字开头,后面是变量名,最后是变量的类型,在java中一般使用分号结尾,go则写不写都行,一般不写
var 变量名 变量的类型var id int
var name string批量声明变量:
使用 var( ) 括号中 写 变量名 变量的类型var (变量名 变量的类型变量名 变量的类型变量名 变量的类型
)var (id intname string
)变量赋值:
go中的变量在声明时会自动初始化,与数字相关的变量默认为 0 ,字符串默认为 “” ,布尔值默认是 false ;切片,函数和指针默认是 nil (nil是go中的空)声明变量同时为变量赋值
var 变量名 类型 值var id int 1
var name string 张三可以在变量声明时为其赋值
//多个变量以逗号分隔,等号后的值按照先后顺序赋值
var id ,name 1 , 张三var (id int 1name string 张三
)go中赋值时的编译器会自动根据等号右侧的数据类型自动推导变量的类型
//可以省略变量类型
var (id 1name 张三
)使用 : 进行赋值
还可以使用简写 : 方式声明变量并初始化 这种方法只能在函数内部使用:是一个简短声明符short variable declaration operator用于在声明变量时简化语法。它允许程序员在声明变量的同时进行初始化。 使用:声明的变量的作用域是局部的也就是说在函数内部使用:声明的变量只能在该函数内部访问。如果在函数外部使用该符号会导致编译错误。 :只能用于声明新变量。如果变量已经被声明就不能再使用:方式来赋值必须使用运算符。 可以在同一行中使用:来同时声明多个变量 func main() {id : 10name : 200 fmt.Println(m, n)//将id name在控制台输出
}匿名变量
匿名变量使用 下划线 _ 来表示 ,作用是可以忽略某个值, 可以用来占位 ,此变量不占用命名空间,同时也不会为其分配内存
//t1 函数返回两个int 类型的值
func t1() (int, int) {return 1, 2
}
func main() {i, _ : t1()//函数返回的 2 被忽略_, j : t1()//函数返回的 1 被忽略fmt.Println(i, j) //输出 1,2
}在for循环中使用
在迭代的过程中如果只关心索引或值中的一个部分可以使用匿名变量。这使得代码更加简洁。示例
package mainimport fmtfunc main() {pairs : []struct {x, y int}{{1, 2},{3, 4},{5, 6},}for _, v : range pairs {fmt.Println(v.x) // 只使用x忽略y}
}常量
常量是程序中不可改变的值。常量在声明后不能被重新赋值。
使用const关键字声明常量
const Pi 3.14类型推断常量可以在声明时指定类型也可以省略编译器会根据值自动推断。
const (
e 2.71828 // 无类型常量
c int 299792458 // 指定类型常量
)作用域
常量的作用域和变量相似可以是局部的或包级别的。 示例 package mainimport fmtconst Pi 3.14 // 声明常量func main() {
fmt.Println(Pi:, Pi)
// Pi 3.14159 // 这将导致编译错误因为常量不能被修改
}| 特性 | 变量 | 常量 |
|----------------|--------------------------|---------------------------|
| 可变性 | 可以被修改 | 不可被修改 |
| 声明关键字 | var 或简短声明符 : | const |
| 声明时类型 | 可选 | 可选 |
| 内存使用 | 占用内存 | 编译时确定无需占用运行时内存 |
| 作用域 | 局部或包级别 | 局部或包级别 |
常量计数器iota
在Go语言中iota是一个预定义的标识符用于简化常量的创建尤其是在需要一系列相关常量时。
iota的值在每个常量声明块中自动递增从0开始。
1. 使用场景
iota通常用于定义一组具有相关性的常量例如枚举值、位掩码等。
2. 基本用法
在一个常量声明中每个常量的iota值会从0开始并在每行中自动递增1。
package mainimport fmtconst (A iota // 0B iota // 1C iota // 2
)func main() {fmt.Println(A, B, C) // 输出: 0 1 2
}
3. 简化语法
在同一个常量声明块中可以省略iota它仍然会正确递增。
package mainimport fmtconst (X iota // 0Y // 1自动从上一个常量继承iota值Z // 2
)func main() {fmt.Println(X, Y, Z) // 输出: 0 1 2
}
4. 自定义增量
可以在常量声明中使用算术运算与iota结合创建具有特定增量的常量。例如如果希望常量的值是2的倍数可以这样做
package mainimport fmtconst (_ iota // 忽略第一个值0Two iota * 2 // 2Four iota * 2 // 4Six iota * 2 // 6
)func main() {fmt.Println(Two, Four, Six) // 输出: 2 4 6
}
5. 复杂使用
iota还可以与位移、位运算等结合使用在需要创建位掩码时非常方便。
package mainimport fmtconst (Flag1 1 iota // 1 0值为1Flag2 // 1 1值为2Flag3 // 1 2值为4Flag4 // 1 3值为8
)func main() {fmt.Println(Flag1, Flag2, Flag3, Flag4) // 输出: 1 2 4 8
}
go的类似枚举
在 Go 1.13 及更高版本中虽然没有引入传统意义上的枚举类型但可以通过使用 const 和 iota 来实现类似的功能 并且可以通过 string 类型的方法来增强枚举的可读性和可维护性。
使用 const 和 iota 定义枚举
在这个例子中我们定义了一个 Weekday 类型并使用 iota 来生成枚举值。然后我们为 Weekday 类型实现了 String 方法这样在打印枚举值时会输出对应的字符串名称而不是整数值。
package mainimport fmttype Weekday intconst (Sunday Weekday iotaMondayTuesdayWednesdayThursdayFridaySaturday
)func (w Weekday) String() string {return [...]string{Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday}[w]
}func main() {fmt.Println(Sunday) // 输出: Sundayfmt.Println(Monday) // 输出: Mondayfmt.Println(Tuesday) // 输出: Tuesdayfmt.Println(Wednesday) // 输出: Wednesdayfmt.Println(Thursday) // 输出: Thursdayfmt.Println(Friday) // 输出: Fridayfmt.Println(Saturday) // 输出: Saturday
}使用 map 实现枚举
另一种方法是使用 map 来实现枚举这样可以更灵活地处理枚举值和名称之间的映射。
package mainimport fmttype Weekday intconst (Sunday Weekday iotaMondayTuesdayWednesdayThursdayFridaySaturday
)var weekdayNames map[Weekday]string{Sunday: Sunday,Monday: Monday,Tuesday: Tuesday,Wednesday: Wednesday,Thursday: Thursday,Friday: Friday,Saturday: Saturday,
}func (w Weekday) String() string {return weekdayNames[w]
}func main() {fmt.Println(Sunday) // 输出: Sundayfmt.Println(Monday) // 输出: Mondayfmt.Println(Tuesday) // 输出: Tuesdayfmt.Println(Wednesday) // 输出: Wednesdayfmt.Println(Thursday) // 输出: Thursdayfmt.Println(Friday) // 输出: Fridayfmt.Println(Saturday) // 输出: Saturday
}附加
2. 布尔类型
类型bool
常量true和false分别为0 0和0 ! 0的值。
3. 整数类型
无符号整数uint8范围0至255。
uint16范围0至65535。
uint32范围0至4294967295。
uint64范围0至18446744073709551615。
带符号整数int8范围-128至127。
int16范围-32768至32767。
int32范围-2147483648至2147483647。
int64范围-9223372036854775808至9223372036854775807。
int至少32位的带符号整数不是int32的别名。
uint至少32位的无符号整数不是uint32的别名。
4. 浮点数和复数类型
浮点数
float32和float64分别为IEEE 754格式的32位和64位浮点数。
复数
complex64和complex128分别为具有float32和float64实部和虚部的复数。
5. 字符串和字节
类型
string表示8位字节字符串通常表示UTF-8编码文本。
byte是uint8的别名通常用于表示字节值。
rune是int32的别名用于表示字符值。
6. 预声明标识符
nil表示指针、通道、函数、接口、映射或切片类型的零值。
iota表示当前常量声明中的未类型化整数序号从0开始递增。
any是interface{}的别名表示可以接受任何类型的空接口。
comparable一个接口所有可比较类型布尔、数字、字符串等都实现该接口但它只能作为类型参数的约束而不能作为变量的类型。
7. 内置函数
基本操作append将元素追加到切片末尾。copy从源切片复制元素到目标切片。delete从映射中删除指定键的元素。len返回值的长度。cap返回切片或通道的容量。
内存管理make用于分配和初始化切片、映射或通道。new分配内存并返回指向新分配零值的指针。
数学操作max返回一组值中的最大值。min返回一组值中的最小值。complex、real、imag用于复数的创建和获取实部、虚部。
通道操作close关闭通道。clear清空映射和切片。
错误处理panic停止当前goroutine的正常执行。recover恢复正在恐慌的goroutine的正常执行。
打印输出print和println将数据格式化并写入标准错误。
8. 错误接口error表示错误条件的常规接口nil值表示没有错误。Galang(二) 基本数据类型
字符串
Go语言中的字符串以原生数据类型出现使用字符串就像使用其他原生数据类型int、bool、float32、float64 等一样。 Go 语言里的字符串的内部实现使用UTF-8 编码。 字符串的值为双引号() 中的内容可以在Go语言的源码中直接添加非ASCII码字符
s1 : hello Word字符串转义符
\r回车符返回行首\n换行符直接跳到下一行的同列位置\t制表符\’单引号\”双引号\反斜杠
多行字符串
Go语言中要定义一个多行字符串时就必须使用反引号字符
s1 : 第一行
第二行
第三行fmt.Println(s1)常用字符串操作
方法作用len(str)求长度或fmt.Sprintf拼接字符型strings.Split分割strings.contains判断是否包含strings.HasPrefix strings.HasSuffix前缀 后缀判断strings.Index() strings.LastIndex()子串出现的位置strings.Join(a[]string, sep string)join操作
package mainimport (fmtstrings
)func main() {// 定义字符串str : Hello, World! Welcome to Go programming.// 1. 求长度length : len(str)fmt.Println(字符串长度:, length)// 2. 拼接字符型str2 : Enjoy learning!concatenated : str str2fmt.Println(拼接后的字符串:, concatenated)// 3. 分割// 注意分割后的部分是字符串数组不是切片parts : strings.Split(str, )fmt.Println(分割后的部分:, parts[0], parts[1], parts[2])// 4. 判断是否包含containsHello : strings.Contains(str, Hello)fmt.Println(包含 Hello?, containsHello)// 5. 前缀和后缀判断hasPrefix : strings.HasPrefix(str, Hello)hasSuffix : strings.HasSuffix(str, programming.)fmt.Println(以 Hello 开头?, hasPrefix)fmt.Println(以 programming. 结尾?, hasSuffix)// 6. 子串出现的位置index : strings.Index(str, World)lastIndex : strings.LastIndex(str, o)fmt.Println(World 出现的位置:, index)fmt.Println(o 最后出现的位置:, lastIndex)// 7. join操作words : []string{Go, is, great!}joined : strings.Join(words, )fmt.Println(连接后的字符串:, joined)// 8. 替换replaced : strings.Replace(str, World, Gopher, 1)fmt.Println(替换后的字符串:, replaced)// 9. 大小写转换upper : strings.ToUpper(str)lower : strings.ToLower(str)fmt.Println(全大写:, upper)fmt.Println(全小写:, lower)// 10. 去掉空白strWithSpaces : Hello, World! trimmed : strings.TrimSpace(strWithSpaces)fmt.Println(去掉空白后的字符串:, trimmed)// 11. 判断是否为空if str {fmt.Println(字符串是空的)} else {fmt.Println(字符串不是空的)}// 12. 格式化字符串name : Goversion : 1.18formatted : fmt.Sprintf(%s programming language version %.2f, name, version)fmt.Println(格式化字符串:, formatted)// 13. 多个替换replacer : strings.NewReplacer(Hello, Hi, World, Gopher)newStr : replacer.Replace(str)fmt.Println(多个替换后的字符串:, newStr)}
byte 和 rune 类型
组成每个字符串的元素叫做“字符”可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号’包裹起来
byte 适合用于处理ASCII字符及二进制数据常用于文件和网络数据的操作。 rune 更适合处理包含Unicode字符的字符串能够处理各种语言的字符是进行国际化开发时不可或缺的类型。
var a 中
var b xGo 语言的字符有以下两种uint8类型或者叫 byte 型代表了ASCII码的一个字符。 rune类型代表一个UTF-8字符。 当需要处理中文、日文或者其他复合字符时则需要用到rune类型。rune类型实际是一个int32
// 遍历字符串
func traversalString() {s : hello世界for i : 0; i len(s); i { //bytefmt.Printf(%v(%c) , s[i], s[i])}fmt.Println()for _, r : range s { //runefmt.Printf(%v(%c) , r, r)}fmt.Println()
}输出:
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) 19990(世) 30028(界)因为UTF8编码下一个中文汉字由3~4个字节组成所以我们不能简单的按照字节去遍历一个包含中文的字符串否则就会出现上面输出中第一行的结果
字符串底层是一个byte数组所以可以和[]byte 类型相互转换。字符串是不能修改的 字符串是由byte字节组成所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符一个rune字符由一个或多个byte组成
修改字符串
要修改字符串需要先将其转换成[]rune或[]byte完成后再转换为string。无论哪种转换都会重新分配内存并复制字节数组
package mainimport (fmt
)func main() {// 使用 byte 处理 ASCII 字符var b byte Afmt.Println(byte 类型:, b)// 使用 rune 处理 Unicode 字符var r rune 汉fmt.Println(rune 类型:, r)// 字符串中的字节和字符数str : Hello, 世界!fmt.Println(字符串的字节数:, len(str))// 使用 range 遍历字符串中的字符fmt.Println(字符和对应的 rune值:)for i, c : range str {fmt.Printf(索引 %d: 字符 %c, rune 值 %d\n, i, c, c)}
}
类型转换
在 Go 语言中类型转换是将一个数据类型的值转换为另一个数据类型的过程。Go 语言提供了安全和明确的类型转换机制以确保类型的一致性。
基本语法
类型转换的基本语法如下
newType(expression) 其中 newType 是目标类型expression 是要转换的值。
基本数值类型的转换
package mainimport fmtfunc main() {var a int 10var b float64 float64(a) // int 转换为 float64fmt.Println(int:, a)fmt.Println(float64:, b)var c float64 3.14var d int int(c) // float64 转换为 int会丢失小数部分fmt.Println(float64:, c)fmt.Println(int:, d)
}
字符与整数的转换
package mainimport fmtfunc main() {var r rune A // 字符 Avar b byte byte(r) // rune 转换为 bytevar ascii int int(b) // byte 转换为 intfmt.Printf(rune: %c, byte: %d, ascii: %d\n, r, b, ascii) // 输出: rune: A, byte: 65, ascii: 65
}
字符串与字节切片的转换package mainimport fmtfunc main() {str : Hello, Go!// 字符串转换为字节切片byteSlice : []byte(str)fmt.Println(Byte Slice:, byteSlice)// 字节切片转换为字符串newStr : string(byteSlice)fmt.Println(String:, newStr)
}接口转换 Go 语言中的类型转换也包括接口类型的转换。可以将实现了某个接口的类型转换为该接口。package mainimport fmttype Animal interface {Speak() string
}type Dog struct{}func (d Dog) Speak() string {return Woof!
}func main() {var a Animal // 接口类型a Dog{} // 赋值实现了 Animal 接口的 Dog 类型// 类型断言if dog, ok : a.(Dog); ok {fmt.Println(它是狗叫声:, dog.Speak())}
}流程控制
1. 条件语句
Go 中的条件语句主要有 if 和 switch。
if 语句
用来根据条件执行特定的代码块。
package mainimport (fmt
)func main() {age : 18if age 18 {fmt.Println(未成年人)} else if age 18 age 65 {fmt.Println(成年人)} else {fmt.Println(老年人)}
}
switch 语句
用于多条件判断它比多个 if 语句更简洁。
package mainimport (fmt
)func main() {day : 3switch day {case 1:fmt.Println(星期一)case 2:fmt.Println(星期二)case 3:fmt.Println(星期三)default:fmt.Println(其他天)}
}
一个分支可以有多个值多个case值中间使用英文逗号分隔。
func testSwitch3() {switch n : 7; n {case 1, 3, 5, 7, 9:fmt.Println(奇数)case 2, 4, 6, 8:fmt.Println(偶数)default:fmt.Println(n)}
}分支还可以使用表达式这时候switch语句后面不需要再跟判断变量
func switchDemo4() {age : 30switch {case age 25:fmt.Println(好好学习吧)case age 25 age 35:fmt.Println(好好工作吧)case age 60:fmt.Println(好好享受吧)default:fmt.Println(活着真好)}
}fallthrough语法可以执行满足条件的case的下一个case是为了兼容C语言中的case设计的
func switchDemo5() {s : aswitch {case s a:fmt.Println(a)fallthroughcase s b:fmt.Println(b)case s c:fmt.Println(c)default:fmt.Println(...)}
}输出 a b
2. 循环语句
Go 语言中提供了 for 循环来实现循环使用非常灵活。
基本的 for 循环
package mainimport (fmt
)func main() {for i : 0; i 5; i {fmt.Println(计数:, i)}
}
for 循环与条件
也可以使用 for 循环形式的条件判断。
package mainimport (fmt
)func main() {i : 0for i 5 {fmt.Println(计数:, i)i}
}
无限循环
使用 for 后不加条件即可形成无限循环。
循环可以通过break、goto、return、panic语句强制退出循环。
package mainimport (fmt
)func main() {i : 0for {if i 5 {break // 使用 break 退出循环}fmt.Println(计数:, i)i}
}
for range 循环 用于遍历数组、切片、字符串、映射map等数据结构。
基本语法
for range 的基本语法如下
for index, value : range collection {// 使用 index 和 value
}
index 是当前元素的索引对于数组、切片和字符串。
value 是当前元素的值。
collection 是需要遍历的集合可以是数组、切片、字符串或映射等。遍历切片
package mainimport (fmt
)func main() {names : []string{Alice, Bob, Charlie}for index, name : range names {fmt.Printf(索引: %d, 名称: %s\n, index, name)}
}遍历数组
package mainimport (fmt
)func main() {numbers : [5]int{1, 2, 3, 4, 5}for index, number : range numbers {fmt.Printf(索引: %d, 数字: %d\n, index, number)}
}遍历字符串 for range 还能用来遍历字符串每次迭代返回一个字符和它的 Unicode 码点。
package mainimport (fmt
)func main() {str : 你好, 世界!for index, char : range str {fmt.Printf(索引: %d, 字符: %c\n, index, char)}
}遍历映射 (map)
package mainimport (fmt
)func main() {ages : map[string]int{Alice: 25,Bob: 30,Charlie: 35,}for name, age : range ages {fmt.Printf(%s 的年龄是: %d\n, name, age)}
}3. 跳转语句
Go 中的跳转语句包括 break、continue 和 goto。
break 语句
用于跳出循环或 switch 语句。
package mainimport (fmt
)func main() {for i : 0; i 10; i {if i 5 {break // 当 i 等于 5 时跳出循环}fmt.Println(计数:, i)}
}
continue 语句
用于跳过当前循环的剩余部分进入下一次循环。
package mainimport (fmt
)func main() {for i : 0; i 10; i {if i%2 0 {continue // 跳过偶数}fmt.Println(奇数:, i)}
}
goto 语句
允许程序跳转到指定标签。使用要谨慎因为可能会导致代码可读性降低。
package mainimport (fmt
)func main() {i : 0
CountLoop:fmt.Println(计数:, i)iif i 5 {goto CountLoop // 跳转到 CountLoop 标签}
}
