Retornar uma saudação aleatória

Nesta seção, você vai mudar seu código para que, em vez de retornar sempre uma única saudação, ele retorne uma entre várias mensagens de saudação predefinidas.

Para isso, você vai usar um slice do Go. Um slice é como um array, exceto que o seu tamanho muda dinamicamente conforme você adiciona e remove itens. O slice é um dos tipos mais úteis do Go.

Você vai adicionar um slice pequeno para conter três mensagens de saudação e depois fazer seu código retornar uma delas aleatoriamente. Para saber mais sobre slices, veja Slices em Go no blog do Go.

  1. Em greetings/greetings.go, altere seu código para que fique como o seguinte.
    package greetings
    
    import (
        "errors"
        "fmt"
        "math/rand"
    )
    
    // Hello returns a greeting for the named person.
    func Hello(name string) (string, error) {
        // If no name was given, return an error with a message.
        if name == "" {
            return name, errors.New("empty name")
        }
        // Create a message using a random format.
        message := fmt.Sprintf(randomFormat(), name)
        return message, nil
    }
    
    // randomFormat returns one of a set of greeting messages. The returned
    // message is selected at random.
    func randomFormat() string {
        // A slice of message formats.
        formats := []string{
            "Hi, %v. Welcome!",
            "Great to see you, %v!",
            "Hail, %v! Well met!",
        }
    
        // Return a randomly selected message format by specifying
        // a random index for the slice of formats.
        return formats[rand.Intn(len(formats))]
    }
    

    Neste código, você:

    • Adiciona uma função randomFormat que retorna um formato de mensagem de saudação selecionado aleatoriamente. Observe que randomFormat começa com letra minúscula, o que a torna acessível apenas ao código do próprio pacote (em outras palavras, ela não é exportada).
    • Em randomFormat, declara um slice formats com três formatos de mensagem. Ao declarar um slice, você omite o tamanho entre os colchetes, assim: []string. Isso diz ao Go que o tamanho do array subjacente ao slice pode ser alterado dinamicamente.
    • Usa o pacote math/rand para gerar um número aleatório que seleciona um item do slice.
    • Em Hello, chama a função randomFormat para obter um formato para a mensagem que será retornada e, em seguida, usa o formato e o valor de name juntos para criar a mensagem.
    • Retorna a mensagem (ou um erro), como antes.
  2. Em hello/hello.go, altere seu código para que fique como o seguinte.

    Você só está adicionando o nome Gladys (ou outro nome, se preferir) como argumento da chamada à função Hello em hello.go.

    package main
    
    import (
        "fmt"
        "log"
    
        "example.com/greetings"
    )
    
    func main() {
        // Set properties of the predefined Logger, including
        // the log entry prefix and a flag to disable printing
        // the time, source file, and line number.
        log.SetPrefix("greetings: ")
        log.SetFlags(0)
    
        // Request a greeting message.
        message, err := greetings.Hello("Gladys")
        // If an error was returned, print it to the console and
        // exit the program.
        if err != nil {
            log.Fatal(err)
        }
    
        // If no error was returned, print the returned message
        // to the console.
        fmt.Println(message)
    }
  3. Na linha de comando, no diretório hello, execute hello.go para confirmar que o código funciona. Execute várias vezes e observe que a saudação muda.
    $ go run .
    Great to see you, Gladys!
    
    $ go run .
    Hi, Gladys. Welcome!
    
    $ go run .
    Hail, Gladys! Well met!
    

A seguir, você vai usar um slice para cumprimentar várias pessoas.