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)
 
}