Go
Slices

Invoering

Syntaxis

• slice: = make ([] type, len, cap) // maak een nieuw segment
• slice = append (slice, item) // voeg een item toe aan een slice
• segment = toevoegen (segment, items ...) // deel van items toevoegen aan een segment
• len: = len (segment) // haal de lengte van een segment op
• cap: = cap (slice) // haal de capaciteit van een slice
• elNum: = copy (dst, slice) // kopieer de inhoud van een slice naar een andere slice

Toevoegen aan segment

slice = append(slice, "hello", "world")

Twee plakjes samen toevoegen

slice1 := []string{"!"}
slice2 := []string{"Hello", "world"}
slice  := append(slice1, slice2...)

Ren in de Go Playground

Elementen verwijderen / plakjes "Slicing"

Als u een of meer elementen uit een segment wilt verwijderen, of als u met een subsegment van een ander bestaand segment moet werken; u kunt de volgende methode gebruiken.

De volgende voorbeelden gebruiken slice of int, maar dat werkt met alle soorten slice.

Dus daarvoor hebben we een plakje nodig, van de heks zullen we enkele elementen verwijderen:

slice := []int{1, 2, 3, 4, 5, 6} 
// > [1 2 3 4 5 6]

We hebben ook de indexen van elementen nodig om te verwijderen:

// index of first element to remove (corresponding to the '3' in the slice)
var first = 2

// index of last element to remove (corresponding to the '5' in the slice)
var last = 4 

En dus kunnen we de plak "in plakjes snijden", waardoor ongewenste elementen worden verwijderd:

// keeping elements from start to 'first element to remove' (not keeping first to remove), 
// removing elements from 'first element to remove' to 'last element to remove'
// and keeping all others elements to the end of the slice
newSlice1 := append(slice[:first], slice[last+1:]...)
// > [1 2 6]

// you can do using directly numbers instead of variables
newSlice2 := append(slice[:2], slice[5:]...)
// > [1 2 6]

// Another way to do the same
newSlice3 := slice[:first + copy(slice[first:], slice[last+1:])]
// > [1 2 6]

// same that newSlice3 with hard coded indexes (without use of variables)
newSlice4 := slice[:2 + copy(slice[2:], slice[5:])]
// > [1 2 6]

Om slechts één element te verwijderen, hoeft u alleen maar de index van dit element als de eerste EN als de laatste te verwijderen index te plaatsen:

var indexToRemove = 3
newSlice5 := append(slice[:indexToRemove], slice[indexToRemove+1:]...)
// > [1 2 3 5 6]

// hard-coded version:
newSlice5 := append(slice[:3], slice[4:]...)
// > [1 2 3 5 6]

En u kunt ook elementen verwijderen uit het begin van het segment:

newSlice6 := append(slice[:0], slice[last+1:]...)
// > [6]

// That can be simplified into
newSlice6 := slice[last+1:]
// > [6]

U kunt ook enkele elementen van het einde van het segment verwijderen:

newSlice7 := append(slice[:first], slice[first+1:len(slice)-1]...)
// > [1 2]

// That can be simplified into
newSlice7 := slice[:first]
// > [1 2]

Als het nieuwe segment exact dezelfde elementen moet bevatten als het eerste, kunt u hetzelfde gebruiken, maar dan als last := first-1 .
(Dit kan handig zijn als uw indexen eerder zijn berekend)

Lengte en capaciteit

Segmenten hebben zowel lengte als capaciteit. De lengte van een segment is het aantal elementen dat zich momenteel in het segment bevindt, terwijl de capaciteit het aantal elementen is dat het segment kan bevatten voordat deze opnieuw moet worden toegewezen.

Wanneer u een segment maakt met de ingebouwde make() -functie, kunt u de lengte en optioneel de capaciteit opgeven. Als de capaciteit niet expliciet is opgegeven, is dit de opgegeven lengte.

var s = make([]int, 3, 5) // length 3, capacity 5

U kunt de lengte van een segment controleren met de ingebouwde len() -functie:

var n = len(s) // n == 3

U kunt de capaciteit controleren met de ingebouwde cap() -functie:

var c = cap(s) // c == 5

Elementen gemaakt door make() worden ingesteld op de nulwaarde voor het elementtype van het segment:

for idx, val := range s {
    fmt.Println(idx, val)
}
// output:
// 0 0
// 1 0
// 2 0

Voer het uit op play.golang.org

U kunt geen toegang krijgen tot elementen voorbij de lengte van een segment, zelfs als de index binnen de capaciteit ligt:

var x = s[3] // panic: runtime error: index out of range

Zolang de capaciteit de lengte overschrijdt, kunt u echter nieuwe elementen toevoegen zonder opnieuw toe te wijzen:

var t = []int{3, 4}
s = append(s, t) // s is now []int{0, 0, 0, 3, 4}
n = len(s) // n == 5
c = cap(s) // c == 5

Als u een segment toevoegt dat de capaciteit mist om de nieuwe elementen te accepteren, wordt de onderliggende array opnieuw toegewezen met voldoende capaciteit:

var u = []int{5, 6}
s = append(s, u) // s is now []int{0, 0, 0, 3, 4, 5, 6}
n = len(s) // n == 7
c = cap(s) // c > 5

Het is daarom over het algemeen een goede gewoonte om voldoende capaciteit toe te wijzen bij het maken van een segment, als u weet hoeveel ruimte u nodig hebt, om onnodige herallocaties te voorkomen.

Inhoud van het ene naar het andere segment kopiëren

Als u de inhoud van een segment naar een in eerste instantie lege segment wilt kopiëren, kunnen de volgende stappen worden genomen om het te bereiken-

1. Maak het bronpunt:

var sourceSlice []interface{} = []interface{}{"Hello",5.10,"World",true}

2. Maak het bestemmingsdeel, met:

• Lengte = lengte van sourceSlice

var destinationSlice []interface{} = make([]interface{},len(sourceSlice))

3. Nu de onderliggende array van de bestemmingsplak groot genoeg is om alle elementen van de bronplak op te nemen, kunnen we de elementen kopiëren met de ingebouwde copy :

copy(destinationSlice,sourceSlice)

Segmenten maken

Segmenten zijn de typische manier waarop programmeurs lijsten met gegevens opslaan.

Gebruik de syntaxis []Type om een segmentvariabele te declareren.

var a []int

Gebruik de syntaxis []Type{values} om een segmentvariabele op één regel te declareren en te initialiseren.

var a []int = []int{3, 1, 4, 1, 5, 9}

Een andere manier om een slice te initialiseren is met de make functie. Het drie argumenten: het Type segment (of kaart ), de length en de capacity .

a := make([]int, 0, 5)

U kunt elementen toevoegen aan uw nieuwe segment met behulp van append .

a = append(a, 5)

Controleer het aantal elementen in uw segment met len .

length := len(a)

Controleer de capaciteit van uw schijf met behulp van de cap . De capaciteit is het aantal elementen dat momenteel is toegewezen voor het segment. Je kunt altijd een schijf toevoegen op capaciteit, omdat Go automatisch een grotere schijf voor je maakt.

capacity := cap(a)

U kunt toegang krijgen tot elementen in een segment met behulp van typische indexeringssyntaxis.

a[0]  // Gets the first member of `a`

U kunt ook een for lus gebruiken for segmenten met range . De eerste variabele is de index in de opgegeven array en de tweede variabele is de waarde voor de index.

for index, value := range a {
    fmt.Println("Index: " + index + " Value: " + value)  // Prints "Index: 0 Value: 5" (and continues until end of slice)
}

Ga spelen

Een segment filteren

Een segment filteren zonder een nieuwe onderliggende array toe te wijzen:

// Our base slice
slice := []int{ 1, 2, 3, 4 }
// Create a zero-length slice with the same underlying array
tmp := slice[:0]

for _, v := range slice {
  if v % 2 == 0 {
    // Append desired values to slice
    tmp = append(tmp, v)
  }
}

// (Optional) Reassign the slice
slice = tmp // [2, 4]

Nulwaarde van segment

De nulwaarde van segment is nil , die de lengte en capaciteit 0 . Een nil segment heeft geen onderliggende array. Maar er zijn ook niet-nul segmenten van lengte en capaciteit 0 , zoals []int{} of make([]int, 5)[5:] .

Elk type dat nulwaarden heeft, kan worden geconverteerd naar nil :

s = []int(nil)

Gebruik om te testen of een segment leeg is:

if len(s) == 0　{
    fmt.Ptintf("s is empty.")
}