go语言学习-基本概念与流程控制

1、hello world

// package: 声明这个文件是属于哪个包的
// 什么是包：可以理解为Go源码的集合，也是一种比较高级的代码复用方案。
// 我们可以把一些复用的代码或者是功能封装在一起，然后形成一个包，可以被另外一个包进行引用，
// 或者是被其他代码进行引用，
// 引用之后我们就可以使用包里面的功能

// main是一个特殊的包，一个可执行的程序有且只有一个main包
// main函数是整个程序的入口，如果一个程序没有main函数是无法正常执行程序的
package main
import "fmt"

// import： 用来导入一个包的

// 定义一个入口函数
func main() { // 花括号进行表示一个代码块，括号内的代码属于同一个块内，
	// 也可以说属于同一个域内
	fmt.Println("Hello World, Hello Go")
}

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

2、 fmt 使用

package main

// import： 用来导入一个包的
import "fmt"

// 定义一个入口函数
func main() { // 花括号进行表示一个代码块，括号内的代码属于同一个块内，
	// 也可以说属于同一个域内
	fmt.Println("Hello World, Hello Go")
	fmt.Println("还可以打印中文")
	fmt.Print("使用print方法1") // 直接打印，不进行换行
	fmt.Print("使用print方法2") // 直接打印，不进行换行
	// 格式化进行打印，%s
	fmt.Printf("我们可以打印一个别的地方，传递过来的值：%s，这个值可以用占位，然后打印", "这是我想打印的内容")
	fmt.Println("还可以打印：", "中文")
	fmtEnv := fmt.Sprintf("拼接字符串:%s, 和这个字符串:%s, 以及一个数字: %d", "s1", "s2", 727585266)
	fmt.Println("拼接后的字符串是: ", fmtEnv)
	fmt.Println(3.1415926)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3、go语言基本概念

3.1 变量和常量

package main

import (
	"fmt"
	"reflect"
)

func main() {
	// 在go语言当中定义变量
	// 第一种方法: var: 关键字， name: 变量名, string: 变量的类型
	// = 表示进行直接赋值
	var name string = "张宇"
	fmt.Println("我的名字是:", name)
	var name2 string
	name2 = "zy"
	fmt.Printf("My English name is: %s\n", name2)
	// var name3, name4 string = "name3", "name4"
	var (
		name3 string = "name3"
		name4 int
	)
	println(name3, name4)
	// 第二种方法，使用语法糖进行声明变量
	b := true
	// b = "string"
	f := 3.1415926
	fmt.Println(b, f)
	b2 := false
	// 可以进行赋值吗？
	b = b2
	fmt.Println(b)
	// 如何确定一个变量的类型？
	// reflect
	// name2Type := reflect.TypeOf(name2)
	fmt.Println("name2的类型是: ", reflect.TypeOf(name2))
	fmt.Println("f的类型是: ", reflect.TypeOf(f))
	// 定义一个常量
	// 关键字const
	const c1, c2, c3 = 1, 2, 3
	// const ()
	// 可以更改c1的值吗？
	// c1 = 5
	fmt.Println("常量的值是:", c1, c2, c3)
}
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
37
38
39
40
41
42
43
44

3.2 函数和作用域

package main
import "fmt"

// 在func之外可以定义一个全局的变量
var globalName string = "zy"

// 不可以使用语法糖
// globalName2 := "dddddd"
// 定义一个函数，这个函数用来打印名字
func printAd() {
	fmt.Println("我是张宇")
	// 我能不能在printAd里面调用name变量？
	// fmt.Println("我是: ", name) //我们不能调用其他函数的变量
	// 调用全局变量
	fmt.Println("全局变量的值: ", globalName)
}
func main() {
	var name = "张宇2"  //定义局部变量
	fmt.Println("name is: ", name)
	fmt.Println("程序开始运行")
	printAd()
	fmt.Println("在main函数内全局变量的值: ", globalName)
	fmt.Println("程序运行结束")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3.3 数值和字符串运算

package main

import (
	"fmt"
	"reflect"
)

func numOperations(a, b int) {
	fmt.Printf("%d + %d = %d\n", a, b, a+b)
	fmt.Printf("%d - %d = %d\n", a, b, a-b)
	fmt.Printf("%d * %d = %d\n", a, b, a*b)
	fmt.Printf("%d / %d = %f\n", a, b, float64(a)/float64(b))
	// 1. 转换类型
	// 2. 除数不能为0 if-else
	fmt.Printf("%d 取余 %d = %d\n", a, b, a%b)
}

// 字符串运算
func stringOperation(a, b string) {
	fmt.Printf("a和b拼接后: %s\n", a+b) // 12 字符串
	ab := a + b
	fmt.Printf("ab: %s, 类型是:%s", ab, reflect.TypeOf(ab))
}

// fmt.Sprintf
func stringSprintf(firstName, secondName string) {
	// fullName := secondName + " " + firstName
	fullName := fmt.Sprintf("%s %s", secondName, firstName)
	fmt.Println("你的全名是:", fullName)
}

func main() {
	// 数值的运算
	// i1 := 1
	// i2 := 2
	// fmt.Println("i1 + i2 = ", i1+i2)
	numOperations(1, 2)
	// numOperations(11111215, 22878454)
	name1 := "张宇"
	name2 := "zy"
	stringOperation(name1, name2)
	stringOperation("1", "2") // =3?  12?
	// numOperations(name1, name2)
	stringSprintf("宇", "张") // 
	// strings.Join
	// 自增和自减
	p1 := 8
	p1++
	fmt.Println("自增后的值:", p1)
	p1--
	p1--
	fmt.Println("自减后的值:", p1)
}
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

3.4 数值类型详解

package main

import (
	"fmt"
	"math"
	"reflect"
)

func main() {
	// 数值类型：int int8 int16 int32 int64 uint
	// int: 正负数  uint：不带符号的数字 // int
	defaultIntType := 1
	fmt.Println("默认的数值类型是:", reflect.TypeOf(defaultIntType))
	// int和操作系统是有关系的
	// 64位的，int64  32位的 int32
	var int64Num int64 = 1
	fmt.Println("int64Num的数值类型是:", reflect.TypeOf(int64Num))
	var uintNum uint = 1
	fmt.Println("uintNum的数值类型是:", reflect.TypeOf(uintNum))
	fmt.Println("int的取值范围:", math.MinInt, math.MaxInt)
	fmt.Println("uint的取值范围:", uint(math.MaxUint))
	fmt.Println(18446744073709551615 > 9223372036854775807)
	// float float32和float64
	var floatNum1 float64 = 3.14
	var floatNum2 float32 = 3.15
	// floatSum := floatNum1 + floatNum2
	fmt.Println(floatNum1, floatNum2)
}
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

3.5 关系和逻辑运算符

//面试点：两个字符串是否可以比较大小，是通过什么比较的： 可以，通过ASSCSI码去比较
package main

import (
	"fmt"
	"reflect"
)

func main() {
	// 大于, 小于
	fmt.Println(727585 > 727588) // false
	fmt.Println(727585 < 727588) // true
	// 是否相等,  =和==的区别
	fmt.Println("a" == "b") // false
	fmt.Println(3.14 == 3.14)

	s1 := "zy"
	s2 := "zhy"
	// xxx := s1 == s2
	fmt.Println("s1和s2相等: ", s1 == s2)
	fmt.Println("s1和s2不相等: ", s1 != s2)
	fmt.Println("s1 > s2:", s1 > s2)
	fmt.Println("s2 > s1:", s2 > s1) //字符串是可以比较大小的， ASCII
	// 逻辑与和逻辑或  && ||
	n1 := 1
	n2 := 1
	n3 := 2
	// 与： 所有的表达式都为true，最终的结果就为true
	fmt.Println(n1 == n2 && n2 == n3) // true false => false
	// 或：任意一个为true，最终结果就为true
	fmt.Println(n1 == n2 || reflect.TypeOf(n3).Kind() == reflect.String)
}
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

4、go语言流程控制

4.1 if-else

package main

import "fmt"

// 定义价格的函数
func printPrice(weather string) {
	defaultPrice := 10
	// if 表达式 {代码块} else {代码块}
	// if 表达式 {代码块} else if  {代码块} else {}
	if weather == "sunny" {
		// 成立的话就执行下面的代码
		fmt.Println("今天是晴天，雨伞的价格是：", defaultPrice)
	} else {
		// 如果不成立执行else里面的代码，当然else可以没有
		fmt.Println("今天不是晴天，雨伞的价格是：", defaultPrice+10)
	}
}

func printPriceWithWeather(weather string) {
	defaultPrice := 10
	// 小雨涨5块
	if weather == "lightRain" {
		// 成立的话就执行下面的代码
		fmt.Println("下小雨了，雨伞的价格是：", defaultPrice+5)
	} else if weather == "heavyRain" {
		// 如果不成立执行else里面的代码，当然else可以没有
		fmt.Println("下大雨了，雨伞的价格是：", defaultPrice+10)
	} else if weather == "rainStorm" {
		fmt.Println("下暴雨了，雨伞的价格是：", defaultPrice+20)
	} else {
		fmt.Println("雨伞的价格是：", defaultPrice)
	}
}

func main() {
	// if else
	// 雨伞：10  下雨：20
	weather := "rain"
	printPrice(weather)

	// 晴天了
	weather = "sunny"
	printPrice(weather)

	// 小雨
	printPriceWithWeather("lightRain")
	printPriceWithWeather("rainStorm")
	// 晴天了
	printPriceWithWeather("")
}
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50

4.2 switch

package main

import "fmt"

func printPriceWithWeather(weather string) {
	defaultPrice := 10
	// 小雨涨5块
	if weather == "lightRain" {
		// 成立的话就执行下面的代码
		fmt.Println("下小雨了，雨伞的价格是：", defaultPrice+5)
	} else if weather == "heavyRain" {
		// 如果不成立执行else里面的代码，当然else可以没有
		fmt.Println("下大雨了，雨伞的价格是：", defaultPrice+10)
	} else if weather == "rainStorm" {
		fmt.Println("下暴雨了，雨伞的价格是：", defaultPrice+20)
	} else {
		fmt.Println("雨伞的价格是：", defaultPrice)
	}
}

func printPriceWithSwitch(weather string) {
	defaultPrice := 10
	/*
	switch是表达式，case是条件。
		表达式被评估一次。
		switch表达式的值与每个case的值进行比较。
		如果匹配，则执行相关的代码块。
		默认关键字是可选的。它指定了如果没有匹配的case时要运行的一些代码。
	*/
	switch weather {
	case "lightRain":
		fmt.Println("下小雨了，雨伞的价格是：", defaultPrice+5)
	case "heavyRain":
		fmt.Println("下大雨了，雨伞的价格是：", defaultPrice+10)
	case "rainStorm":
		fmt.Println("下暴雨了，雨伞的价格是：", defaultPrice+20)
	case "snowing", "sunny":
		// if else
		fmt.Println("雨伞的价格是：", defaultPrice)
	default:
		fmt.Println("我不知道现在是什么天气，所以我不卖了~")
	}
}

func main() {
	// // 小雨
	// printPriceWithWeather("lightRain")
	// printPriceWithWeather("rainStorm")
	// // 晴天了
	// printPriceWithWeather("")
	printPriceWithSwitch("")
	printPriceWithSwitch("snowing")
}
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

4.3 for循环

package main

import (
	"fmt"
)

func main() {
	// for 1-100
	// num := 1
	count := 0 // 偶数的个数
	// 判断1-100有哪些偶数，有多少个偶数
	for num := 1; num <= 100; num++ {
		if num%2 == 0 {
			// 说明是偶数
			fmt.Println("发现一个偶数:", num)
			count++
		}
		// time.Sleep(time.Second)
	}
	// for结束后会执行下面的代码
	fmt.Printf("1-100一共有偶数:%d个\n", count)

	// 判断是否是奇数
	num2 := 1
	for num2 <= 100 {
		if num2%2 != 0 {
			// 奇数
			fmt.Println("发现奇数:", num2)
		}
		num2++
	}
}
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

4.4 for循环的死循环实现

package main

import (
	"fmt"
)

func main() {
// 每十秒执行一次代码。 
//for此处不带条件的话就是死循环，gp语言默认是没有死循环一说的
	for {
	// HH:SS:MM
	timeNow := time.Now()
	// 2006-01-02 15:04:05 go语言的诞生时间
	fmt.Println("当前的时间是:", timeNow.Format("2006-01-02 15:04:05")) // 这里面的代码会一直执行
	fmt.Println("我错了，原谅我吧")
	time.Sleep(time.Second * 3)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.4 break和continue

package main

import (
	"fmt"
)

func main() {
	// break continue
	// break： 终止循环
	// continue： 终止本次循环，继续下一次循环
	// 0-100: 88
	for i := 0; i < 100; i++ {
		if i == 88 {
			fmt.Println("我找到了88")
			break
		}
		fmt.Println("现在的数值是：", i)
	}
	// continue
	for i := 0; i < 100; i++ {
		if i == 88 {
			fmt.Println("我找到了88")
			continue
		}
		fmt.Println("现在的数值是：", i)
	}
}
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