Go
skivor

Introduktion

Syntax

• skiva: = make ([] typ, len, cap) // skapa en ny skiva
• skiva = bifoga (skiva, objekt) // bifoga ett objekt till ett segment
• skiva = bifoga (skiva, artiklar ...) // lägga till bitar av objekt till en skiva
• len: = len (skiva) // få längden på en skiva
• mössa: = lock (skiva) // få kapaciteten för en skiva
• elNum: = kopiera (dst, skiva) // kopiera innehållet i en skiva till en annan skiva

Tillägg till skiva

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

Lägga till två skivor tillsammans

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

Kör på Go Playground

Ta bort element / "Skivning" -skivor

Om du behöver ta bort ett eller flera element från en skiva, eller om du behöver arbeta med en delskiva från en annan befintlig; Du kan använda följande metod.

Följande exempel använder skiva int, men som fungerar med alla typer av skivor.

Så för det behöver vi en bit, från häxa tar vi bort några element:

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

Vi behöver också index för element för att ta bort:

// 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 

Och så kan vi "skära" skivan och ta bort oönskade element:

// 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]

För att ta bort bara ett element måste du bara sätta indexet för detta element som det första OCH som det sista indexet som ska tas bort, precis så:

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]

Och du kan också ta bort element från början av segmentet:

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

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

Du kan också ta bort vissa element från slutet av segmentet:

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

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

Om den nya skivan måste innehålla exakt samma element än den första, kan du använda samma sak men med last := first-1 .
(Detta kan vara användbart om dina index har beräknats tidigare)

Längd och kapacitet

Skivor har både längd och kapacitet. Längden på en skiva är antalet element som för närvarande finns i skivan, medan kapaciteten är antalet element som skivan kan hålla innan de behöver omfördelas.

När du skapar ett segment med den inbyggda make() -funktionen kan du ange dess längd och eventuellt dess kapacitet. Om kapaciteten inte specifikt anges kommer den att vara den angivna längden.

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

Du kan kontrollera längden på ett segment med den inbyggda len() -funktionen:

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

Du kan kontrollera kapaciteten med den inbyggda cap() -funktionen:

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

Element som skapas av make() ställs in på nollvärdet för segmentens elementtyp:

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

Kör den på play.golang.org

Du kan inte få tillgång till element som är längre än en bit, även om indexet är inom kapacitet:

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

Så länge kapaciteten överstiger längden kan du dock lägga till nya element utan att omfördela:

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

Om du lägger till ett segment som saknar kapacitet att acceptera de nya elementen kommer den underliggande matrisen att omfördelas för dig med tillräcklig kapacitet:

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

Det är därför generellt god praxis att tilldela tillräcklig kapacitet när du först skapar en bit, om du vet hur mycket utrymme du behöver, för att undvika onödiga omfördelningar.

Kopiera innehållet från ett segment till ett annat segment

Om du vill kopiera innehållet i en skiva till en initialt tom skiva kan du vidta följande steg för att göra det-

1. Skapa källskivan:

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

2. Skapa destinationsskivan med:

• Längd = Längd på källskiva

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

3. Nu när destinationsskivans underliggande array är tillräckligt stor för att rymma alla elementen i källskivan, kan vi fortsätta att kopiera elementen med den inbyggda copy :

copy(destinationSlice,sourceSlice)

Skapa skivor

Skivor är det typiska sättet att programmerare lagrar datalistor.

För att förklara en segmentvariabel använder du []Type syntax.

var a []int

För att deklarera och initiera en segmentvariabel på en rad använder du syntaxen []Type{values} .

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

Ett annat sätt att initialisera en bit är med make funktionen. Det tre argument: Type av segmentet (eller kartan ), length och capacity .

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

Du kan lägga till element till din nya bit med hjälp av append .

a = append(a, 5)

Kontrollera antalet element i skivan med len .

length := len(a)

Kontrollera kapaciteten på din skiva med cap . Kapaciteten är antalet element som för närvarande tilldelas att vara i minnet för segmentet. Du kan alltid lägga till ett segment med kapacitet eftersom Go automatiskt skapar en större bit för dig.

capacity := cap(a)

Du kan komma åt element i ett segment med typisk indexeringssyntax.

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

Du kan också använda en for slinga över skivor med range . Den första variabeln är indexet i den angivna arrayen, och den andra variabeln är värdet för indexet.

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

Gå lekplats

Filtrera en bit

Så här filtrerar du ett segment utan att tilldela ett nytt underliggande array:

// 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]

Nollvärde på skivan

Nollvärdet för skivan är nil , som har längden och kapaciteten 0 . En nil har ingen underliggande grupp. Men det finns också icke-nollskivor med längd och kapacitet 0 , som []int{} eller make([]int, 5)[5:] .

Alla typer som har nollvärden kan konverteras till nil :

s = []int(nil)

För att testa om ett segment är tomt använder du:

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