Go語言基礎之切片

来源:https://www.cnblogs.com/Golanguage/archive/2020/02/10/12293187.html
-Advertisement-
Play Games

本文主要介紹Go語言中切片（slice）及它的基本使用。 因為數組的長度是固定的並且數組長度屬於類型的一部分，所以數組有很多的局限性。 例如： func arraySum(x [3]int) int{ sum := 0 for _, v := range x{ sum = sum + v } ret ...


本文主要介紹Go語言中切片（slice）及它的基本使用。

因為數組的長度是固定的並且數組長度屬於類型的一部分，所以數組有很多的局限性。 例如：

func arraySum(x [3]int) int{
    sum := 0
    for _, v := range x{
        sum = sum + v
    }
    return sum
}

這個求和函數只能接受[3]int類型，其他的都不支持。 再比如，

a := [3]int{1, 2, 3}

數組a中已經有三個元素了，我們不能再繼續往數組a中添加新元素了。

切片

切片（Slice）是一個擁有相同類型元素的可變長度的序列。它是基於數組類型做的一層封裝。它非常靈活，支持自動擴容。

切片是一個引用類型，它的內部結構包含地址、長度和容量。切片一般用於快速地操作一塊數據集合。

切片的定義

聲明切片類型的基本語法如下：

var name []T

其中，

  • name:表示變數名
  • T:表示切片中的元素類型

舉個例子：

func main() {
	// 聲明切片類型
	var a []string              //聲明一個字元串切片
	var b = []int{}             //聲明一個整型切片並初始化
	var c = []bool{false, true} //聲明一個布爾切片並初始化
	var d = []bool{false, true} //聲明一個布爾切片並初始化
	fmt.Println(a)              //[]
	fmt.Println(b)              //[]
	fmt.Println(c)              //[false true]
	fmt.Println(a == nil)       //true
	fmt.Println(b == nil)       //false
	fmt.Println(c == nil)       //false
	// fmt.Println(c == d)   //切片是引用類型，不支持直接比較，只能和nil比較
}

切片的長度和容量

切片擁有自己的長度和容量，我們可以通過使用內置的len()函數求長度，使用內置的cap()函數求切片的容量。

基於數組定義切片

由於切片的底層就是一個數組，所以我們可以基於數組定義切片。

func main() {
	// 基於數組定義切片
	a := [5]int{55, 56, 57, 58, 59}
	b := a[1:4]                     //基於數組a創建切片，包括元素a[1],a[2],a[3]
	fmt.Println(b)                  //[56 57 58]
	fmt.Printf("type of b:%T\n", b) //type of b:[]int
}

還支持如下方式：

c := a[1:] //[56 57 58 59]
d := a[:4] //[55 56 57 58]
e := a[:]  //[55 56 57 58 59]

切片再切片

除了基於數組得到切片，我們還可以通過切片來得到切片。

func main() {
	//切片再切片
	a := [...]string{"北京", "上海", "廣州", "深圳", "成都", "重慶"}
	fmt.Printf("a:%v type:%T len:%d  cap:%d\n", a, a, len(a), cap(a))
	b := a[1:3]
	fmt.Printf("b:%v type:%T len:%d  cap:%d\n", b, b, len(b), cap(b))
	c := b[1:5]
	fmt.Printf("c:%v type:%T len:%d  cap:%d\n", c, c, len(c), cap(c))
}

輸出：

a:[北京 上海 廣州 深圳 成都 重慶] type:[6]string len:6  cap:6
b:[上海 廣州] type:[]string len:2  cap:5
c:[廣州 深圳 成都 重慶] type:[]string len:4  cap:4

註意： 對切片進行再切片時，索引不能超過原數組的長度，否則會出現索引越界的錯誤。

使用make()函數構造切片

我們上面都是基於數組來創建的切片，如果需要動態的創建一個切片，我們就需要使用內置的make()函數，格式如下：

make([]T, size, cap)

其中：

  • T:切片的元素類型
  • size:切片中元素的數量
  • cap:切片的容量

舉個例子：

func main() {
	a := make([]int, 2, 10)
	fmt.Println(a)      //[0 0]
	fmt.Println(len(a)) //2
	fmt.Println(cap(a)) //10
}

上面代碼中a的內部存儲空間已經分配了10個，但實際上只用了2個。 容量並不會影響當前元素的個數，所以len(a)返回2，cap(a)則返回該切片的容量。

切片的本質

切片的本質就是對底層數組的封裝，它包含了三個信息：底層數組的指針、切片的長度（len）和切片的容量（cap）。

舉個例子，現在有一個數組a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}，切片s1 := a[:5]，相應示意圖如下。  切片s2 := a[3:6]，相應示意圖如下： 

切片不能直接比較

切片之間是不能比較的，我們不能使用==操作符來判斷兩個切片是否含有全部相等元素。 切片唯一合法的比較操作是和nil比較。 一個nil值的切片並沒有底層數組，一個nil值的切片的長度和容量都是0。但是我們不能說一個長度和容量都是0的切片一定是nil，例如下麵的示例：

var s1 []int         //len(s1)=0;cap(s1)=0;s1==nil
s2 := []int{}        //len(s2)=0;cap(s2)=0;s2!=nil
s3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil

所以要判斷一個切片是否是空的，要是用len(s) == 0來判斷，不應該使用s == nil來判斷。

切片的賦值拷貝

下麵的代碼中演示了拷貝前後兩個變數共用底層數組，對一個切片的修改會影響另一個切片的內容，這點需要特別註意。

func main() {
	s1 := make([]int, 3) //[0 0 0]
	s2 := s1             //將s1直接賦值給s2，s1和s2共用一個底層數組
	s2[0] = 100
	fmt.Println(s1) //[100 0 0]
	fmt.Println(s2) //[100 0 0]
}

切片遍歷

切片的遍歷方式和數組是一致的，支持索引遍歷和for range遍歷。

func main() {
	s := []int{1, 3, 5}

	for i := 0; i < len(s); i++ {
		fmt.Println(i, s[i])
	}

	for index, value := range s {
		fmt.Println(index, value)
	}
}

append()方法為切片添加元素

Go語言的內建函數append()可以為切片動態添加元素，每個切片會指向一個底層數組，這個數組的容量夠用就添加新增元素。當底層數組不能容納新增的元素時，切片就會自動按照一定的策略進行“擴容”，此時該切片指向的底層數組就會更換。“擴容”操作往往發生在append()函數調用時，所以我們通常都需要用原變數接收append函數的返回值。

舉個例子：

func main() {
	//append()添加元素和切片擴容
	var numSlice []int
	for i := 0; i < 10; i++ {
		numSlice = append(numSlice, i)
		fmt.Printf("%v  len:%d  cap:%d  ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)
	}
}

輸出：

[0]  len:1  cap:1  ptr:0xc0000a8000
[0 1]  len:2  cap:2  ptr:0xc0000a8040
[0 1 2]  len:3  cap:4  ptr:0xc0000b2020
[0 1 2 3]  len:4  cap:4  ptr:0xc0000b2020
[0 1 2 3 4]  len:5  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5]  len:6  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5 6]  len:7  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5 6 7]  len:8  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5 6 7 8]  len:9  cap:16  ptr:0xc0000b8000
[0 1 2 3 4 5 6 7 8 9]  len:10  cap:16  ptr:0xc0000b8000

從上面的結果可以看出：

  1. append()函數將元素追加到切片的最後並返回該切片。
  2. 切片numSlice的容量按照1，2，4，8，16這樣的規則自動進行擴容，每次擴容後都是擴容前的2倍。

append()函數還支持一次性追加多個元素。 例如：

var citySlice []string
// 追加一個元素
citySlice = append(citySlice, "北京")
// 追加多個元素
citySlice = append(citySlice, "上海", "廣州", "深圳")
// 追加切片
a := []string{"成都", "重慶"}
citySlice = append(citySlice, a...)
fmt.Println(citySlice) //[北京 上海 廣州 深圳 成都 重慶]

切片的擴容策略

可以通過查看$GOROOT/src/runtime/slice.go源碼，其中擴容相關代碼如下：

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
	newcap = cap
} else {
	if old.len < 1024 {
		newcap = doublecap
	} else {
		// Check 0 < newcap to detect overflow
		// and prevent an infinite loop.
		for 0 < newcap && newcap < cap {
			newcap += newcap / 4
		}
		// Set newcap to the requested cap when
		// the newcap calculation overflowed.
		if newcap <= 0 {
			newcap = cap
		}
	}
}

從上面的代碼可以看出以下內容：

  • 首先判斷，如果新申請容量（cap）大於2倍的舊容量（old.cap），最終容量（newcap）就是新申請的容量（cap）。
  • 否則判斷，如果舊切片的長度小於1024，則最終容量(newcap)就是舊容量(old.cap)的兩倍，即（newcap=doublecap），
  • 否則判斷，如果舊切片長度大於等於1024，則最終容量（newcap）從舊容量（old.cap）開始迴圈增加原來的1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最終容量（newcap）大於等於新申請的容量(cap)，即（newcap >= cap）
  • 如果最終容量（cap）計算值溢出，則最終容量（cap）就是新申請容量（cap）。

需要註意的是，切片擴容還會根據切片中元素的類型不同而做不同的處理，比如int和string類型的處理方式就不一樣。

使用copy()函數複製切片

首先我們來看一個問題：

func main() {
	a := []int{1, 2, 3, 4, 5}
	b := a
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(b) //[1 2 3 4 5]
	b[0] = 1000
	fmt.Println(a) //[1000 2 3 4 5]
	fmt.Println(b) //[1000 2 3 4 5]
}

由於切片是引用類型，所以a和b其實都指向了同一塊記憶體地址。修改b的同時a的值也會發生變化。

Go語言內建的copy()函數可以迅速地將一個切片的數據複製到另外一個切片空間中，copy()函數的使用格式如下：

copy(destSlice, srcSlice []T)

其中：

  • srcSlice: 數據來源切片
  • destSlice: 目標切片

舉個例子：

func main() {
	// copy()複製切片
	a := []int{1, 2, 3, 4, 5}
	c := make([]int, 5, 5)
	copy(c, a)     //使用copy()函數將切片a中的元素複製到切片c
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1 2 3 4 5]
	c[0] = 1000
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1000 2 3 4 5]
}

從切片中刪除元素

Go語言中並沒有刪除切片元素的專用方法，我們可以使用切片本身的特性來刪除元素。 代碼如下：

func main() {
	// 從切片中刪除元素
	a := []int{30, 31, 32, 33, 34, 35, 36, 37}
	// 要刪除索引為2的元素
	a = append(a[:2], a[3:]...)
	fmt.Println(a) //[30 31 33 34 35 36 37]
}

總結一下就是：要從切片a中刪除索引為index的元素，操作方法是a = append(a[:index], a[index+1:]...)

練習題

1.請寫出下麵代碼的輸出結果。

func main() {
	var a = make([]string, 5, 10)
	for i := 0; i < 10; i++ {
		a = append(a, fmt.Sprintf("%v", i))
	}
	fmt.Println(a)
}

2.請使用內置的sort包對數組var a = [...]int{3, 7, 8, 9, 1}進行排序（附加題，自行查資料解答）。

轉載自李文周博客


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 77.封裝的作用和含義
    我要看電視，只需要按一下開關和換台就可以了。有必要瞭解電視機內部的結構嗎?有必要碰碰顯像管嗎?製造廠家為了方便我們使用電視，把複雜的內部細節全部封裝起來，只給我們暴露簡單的介面，比如：電源開關。具體內部是怎麼實現的，我們不需要操心。 需要讓用戶知道的才暴露出來，不需要讓用戶知道的全部隱藏起來，這就是 ...
  • 從零開始搭建Go語言開發環境
    一步一步，從零搭建Go語言開發環境。 安裝Go語言及搭建Go語言開發環境 下載 Go官網下載地址：https://golang.org/dl/ Go官方鏡像站（推薦）：https://golang.google.cn/dl/ 版本的選擇 Windows平臺和Mac平臺推薦下載可執行文件版，Linux ...
  • VS Code配置Go語言開發環境
    VS Code是微軟開源的一款編輯器，插件系統十分的豐富。本文就介紹瞭如何使用VS Code搭建Go語言開發環境。 VS Code配置Go語言開發環境 說在前面的話，Go語言是採用UTF8編碼的，理論上使用任何文本編輯器都能做Go語言開發。大家可以根據自己的喜好自行選擇。編輯器/IDE沒有最好只有最 ...
  • Go語言基礎之變數和常量
    變數和常量是編程中必不可少的部分，也是很好理解的一部分。 標識符與關鍵字 標識符 在編程語言中標識符就是程式員定義的具有特殊意義的詞，比如變數名、常量名、函數名等等。 Go語言中標識符由字母數字和_(下劃線）組成，並且只能以字母和_開頭。 舉幾個例子：abc, _, _123, a123。 關鍵字 ...
  • Go語言基礎之基本數據類型
    Go語言中有豐富的數據類型，除了基本的整型、浮點型、布爾型、字元串外，還有數組、切片、結構體、函數、map、通道（channel）等。Go 語言的基本類型和其他語言大同小異。 基本數據類型 整型 整型分為以下兩個大類： 按長度分為：int8、int16、int32、int64 對應的無符號整型：ui ...
  • JavaSE學習筆記（7）---數組
    JavaSE學習筆記（7） 數組 1、什麼是數組 數組是相同類型數據的有序集合。數組描述的是相同類型的若幹個數據，按照一定的先後次序排列組合而成。其中，每一個數據稱作一個元素，每個元素可以通過一個索引(下標)來訪問它們。數組的三個基本特點： 1. 長度是確定的。數組一旦被創建，它的大小就是不可以改變 ...
  • Go語言基礎之運算符
    運算符用於在程式運行時執行數學或邏輯運算。 運算符 Go 語言內置的運算符有： 算術運算符 關係運算符 邏輯運算符 位運算符 賦值運算符 算數運算符 運算符描述 + 相加 - 相減 * 相乘 / 相除 % 求餘 註意： ++（自增）和--（自減）在Go語言中是單獨的語句，並不是運算符。 關係運算符 ...
  • Go語言基礎之流程式控制制
    流程式控制制是每種編程語言控制邏輯走向和執行次序的重要部分，流程式控制制可以說是一門語言的“經脈”。 Go語言中最常用的流程式控制制有if和for，而switch和goto主要是為了簡化代碼、降低重覆代碼而生的結構，屬於擴展類的流程式控制制。 if else(分支結構) if條件判斷基本寫法 Go語言中if條件判斷 ...
一周排行
    -Advertisement-
    Play Games
  • Dapr Outbox 執行流程
    Dapr Outbox 是1.12中的功能。 本文只介紹Dapr Outbox 執行流程，Dapr Outbox基本用法請閱讀官方文檔 。本文中appID=order-processor，topic=orders 本文前提知識：熟悉Dapr狀態管理、Dapr發佈訂閱和Outbox 模式。 Outbo ...
  • Advanced .Net Debugging 7：托管堆與垃圾收集
    引言 在前幾章我們深度講解了單元測試和集成測試的基礎知識，這一章我們來講解一下代碼覆蓋率,代碼覆蓋率是單元測試運行的度量值,覆蓋率通常以百分比表示，用於衡量代碼被測試覆蓋的程度，幫助開發人員評估測試用例的質量和代碼的健壯性。常見的覆蓋率包括語句覆蓋率（Line Coverage）、分支覆蓋率（Bra ...
  • C#S7.NET實現西門子PLCDB塊數據採集的完整步驟
    前言 本文介紹瞭如何使用S7.NET庫實現對西門子PLC DB塊數據的讀寫，記錄了使用電腦模擬，模擬PLC，自至完成測試的詳細流程，並重點介紹了在這個過程中的易錯點，供參考。 用到的軟體： 1.Windows環境下鏈路層網路訪問的行業標準工具（WinPcap_4_1_3.exe）下載鏈接：http ...
  • WPF控制項：密碼框綁定MVVM
    從依賴倒置原則（Dependency Inversion Principle, DIP）到控制反轉（Inversion of Control, IoC）再到依賴註入（Dependency Injection, DI）的演進過程，我們可以理解為一種逐步抽象和解耦的設計思想。這種思想在C#等面向對象的編 ...
  • Python中的私有屬性與私有方法
    關於Python中的私有屬性和私有方法 Python對於類的成員沒有嚴格的訪問控制限制，這與其他面相對對象語言有區別。關於私有屬性和私有方法，有如下要點： 1、通常我們約定，兩個下劃線開頭的屬性是私有的（private）。其他為公共的（public）； 2、類內部可以訪問私有屬性（方法）； 3、類外 ...
  • C++ 訪問說明符詳解：封裝數據，控制訪問，提升安全性
    C++ 訪問說明符 訪問說明符是 C++ 中控制類成員（屬性和方法）可訪問性的關鍵字。它們用於封裝類數據並保護其免受意外修改或濫用。 三種訪問說明符： public：允許從類外部的任何地方訪問成員。 private：僅允許在類內部訪問成員。 protected：允許在類內部及其派生類中訪問成員。 示 ...
  • static_cast與dynamic_cast到底是什麼？
    寫這個隨筆說一下C++的static_cast和dynamic_cast用在子類與父類的指針轉換時的一些事宜。首先，【static_cast，dynamic_cast】【父類指針，子類指針】，兩兩一組，共有4種組合：用 static_cast 父類轉子類、用 static_cast 子類轉父類、使用 ...
  • C語言數據結構：雙向鏈表的增刪操作
    /******************************************************************************************************** * * * 設計雙向鏈表的介面 * * * * Copyright (c) 2023-2 ...
  • @ComponentScan註解的實現，Spring掃描包的過程
    相信接觸過spring做開發的小伙伴們一定使用過@ComponentScan註解 @ComponentScan("com.wangm.lifecycle") public class AppConfig { } @ComponentScan指定basePackage，將包下的類按照一定規則註冊成Be ...
  • opensips開啟python支持
    操作系統 ：CentOS 7.6_x64 opensips版本： 2.4.9 python版本：2.7.5 python作為腳本語言，使用起來很方便，查了下opensips的文檔，支持使用python腳本寫邏輯代碼。今天整理下CentOS7環境下opensips2.4.9的python模塊筆記及使用 ...
所有分類