Go语言基础语法
- 一. golang 标识符，关键字，命名规则
- 二. golang 变量
- 三. golang 常量
- 四. golang 数据类型
- 五. golang 布尔类型
- 六. golang 数字类型
- 七. golang 字符串
- 1. go语言字符串字面量
- 2. go语言字符串连接
- (1). 使用加号
- (2). 使用 fmt.Sprintf() 函数
- (3). strings.Join()
- (4). buffer.WriteString()
- 3. go语言字符串转义字符
- 4. go语言字符串切片操作
- 5. go语言字符串常用方法
- 八. golang格式化输出
- 九. golang运算符
- 1. 算术运算符
- 2. 关系运算符
- 3. 逻辑运算符
- 4. 位运算符
- 5. 赋值运算符
- 十. golang流程控制
- 1. if 语句
- 2. if else 语句
- 3. if else if 语句
- 4. 嵌套 if 语句
- 4. switch语句
- 5. for 循环语句
- 6. for range 循环语句
一. golang 标识符，关键字，命名规则
二. golang 变量
三. golang 常量
四. golang 数据类型
五. golang 布尔类型
六. golang 数字类型
七. golang 字符串
1. go语言字符串字面量
在Go语言中，字符串字面量使用双引号 “” 或者反引号 ’ 来创建。双引号用来创建可解析的字符串，支持转义，但不能用来引用多行；反引号用来创建原生的字符串字面量，可能由多行组成，但不支持转义，并且可以包含除了反引号外其他所有字符。双引号创建可解析的字符串应用最广泛，反引号用来创建原生的字符串则多用于书写多行消息，HTML以及正则表达式。
package main
import (
"fmt"
)
func main() {
var s1 string = "hello world"
var s2 string = `
<html>
<head><title> hello world </title>
</html>
`
fmt.Printf("s1: %v\n", s1)
fmt.Printf("s2: %v\n", s2)
}
运行结果
s1: hello world
s2:
<html>
<head><title> hello world </title>
</html>
2. go语言字符串连接
(1). 使用加号
package main
import (
"fmt"
)
func main() {
name := "lyp"
age := "20"
msg := name + " is " + age
fmt.Printf("msg: %v\n", msg)
msg = ""
msg += name
msg += " is "
msg += age
fmt.Printf("msg: %v\n", msg)
}
运行结果
msg: lyp is 20
msg: lyp is 20
(2). 使用 fmt.Sprintf() 函数
package main
import (
"fmt"
)
func main() {
name := "lyp"
age := "20"
msg := fmt.Sprintf("%s is %s", name, age)
fmt.Printf("msg: %v\n", msg)
}
运行结果
msg: lyp is 20
(3). strings.Join()
package main
import (
"fmt"
"strings"
)
func main() {
name := "lyp"
age := "20"
msg := strings.Join([]string{name, age}, " is ")
fmt.Printf("msg: %v\n", msg)
}
运行结果
msg: lyp is 20
(4). buffer.WriteString()
package main
import (
"bytes"
"fmt"
)
func main() {
var buffer bytes.Buffer
buffer.WriteString("lyp")
buffer.WriteString(" is ")
buffer.WriteString("20")
fmt.Printf("buffer.String(): %v\n", buffer.String())
}
运行结果
buffer.String(): lyp is 20
3. go语言字符串转义字符
Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等，如下表所示
package main
import "fmt"
func main() {
fmt.Printf("hello\tworld\n")
fmt.Printf("\"c:\\test\\\"")
}
运行结果
hello world
"c:\test\"
4. go语言字符串切片操作
package main
import "fmt"
func main() {
str := "hello world"
n := 3
m := 5
fmt.Println(str[n]) //获取字符串索引位置为n的原始字节
fmt.Println(str[n:m]) //截取得字符串索引位置为 n 到 m-1 的字符串
fmt.Println(str[n:]) //截取得字符串索引位置为 n 到 len(s)-1 的字符串
fmt.Println(str[:m]) //截取得字符串索引位置为 0 到 m-1 的字符串
}
运行结果
108
lo
lo world
hello
5. go语言字符串常用方法
package main
import (
"fmt"
"strings"
)
func main() {
s := "hello world！"
fmt.Printf("len(s): %v\n", len(s))
fmt.Printf("strings.Split(s, \"\"): %v\n", strings.Split(s, " "))
fmt.Printf("strings.Contains(s, \"hello\"): %v\n", strings.Contains(s, "hello"))
fmt.Printf("strings.HasPrefix(s, \"hello\"): %v\n", strings.HasPrefix(s, "hello"))
fmt.Printf("strings.HasSuffix(s, \"world！\"): %v\n", strings.HasSuffix(s, "world！"))
fmt.Printf("strings.Index(s, \"l\"): %v\n", strings.Index(s, "l"))
fmt.Printf("strings.LastIndex(s, \"l\"): %v\n", strings.LastIndex(s, "l"))
}
运行结果
len(s): 14
strings.Split(s, ""): [hello world！]
strings.Contains(s, "hello"): true
strings.HasPrefix(s, "hello"): true
strings.HasSuffix(s, "world！"): true
strings.Index(s, "l"): 2
strings.LastIndex(s, "l"): 9
八. golang格式化输出
package main
import "fmt"
type WebSite struct {
Name string
}
func main() {
site := WebSite{Name: "lyp"}
fmt.Printf("site: %v\n", site)
fmt.Printf("site: %#v\n", site)
fmt.Printf("site: %T\n", site)
fmt.Println("%%")
b := true
fmt.Printf("b: %t\n", b)
i := 8
fmt.Printf("i: %v\n", i)
fmt.Printf("i: %b\n", i)
i = 96
fmt.Printf("i: %c\n", i)
fmt.Printf("i: %x\n", i)
x := 100
p := &x
fmt.Printf("p: %v\n", p)
}
运行结果
site: {lyp}
site: main.WebSite{Name:"lyp"}
site: main.WebSite
%%
b: true
i: 8
i: 1000
i: `
i: 60
p: 0xc000016120
九. golang运算符
1. 算术运算符
++（自增）和–（自减）在Go语言中是单独的语句，并不是运算符(不能用在表达式中)
package main
import "fmt"
func main() {
a := 100
b := 10
fmt.Printf("(a + b): %v\n", (a + b))
fmt.Printf("(a - b): %v\n", (a - b))
fmt.Printf("(a * b): %v\n", (a * b))
fmt.Printf("(a / b): %v\n", (a / b))
fmt.Printf("(a %% b): %v\n", (a % b))
a++
fmt.Printf("a: %v\n", a)
b--
fmt.Printf("b: %v\n", b)
}
2. 关系运算符
package main
import "fmt"
func main() {
a := 1
b := 2
fmt.Printf("(a > b): %v\n", (a > b))
fmt.Printf("(a < b): %v\n", (a < b))
fmt.Printf("(a >= b): %v\n", (a >= b))
fmt.Printf("(a <= b): %v\n", (a <= b))
fmt.Printf("(a == b): %v\n", (a == b))
fmt.Printf("(a != b): %v\n", (a != b))
}
3. 逻辑运算符
package main
import "fmt"
func main() {
a := true
b := false
fmt.Printf("(a && b): %v\n", (a && b))
fmt.Printf("(a || b): %v\n", (a || b))
fmt.Printf("(!a): %v\n", (!a))
fmt.Printf("(!b): %v\n", (!b))
}
4. 位运算符
package main
import "fmt"
func main() {
a := 4 // 二进制 100
fmt.Printf("a: %b\n", a)
b := 8 // 二进制 1000
fmt.Printf("b: %b\n", b)
fmt.Printf("(a & b): %v, %b \n", (a & b), (a & b))
fmt.Printf("(a | b): %v, %b\n", (a | b), (a | b))
fmt.Printf("(a ^ b): %v, %b\n", (a ^ b), (a ^ b))
fmt.Printf("(a << 2): %v, %b\n", (a << 2), (a << 2))
fmt.Printf("(b >> 2): %v, %b\n", (b >> 2), (b >> 2))
}
5. 赋值运算符
package main
import "fmt"
func main() {
var a int
a = 100
fmt.Printf("a: %v\n", a)
a += 1 // a = a + 1
fmt.Printf("a: %v\n", a)
a -= 1 // a = a -1
fmt.Printf("a: %v\n", a)
a *= 2 // a = a * 2
fmt.Printf("a: %v\n", a)
a /= 2 // a = a / 2
fmt.Printf("a: %v\n", a)
}
十. golang流程控制
1. if 语句
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
}
(1). 不需使用括号将条件包含起来
(2). 大括号{}必须存在，即使只有一行语句
(3). 左括号必须在if或else的同一行
(4). 在if之后，条件语句之前，可以添加变量初始化语句，使用；进行分隔
(5). 不能使用0或非0表示真假
func test3() {
if age := 20; age > 18 {
fmt.Println("你是成年人")
}
fmt.Printf("程序运行结束")
}
func main() {
// test1()
// test2()
test3()
}
func test4() {
var i = 1
if i { // 编译失败
fmt.Println("here")
}
fmt.Printf("程序运行结束")
}
2. if else 语句
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
} else {
/* 在布尔表达式为 false 时执行 */
}
func f2() {
var s int
fmt.Println("输入一个数字：")
fmt.Scan(&s)
if s%2 == 0 {
fmt.Print("s 是偶数\n")
} else {
fmt.Print("s 不是偶数\n")
}
fmt.Print("s 的值是：", s)
}
3. if else if 语句
if 布尔表达式1 {
// do something
} else if 布尔表达式2 {
// do something else
}else {
// catch-all or default
}
func f5() {
if score := 80; score >= 60 && score <= 70 {
fmt.Println("C")
} else if score > 70 && score <= 90 {
fmt.Println("B")
} else {
fmt.Println("A")
}
}
4. 嵌套 if 语句
if 布尔表达式 1 {
/* 在布尔表达式 1 为 true 时执行 */
if 布尔表达式 2 {
/* 在布尔表达式 2 为 true 时执行 */
}
}
func f2() {
// 判断男女生及年龄
gender := "女生"
age := 16
if gender == "男生" {
fmt.Println("男生")
if age > 18 {
fmt.Println("成年")
} else {
fmt.Println("未成年")
}
} else {
fmt.Println("女生")
if age > 18 {
fmt.Println("成年")
} else {
fmt.Println("未成年")
}
}
}
4. switch语句
switch var1 {
case val1:
...
case val2:
...
default:
...
}
func f() {
grade := "A"
switch grade {
case "A":
fmt.Println("优秀")
case "B":
fmt.Println("良好")
default:
fmt.Println("一般")
}
}
多条件匹配
func f() {
day := 3
switch day {
case 1, 2, 3, 4, 5:
fmt.Println("工作日")
case 6, 7:
fmt.Println("休息日")
}
}
case 可以是条件表达式
func f() {
score := 90
switch {
case score >= 90:
fmt.Println("享受假期")
case score < 90 && score >= 80:
fmt.Println("好好学习吧！")
default:
fmt.Println("玩命学习！")
}
}
fallthrough 强制执行后面的一个 case 代码
fallthrough 不能用在switch的最后一个分支
switch {
case false:
fmt.Println("The integer was <= 4")
fallthrough
case true:
fmt.Println("The integer was <= 5")
fallthrough
case false:
fmt.Println("The integer was <= 6")
fallthrough
case true:
fmt.Println("The integer was <= 7")
fallthrough
case false:
fmt.Println("The integer was <= 8")
default:
fmt.Println("default case")
}
5. for 循环语句
go语言中的 for 循环，只有 for 关键字，去除了像其他语言中的 while 和 do while
for 初始语句;条件表达式;结束语句{
循环体语句
}
func f() {
for i := 1; i <= 10; i++ {
fmt.Printf("i: %v\n", i)
}
}
func f() {
i := 1
for ; i <= 10; i++ {
fmt.Printf("i: %v\n", i)
}
}
func f() {
i := 1 // 初始条件
for i <= 10 {
fmt.Printf("i: %v\n", i)
i++ // 结束条件
}
}
for循环可以通过 break goto return panic 语句强制退出循环。
6. for range 循环语句
Go语言中可以使用 for range 遍历数组、切片、字符串、map 及通道(channel)。通过for range遍历的返回值有以下规律
1.数组、切片、字符串返回索引和值。
2.map返回建和值。
3.通道(channel)只返回通道内的值。
// 循环数组
func f() {
var a = [5]int{1, 2, 3, 4, 5}
for i, v := range a {
fmt.Printf("i: %d, v: %v\n", i, v)
}
}
func main() {
f()
}
// 循环字符串
func f() {
var s = "多课网，go教程"
for i, v := range s {
fmt.Printf("i: %d, v: %c\n", i, v)
}
// %c 按照字符输出
}
func main() {
f()
}
// 循环切片
func f() {
var s = []int{1, 2, 3, 4, 5}
for i, v := range s {
fmt.Printf("i, %d, v: %v\n", i, v)
}
}
func main() {
f()
}
// 循环 map
func f() {
m := make(map[string]string)
m["name"] = "tom"
m["age"] = "20"
m["email"] = "tom@gmail.com"
for k, v := range m {
fmt.Printf("k: %v, v: %v\n", k, v)
}
}
func main() {
f()
}
