Rumah >pembangunan bahagian belakang >Golang >nilai pengubahsuaian hirisan golang
Golang ialah bahasa pengaturcaraan bertaip statik yang menyokong struktur data seperti tatasusunan dan kepingan. Dalam Golang, hirisan ialah jujukan panjang berubah-ubah, serupa dengan tatasusunan dinamik. Ia lebih fleksibel daripada tatasusunan dan boleh membesar atau mengecil dalam saiz pada masa jalan tanpa perlu menentukan saiz terlebih dahulu.
Apabila menggunakan kepingan, kita selalunya perlu mengubah suai elemen kepingan. Artikel ini akan memperincikan cara mengubah suai nilai hirisan di Golang.
Di Golang, anda boleh menggunakan kaedah berikut untuk mengisytiharkan dan memulakan pembolehubah hirisan:
// 声明一个切片 var slice []int // 声明并初始化一个切片 slice := []int{1, 2, 3} // 创建一个长度为5的切片 slice := make([]int, 5) // 创建一个长度为5,容量为10的切片 slice := make([]int, 5, 10)
Seperti yang anda lihat, mencipta kepingan dalam Golang ialah sangat mudah. Panjang dan kapasiti hirisan yang dibuat menggunakan dua kaedah pertama adalah kedua-duanya 3, iaitu bilangan awal elemen ialah 3. Menggunakan fungsi make
, anda boleh membuat kepingan dengan panjang dan kapasiti tertentu.
Dalam Golang, elemen kepingan boleh diakses melalui indeks. Contohnya, untuk mengakses elemen pertama kepingan, anda boleh menggunakan kod berikut:
slice := []int{1, 2, 3} fmt.Println(slice[0]) // 输出1
Jika anda ingin mengubah suai nilai kepingan, anda boleh melakukannya mengikut indeks:
slice := []int{1, 2, 3} slice[0] = 4 fmt.Println(slice) // 输出[4 2 3]
Seperti yang anda lihat, kami menggunakan kaedah pengindeksan mengubah suai elemen pertama kepingan dan mengemas kininya kepada 4.
Jika anda ingin mengubah suai berbilang elemen pada masa yang sama, anda boleh menggunakan for
untuk melingkari hirisan dan mengubah suai setiap elemen:
slice := []int{1, 2, 3} for i := 0; i < len(slice); i++ { slice[i] = slice[i] * 2 } fmt.Println(slice) // 输出[2 4 6]
Di sini kita darabkan setiap elemen dengan 2, dan kemudian Keluarkan kepingan yang diubah suai.
Di Golang, kepingan ialah jenis rujukan, bukan jenis nilai. Ini bermakna apabila kita menghantar kepingan sebagai hujah kepada fungsi, fungsi tersebut akan beroperasi secara langsung pada kepingan asal dan bukannya membuat salinannya.
Berikut ialah contoh:
func modifySlice(slice []int) { slice[0] = 10 } func main() { slice := []int{1, 2, 3} fmt.Println(slice) // 输出[1 2 3] modifySlice(slice) fmt.Println(slice) // 输出[10 2 3] }
Dalam contoh ini, kami mentakrifkan fungsi modifySlice
untuk mengubah suai elemen pertama hirisan. Kami mula-mula mencetak hirisan asal, kemudian panggil fungsi modifySlice
untuk mengubah suai nilai hirisan dan cetak hirisan sekali lagi.
Perhatikan bahawa apabila kita lulus parameter hirisan, fungsi tersebut mengubah suai elemen pertama hirisan asal. Ini kerana kepingan ialah jenis rujukan dan kami menghantar alamat kepingan asal, bukan salinan.
Di Golang, kita boleh menggunakan fungsi append
untuk menambah elemen baharu pada kepingan. append
Fungsi mengembalikan kepingan baharu tanpa mengubah suai kepingan asal.
Berikut ialah contoh menambah elemen pada kepingan menggunakan fungsi append
:
slice := []int{1, 2, 3} slice = append(slice, 4) fmt.Println(slice) // 输出[1 2 3 4]
Dalam contoh ini, kami menggunakan fungsi append
untuk menambah nilai 4 hingga akhir daripada kepingan itu. Ambil perhatian bahawa kami menetapkan nilai pulangan fungsi append
kepada kepingan asal Ini kerana fungsi append
mengembalikan kepingan baharu dan bukannya mengubah suai kepingan asal.
Selain menambah elemen baharu pada kepingan, fungsi append
juga boleh menambah berbilang elemen:
slice := []int{1, 2, 3} newSlice := []int{4, 5, 6} slice = append(slice, newSlice...) fmt.Println(slice) // 输出[1 2 3 4 5 6]
Dalam contoh ini, kami menggunakan operator ...
untuk menghantar newSlice
Berikan fungsi append
. Ini memberitahu pengkompil untuk menambah semua elemen dalam newSlice
ke penghujung kepingan slice
.
Di Golang, kepingan boleh berkongsi tatasusunan asas yang sama. Ini bermakna jika dua keping berkongsi tatasusunan asas yang sama, apabila satu keping diubah suai, nilai keping yang lain juga akan berubah.
Berikut ialah contoh pengubahsuaian menggunakan tatasusunan asas yang dikongsi:
slice := []int{1, 2, 3} newSlice := slice[1:3] newSlice[0] = 4 fmt.Println(slice) // 输出[1 4 3] fmt.Println(newSlice) // 输出[4 3]
Dalam contoh ini kita mencipta kepingan baharu newSlice
yang bermula pada indeks 1 kepingan asal slice
Bermula dan berakhir pada indeks 3. Kami kemudian mengubah suai nilai tatasusunan newSlice
dengan menetapkan elemen pertama slice
.
Perhatikan bahawa sejak newSlice
dan slice
berkongsi tatasusunan asas yang sama, apabila elemen pertama newSlice
diubah suai, nilai elemen kedua slice
juga akan berubah.
Di Golang, kepingan ialah struktur data berguna yang boleh diubah saiz secara dinamik mengikut keperluan. Apabila menggunakan kepingan, kita perlu tahu cara mengubah suai nilai elemen kepingan. Unsur-unsur kepingan boleh diakses dan diubah suai dengan mudah menggunakan indeks. Apabila kita menghantar kepingan ke fungsi, fungsi itu beroperasi terus pada kepingan asal. Selain itu, kepingan juga mempunyai ciri berkongsi tatasusunan asas, yang juga memerlukan perhatian kita.
Atas ialah kandungan terperinci nilai pengubahsuaian hirisan golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!