Apa itu slice dalam golang

Dalam golang, hirisan ialah rujukan kepada serpihan bersebelahan tatasusunan ini boleh menjadi keseluruhan tatasusunan atau subset beberapa item yang dikenal pasti oleh indeks permulaan dan akhir. Struktur dalaman hirisan dalam bahasa Go termasuk alamat, saiz dan kapasiti Kepingan biasanya digunakan untuk mengendalikan set data dengan cepat Jika set data dibandingkan dengan memotong kek, sekeping adalah "kepingan" yang anda inginkan proses termasuk bermula dari Di mana untuk bermula (kedudukan permulaan kepingan) dan berapa besar untuk dipotong (saiz kepingan), kapasiti boleh difahami sebagai saiz poket yang memegang kepingan.

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Hiris ialah rujukan kepada serpihan berterusan tatasusunan, jadi hirisan ialah jenis rujukan (jadi lebih serupa dengan jenis tatasusunan dalam C/C, atau jenis senarai dalam Python), serpihan ini boleh Ia adalah keseluruhan tatasusunan, atau ia boleh menjadi subset beberapa item yang dikenal pasti oleh indeks permulaan dan akhir Perlu diingat bahawa item yang dikenal pasti oleh indeks akhir tidak termasuk dalam kepingan.

Struktur dalaman hirisan dalam bahasa Go termasuk alamat, saiz dan kapasiti Kepingan biasanya digunakan untuk mengendalikan set data dengan cepat Jika set data dibandingkan dengan memotong kek, kepingan adalah "kepingan " anda mahu. , proses pemotongan termasuk di mana untuk bermula (kedudukan permulaan kepingan) dan berapa besar untuk dipotong (saiz kepingan). Kapasiti boleh difahami sebagai saiz poket yang memegang kepingan, seperti yang ditunjukkan dalam rajah di bawah.

Rajah: Struktur kepingan dan peruntukan memori

Menjana kepingan baharu daripada tatasusunan atau kepingan

Slices menghala ke kawasan memori berterusan secara lalai, yang boleh menjadi tatasusunan atau kepingan itu sendiri.

Menjana kepingan daripada kawasan memori berterusan ialah operasi biasa Formatnya adalah seperti berikut:

slice [开始位置 : 结束位置]

Sintaks adalah seperti berikut:

• <🎜. >slice: mewakili hirisan sasaran;

• Kedudukan mula: sepadan dengan indeks objek hirisan sasaran; sepadan dengan indeks akhir kepingan sasaran.

• Janakan kepingan daripada tatasusunan, kodnya adalah seperti berikut:

di mana a ialah tatasusunan dengan 3 elemen integer, dimulakan kepada nilai 1 hingga 3, Menggunakan a[1:2] boleh menjana hirisan baharu Hasil kod yang dijalankan adalah seperti berikut:

di mana [2] ialah hasil daripada operasi penghirisan [1:2].

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

Menjana kepingan baharu daripada tatasusunan atau kepingan mempunyai ciri-ciri berikut:

[1 2 3]  [2]

Bilangan elemen yang diambil ialah: kedudukan akhir - kedudukan mula; 🎜>

Elemen yang dikeluarkan tidak termasuk indeks yang sepadan dengan kedudukan akhir hirisan diperoleh menggunakan slice[len(slice)]; 🎜>Apabila kedudukan permulaan lalai digunakan, ia bermakna berterusan Dari awal kawasan ke kedudukan akhir

• Apabila kedudukan akhir lalai digunakan, ia bermakna dari kedudukan mula; ke hujung keseluruhan kawasan berterusan;

• Kedua-duanya pada masa yang sama Secara lalai, ia bersamaan dengan kepingan itu sendiri apabila kedua-duanya

• ialah 0 pada masa yang sama, ia bersamaan dengan kepingan kosong dan biasanya digunakan untuk tetapan semula kepingan.

• Apabila mengambil nilai elemen kepingan mengikut kedudukan indeks, julat nilai ialah (0~len(slice)-1 Jika ia melebihi had, ralat masa jalan akan berlaku dilaporkan. Apabila hirisan dijana, akhir Kedudukan boleh diisi dalam len(slice) tetapi tiada ralat akan dilaporkan. [Cadangan berkaitan:
Pergi tutorial video
• ]
  Mari kita biasakan dengan ciri-ciri menghiris melalui contoh.

• 1) Hasilkan kepingan daripada julat yang ditentukan

Kepingan dan tatasusunan tidak boleh dipisahkan jika tatasusunan difahami sebagai bangunan pejabat, maka penghirisan adalah untuk memisahkan lantai berturut-turut yang berbeza Sewa kepada pengguna. Proses penyewaan memerlukan pemilihan lantai mula dan lantai akhir Proses ini akan menghasilkan kepingan Kod sampel adalah seperti berikut:

Keluaran kod adalah seperti berikut:

<🎜. >

Bangunan bertingkat 30 tingkat dibina dalam kod Nilai elemen tatasusunan dari 1 hingga 30, mewakili tingkat bebas yang berbeza rancangan jualan. Perihalan kod adalah seperti berikut:

var highRiseBuilding [30]int
for i := 0; i < 30; i++ {
        highRiseBuilding[i] = i + 1
}
// 区间
fmt.Println(highRiseBuilding[10:15])
// 中间到尾部的所有元素
fmt.Println(highRiseBuilding[20:])
// 开头到中间指定位置的所有元素
fmt.Println(highRiseBuilding[:2])

Baris 8, cuba sewa lantai selang.

Barisan 11, untuk disewa atas 20 tingkat.

Barisan 14, menyewa bawah 2 tingkat, selalunya kedai komersial.

• Slices adalah sedikit seperti penunjuk dalam bahasa C Penunjuk boleh melakukan operasi, tetapi pada kos operasi memori di luar sempadan, Slices meningkatkan saiz berdasarkan penunjuk kawasan memori yang sepadan dengan kepingan , alamat dan saiz di dalam kepingan tidak boleh dilaraskan secara manual apabila menggunakan kepingan, jadi kepingan itu lebih selamat dan lebih berkuasa daripada penunjuk.

• 2) Mewakili kepingan asal

Dalam format menjana kepingan, apabila kedudukan mula dan akhir diabaikan, kepingan yang dihasilkan akan mewakili sama seperti yang asal kepingan kepingan, dan kepingan yang dihasilkan juga konsisten dalam kandungan data dengan kepingan asal Kodnya adalah seperti berikut:

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

  a 是一个拥有 3 个元素的切片，将 a 切片使用 a[:] 进行操作后，得到的切片与 a 切片一致，代码输出如下：

  

  3) 重置切片，清空拥有的元素

  把切片的开始和结束位置都设为 0 时，生成的切片将变空，代码如下：

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

  代码输出如下：

  

  直接声明新的切片

  除了可以从原有的数组或者切片中生成切片外，也可以声明一个新的切片，每一种类型都可以拥有其切片类型，表示多个相同类型元素的连续集合，因此切片类型也可以被声明，切片类型声明格式如下：

  var name []Type

  其中 name 表示切片的变量名，Type 表示切片对应的元素类型。

  下面代码展示了切片声明的使用过程：

  // 声明字符串切片
  var strList []string
  // 声明整型切片
  var numList []int
  // 声明一个空切片
  var numListEmpty = []int{}
  // 输出3个切片
  fmt.Println(strList, numList, numListEmpty)
  // 输出3个切片大小
  fmt.Println(len(strList), len(numList), len(numListEmpty))
  // 切片判定空的结果
  fmt.Println(strList == nil)
  fmt.Println(numList == nil)
  fmt.Println(numListEmpty == nil)

  代码输出结果：

  

  代码说明如下：

  • 第 2 行，声明一个字符串切片，切片中拥有多个字符串。

  • 第 5 行，声明一个整型切片，切片中拥有多个整型数值。

  • 第 8 行，将 numListEmpty 声明为一个整型切片，本来会在{}中填充切片的初始化元素，这里没有填充，所以切片是空的，但是此时的 numListEmpty 已经被分配了内存，只是还没有元素。

  • 第 11 行，切片均没有任何元素，3 个切片输出元素内容均为空。

  • 第 14 行，没有对切片进行任何操作，strList 和 numList 没有指向任何数组或者其他切片。

  • 第 17 行和第 18 行，声明但未使用的切片的默认值是 nil，strList 和 numList 也是 nil，所以和 nil 比较的结果是 true。

  • 第 19 行，numListEmpty 已经被分配到了内存，但没有元素，因此和 nil 比较时是 false。

  切片是动态结构，只能与 nil 判定相等，不能互相判定相等。声明新的切片后，可以使用 append() 函数向切片中添加元素。

  使用 make() 函数构造切片

  如果需要动态地创建一个切片，可以使用 make() 内建函数，格式如下：

  make( []Type, size, cap )

  其中 Type 是指切片的元素类型，size 指的是为这个类型分配多少个元素，cap 为预分配的元素数量，这个值设定后不影响 size，只是能提前分配空间，降低多次分配空间造成的性能问题。

  示例如下：

  a := make([]int, 2)
  b := make([]int, 2, 10)
  
  fmt.Println(a, b)
  fmt.Println(len(a), len(b))

  代码输出如下：

  

  其中 a 和 b 均是预分配 2 个元素的切片，只是 b 的内部存储空间已经分配了 10 个，但实际使用了 2 个元素。

  容量不会影响当前的元素个数，因此 a 和 b 取 len 都是 2。

  温馨提示

  使用 make() 函数生成的切片一定发生了内存分配操作，但给定开始与结束位置（包括切片复位）的切片只是将新的切片结构指向已经分配好的内存区域，设定开始与结束位置，不会发生内存分配操作。

  更多编程相关知识，请访问：编程视频！！

  Atas ialah kandungan terperinci Apa itu slice dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!