Go的学习旅程1:基本语法知识

最新推荐文章于 2021-11-12 10:02:36 发布

原创最新推荐文章于 2021-11-12 10:02:36 发布 · 9k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#go

Golang 专栏收录该内容

30 篇文章

订阅专栏

本文详细介绍Go语言的基础概念，包括变量赋值、常量与枚举、条件语句、循环、函数及指针等内容。通过具体实例讲解如何进行变量定义与赋值、常量的使用、不同类型的循环语句以及函数的定义与调用方式。

1.变量的赋值

package main

//引入包
import "fmt"

//包内变量赋值(不能使用 :=)
var (
	a = 1
	b = true
	c = "我是你爸爸"
)

//变量赋值的方法(规定类型)
func aaa() {
	//可以规定类型
	var a, b, c int = 1, 2, 3
	fmt.Println(a, b, c)
}

//变量赋值的方法(不规定类型)
func bbb() {
	//可以不规定类型
	var d, e, f = 1, true, "我是你爷"
	fmt.Println(d, e, f)
}

//变量赋值的方法(简单,推荐) var 等价于 :=
func ccc() {
	//首次变量定义
	j, h, k := 2, true, "我是你奶奶"
	//其他变量赋值
	j = 12121212
	fmt.Println(j, h, k)
}

func main() {
	fmt.Print("hello, world\n")
	aaa()
	bbb()
	ccc()
}

//Println和Print基本类似,但是Println可以换行,Print不会换行

结果展示:

2.常量与枚举

package main

import "fmt"

//常量也可以定义在外面
const (
	d, e, f = 4, 5, 6
)

//常量的定义
func chang() {
	const (
		a, b, c = 111, 2222, 33333
	)
	g := a * d
	fmt.Println(a, b, c, g)
}

func main() {
	chang()
	//枚举iota
	const (
		a = iota //0
		b        //1
		c        //2
		d = "ha" //独立值，iota += 1
		e        //"ha"   iota += 1
		j        //"ha"   iota += 1
		f = 100  //iota +=1
		g        //100  iota +=1
		k        //100  iota +=1
		h = iota //9,恢复计数
		_        //10
		_        //11
		i        //12
	)
	// 1 << (10 * iota)中 ,iota是枚举类型的自增型,0,1,2,3,4....
	//	 << 则代表1的二进制转化后,向左面移动(10 * iota)位,剩余数位用0补全(相当于直接后面补了(10 * iota)个0)
	// 最后再转化成10进制的值
	const (
		aa = 1 << (10 * iota)
		bb
		cc
		dd
		ee
		ff
	)
	fmt.Println(a, b, c, d, e, j, f, g, k, h, i)
	fmt.Println(aa, bb, cc, dd, ee, ff)
}

结果展示:

3.条件语句

package main

import (
	"fmt"
	"io/ioutil"
)

//在函数中的判断
func ffff(v int) int {
	if v >= 100 {
		return 100
	} else if v >= 200 {
		return 200
	} else {
		return v
	}
}

func bbbb(number int) string {
	g := ""
	switch {
	case number == 1:
		g = "A"
	case number == 2:
		g = "B"
	case number == 3:
		g = "C"
	default:
		return "我不知道了"
	}
	return g
}

func cccc(number int) string {
	switch number {
	case 1, 0:
		return "AA"
	case 2, 3:
		return "BB"
	case 4, 5:
	case 7, 8:
		return "CC"
	default:
		return "我不会了"
	}
	return "结局了!!"
}

func main() {
	fmt.Println(ffff(90))

	// 查找文件并读取111.txt
	const name = "111.txt"
	// ioutil.ReadFile返回的参数有两个,即:内容和错误信息
	content, err := ioutil.ReadFile(name)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Printf("%s\n", content)
	}
	//这样的写法中,content是不能在外部调用的,他的生命周期只有在if中
	if content, err := ioutil.ReadFile(name); err != nil {
		fmt.Println(err)
	} else {
		fmt.Printf("%s\n", content)
	}

	fmt.Println(bbbb(651561))
	fmt.Println(cccc(4))
	fmt.Println(cccc(7))

}

结果展示:

4.循环

package main

import (
	"fmt"
	"os"
	"strconv"
)

//二进制的转化
func er(num int) string {
	res := ""
	//没有起始条件,但是";"需要写
	for ; num > 0; num /= 2 {
		lsb := num % 2
		//转化为string
		res = strconv.Itoa(lsb) + res
	}
	return res
}

//每句读文件爱你
func file(name string) {
	file, err := os.Open(name)
	if err != nil {
		//打断并报错
		panic(err)
	}
	for {
		fmt.Println(1111)
	}
	fmt.Printf("%s\n", file)
}

func main() {
	// a := 0
	// for i := 0; i < 5; i++ {
	// 	fmt.Println(i)
	// }

	// for a < 5 {
	// 	fmt.Println(a)
	// 	a++
	// }
	fmt.Println(
		er(5),
	)
	file("11.txt")
}

结果展示:

5.函数

package main

import (
	"fmt"
)

//函数的表达式
func aaa(a, b int, p string) int {
	switch p {
	case "+":
		return a + b
	case "-":
		return a - b
	case "*":
		return a * b
	case "/":
		//调用其他的函数,'_'表示不需要的参数
		c, _ := ccc(a, b)
		return c
	default:
		panic("我错了,我传的是:" + p)
	}
}

//返回两个参数
func eee(a, b int, op string) (int, error) {
	switch op {
	case "+":
		return a + b, nil
	case "-":
		return a - b, nil
	case "*":
		return a * b, nil
	case "/":
		return a / b, nil
	default:
		return 0,
			fmt.Errorf("你错了吧: %s", op)
	}
}

//函数传递两个数值
func bbb(a, b int) (int, int) {
	return a / b, a % b
}

//函数输出数值定义
func ccc(a, b int) (c, d int) {
	c = a / b
	d = a % b
	return c, d
}

func ppp(a, b int) int {
	return a * b
}

//函数作为参数,调用一个返回值
func ddd(op func(int, int) int, a, b int) int {
	return op(a, b)
}

//函数作为参数,调用两个返回值
func aa(op func(a, b int, op string) (int, error), c, d int, pp string) (int, error) {
	return op(c, d, pp)
}

func main() {
	fmt.Println(aaa(12, 2, "*"))
	fmt.Println(bbb(13, 3))
	c, d := ccc(13, 3)
	fmt.Println(c, d)
	fmt.Println(aaa(12, 2, "/"))
	fmt.Println(eee(12, 2, "@"))
	// 外部判断
	if reulet, err := eee(12, 2, "@"); err != nil {
	    fmt.Println("错误:", err)
	} else {
	    fmt.Println(reulet)
	}
	//调用函数
	fmt.Println(ddd(ppp, 3, 4))
	fmt.Println(aa(eee, 13, 4, "*"))

}

结果展示:

6.指针

指针的定义
指针就是一个存放地址的变量
当指针指向某个变量
这时这个指针里就存放了那个变量的地址
同时可以利用指针直接取变量中的值用只要在指针前加 * 就是取其
真值了(也就是被指向的变量的值)
举个例子
int i=0,*p;
声明了一个 int 类型的变量i和指针p
假设i在内存中所存在的地址为aaaaa(随便写的)
p->i 就是使指针p指向i
也就是说指针p中存放了aaaaa这个地址
当你操作这个p时就是直接操作了aaaaa这个地址中存放的东西
间接操作了变量i,
这就是指针的作用

package main

import (
	"fmt"
)

//一般交换
func aaa(a, b int) (int, int) {
	return b, a
}

//利用指针交换
func bbb(a, b *int) {
	*a, *b = *b, *a
}

//增加
func add(a *int) int {
	*a = *a + 1
	return *a
}

func main() {
	a := 2
	//定义指针b=指针a, fmt.Println(&a) == fmt.Println(b)
	//&是可以把具体的值转化为指针
	//*可以把指针转化对应的值
	var b *int = &a
	*b = 3
	fmt.Println(*b)
	fmt.Println(a)
	fmt.Println(add(&a))

	//a的 结果是3
	// fmt.Println(a)
	// fmt.Println(aaa(3, 6))
	// //先转换
	// c := 4
	// d := 6
	// bbb(&c, &d)
	// //再输出
	// fmt.Println(c, d)
}