Go語言實現(xiàn)切片增刪改查的示例代碼
引言
Golang 的數(shù)組是固定長度，可以容納相同數(shù)據(jù)類型的元素的集合。
但是當長度固定了，在使用的時候肯定是會帶來一些限制，比如說：申請的長度太大會浪費內存，太小又不夠用。
鑒于上述原因，我們有了 go 語言的切片，可以把切片理解為，可變長度的數(shù)組，其實它底層就是使用數(shù)組實現(xiàn)的，增加了自動擴容功能。
切片(Slice)是一個擁有相同類型元素的可變長度的序列。
一、切片的基礎語法
1. 語法
聲明一個切片和聲明一個數(shù)組類似，只要不添加長度即可
var identifier []type
切片是引用類型，可以使用make函數(shù)來創(chuàng)建切片：
var slice1 []type =make([]type, len)
也可以簡寫為
slice1 := make([]type, len)
也可以指定容量，其中capacity為可選參數(shù)
make([]T,length,capacity)
這里len是數(shù)組的長度并且也是切片的初始長度
2. 示例
切片在沒有賦值之前是空值
聲明變量的方式創(chuàng)建切片
package main
import "fmt"
func main() {
var names []string
var numbers []int
fmt.Printf("names: %v\n", names)
fmt.Printf("numbers: %v\n", numbers)
fmt.Println(names == nil)
fmt.Println(numbers == nil)
}
輸出結果如下
names: []
numbers: []
true
true
使用make函數(shù)創(chuàng)建切片
package main
import "fmt"
func main() {
var a = make([]int, 2)
var b = make([]int, 3)
fmt.Printf("a: %v\n", a)
fmt.Printf("b: %v\n", b)
}
輸出結果如下
a: [0 0]
b: [0 0 0]
3. 切片的長度和容量
切片擁有自己的長度和容量，我們可以通過使用內置的len()函數(shù)求出長度，使用內置的cap()函數(shù)求出切片的內容。
package main
import "fmt"
func main() {
var names = []string{"hello", "world"}
var num = []int{1, 2, 3}
fmt.Printf("len: %d cap: %d\n", len(names), cap(names))
fmt.Printf("len: %d cap: %d\n", len(num), cap(num))
fmt.Printf("num[2]: %v\n", num[2])//根據(jù)下標索引來獲取切片的元素
fmt.Println("-----------")
var a = make([]string, 2, 3)
fmt.Printf("len: %d cap: %d", len(a), cap(a))
}輸出結果如下
len: 2 cap: 2
len: 3 cap: 3
num[2]: 3
-----------
len: 2 cap: 3
二、切片的初始化
切片的初始化方式有很多種，可以直接初始化，也可以使用數(shù)組初始化。
1. 直接初始化
package main
import "fmt"
func main() {
a := []int{1, 2, 3}
fmt.Printf("a: %v\n", a)
}
輸出結果如下
a: [1 2 3]
2. 使用數(shù)組初始化
package main
import "fmt"
func main() {
a := [...]int{1, 2, 3}
b := a[:]
fmt.Printf("b: %v\n", b)
}
輸出結果
b: [1 2 3]
3. 使用數(shù)組的部分元素初始化（切片表達式）
切片的底層就是一個數(shù)組，所以我們可以基于數(shù)組通過切片表達式得到切片。
切片表達式中的low和high表示一個索引范圍（包左不包右），得到切片的長度=high-low，容量等于得到的切片的底層數(shù)組的容量。
package main
import "fmt"
func main() {
a := [...]int{1, 2, 3, 4, 5, 6, 7, 8}
b := a[2:5] //下標2到5，左閉右開，不包括5
fmt.Printf("b: %v\n", b)
c := a[2:] //下標2后面的所有
fmt.Printf("c: %v\n", c)
d := a[:3] //下標3之前的，不包括3
fmt.Printf("d: %v\n", d)
e := a[:] //取所有值
fmt.Printf("e: %v\n", e)
}
輸出結果如下
b: [3 4 5]
c: [3 4 5 6 7 8]
d: [1 2 3]
e: [1 2 3 4 5 6 7 8]
4. 空(nil)切片
一個切片在未初始化之前默認為nil，長度為0，容量為0
package main
import "fmt"
func main() {
var a []int
fmt.Println(a == nil)
fmt.Printf("len: %d,cap: %d\n", len(a), cap(a))
}
輸出結果如下
true
len: 0,cap: 0
三、切片的遍歷
切片的遍歷和數(shù)組的遍歷非常類型，可以使用for循環(huán)索引遍歷，或者for range循環(huán)
1. for 循環(huán)遍歷
package main
import "fmt"
func main() {
s1 := []int{1, 2, 3, 4, 5, 6}
for i := 0; i < len(s1); i++ {
fmt.Printf("s1[%d]: %v\n", i, s1[i])
}
}
輸出結果如下
s1[0]: 1
s1[1]: 2
s1[2]: 3
s1[3]: 4
s1[4]: 5
s1[5]: 6
2. for range遍歷
package main
import "fmt"
func main() {
s1 := []int{1, 2, 3, 4, 5, 6}
for i, v := range s1 {
fmt.Printf("i: %v,v: %v\n", i, v)
}
}
輸出結果如下，i是索引，v是值
i: 0,v: 1
i: 1,v: 2
i: 2,v: 3
i: 3,v: 4
i: 4,v: 5
i: 5,v: 6
四、切片元素的添加和刪除copy
切片是一個動態(tài)數(shù)組，可以使用append()函數(shù)添加元素
go 語言中并沒有刪除切片元素的專用方法，我們可以使用切片本身的特性來刪除元素。
由于切片是引用類型，通過賦值的方式，會修改原有內容，go 提供了copy()函數(shù)來拷貝切片
1. 添加元素
package main
import "fmt"
func main() {
a := []int{}
a = append(a, 1)
a = append(a, 2)
a = append(a, 3, 4, 5) //添加多個元素
fmt.Printf("a: %v\n", a)
fmt.Println("---------------------")
a1 := []int{3, 4, 5}
a2 := []int{1, 2}
a2 = append(a2, a1...) //添加另外一個切片進去
fmt.Printf("a2: %v\n", a2)
}
輸出結果如下
a: [1 2 3 4 5]
---------------------
a2: [1 2 3 4 5]
2. 刪除元素
package main
import "fmt"
func main() {
var s1 = []int{1, 2, 3, 4}
fmt.Println("---刪除之前---")
fmt.Printf("s1: %v\n", s1)
//刪除3這個元素，它的下標索引為2
s1 = append(s1[:2], s1[3:]...)
fmt.Println("---刪除之后---")
fmt.Printf("s1: %v\n", s1)
}
執(zhí)行結果如下
---刪除之前---
s1: [1 2 3 4]
---刪除之后---
s1: [1 2 4]
刪除元素的公式
要從切片a中刪除索引為index的元素，操作方法如下
a = append(a[:index], a[index+1:]...)
3. 修改切片元素
package main
import "fmt"
func main() {
var s1 = []int{1, 2, 3, 4, 5}
s1[1] = 100 //索引1的值改為100
fmt.Printf("s1: %v\n", s1)
}
輸出結果如下
s1: [1 100 3 4 5]
4. 查找切片元素
package main
import "fmt"
func main() {
var s1 = []int{1, 2, 3, 4, 5}
var key = 2 //查找2所在的位置
for i, v := range s1 {
if v == key {
fmt.Printf("s1: %v\n", s1)
fmt.Printf("索引為: %v\n", i)
}
}
}
輸出結果如下
s1: [1 2 3 4 5]
索引為: 1
5. 拷貝切片
package main
import "fmt"
func main() {
var s1 = []int{1, 2, 3, 4, 5}
var s2 = s1
s2[0] = 100
fmt.Printf("s1: %v\n", s1)
fmt.Printf("s2: %v\n", s2)
}
輸出結果如下
s1: [100 2 3 4 5]
s2: [100 2 3 4 5]
可以看到當s2的值改變的時候，s1的值也改變了，因為s2復制了s1的是他的內存地址，所以相關聯(lián)都會改變
使用copy方法修改則不會對源切片的值有影響
package main
import "fmt"
func main() {
var s1 = []int{1, 2, 3, 4, 5}
var s2 = make([]int, 4) //需要make一個切片的類型，指定有5個元素
copy(s2, s1) //指定復制的切片
s2[0] = 100
fmt.Printf("s1: %v\n", s1)
fmt.Printf("s2: %v\n", s2)
}
輸出結果
s1: [1 2 3 4 5]
s2: [100 2 3 4 5]
到此這篇關于Go語言實現(xiàn)切片增刪改查的示例代碼的文章就介紹到這了,更多相關Go語言切片增刪改查內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
golang gorm 計算字段和獲取sum()值的實現(xiàn)
這篇文章主要介紹了golang gorm 計算字段和獲取sum()值的實現(xiàn)操作，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-12-12
這篇文章主要介紹了golang?熔斷器的實現(xiàn)過程，Go?項目中使用熔斷技術提高系統(tǒng)容錯性。接下倆就來給打家介紹?go?熔斷器和其使用,需要的朋友可以參考一下2022-01-01
在Golang中，異常處理是非常重要的一部分，能夠有效地控制和處理代碼中的異常情況。通過Golang的異常處理機制，可以優(yōu)雅地捕獲和處理異常，保障代碼的可靠性和穩(wěn)定性。同時，Golang還提供了豐富的工具和API，幫助開發(fā)者更加輕松地進行異常處理2023-04-04
Go語言提供了很多文件操作的支持，在不同場景下，有對應的處理方式，本節(jié)我們來介紹一下Go語言讀取txt文檔的相關知識，感興趣的朋友跟隨小編一起看看吧2022-01-01
在?Golang?語言開發(fā)中，我們經常會使用結構體類型，如果我們使用的結構體類型的變量包含指針類型的字段，我們在記錄日志的時候，指針類型的字段的值是指針地址，將會給我們?debug?代碼造成不便2022-10-10
這篇文章主要為大家詳細介紹了Go語言中Chan實現(xiàn)原理的相關資料，文中的示例代碼講解詳細，對我們學習Go語言有一定的幫助，需要的可以參考一下2023-02-02
本文主要介紹了go語言int64整型轉字符串的實現(xiàn)，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2023-03-03
Golang?pprof監(jiān)控之cpu占用率統(tǒng)計原理詳解
經過前面的幾節(jié)對pprof的介紹，對pprof統(tǒng)計的原理算是掌握了七八十了，但唯獨還沒有分析pprof?工具是如何統(tǒng)計cpu使用情況的，今天我們來分析下這部分2023-04-04
這篇文章主要介紹了go語言使用pipe讀取子進程標準輸出的方法,實例分析了Go語言針對進程操作的技巧,具有一定參考借鑒價值,需要的朋友可以參考下2015-03-03
這篇文章主要介紹了golang time包的用法詳解，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2019-04-04