第一个Go程序
package main
import "fmt"
func main() {
fmt.Println("hello world")
}
运行方式1：
go run main.go
运行方式2：
go build
.\hello_go.exe
运行方式3：goland右键运行
字符串拼接
使用加号可以对字符串进行拼接。
package main
import "fmt"
func main() {
fmt.Println("hello world" + "你好世界")
}
变量的声明和初始化
package main
import "fmt"
func main() {
var a, b, c int
a = 11
b = 22
c = 333
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
}
简短的声明
上面的变量定义和初始化有更简单的方式，如下：
package main
import "fmt"
func main() {
a := 11
b := 22
c := 333
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
}
格式化输出
使用%d可以在字符串中格式化输入整数类型，如下：
package main
import "fmt"
func main() {
a := 11
b := 22
c := 333
fmt.Printf("a=%d, b=%d, c=%d\n", a, b, c)
}
if语句
if语句主要有三种格式，如下：
package main
import "fmt"
func main() {
a := 33
// 单分支
if a > 0 {
fmt.Println(a)
}
// 双分支
if a < 0 {
fmt.Println(a)
} else {
fmt.Println(a + a)
}
// 多分支
if a > 100 {
fmt.Println(a)
} else if a > 0 {
fmt.Println(a + a)
} else {
fmt.Println(a + a + a)
}
}
for循环
累加求和：
package main
import "fmt"
func main() {
sum := 0
for i := 0; i < 101; i++ {
sum += i
}
fmt.Println(sum)
}
双重for循环打印九九乘法表
package main
import "fmt"
func main() {
for i := 1; i < 10; i++ {
for j := 1; j <= i; j++ {
fmt.Printf("%d * %d = %d\t", j, i, i*j)
}
fmt.Println()
}
}
for遍历数组
package main
import "fmt"
func main() {
arr := []int{11, 22, 33}
for k, v := range arr {
fmt.Println(k, v)
}
}
for 遍历字符串
package main
import "fmt"
func main() {
arr := "abc"
for k, v := range arr {
fmt.Println(k, v)
}
}
for遍历字典
package main
import "fmt"
func main() {
arr := map[string]int{"one": 1, "two": 2, "three": 3}
for k, v := range arr {
fmt.Println(k, v)
}
}
for 遍历管道
package main
import "fmt"
func main() {
c := make(chan int)
go func() {
c <- 33
c <- 333
c <- 333333
close(c)
}()
for v := range c {
fmt.Println(v)
}
}
匿名变量
如果我们在遍历的时候，不想要key或者value，也可以用下划线替代，下划线叫做匿名变量。
package main
import "fmt"
func main() {
c := []int{1, 2, 3}
for _, v := range c {
fmt.Println(v)
}
}
switch 语句
go语言里面的switch语句每个case天生就是独立的，不需要加break。
package main
func main() {
s := "python"
switch s {
case "python":
print("1")
case "go":
print("2")
case "java":
print("3")
default:
print("4")
}
}
switch 可以一个分支捕获多个值
这个是go语言的特点，很少在其他语言看见，我们来看例子：
package main
func main() {
s := "python"
switch s {
case "python", "go", "java":
print("1")
default:
print("4")
}
}
switch的分支可以捕获条件判断
这个也是go语言的特点，我们来看例子：
package main
func main() {
s := 33
switch {
case s > 0 || s < 100:
print("1")
default:
print("4")
}
}
字符串可以通过索引访问字符
package main
func main() {
s := "abcde"
print(s[0])
}
字符串可以通过切片访问连续字符
package main
func main() {
s := "abcde"
print(s[0:3])
}
统计字符串的个数要用特殊的方法
package main
import "unicode/utf8"
func main() {
s := "abcde"
print(utf8.RuneCountInString(s))
}
将字符编码转换为字符
package main
func main() {
s := "abcde"
print(string(s[1]))
}
遍历字符串的每一个字符
package main
import "fmt"
func main() {
s := "我 爱 你 中 国"
cs := []rune(s)
for _, ch := range cs {
fmt.Println(string(ch))
}
}
使用buffer累加字符串
package main
import (
"bytes"
"fmt"
)
func main() {
var bf bytes.Buffer
for i := 0; i < 10; i++ {
fmt.Fprintf(&bf, "a%d ", i)
}
s := bf.String()
fmt.Println(s)
}
通过指针修改变量的值
指针可以直接对内存地址进行操作。使用*表示指针，使用&取地址。
package main
import "fmt"
func main() {
a := 33
pa := &a
*pa = 333
fmt.Println(a)
fmt.Println(*pa)
}
使用指针交换两个变量的值
package main
import "fmt"
func swap(a, b *int) {
*a, *b = *b, *a
}
func main() {
a, b := 33, 11
fmt.Println(a, b)
swap(&a, &b)
fmt.Println(a, b)
}
数组的基本使用
package main
import "fmt"
func main() {
// 声明
var arr [8]int
// 赋值
for i := 0; i < 8; i++ {
arr[i] = i * 33
}
// 遍历
for i := 0; i < 8; i++ {
fmt.Println(arr[i])
}
}
结构体的基本用法
package main
import "fmt"
type User struct {
Name string
Age int
}
func main() {
zs := User{"zs", 20}
ls := User{Name: "ls", Age: 20}
fmt.Println(zs, ls)
}
结构体作为函数参数
package main
import "fmt"
type User struct {
Name string
Age int
}
func printUser(u User) {
fmt.Printf("姓名：%s 年龄：%d \n", u.Name, u.Age)
}
func main() {
zs := User{"zs", 20}
ls := User{Name: "ls", Age: 20}
printUser(zs)
printUser(ls)
}
结构体指针作为函数参数
package main
import "fmt"
type User struct {
Name string
Age int
}
func printUser(u *User) {
fmt.Printf("姓名：%s 年龄：%d \n", u.Name, u.Age)
}
func main() {
zs := User{"zs", 20}
ls := User{Name: "ls", Age: 20}
printUser(&zs)
printUser(&ls)
}
切片的增删改查
切片在go语言里面非常常用，因为其有动态扩展的特性。
package main
import "fmt"
func main() {
var arr []int
// 增加
arr = append(arr, 11)
arr = append(arr, 22)
arr = append(arr, 33)
// 删除 索引1
index := 1
arr = append(arr[:index], arr[index+1:]...)
// 修改
arr[0] = 888
// 遍历
for _, v := range arr {
fmt.Println(v)
}
}
map的增删改查
package main
import "fmt"
func main() {
var m = make(map[string]int)
// 增加
m["a"] = 11
m["b"] = 12
m["c"] = 13
// 删除
delete(m, "a")
// 修改
m["c"] = 888
// 遍历
for k, v := range m {
fmt.Println(k, v)
}
}
加法函数
package main
import "fmt"
func add(a, b int) int {
return a + b
}
func main() {
fmt.Println(add(1, 2))
}
函数的可变参数
package main
import "fmt"
func add(arr ...int) int {
sum := 0
for i := 0; i < len(arr); i++ {
sum += arr[i]
}
return sum
}
func main() {
fmt.Println(add(1, 2))
fmt.Println(add(1, 2, 3, 4, 5))
}
匿名函数
package main
import "fmt"
func main() {
defer func() {
fmt.Println("这个是匿名函数")
}()
fmt.Println("xxx")
}
