Go学习笔记（二）

2019-08-04  本文已影响0人  dev_winner 
  if number := 4; 100 > number {
      number += 3
  } else if 100 < number {
      number -= 2
  } else {
      fmt.Println("OK!")
}   

// 程序所属包,每个.go文件必须要有package关键字
package main // 包名尽量与文件目录名一样

// 导入依赖包
import (
    . "fmt"
    "time"
)

func main() {
    a := -1
    if a > 0 {
        Println("a > 0 !!!")
    }else if a < 0 {
        Println("a < 0 !!!")
    }else {
        Println("a == 0 !!!")
    }

    b := 1
    switch b {
    case 1:
        Println("1...")
    case 2:
        Println("2...")
    case 3:
        Println("3...")
    default:
        Println("以上都不满足条件！！！")
    }

    var c interface{}
    c = "学习Go语言"
    switch c.(type) {  // 判断变量c的类型
    case int:
        Println("变量c为整型")
    case string:
        Println("变量c为字符串型")
    default:
        Println("以上都不满足条件！！！")
    }
    // a < 0 !!!
    // 1...
    // 变量c为字符串型

    // 循环语句
    for i := 1; i < 5; i++ {
        Println("Go...")
    }

    arr := [] string{"香蕉","苹果","雪梨"}
    // for-each循环遍历数组，若只要value，且不使用key，只需将key变量改成下划线_，否则会报错
    for key, value := range arr {
        Print(key)
        Println("--->" + value)
    }

    // goto 语句
    // goto One  // 只跳转执行一次
        Println("这里是中间代码块！！！")
    One:
        Println("这里是代码块一！！！")
        time.Sleep(1 * time.Second)
    // 若放在此处，则进入死循环
    // goto One
}

Go命令基础

几种形式表示rune类型值 特殊的字符序列 
package main

import ( 
    "fmt" 
)

func main() {
    // 声明一个string类型变量并赋值
    var str1 string = "\\\"" 
    
    // 这里用到了字符串格式化函数。其中，%q用于显示字符串值的表象值并用双引号包裹。
    fmt.Printf("用解释型字符串表示法表示的 %q 所代表的是 %s。\n", str1, `\"`)
}
// 输出结果：用解释型字符串表示法表示的 "\\\"" 所代表的是 \"。

数组类型

切片类型

package main // 包名尽量与文件目录名一样

// 导入依赖包
import (
    . "fmt"
)

func main() {
    var arr = []int32{1, 2, 3, 4, 5, 9, 8, 7}
    var num [5]int8  // 只声明一个数组类型的变量，默认赋值为零值
    for i := 1; i < 5; i++ {
        Print(num[i])
        if i != 4 {
            Print(" ")
        } else {
            Println("")
        }
    }

    Println("原数组中的元素如下：")
    var len1 = len(arr)
    for i := 0; i < len1; i++ {
        Print(arr[i])
        if i == len1 - 1 {
            Println("")
        }else {
            Print(" ")
        }
    }

    Println("以下是获取的切片值：")
    var slice1 = arr[1 : 4]  // 左闭右开：[1, 3]
    for index, value := range slice1 { // for-each循环
        Println(index, value)
    }

    var n1, n2 = 1, 1.1
    // 格式化输出：%v，用于表示true or false
    Printf("%v\n", n1 == int(n2)) // 使用的输出函数是Printf()

    var numbers1 = [5]int{1, 2, 3, 4, 5}
    println("数组的长度为：", len(numbers1))
    slice2 := numbers1[2 : len(numbers1)]
    Println("切片的长度为", len(slice2))
    // 一个切片值的容量即为它的第一个元素值在其底层数组中的索引值与该数组长度的差值的绝对值。

    var slice3 []int
    println(slice3)
    // for index, key := range slice3 {
    //  Println(index, key)
    // } 
}

package main // 包名尽量与文件目录名一样

// 导入依赖包
import (
    . "fmt"
)

func main() {
    var  num1 = [...]int{1, 2, 3, 4, 5}
    var slice1 = num1[1 : 3 : 4] // 切片的长度为3，实际容量是4
    Println("切片的长度为：", len(slice1))
    Println("切片的容量为：", cap(slice1))
    slice1 = slice1[: cap(slice1)] // 获取相同容量的切片长度4
    Println("切片的长度为：", len(slice1)) 
    Println("切片的容量为：", cap(slice1))
    
    slice1 = append(slice1, 6, 7, 11)
    Println("切片的长度为：", len(slice1)) 
    Println("切片的容量为：", cap(slice1))
    
    var slice2 = []int{0, 0, 0}
    copy(slice1, slice2)  // 切片slice2前三个元素会将slice1前三个元素覆盖
    Println("切片的长度为：", len(slice1)) 
    Println("切片的容量为：", cap(slice1))
    
    // for-each循环遍历
    for k, v := range slice1 {
        Println(k, v)
    }
}

字典类型

通道类型

package main // 包名尽量与文件目录名一样

// 导入依赖包
import (
    . "fmt"
)

func main() {
    ch2 := make(chan string, 1)
    // 下面就是传说中的通过启用一个Goroutine来并发的执行代码块的方法。
    // 关键字 go 后跟的就是需要被并发执行的代码块，它由一个匿名函数代表。
    // 在这里，我们只要知道在花括号中的就是将要被并发执行的代码就可以了。
    go func() {
        ch2 <- ("已到达！")
    }()
    var value string = "数据"
    value = value + (<- ch2) // 从通道那里接收值
    Println(value)  // 数据已到达！
}

var myChannel = make(chan int, 3)
var sender Sender = myChannel
var receiver Receiver = myChannel

但是，反之则是不行的，像下面这样的代码是通不过编译的：

var myChannel1 chan int = sender 

package main // 包名尽量与文件目录名一样

// 导入依赖包
import (
    "fmt"
    "time"
)

type Sender chan<- int  // 发送通道

type Receiver <-chan int // 接收通道

func main() {
    var myChannel = make(chan int, (0)) // 创建一个非缓冲通道
    // 由于创建的是非缓冲通道，只有当接收方已从该通道值中接收了这条数据，发送方才能向通道值发送数据
    // 因此输出结果为：
    // Received! 6
    // Sent!
    var number = 6
    // 并发程序
    go func() {
        var sender Sender = myChannel
        sender <- number // 只向通道发送数据
        fmt.Println("Sent!")
    }()
    go func() {
        var receiver Receiver = myChannel 
        fmt.Println("Received!", <-receiver)  // 只从通道中接收数据
    }()
    // 让main函数执行结束的时间延迟1秒，
    // 以使上面两个代码块有机会被执行。
    time.Sleep(time.Second)
}
上一篇 下一篇

猜你喜欢

热点阅读