數組

數組的定義：

數組是具有固定長度并擁有零個或者多個相同數據類型元素的序列

定義一個數組的方法：
var 變量名[len] type

例子：
var a[5] int //3個整數的數組
var a[5]string //3個字符串的數組

像上面這種定義方法，我們是指定了數組的長度,但是還有如下定義方法：
var a=[...]int{1,2,3}
如果把數組的長度替換為...，那么數組的長度由初始化數組的元素個數決定

數組中的每個元素是通過索引來訪問，索引是從0開始
例如 數組var a[5]int 獲取第一個元素就是a[0],
獲取數組的長度是通過len(a)

這里需要知道：數組的長度也是數組類型的一部分，所以要知道[3]int和[4]int是不同的數組類型

默認情況下一個新數組中的元素初始值為元素類型的零值
如一個證書類型的數組，默認值就是0

初始化數組：

有一下幾種方法：
var a = [5] int{1,2,3,4,5}
var a = [5] int{1,2,3}
var a = [...]int{1,2,3,4}
var a = [5]string{1:"go",3:"python"}

關于數組的類型：
值類型

數組的遍歷

數組的遍歷方法：
var a = [3]int{1, 2, 3}
for i, v := range a {
fmt.Printf("%d %d\n", i, v)
}
當然如果不需要索引也可以：
var a = [3]int{1, 2, 3}
for _, v := range a {
fmt.Printf("%d\n", v)
}

二維數組

var a[3][2]

其實二維數組可以通過excel表格理解，就是幾行幾列的問題，像上面的這個例子就是一個3行2列的二維數組。
關于二維數組的遍歷,創建一個二維數組并循環賦值，然后循環打印內容
var c [3][2]int
for i := 0; i < 3; i++ {
for j := 0; j < 2; j++ {
c[i][j] = rand.Intn(10)
}
}
for i := 0; i < 3; i++ {
for j := 0; j < 2; j++ {
fmt.Printf("%d ", c[i][j])
}
fmt.Println()
}

關于數組的比較

如果兩個數組的元素類型相同是可以相互比較的，例如數組a:= [2]int{1,2}和數組b:=[2]int{3,4}
因為同樣都是int類型，所以可以通過==來比較兩個數組，看兩邊的元素是否完全相同，使用!= 比較看兩邊的元素是否不同

通過下面的例子演示更加清晰：

a := [2]int{1, 2} b := [...]int{1, 2} c := [2]int{3, 2} d := [3]int{1, 2} fmt.Println(a == b, a == c, b == c) fmt.Println(a == d)

上面的例子中第一個打印的結果是true,false,false，而當添加第二個打印的時候，就無法編譯過去，因為兩者是不能比較的

切片slice

定義

slice 表示一個擁有相同類型元素的可變長的序列

定義一個slice其實和定義一個數組非常類似
var 變量名[]type
var b = []int

和數組對比slice似乎就是一個沒有長度的數組

slice的初始化
var a[5] int //這是定義一個數組
var b[]int = a[0,2]
var b[]int = a[0:5]
var b[]int = a[:]
var b[]int = a[:3]

var b[] int = []int{1,2,3,4}

同樣遍歷切片和數組是一模一樣的

通過把數組和slice對比我們其實可以發現，兩者其實非常類似，當然兩者也確實有著緊密的關系

slice的底層實現就是一個數組，通常我們會叫做slice的底層數組。
slice具有三個屬性：指針，長度和容量，如下圖

指針指向數組的第一個可以從slice中訪問的元素，這個元素不一定是數組的第一個元素
長度是指slice中元素的個數，不能超過slice的容量
容量的大小是從slice的起始元素到底層數組的最后一個元素的個數
通過len和cap可以獲取slice的長度和容量
通過下面例子理解：
var s = [5]int{1, 2, 3, 4, 5}
var b = s[2:3]
var c = s[0:4]
現在問b的長度以及容量，c的長度以及容量
對比上面的定義其實很好明白
s 就好比slice的底層數組
而對于b這個slice來說他是從數組的第三個元素開始切片，切片的時候是左閉右開原則
所以b的長度是1
對于b的容量根據定義我們知道是從數組的第三個元素到數組的最后
所以b的容量是3

這樣我們也可以很容易得到c的長度是3，容量是5

slice創建

內置函數make可以創建一個具有指定元素類型、長度和容量的slice,其中容量參數可以省略，這樣默認slice的長度和容量就相等了

make([]type,len,cap)
make([]type,len)

現在說說關于：
make([]type,len)
make([]type,len,cap)

其實make創建了一個無名數組并返回了它的一個slice;這個數組僅可以通過slice來訪問。
第一個：make([]type,len)返回的slice引用了整個數組。
第二個：make([]type,len,cap)slice只引用了數組的前len個元素，但是它的容量是數組的長度
通過下圖理解切片的創建過程：

關于copy

該函數主要是切片（slice）的拷貝，不支持數組
將第二個slice里的元素拷貝到第一個slice里。如果加入的兩個數組切片不一樣大，就會按其中較小的那個數組切片的元素個數進行復制。

通過下面例子便于理解：

s1 := []int{1, 2, 3, 7, 8} s2 := []int{4, 5, 6} copy(s2, s1) fmt.Printf("%#v\n", s2)

這樣打印s2的結果就是：[]int{1, 2, 3}
將代碼更改為：

s1 := []int{1, 2, 3, 7, 8} s2 := []int{4, 5, 6} copy(s1, s2) fmt.Printf("%#v\n", s1)

這樣打印s1的結果為：[]int{4, 5, 6, 7, 8}
這次拷貝就是把s2中的前三個元素拷貝到s1中的前三個，把s1中的前三個進行了覆蓋

關于append

內置的函數append可以把元素追加到slice的后面

通過下面例子理解，把“hello go”每個字符循環添加到一個slice中

var runnes []rune for _, v := range "hello,go" {runnes = append(runnes, v) } fmt.Printf("%q\n", runnes)

例子2直接在一個已經有元素的slice追加

s1 := []int{1, 2, 3} s1 = append(s1, 4, 5) fmt.Printf("%#v\n", s1)

如果想要把另外一個slice也直接append到現在的slice中：

s1 := []int{1, 2, 3} s2 := []int{4, 5} s1 = append(s1, s2...) fmt.Printf("%#v\n", s1)

這里在s2后面通過...其實就是把s2中的元素給展開然后在append進s1中

其實append函數對于理解slice的工作原理是非常重要的，下面是一個為[]int數組slice定義的一個方法：

func appendInt(x []int, y int) []int {var z []intzlen := len(x) + 1if zlen <= cap(x) {//slice仍有增長空間擴展slice內容z = x[:zlen]} else {//slice 已經沒有空間，為他分配一個新的底層數組//當然實際go底層擴展的時候的策略可能復雜的多，這里是通過擴展一倍為例子zcap := zlenif zcap < 2*len(x) {zcap = 2 * len(x)}z = make([]int, zlen, zcap)copy(z, x)}z[len(x)] = yreturn z

從上面的這個方法可以看出：
每次appendInt的時候都會檢查slice是否有足夠的容量來存儲數組中的新元素，如果slice容量足夠，那么他會定義一個新的slice,注意這里仍然引用原始的底層數組，然后將新元素y復制到新的位置，并返回新的slice,這樣我們傳入的參數切片x和函數返回值切片z其實用的是相同的底層數組。
如果slice的容量不夠容納增長的元素，appendInt函數必須創建一個擁有足夠容量的新的底層數組來存儲新的元素，然后將元素從切片x復制到這個數組，再將新元素y追加到數組后面。這樣返回的切片z將和傳入的參數切片z引用不同的底層數組。

關于切片的比較

和數組不同的是，切片是無法比較的，因此不能通過==來比較兩個切片是否擁有相同的元素
slice唯一允許的比較操作是和nill比較，切片的零值是nill
這里需要注意的是：值為nill的slice的長度和容量都是零，但是這不是決定的，因為存在非nill的slice的長度和容量是零所以想要檢查一個slice是否為還是要使用len(s) == 0 而不是s == nill

下面是整理的練習切片使用的例子

如何修改一個字符串？

package mainimport ("fmt" )func changeString(str1 string) {var runnes = []rune(str1)runnes[0] = 'h'res := string(runnes)fmt.Println(res) }func main() {changeString("Hello,Go") }

這里是把開頭的大寫的h換成了小寫

再看一個例子：
實現字符串的反轉

func reverseStr(str1 string) {var runes = []rune(str1)var res stringfor i := len(runes) - 1; i >= 0; i-- {res += string(runes[i])}fmt.Println(res) }

上面這個方法就可以實現對字符串的反轉，當然方法不止一種，下面也是一種方法

func reverseStr2(str1 string) {var runes = []rune(str1)for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {runes[i], runes[j] = runes[j], runes[i]}res := string(runes)fmt.Println(res) }

上面的方法中我一直在用到rune，這個東西是什么東西呢？接著看

GO當中的：string rune,byte

在Go當中的字符換string 底層是用byte數組存的，并且是不可改變的
當我們通過for key, value := range str這種方式循環一個字符串的時候，其實返回的每個value類型就是rune
而我們知道在go中雙引號引起來的是字符串string，在go中表示字符串有兩種方式：
一種是byte，代表utf-8字符串的單個字節的值；另外一個是rune,代表單個unicode字符串
關于rune官網中一段解釋：
rune is an alias for int32 and is equivalent to int32 in all ways. It is
used, by convention, to distinguish character values from integer values.

我們通過下面的代碼例子來理解一下：

var a = "我愛你go"
fmt.Println(len(a))

上面已經說了，字符串的底層是byte字節數組，所以我們通過len來計算長度的時候，其實就是獲取的該數組的長度，而一個中文字符是占3個字節，所以上面的結果是11
可能很多人第一眼看的時候，尤其初學者可能會覺得長度應該是5，其實，如果想要轉換成4只需要通過蝦米那方式就可以：

var a = "我愛你go"
fmt.Println(len([]rune(a)))

時間和日期類型

當前時間：now:= time.Now()

time.Now().Day()

time.Now().Minute()

time.Now().Month()

time.Now().Year()

time.Duration用來表示納秒

一些常用的時間常量

const (
Nanosecond Duration = 1
Microsecond =1000 * Nanosecond
Millisecond =1000 * Microsecond
Second =1000 * Millisecond
Minute =60 * Second
Hour =60 * Minute
)

注意：如果想要格式化時間的時候，要特別特別注意，只能通過如下方式格式化：
fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
Format里面的時間是固定的，因為是go第一個程序的誕生時間，也不知道go的開發者怎么想的，估計是想讓所有學習go的人記住這個偉大的時刻吧

?

切片處理補充

關于切片刪除

代碼例子：

package mainimport "fmt"func main() {index := 2var s = []int{10,15,8,20}s = append(s[:index],s[index+1:]...)fmt.Println(s) }

?

總結

以上是生活随笔為你收集整理的Go基础之--数组和切片的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。