Prijunkite du griežinėliai „Go“

Bandau sujungti gabalą [1, 2] ir gabalėlį [3, 4] . Kaip tai padaryti Go?

Bandžiau:

 append([]int{1,2}, []int{3,4}) 

bet gavo:

 cannot use []int literal (type []int) as type int in append 

Tačiau atrodo, kad dokumentai rodo, kad yra įmanoma, kad trūksta?

 slice = append(slice, anotherSlice...) 
193
27 апр. nustatė Kevin Burke , balandžio 27 d 2013-04-27 07:08 '13, 7:08, 2013-04-27 07:08
@ 4 atsakymai

Pridėkite taškų po antrojo fragmento:

 //---------------------------vvv append([]int{1,2}, []int{3,4}...) 

Tai panaši į bet kurią kitą variacijos funkciją.

 func foo(is ...int) { for i := 0; i < len(is); i++ { fmt.Println(is[i]) } } func main() { foo([]int{9,8,7,6,5}...) } 
315
27 апр. vartotojo1106925 atsakymas 27 Bal 2013-04-27 07:12 '13, 7:12, 2013-04-27 07:12

Fragmentų pridėjimas ir kopijavimas

Priedo varianto funkcija prideda n ar daugiau x reikšmių s tipo s , kuri turi būti pjūvio rūšis, ir grąžina pjūvio, taip pat ir s tipo, rezultatą. x reikšmės perduodamos tipui ...T , kur T yra elemento tipas s ir taikomos atitinkamos parametrų perdavimo taisyklės. Ypatingu atveju papildymas taip pat priima pirmąjį argumentą, priskirtą tipui []byte su antruoju argumentų string po kurios seka ... Ši forma prideda eilutės baitus.

 append(s S, x ...T) S // T is the element type of S s0 := []int{0, 0} s1 := append(s0, 2) // append a single element s1 == []int{0, 0, 2} s2 := append(s1, 3, 5, 7) // append multiple elements s2 == []int{0, 0, 2, 3, 5, 7} s3 := append(s2, s0...) // append a slice s3 == []int{0, 0, 2, 3, 5, 7, 0, 0} 

Argumentų perdavimas ... Parametrai

Jei f yra kintamasis su baigtiniu parametro tipu ...T , tuomet per funkciją argumentas yra lygiavertis []T tipo parametrams. Kiekviename kvietime į f , galutinis parametras perduodamas argumentas yra naujas []T tipo gabalas, kurio vėlesni elementai yra tikrieji argumentai, kurie visi turi būti priskirti T tipui. Todėl pjūvio ilgis yra argumentų, susijusių su galutiniu parametru, skaičius ir gali skirtis kiekvienoje skambučio vietoje.

Atsakymas į jūsų klausimą yra pavyzdys s3 := append(s2, s0...)Go > . Pavyzdžiui

border=0
 s := append([]int{1, 2}, []int{3, 4}...) 
36
27 апр. peterSO atsakymas, balandžio 27 d 2013-04-27 15:18 '13, 15:18, 2013-04-27 15:18

Nieko kitokio atsakymo, bet trumpą paaiškinimą dokumentuose turėjau suprantamesnis nei jų pavyzdžiai:

funkcija pridedama

func append(slice []Type, elems ...Type) []Type inline funkciją, elementai pridedami prie fragmento pabaigos. Jei tai yra pakankamai pralaidumo, paskirties vieta bus perskirstyta, kad būtų galima priimti naujus elementus. Jei ne, nauja bazinė masyvas bus priskirtas. priedas grąžina atnaujintą fragmentą. Todėl būtina išsaugoti papildymo rezultatą, dažnai kintamąjį, kuriame yra pati gabalas:

 slice = append(slice, elem1, elem2) slice = append(slice, anotherSlice...) 

Ypatingu atveju yra teisėta pridėti eilutę į baito dalį, pavyzdžiui:

 slice = append([]byte("hello "), "world"...) 
16
17 апр. atsakymas pateikiamas fiatjaf 17 Bal. 2015-04-17 05:03 '15, 5:03, 2015-04-17 05:03

Manau, svarbu pažymėti ir žinoti, kad jei paskirties skiltelė (pridedamas fragmentas) turi pakankamą talpą, pridėjimas įvyksta vietoje, paskiriant gavėją (pakartotinai pridedant, kad padidintumėte jo ilgį).

Tai reiškia, kad jei taikinys sukuriamas pjaustant didesnę masyvą arba sluoksnį, turintį papildomų elementų, kurie yra ne tik dėl gauto fragmento ilgio, jie gali būti perrašyti.

Norėdami tai įrodyti, žr. Šį pavyzdį:

 a := [10]int{1, 2} fmt.Printf("a: %v\n", a) x, y := a[:2], []int{3, 4} fmt.Printf("x: %v, y: %v\n", x, y) fmt.Printf("cap(x): %v\n", cap(x)) x = append(x, y...) fmt.Printf("x: %v\n", x) fmt.Printf("a: %v\n", a) 

Išvada (pabandykite eiti žaidimų aikštelėje ):

 a: [1 2 0 0 0 0 0 0 0 0] x: [1 2], y: [3 4] cap(x): 10 x: [1 2 3 4] a: [1 2 3 4 0 0 0 0 0 0] 

Mes sukūrėme paramos a masyvą, kurio ilgis yra 10 . Tada mes sukuriame užduoties x pjūvį, pjaustant šį masyvą a , pjūvis y sukuriamas naudojant junginį literal []int{3, 4} . Dabar, kai pridedame y į x , rezultatas yra tikėtinas [1 2 3 4] , bet tai gali būti stebina tai, kad palaikymo masyvas a pat pasikeitė, nes talpa x yra 10 , o tai yra pakankamai, kad pridėtumėte y todėl x bus perskaičiuotas, kuris taip pat naudoja tą patį masyvą palaikymo a , ir append() nukopijuos elementus y ten.

Jei norite to išvengti, galite naudoti išraiškos pilną sluoksnį , kuris turi formą

 a[low : high : max] 

kuri sukuria gabalėlį ir taip pat kontroliuoja gautą gabalėlių talpą, nustatydama max - low .

Žr. Modifikuotą pavyzdį (vienintelis skirtumas yra tas, kad mes sukuriame x taip: x = a[:2:2] :

 a := [10]int{1, 2} fmt.Printf("a: %v\n", a) x, y := a[:2:2], []int{3, 4} fmt.Printf("x: %v, y: %v\n", x, y) fmt.Printf("cap(x): %v\n", cap(x)) x = append(x, y...) fmt.Printf("x: %v\n", x) fmt.Printf("a: %v\n", a) 

Atsijungti (pabandykite apsilankyti žaidimų aikštelėje )

 a: [1 2 0 0 0 0 0 0 0 0] x: [1 2], y: [3 4] cap(x): 2 x: [1 2 3 4] a: [1 2 0 0 0 0 0 0 0 0] 

Kaip matote, mes gauname tą patį rezultatą x , bet palaikymo masyvas a nepasikeitė, nes talpa x buvo „tik“ 2 (dėl išraiškos a[:2:2] pilnų fragmentų). Taigi, pridedant priedą, priskiriamas naujas paramos masyvas, kuris gali saugoti ir x ir y elementus, kurie skiriasi nuo a .

6
14 окт. atsakymas duodamas icza 14 oct. 2016-10-14 10:04 '16 at 10:04 2016-10-14 10:04

Kiti klausimai apie žymes arba Užduoti klausimą