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.

Mengisytiharkan dan memulakan kepingan

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.

Ubah suai nilai kepingan

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.

Ciri jenis rujukan bagi kepingan

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.

tambah fungsi kepingan

Di Golang, kita boleh menggunakan fungsi append untuk menambah elemen baharu pada kepingan. appendFungsi 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.

Ciri tatasusunan asas yang dikongsi bagi kepingan

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.

Ringkasan

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!