Existe uma maneira de iterar em uma fatia ao contrário no Go?

95

Seria conveniente ser capaz de dizer algo como:

for _, element := reverse range mySlice {
        ...
}

go

— agam
fonte

139

Não, não há um operador conveniente para adicionar ao alcance um existente. Você terá que fazer uma contagem regressiva normal do loop for:

s := []int{5, 4, 3, 2, 1}
for i := len(s)-1; i >= 0; i-- {
   fmt.Println(s[i])
}

— Ulf Holm Nielsen
fonte

A página go efetiva é um exemplo, mas esta é realmente um pouco melhor e declara menos variáveis.

— Kevin Cantwell

3

IMO Go precisa desesperadamente de uma construção de alcance descendente. Não ter acarreta muito trabalho extra, como podemos ver .... -

— Vetor

24

Eu não diria desesperadamente, seria bom.

— Adam Kurkiewicz

46

Você também pode fazer:

s := []int{5, 4, 3, 2, 1}
for i := range s {
        fmt.Println(s[len(s)-1-i]) // Suggestion: do `last := len(s)-1` before the loop
}

Resultado:

Também aqui: http://play.golang.org/p/l7Z69TV7Vl

— zzzz
fonte

14

Variação com índice

for k := range s {
        k = len(s) - 1 - k
        // now k starts from the end
    }

— Nicky Feller
fonte

6

Que tal usar adiar:

s := []int{5, 4, 3, 2, 1}
for i, _ := range s {
   defer fmt.Println(s[i])
}

— Matt
fonte

8

Votei positivamente apenas pelo fato de que trouxe algum conhecimento novo sobre, defermas acredito que usar isso dentro de um loop para reverso é bastante complicado e deve ser bastante ineficaz em termos de memória.

— Alexander Trakhimenok

10

Ele "funciona", mas se o loop não for a última coisa na função, você poderá obter resultados inesperados. Exemplo.

— Daniel

5

Isso está sendo usado deferde uma forma para a qual não se destina. Não use isso, pois pode ter efeitos colaterais desagradáveis (execução fora de ordem). Basta usar o forloop na resposta aceita. O objetivo do Go é minimizar esse tipo de hacks inteligentes (não), uma vez que eles tendem a morder sua bunda mais tarde.

— RickyA

4

Este é um uso hacky de adiar e deve ser evitado. Se esta for, por exemplo, uma função que alguém pode estender no futuro, pode ter consequências indesejadas.

— Amir Keibi de

4

Isso não era muito 'duvidoso' o suficiente, então eu fui em frente e adicionei os canais play.golang.org/p/GodEiv1LlIJ

— Xeoncross

4

Pode-se usar um canal para reverter uma lista em uma função sem duplicá-la. Isso torna o código mais agradável no meu sentido.

package main

import (
    "fmt"
)

func reverse(lst []string) chan string {
    ret := make(chan string)
    go func() {
        for i, _ := range lst {
            ret <- lst[len(lst)-1-i]
        }
        close(ret)
    }()
    return ret
}

func main() {
    elms := []string{"a", "b", "c", "d"}
    for e := range reverse(elms) {
        fmt.Println(e)
    }
}

— user983716
fonte

Isso me parece uma solução limpa e agradável de usar. É possível generalizar isso usando o tipo []interface{}? Porque a reversefunção presente só suporta strings.

— Atmocreations

Com certeza, basta substituir a string pela interface {} e você está pronto para ir. Só quero enfatizar que uma função com assinatura func reverse(lst []interface{}) chan inyterface{} não aceitará mais uma string [] como entrada. Mesmo que a string possa ser convertida na interface {}, [] string não pode ser convertida na [] interface {}. Infelizmente, a função reversa atual é o tipo de função que precisa ser muito reescrita.

— user983716

Obrigado. Essa é a parte feia de ir, eu acho - o que é de alguma forma inevitável. Obrigado!

— Atmocreations

Eu implementaria uma pilha em vez disso.

— ᐅ devrimbaris

0

Quando preciso extrair elementos de uma fatia e intervalo reverso, uso algo como este código:

// reverse range
// Go Playground: https://play.golang.org/p/gx6fJIfb7fo
package main

import (
    "fmt"
)

type Elem struct {
    Id   int64
    Name string
}

type Elems []Elem

func main() {
    mySlice := Elems{{Id: 0, Name: "Alice"}, {Id: 1, Name: "Bob"}, {Id: 2, Name: "Carol"}}
    for i, element := range mySlice {
        fmt.Printf("Normal  range: [%v] %+v\n", i, element)
    }

    //mySlice = Elems{}
    //mySlice = Elems{{Id: 0, Name: "Alice"}}
    if last := len(mySlice) - 1; last >= 0 {
        for i, element := last, mySlice[0]; i >= 0; i-- {
            element = mySlice[i]
            fmt.Printf("Reverse range: [%v] %+v\n", i, element)
        }
    } else {
        fmt.Println("mySlice empty")
    }
}

Resultado:

Normal  range: [0] {Id:0 Name:Alice}
Normal  range: [1] {Id:1 Name:Bob}
Normal  range: [2] {Id:2 Name:Carol}
Reverse range: [2] {Id:2 Name:Carol}
Reverse range: [1] {Id:1 Name:Bob}
Reverse range: [0] {Id:0 Name:Alice}

Playground: https://play.golang.org/p/gx6fJIfb7fo

— Vladimir filin
fonte