2024-05-31    2024-05-31    2709 字  6 分钟
CS

语法基础

  • 第一个Go程序

    1
2
3
4
5
6
7

    package main	// go程序以包管理
import "fmt"	// 类似C++ #include <>
func main() {	// 主函数，并且花括号不能换行
    fmt.Println("Hello World")	// 调用系统函数输出
    // 无需写return
}
// go程序无需;分隔每句代码

  • 变量的定义和使用

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

    package main
import "fmt"
func main() {
	var a int	// 使用var关键字来声明变量，声明格式为var 变量名 变量类型
	fmt.Println("a =", a)	// a = 0，整形默认零值为0
	a = 10	// 给变量赋值
	fmt.Println("a =", a)	// a = 10

	var b int = 10	// 可以在声明的时候赋值
	b = 20
	fmt.Println("b =", b)

    c := 30	// 自动类型推导，用:=可以不用加var和类型
	fmt.Printf("c types is %T\n", c)
}

  • 一条语句声明多个变量

    1
2
3
4
5
6
7

    package main
import "fmt"
func main() {
	a, b, c := 1, 2, 3.3	// 自动类型推导，可以是不同的类型
	fmt.Println(a, b, c)
	fmt.Printf("a type %T, b type %T, c type %T\n", a, b, c)
}

  • 匿名变量

    1
2
3
4
5
6

    package main
import "fmt"
func main () {
	a, _ := 10, 20	// "_"为匿名变量，20会被丢弃，一般是结合函数使用，例子这样用简直鸡肋
	fmt.Println("a =", a)
}

  • 常量

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

    package main

import "fmt"

func main() {
	// 变量声明使用var，常量声明使用const
	const a = 10	//常量自动类型推导用=不用:=
	const b int = 20
	fmt.Println("a =", a, "b =", b)

}

  • 多个变量或常量的定义

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

    package main
import "fmt"
func main () {
	var (
		a int
		b float64
	)
    // 感觉不如 a, b := 1, 1.1
	a = 10
	b = 3.14

	fmt.Println("a =", a)
	fmt.Println("b =", b)
	const (
		c  = 10
		d  = 1.1
	)
	// 也可以自动类型推导
	fmt.Println("c =", c)
	fmt.Println("d =", d)
}

  • 枚举类型

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

    package main

import "fmt"

func main() {
	// 1.iota，只能放在const中
	const (
		a = iota	//0
		b = iota	//1
		c = iota	//2
	)

	fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)

	// 2.只写一个iota
	const (
		a1 = iota
		b1 = iota
		c1 = iota
	)

	fmt.Printf("a1 = %d, b1 = %d, c1 = %d\n", a1, b1, c1)

	// 3.iota遇到const重置为0
	const d = iota
	fmt.Println("d =", d)

	// 4.同一行的值都一样
	const (
		i = iota
		j1, j2, j3 = iota, iota, iota
		k = iota
	)

	fmt.Printf("i = %d, j1 = %d, j2 = %d, j3 = %d, k = %d", i, j1, j2, j3, k)
}

  • bool类型

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

    package main

import "fmt"

func main () {
	var a bool

	fmt.Println("a =", a)	//bool的零值为false

	a = true

	fmt.Println("a =", a)

	// 自动类型推导
	var b = true
	fmt.Println("b =", b)

	c := true
	fmt.Println("c =", c)
}

  • 浮点型

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

    package main

import "fmt"

func main () {
	var f1 float32
	f1 = 3.14
	fmt.Println("f1 =", f1)

	// 自动类型推导, 其类型为float64
	f2 := 3.14
	fmt.Printf("f2 type is %T\n", f2)
}

  • 字符类型

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

    package main

import "fmt"

func main () {
	var ch byte = 'c'
	fmt.Println("ch =", ch)	//输出对应的ascii码

	fmt.Printf("ch = %c, ch = %d\n", ch, ch)	//格式化输出

	ch1 := 'a'
	fmt.Printf("ch1 = %c\n", ch1)

	fmt.Printf("大写转小写:%c\n", 'A' + 32)
}

  • 字符串类型

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

    package main

import "fmt"

func main() {
	var str1 string
	str1 = "abc"
	fmt.Println("str1 =", str1)

	str2 := "Mike"
	fmt.Println("str2 =", str2)

	fmt.Println("len(str2) =", len(str2))
}

  • 字符串和字符的区别

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

    package main

import "fmt"

func main() {
	var (
		str1 string
		ch   byte
	)
	str1 = "Hello"
	ch = 'h'
	// 字符不可以被Println显示，字符串可以
	fmt.Println("ch =", ch, "str1 =", str1)
	// 字符串每个位置都是字符（和C++一样的）
	fmt.Printf("str1[0] = %c, str1[1] = %c", str1[0], str1[1])

}

  • 复数类型

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

    package main

import "fmt"

func main() {
	var t complex128	// 复数类型
	t = 2.1 + 3.14i		// 复数由实部和虚部组成
    fmt.Println("t =", t)	// (2.1+3.14i)

	t2 := 3.3 + 4.4i	// 支持自动类型推导
	fmt.Println("t2 =", t2)
	fmt.Printf("t2 type is %T\n", t2)
	fmt.Println("real(t2) =", real(t2), "imag(t2) =", imag(t2))	// 获取实部和虚部的函数
}

  • 格式化输出（Printf）

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

    package main

import "fmt"

func main() {
	a := 10
	b := "abc"
	c := 'a'
	d := 1.1

	fmt.Printf("%T, %T, %T, %T\n", a, b, c, d)
	fmt.Printf("%d, %s, %c, %f\n", a, b, c, d)
	// %v自动格式化输出，不过可能不是很智能，比如%c会输出成整数
	fmt.Printf("%v, %v, %v, %v", a, b, c, d)
}

  • 输入（cin）

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

    package main

import "fmt"

func main() {
	var a int
	var b int
	fmt.Printf("请输入变量a和变量b: ")
	// fmt.Scanf("%d %d", &a, &b)
	// 还可以这样
	fmt.Scan(&a, &b)
	fmt.Println("a =", a, "b =", b)
}
// 如果输入1.1 2.2输出结果就成了1, 0不知道为啥，可以了解一下Go的底层（如果C++肯定是1, 2）

  • 类型转换

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

    package main

import "fmt"

func main() {
	// 类型转换，有的类型不能相互转换，如bool和int这个和C++基本一样
	var ch byte	// char
	ch = 'a'
	fmt.Printf("ch = %c\n", ch)
	var t int
    t = int(ch)	// char可以转int,此处可以用:=免去声明，注意括号是将变量括起来而不是类型
	fmt.Println("t =", t)
}

  • 类型别名

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

    package main
import "fmt"
func main() {
	// 可以使用type来为类型起一个别名，命名格式为type 别名 类型
	type bigint int64

	var a bigint
	fmt.Printf("a types is %T\n", a)

	// 也可以同时定义多个type
	type (
		long int64
		char byte
	)

	var b long = 11
	var c char = 'a'
	fmt.Printf("b = %d, c = %c\n", b, c)
}

  • 运算符

    和C++差不多，主要区别在于Go语言没有前置++和–，统一使用后置

  • if的使用

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

    package main

import "fmt"

func main() {
	s := "屌丝"
	if s == "王思聪" {	// 可以不加括号也可加，花括号不能换行
		fmt.Println("左手一个妹子，右手一个大妈")
	}

	// if支持一个初始化语句，初始化语句和条件用;分隔
	if a := 10; a == 10 {	// 这里把两条括起来好像就有问题了，所以平时还是不写括号吧习惯就行
		fmt.Println("a == 10")
	}
}

  • if、elseif、else的使用

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

    package main
import "fmt"
func main() {
	a := 10
	if a == 10 {
		fmt.Println("a = 10")
	} else if a < 10 {	// 重点就是不换行
		fmt.Println("a < 10")
	} else if a > 10 {
		fmt.Println("a > 10")
	} else {
		fmt.Println("这个是不可能的")
	}
}

  • 多个if和多个if、else的区别

    多个if会导致每个if都会执行一次，量变引起质变，而if、else只要某一条条件成立后面的不会再判断，可以一定程度减轻CPU负担，所以能用则用，尽量避免多个if的情况。

  • switch语句的使用

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

    package main

import "fmt"

func main() {
	var a int
	fmt.Println("请输入a的值")
	fmt.Scan(&a)

	switch a { // switch可以没有条件，case里放<,>等，也可以switch里放一个初始化
	case 1: // 可以这样写多条case 1,2,3:
		fmt.Println("a = 1")
		// go语言默认会有break，所以可以不加
	case 2:
		fmt.Println("a = 2")
	case 3:
		fmt.Println("a = 3")
		fallthrough // 加上这个后这条case和c中没加break效果一样（不过仅适用当前的case）
	case 4:
		fmt.Println("a = 4")
	default:
		fmt.Println("其他")
	}
}

  • for的使用

     1
 2
 3
 4
 5
 6
 7
 8
 9
10

    package main
import "fmt"
func main() {
	// 求1 ~ 100累加和
	sum := 0
	for i := 1; i <= 100; i++ {	// 可以像C那样加括号，为了符合Go风格，还是不加吧
		sum += i;
	}
	fmt.Println("sum =", sum)
}

  • range的使用

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

    package main
import "fmt"
func main() {
	str := "abc"
	// 通过传统for循环
	for i := 0; i < len(str); i++ {
		fmt.Printf("str[%d] = %c\n", i, str[i])
	}
	// 通过range，返回值为下标，数据（有意思，可以了解一下底层原理）
	for i, data := range str {
		fmt.Printf("str[%d] = %c\n", i, data)
	}
	// 可以丢弃一些参数,用"_",如果没有加"_"默认也是丢弃
	for i, _ := range str {
		fmt.Printf("str[%d] = %c\n", i, str[i])
	}
}

  • break和continue的区别

    和C++一样，break跳出循环，continue直接进入下次循环

  • goto的使用

    和C++一样，不建议使用，容易混乱