Come scoprire la posizione dell'elemento nello slice?

Come si determina la posizione di un elemento presente in slice?

Ho bisogno di qualcosa come il seguente:

type intSlice []int

func (slice intSlice) pos(value int) int {
    for p, v := range slice {
        if (v == value) {
            return p
        }
    }
    return -1
}

Spiacenti, non esiste una funzione di libreria generica per farlo. Go non ha un modo semplice per scrivere una funzione che può operare su qualsiasi slice.

La tua funzione funziona, anche se sarebbe un po 'meglio se la scrivessi usando range.

Se ti capita di avere una fetta di byte, c'è bytes.IndexByte .

Puoi creare funzioni generiche in modo idiomatico:

func SliceIndex(limit int, predicate func(i int) bool) int {
    for i := 0; i < limit; i++ {
        if predicate(i) {
            return i
        }
    }
    return -1
}

E utilizzo:

xs := []int{2, 4, 6, 8}
ys := []string{"C", "B", "K", "A"}
fmt.Println(
    SliceIndex(len(xs), func(i int) bool { return xs[i] == 5 }),
    SliceIndex(len(xs), func(i int) bool { return xs[i] == 6 }),
    SliceIndex(len(ys), func(i int) bool { return ys[i] == "Z" }),
    SliceIndex(len(ys), func(i int) bool { return ys[i] == "A" }))

Potresti scrivere una funzione;

func indexOf(element string, data []string) (int) {
   for k, v := range data {
       if element == v {
           return k
       }
   }
   return -1    //not found.
}

Restituisce l'indice di un carattere / stringa se corrisponde all'elemento. Se non viene trovato, restituisce -1.

Non esiste una funzione di libreria per questo. Devi codificare da solo.

func index(slice []string, item string) int {
    for i, _ := range slice {
        if slice[i] == item {
            return i
        }
    }
    return -1
}

Un'altra opzione è ordinare la fetta utilizzando il pacchetto di ordinamento, quindi cercare l'elemento che stai cercando:

package main

import (
    "sort"
    "log"
    )

var ints = [...]int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}

func main() {
        data := ints
        a := sort.IntSlice(data[0:])
        sort.Sort(a)
        pos := sort.SearchInts(a, -784)
        log.Println("Sorted: ", a)
        log.Println("Found at index ", pos)
}

stampe

2009/11/10 23:00:00 Sorted:  [-5467984 -784 0 0 42 59 74 238 905 959 7586 7586 9845]
2009/11/10 23:00:00 Found at index  1

Funziona per i tipi di base e puoi sempre implementare l'interfaccia di ordinamento per il tuo tipo se devi lavorare su una fetta di altre cose. Vedi http://golang.org/pkg/sort

Dipende da cosa stai facendo però.