Comment connaître la position de l'élément dans la tranche?

Comment déterminer la position d'un élément présent en tranche?

J'ai besoin de quelque chose comme ce qui suit:

type intSlice []int

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

Désolé, il n'y a pas de fonction de bibliothèque générique pour faire cela. Go n'a pas un moyen simple d'écrire une fonction qui peut fonctionner sur n'importe quelle tranche.

Votre fonction fonctionne, même si ce serait un peu mieux si vous l'écriviez en utilisant range.

Si vous avez une tranche d'octets, il y a bytes.IndexByte .

Vous pouvez créer une fonction générique de manière idiomatique:

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

Et l'utilisation:

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" }))

Vous pouvez écrire une fonction;

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

Cela renvoie l'index d'un caractère / chaîne s'il correspond à l'élément. S'il n'est pas trouvé, renvoie un -1.

Il n'y a pas de fonction de bibliothèque pour cela. Vous devez coder vous-même.

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

Une autre option consiste à trier la tranche à l'aide du package de tri, puis à rechercher l'élément que vous recherchez:

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)
}

impressions

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

Cela fonctionne pour les types de base et vous pouvez toujours implémenter l'interface de tri pour votre propre type si vous avez besoin de travailler sur une tranche d'autres choses. Voir http://golang.org/pkg/sort

Cela dépend de ce que vous faites.