Comment faire pour générer une séquence de nombres dans Golang?

Je veux générer une séquence de nombres dans Golang, mais je ne peux pas trouver toutes les fonctions intégrées pour cela.
Fondamentalement, je veux l'équivalent de PHP gamme fonction dans Golang:

array range ( mixed $start , mixed $end [, number $step = 1 ] )

Il serait utile lors de la création d'une tranche/tableau des types numériques, et vous voulez remplir/initialiser avec une séquence numérique.

OriginalL'auteur sepehr | 2016-10-05

  1. 24

    Il n'y a pas d'équivalent PHP range dans la bibliothèque standard. Vous devez créer un vous-même. Le plus simple est d'utiliser un for boucle:

    func makeRange(min, max int) []int {
    a := make([]int, max-min+1)
    for i := range a {
        a[i] = min + i
    }
    return a
}

    De l'utiliser:

    a := makeRange(10, 20)
fmt.Println(a)

    De sortie (essayez sur la Aller De L'Aire De Jeux):

    [10 11 12 13 14 15 16 17 18 19 20]

    Notez également que si la plage est petite, vous pouvez utiliser un composite littérale:

    a := []int{1, 2, 3}
fmt.Println(a) //Output is [1 2 3]

    OriginalL'auteur icza

  2. 3

    1 - Vous pouvez utiliser:

    //Create a slice containing a range of elements.
//
// start: First value of the sequence.
// end:   The sequence is ended upon reaching the end value.
// step:  step will be used as the increment between elements in the sequence.
//        step should be given as a positive number.
//
//Return Values: Returns a slice of elements from start to end, inclusive.
func NewSlice(start, end, step int) []int {
    if step <= 0 || end < start {
        return []int{}
    }
    s := make([]int, 0, 1+(end-start)/step)
    for start <= end {
        s = append(s, start)
        start += step
    }
    return s
}

    Essayer sur La Aller De L'Aire De Jeux:

    package main

import "fmt"

//Create a slice containing a range of elements.
//
// start: First value of the sequence.
// end:   The sequence is ended upon reaching the end value.
// step:  step will be used as the increment between elements in the sequence.
//        step should be given as a positive number.
//
//Return Values: Returns a slice of elements from start to end, inclusive.
func NewSlice(start, end, step int) []int {
    if step <= 0 || end < start {
        return []int{}
    }
    s := make([]int, 0, 1+(end-start)/step)
    for start <= end {
        s = append(s, start)
        start += step
    }
    return s
}

func main() {
    s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println(s) //[0 1 2 3 4 5 6 7 8 9]

    fmt.Println(NewSlice(10, 19, 1))  //[10 11 12 13 14 15 16 17 18 19]
    fmt.Println(NewSlice(10, 28, 2))  //[10 12 14 16 18 20 22 24 26 28]
    fmt.Println(NewSlice(-10, -1, 1)) //[-10 -9 -8 -7 -6 -5 -4 -3 -2 -1]
}

    2 - Vous pouvez utiliser:

    //Returns a slice of elements with exact count.
//step will be used as the increment between elements in the sequence.
//step should be given as a positive, negative or zero number.
func NewSlice(start, count, step int) []int {
    s := make([]int, count)
    for i := range s {
        s[i] = start
        start += step
    }
    return s
}

    Essayer sur La Aller De L'Aire De Jeux:

    package main

import "fmt"

func NewSlice(start, count, step int) []int {
    s := make([]int, count)
    for i := range s {
        s[i] = start
        start += step
    }
    return s
}

func main() {
    s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println(s) //[0 1 2 3 4 5 6 7 8 9]

    fmt.Println(NewSlice(10, 10, 1))  //[10 11 12 13 14 15 16 17 18 19]
    fmt.Println(NewSlice(10, 10, 2))  //[10 12 14 16 18 20 22 24 26 28]
    fmt.Println(NewSlice(-1, 10, -1)) //[-1 -2 -3 -4 -5 -6 -7 -8 -9 -10]
    fmt.Println(NewSlice(20, 10, 0))  //[20 20 20 20 20 20 20 20 20 20]
}

    OriginalL'auteur