go语言基础

1.常量，变量，指针定义

package main

import "fmt"

const s = 2

const (
	Unknown = 0
	Female  = 1
	Male    = 2
)

var n = 3

func main() {

	a, b, c := 1, 2, "str1"
	a, b = b, a
	b = a + s
	fmt.Printf("a=%d b=%d c=%s\n", a, b, c)

	var ptr *int

	ptr = &b
	fmt.Println(ptr)

	fmt.Println(*ptr)

	sum := 1
	for i := 0; i < 10; i++ {
		sum += i
	}
	fmt.Println(sum)

}

2. 函数，闭包

package main

import "fmt"

type Circle struct {
	radius float64
}

func main() {
	a, b := "first", "second"
	swap(a, b)
	fmt.Printf("a=%s b=%s\n", a, b)

	swap1(&a, &b)
	fmt.Printf("a=%s b=%s\n", a, b)

	nextNumber := getSequence()

	fmt.Println(nextNumber())
	fmt.Println(nextNumber())
	fmt.Println(nextNumber())

	var c1 Circle
	c1.radius = 2
	area := c1.getArea()
	fmt.Println(area)
}

// 函数 值传递
func swap(x, y string) {
	x, y = y, x
}

//  函数 引用传递
func swap1(x *string, y *string) {
	*x, *y = *y, *x
}

// 闭包
func getSequence() func() int {
	i := 0
	return func() int {
		i++
		return i
	}
}

// 方法 一个包含了接受者的函数
func (c Circle) getArea() float64 {
	return 3.14 * c.radius * c.radius
}

3.数组，结构体

package main

import "fmt"

var balance [5]float32

type Books struct {
	Title   string
	Author  string
	Subject string
	BookId  int
}

func main() {

	// 将索引为 1 和 3 的元素初始化
	balance = [5]float32{1: 2.0, 3: 7.0}
	for i := 0; i < 5; i++ {
		fmt.Printf("balance[%d]= %f\n", i, balance[i])
	}

	balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

	// 动态推断数组长度
	balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

	for i := 0; i < 5; i++ {
		fmt.Printf("balance[%d]= %f\n", i, balance[i])
	}

	fmt.Println(getAverage(balance))

	book1 := Books{"go语言", "作者", "计算机", 12323}
	book2 := new(Books)
	book3 := Books{Title: "java语言", BookId: 12321}

	book2.BookId = 1
	book2.Title = "测试名称"

	fmt.Println(book1.Title)

	fmt.Println(book2.Title)

	fmt.Println(book3.Title)
}

func getAverage(arr [5]float32) float32 {
	var avg, sum float32

	for i := 0; i < len(arr); i++ {
		sum += arr[i]
	}
	avg = sum / float32(len(arr))
	return avg
}

4.形参值传递，地址传递　

package main

import (
	"fmt"
)

// Go语言的数组是值，其长度是其类型的一部分，作为函数参数时，是值传递，函数中的修改对调用者不可见
func change1(nums [6]int) {
	nums[0] = 4
}

// 传递进来数组的内存地址，然后定义指针变量指向该地址，则会改变数组的值
func change2(nums *[6]int) {
	nums[0] = 5
}

// Go语言中对数组的处理，一般采用切片的方式，切片包含对底层数组内容的引用，作为函数参数时，类似于指针传递，函数中的修改对调用者可见
func change3(nums []int) {
	nums[0] = 6
}

type Books1 struct {
	Title   string
	Author  string
	Subject string
	BookId  int
}

// Go语言中结构体做为参数时，是值传递，函数中的修改对调用者不可见
func changeBook1(book Books1) {
	book.Title = "修改后的书名"
}

func changeBook2(book *Books1) {
	book.Title = "修改后的书名"
}

// Go语言中map作为参数时，是引用传递，函数中的修改对调用者可见
func changeMap(maps map[string]string) {
	for k, _ := range maps {
		maps[k] = "test" + k
	}
}

func main() {
	var nums1 = [6]int{1, 2, 3, 4, 5, 6}
	var nums2 = []int{1, 2, 3}
	change1(nums1)
	fmt.Println(nums1[0:3]) //  [1 2 3]
	change2(&nums1)
	fmt.Println(nums1) //  [5 2 3 4 5 6]
	change3(nums2)
	fmt.Println(nums2[:3]) //  [6 2 3]

	book1 := Books1{"go语言", "作者", "计算机", 12323}

	// 参数为结构体，方法修改参数未改变
	changeBook1(book1)
	fmt.Println(book1.Title)

	// 参数为结构体指针，方法修改参数改变
	changeBook2(&book1)
	fmt.Println(book1.Title)

	pt := &book1
	fmt.Println(pt)
	fmt.Println(*pt)
	fmt.Println(&pt)
	fmt.Println(book1)

	str := "world"
	pStr := &str
	fmt.Println(pStr)
	fmt.Println(&pStr)

	// map是地址传递
	maps := map[string]string{"k1": "v1", "k2": "v2"}
	fmt.Println(maps)

	changeMap(maps)

	fmt.Println(maps)

}

5. 切片，map

package main

import "fmt"

func main() {

	arr := [...]int{1, 2, 3, 4, 5}

	s := arr[0:3]

	fmt.Println(s)

	// 定义切片
	s1 := make([]int, 0)

	// 切片赋值
	s1 = append(s1, 1, 3, 5)

	fmt.Println(s1)

	// 创建新切片s2, 容量是s1的2倍
	s2 := make([]int, len(s1), (cap(s1))*2)

	// 将s1拷贝到s2
	copy(s2, s1)
	fmt.Println(s2)

	s3 := []int{1, 3, 5}
	fmt.Println(s3)

	// 遍历数组
	for _, v := range arr {
		fmt.Print(v)
	}

	areaMap := make(map[string]string)

	areaMap["中国"] = "北京"
	areaMap["美国"] = "纽约"
	areaMap["日本"] = "东京"

	// 遍历map
	for k, v := range areaMap {
		fmt.Println(k, v)
	}

	// 根据key删除map
	delete(areaMap, "日本")

	for k, v := range areaMap {
		fmt.Println(k, v)
	}
	
	kvs := map[string]string{"key": "apple", "value": "banana"}
	for k, v := range kvs {
		fmt.Printf("%s -> %s\n", k, v)
	}

}

6.接口，方法，类型转换

package main

import (
	"fmt"
	"strconv"
)

type Phone interface {
	call() string
}

type Android struct {
	brand string
}

type IPhone struct {
	version string
}

func (android Android) call() string {
	return "I am Android " + android.brand
}

func (iPhone IPhone) call() string {
	return "I am iPhone " + iPhone.version
}

func printCall(p Phone) {
	fmt.Println(p.call() + ", I can call you!")
}

func main() {
	vivo := Android{brand: "Vivo"}
	hw := Android{"HuaWei"}

	i7 := IPhone{version: "7 Plus"}
	ix := IPhone{"X"}

	printCall(vivo)
	printCall(hw)
	printCall(i7)
	printCall(ix)

	//接口类型转换
	var i interface{} = "Hello, World"
	str, ok := i.(string)
	if ok {
		fmt.Printf("'%s' is a string\n", str)
	} else {
		fmt.Println("conversion failed")
	}

	// 数字类型转换
	var sum int = 17
	var count int = 5
	var mean float32
	mean = float32(sum) / float32(count)
	fmt.Printf("mean 的值为: %f\n", mean)

	// 字符串转整数
	str1 := "123"
	num, err := strconv.Atoi(str1)
	if err != nil {
		fmt.Println("转换错误:", err)
	} else {
		fmt.Printf("字符串 '%s' 转换为整数为：%d\n", str1, num)
	}

	// 整数转字符串
	num2 := 123
	str2 := strconv.Itoa(num2)
	fmt.Printf("整数 %d  转换为字符串为：'%s'\n", num2, str2)

	// 字符串转浮点数
	str3 := "3.14"
	num3, err := strconv.ParseFloat(str3, 64)
	if err != nil {
		fmt.Println("转换错误:", err)
	} else {
		fmt.Printf("字符串 '%s' 转为浮点型为：%f\n", str3, num3)
	}

	// 浮点数转字符串
	num4 := 3.14
	str4 := strconv.FormatFloat(num4, 'f', 2, 64)
	fmt.Printf("浮点数 %f 转为字符串为：'%s'\n", num4, str4)
}

7.并发

package main

import (
	"fmt"
	"time"
)

func say(s string) {
	for i := 0; i < 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s)
	}
}

func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum // 把 sum 发送到通道 c
}

func main() {

	go say("world")
	say("hello")

	s := []int{7, 2, 8, -9, 4, 0}

	s1 := s[:len(s)/2]
	fmt.Println(s1)

	s2 := s[len(s)/2:]
	fmt.Println(s2)

	c := make(chan int)
	go sum(s[:len(s)/2], c)
	go sum(s[len(s)/2:], c)
	x, y := <-c, <-c // 从通道 c 中接收

	fmt.Println(x, y, x+y)

}