99Go语言基础

其他参考链接：https://blog.csdn.net/weixin_50941083/article/details/125590486

输入输出

package main

import "fmt"

func main() {
	/**
	输入和输出：fmt包

	输出：
	    fmt.Println() // 打印换行
		fmt.Print() // 打印
		fmt.Printf() // 格式化打印


	输入：
		fmt.Scanf()
		fmt.Scanln()
		fmt.Scan()
	*/

	var x int
	var y float64

	fmt.Println("请输入两个数 1、整数,2、浮点数:")
	// 变量取地址  &变量
	// 指针、地址来修改和操作变量
	// Scanln 阻塞等待你的键盘输入
	fmt.Scanln(&x, &y)
	fmt.Println("x:", x)
	fmt.Println("y:", y)
}

iota常量计数器

package main

import "fmt" // 导入一个系统包fmt用来输入的

func main() {
	// iota 常量计数器 默认第一个是0
	const (
		a = iota
		b
		c
		d = "hahha"
		e
		f = 100
		g
		h = iota
		i
	)

	const (
		j = iota // 0
		k        // 1
	)
	fmt.Println(a, b, c, d, e, f, g, h, i, j, k) // 0 1 2 hahha hahha 100 100 7 8 0 1
}

switch case

package main

import "fmt"

func main() {
	a := false
	switch a {   // 不写a默认 true
	case false:
		fmt.Println("1、case条件为false")
		fallthrough // case穿透的，不管下一个条件满不满足，都会执行
	case true:
		if a == false {
			break // 终止case穿透
		}
		fmt.Println("2、case条件为true")

	}
}

for循环，go中无while

package main

import "fmt"

func main() {
	// for 条件的起始值; 循环条件; 控制变量自增或者自减
	//  for    ; 循环条件 ；
	//  for  {}  无限循环
	for i := 0; i < 5; i++ {
		fmt.Println("你好", i)
	}

	// // 1、计算1 到 999 之间的和
	// sum := 0
	// for i := 1; i < 1000; i++ {
	// 	sum += i
	// 	fmt.Println(sum)
	// }
	// fmt.Printf("1到999之间的和为:%d", sum)
}


// 打印九九乘法表
package main

import (
	"fmt"
)

func main() {
	for i := 1; i < 10; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%d*%d=%d", j, i, i*j)
		}
		fmt.Println()
	}
}

string

package main

import (
	"fmt"
)

func main() {
	str := "hello,zhangsan"
	fmt.Println(str)

	// 获取字符串的长度 len
	fmt.Println("字符串的长度为：", len(str))

	// 获取指定的字节
	fmt.Println(str[0]) // 104  ascill码为104
	fmt.Printf("字节打印：%c", str[0])

	// for
	for i := 0; i < len(str); i++ {
		fmt.Printf("字节打印：%c\n", str[i])
	}

	// for range循环，遍历数组、切片
	// 返回下标和对应的值，使用这个值就可以了
	for i, v := range str {
		fmt.Print(i)
		fmt.Printf("%c\n", v)
	}
}

函数

package main

import (
	"fmt"
)

/***
-函数是基本的代码块，用于执行一个任务。
-Go语言最少有个main()函数。
-你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。
-函数声明告诉了编译器函数的名称，返回类型，和参数。
*/

//	func 函数名(参数,参数 ...) 函数调用后的返回类型 {
//			函数体：执行一段代码
//			return 返回结果
//	}
func add(a, b int) int {
	return a + b
}

func main() {
	// 调用函数： 函数名()
	c := add(1, 3)
	fmt.Println("add函数返回值:", c)
}

可变参数

package main

import "fmt"

func main() {
	res := getSum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
	fmt.Println("和为：", res)
}

// ...可变参数
func getSum(nums ...int) int {
	sum := 0
	for i := 0; i < len(nums); i++ {
		sum += nums[i]
		fmt.Println(nums[i])
	}
	return sum
}

值传递和引用传递

package main

import "fmt"

func main() {
	// 值传递
	// 定义一个数组  [个数] 类型
	arr := [4]int{1, 2, 3, 4}
	fmt.Println(arr)
	update(arr)

	// 引用传递
	// 切片，可以扩容的数组
	s1 := []int{1, 2, 3, 4}
	update2(s1)
	fmt.Println("引用传递调用函数后的数据s1:", s1)
}

func update(arr2 [4]int) {
	fmt.Println("arr2接受的数据:", arr2)
	arr2[0] = 100
	fmt.Println("arr2修改后的数据:", arr2)

}

func update2(s2 []int) {
	fmt.Println("s2接受的数据:", s2)
	s2[0] = 100
	fmt.Println("s2修改后的数据:", s2)
}

递归

package main

import "fmt"

/**
使用递归求和1到5
*/
func main() {
	sum := getSum(5)
	fmt.Println(sum)
}

func getSum(n int) int {
	// 递归函数：定义：一个函数自己调用自己，就叫递归函数
	// 注意：递归函数需要一个出口，逐渐向出口靠近，没有出口就会形成死循环
	if n == 1 {
		return 1
	}
	return getSum(n-1) + n
}

defer延后执行

package main

import "fmt"

// defer 关闭操作
func main() {
	fmt.Println("1")
	fmt.Println("2")
	// 当有多条defer语句，会按照逆向顺序执行
	defer f("3") // 参数已经传递进去了，只是在最后执行
	fmt.Println("4")
}

func f(s string) {
	fmt.Println(s)
}

函数类型

package main

import (
	"fmt"
)

// func() 本身就是一个数据类型
func main() {

	// f1 如果不加括号，函数就是一个变量了
	// f1() 如果加了括号就成了函数的调用
	fmt.Printf("%T", f)       // func()
	fmt.Printf("%T", "hello") // string
	fmt.Printf("%T", 10)      // int

}

func f() {

}

// func f2(f func()) {

// }

匿名函数

package main

import "fmt"

// 匿名函数
func main() {
	f1()
	f2 := f1 // 函数本身也是一个变量
	f2()

	// 匿名函数
	f3 := func() {
		fmt.Println("我是f3函数")
	}
	f3()

	// 匿名函数自己调用自己
	func() {
		fmt.Println("我是f4函数")
	}()

	// 匿名函数自己调用自己，可以有参数
	func(a, b int) {
		fmt.Println(a, b)
		fmt.Println("我是f5函数")
	}(1, 2)

	// 匿名函数自己调用自己，可以有参数,带返回值
	res := func(a, b int) int {
		return a + b
		// fmt.Println("我是f5函数")
	}(1, 2)
	fmt.Println(res)
}

func f1() {
	fmt.Println("我是f1函数")
}

回调函数和高阶函数

package main

import "fmt"

/**
存在函数f1() 和 f2()
将f1函数作为f2这个函数的参数
f2函数：就叫做高阶函数，接收了一个函数作为参数的函数
f1函数：就叫做回调函数，作为另外一个函数的参数
*/
func main() {
	r1 := add(1, 2)
	fmt.Println(r1)

	r2 := oper(3, 4, add)
	fmt.Println(r2)

	r3 := oper(8, 4, sub)
	fmt.Println(r3)

	r4 := oper(8, 0, func(a int, b int) int {
		if b == 0 {
			fmt.Println("除数不能为0")
			return 0
		}
		return a / b
	})
	fmt.Println(r4)
}

// 高阶函数，可以接收一个函数作为参数
func oper(a, b int, fun func(int, int) int) int {
	r := fun(a, b)
	return r
}

func add(a, b int) int {
	return a + b
}

func sub(a, b int) int {
	return a - b

}

闭包

package main

import "fmt"

func main() {
	r1 := increment()
	fmt.Println(r1)

	v1 := r1()
	fmt.Println(v1)
	v2 := r1()
	fmt.Println(v2)
	fmt.Println(r1())
	fmt.Println(r1())
	fmt.Println(r1())

	//
	r2 := increment()
	v3 := r2()
	fmt.Println(v3)
}

// 自增
func increment() func() int {
	// 局部变量i
	i := 0
	// 定义一个匿名函数，给变量自增并返回
	fun := func() int { // 内存函数，没有执行
		i++
		return i
	}
	return fun
}