Sebuah artikel menganalisis secara ringkas hirisan di Golang

Artikel ini akan mengajar anda tentang Golang dan bercakap tentang Slice dalam asas bahasa Go. Saya harap ia akan membantu anda.

1 Definisi kepingan

Daripada bahagian sebelumnya kita tahu bahawa kerana panjang tatasusunan adalah tetap dan tatasusunan panjang kepunyaan Sebahagian daripada jenis, sudah ada tiga elemen dalam tatasusunan a, dan kami tidak lagi boleh menambah elemen baharu pada tatasusunan a. Dalam js, adalah perkara biasa bagi kita untuk menambah elemen pada tatasusunan dan operasi lain Jadi apa yang perlu kita lakukan dengan pergi? Ini akan memperkenalkan fokus kami hari ini - menghiris. [Cadangan tutorial pengaturcaraan: Tutorial Pengaturcaraan]

Kepingan ialah jujukan unsur-unsur yang sama dengan jenis yang sama. Ia adalah lapisan enkapsulasi berdasarkan jenis tatasusunan. Ia sangat fleksibel dan menyokong pengembangan automatik. Potongan ialah jenis rujukan dan struktur dalamannya mengandungi 地址, 长度 dan 容量. Slices biasanya digunakan untuk beroperasi dengan cepat pada koleksi data.

Sintaks asas untuk mengisytiharkan jenis kepingan adalah seperti berikut:

var name []T

Di mana,

• nama: mewakili nama pembolehubah
• T : mewakili hirisan Jenis unsur

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比较
}

2 Ungkapan penghirisan mudah

Lapisan bawah hirisan ialah tatasusunan, jadi kita boleh. dapatkannya melalui ungkapan penghirisan berdasarkan kepingan tatasusunan. low dan high dalam ungkapan penghirisan mewakili julat indeks (kiri disertakan, kanan tidak disertakan), iaitu, kod berikut memilih elemen 1<=索引值<4 daripada tatasusunan a untuk membentuk kepingan s, dan kepingan yang terhasil ialah 长度=high-low, kapasiti adalah sama dengan kapasiti tatasusunan asas bagi kepingan yang diperolehi.

func main() {
	a := [5]int{1, 2, 3, 4, 5}
	s := a[1:3]  // s := a[low:high]
	fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
}



输出：
a[2:]  // 等同于 a[2:len(a)]
a[:3]  // 等同于 a[0:3]
a[:]   // 等同于 a[0:len(a)]

3 Lengkapkan ungkapan hirisan

untuk tatasusunan, penuding kepada tatasusunan atau hiris a(Perhatikan bahawa ia tidak boleh menjadi rentetan ) menyokong ungkapan hirisan penuh

a[low : high : max]

Kod di atas akan membina hirisan jenis yang sama, panjang yang sama dan elemen sebagai ungkapan hirisan ringkas a[low: high]. Selain itu, ia menetapkan kapasiti kepingan yang terhasil kepada max-low. Hanya nilai indeks pertama (rendah) boleh ditinggalkan dalam ungkapan penghirisan penuh ia lalai kepada 0.

func main() {
	a := [5]int{1, 2, 3, 4, 5}
	t := a[1:3:5]
	fmt.Printf("t:%v len(t):%v cap(t):%v\n", t, len(t), cap(t))
}

输出：
t:[2 3] len(t):2 cap(t):4

Syarat yang perlu dipenuhi ungkapan hirisan lengkap ialah 0 <= low <= high <= max <= cap(a), dan syarat lain adalah sama dengan ungkapan hirisan ringkas.

4 Gunakan fungsi make() untuk membina kepingan

Kita semua mencipta kepingan berdasarkan tatasusunan, kita perlu untuk menggunakan Fungsi make() terbina dalam mempunyai format berikut:

make([]T, size, cap)

di mana:

• T: jenis elemen hirisan
• saiz : bilangan elemen dalam kepingan
• kap: Kapasiti kepingan

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

Dalam kod di atas, 10 ruang storan dalaman a telah diperuntukkan, tetapi hanya 2 sahaja yang digunakan. Kapasiti tidak menjejaskan bilangan elemen semasa, jadi len(a) mengembalikan 2, dan cap(a) mengembalikan kapasiti hirisan.

5 Tentukan sama ada kepingan itu kosong

Intipati kepingan adalah untuk merangkum tatasusunan pendasar Ia mengandungi tiga keping maklumat: penunjuk pendasar tatasusunan dan panjang hirisan (len) dan kapasiti hirisan (cap).

kepingan tidak boleh dibandingkan. Kami tidak boleh menggunakan operator == untuk menentukan sama ada dua keping mengandungi semua elemen yang sama. Satu-satunya operasi perbandingan undang-undang untuk kepingan adalah dengan nil. Sekeping nilai nil tidak mempunyai tatasusunan asas dan panjang serta kapasiti sekeping nilai nil adalah kedua-duanya 0. Tetapi kita tidak boleh mengatakan bahawa kepingan dengan kedua-dua panjang dan kapasiti mestilah nil, seperti contoh berikut:

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

Untuk menyemak sama ada kepingan itu kosong, sentiasa gunakan len(s) == 0 untuk menilai dan s == nil tidak boleh digunakan untuk menilai.

6. Salinan tugasan hirisan

Dua pembolehubah sebelum dan selepas menyalin berkongsi tatasusunan asas Pengubahsuaian satu keratan akan menjejaskan kandungan kepingan lain perhatian.

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

7. Melintasi hirisan

Kaedah melintasi kepingan adalah sama seperti tatasusunan, dan menyokong traversal indeks dan for range traversal.

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

8 Kaedah append() menambah elemen pada kepingan

Fungsi terbina dalam bahasa Go append() boleh menambah elemen secara dinamik pada kepingan itu. Anda boleh menambah satu elemen pada satu masa, berbilang elemen atau elemen daripada kepingan lain (diikuti dengan...).

func main(){
	var s []int
	s = append(s, 1)        // [1]
	s = append(s, 2, 3, 4)  // [1 2 3 4]
	s2 := []int{5, 6, 7}  
	s = append(s, s2...)    // [1 2 3 4 5 6 7]
}

Kepingan bernilai sifar yang diisytiharkan melalui var boleh digunakan terus dalam fungsi append() tanpa pengamulaan.

var s []ints = append(s, 1, 2, 3)

每个切片会指向一个底层数组，这个数组的容量够用就添加新增元素。当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行“扩容”，此时该切片指向的底层数组就会更换。“扩容”操作往往发生在append()函数调用时，所以我们通常都需要用原变量接收append函数的返回值。

9.使用copy()函数复制切片

由于切片是引用类型，所以a和b其实都指向了同一块内存地址。修改b的同时a的值也会发生变化。

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

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

10.从切片中删除元素

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:]...)

结束:

再次提醒，需要进技术交流群的同学，可以加我微信fangdongdong_25,需要进前端工程师交流群的备注“前端”，需要进go后端交流群的备注“go后端”

【相关推荐：Go视频教程】

Atas ialah kandungan terperinci Sebuah artikel menganalisis secara ringkas hirisan di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!