En este artículo, vamos a demostrar cómo devolver múltiples valores distintos de una sola función en Go. Esta es una característica muy útil en comparación con la mayoría de los lenguajes de programación donde una función puede devolver solamente un valor. En la mayoría de los lenguajes de programación, si desea devolver múltiples valores, se puede lograr a través del uso de tuplas, hash, modelos o otras formas. Go es uno de los pocos que admite de forma nativa múltiples valores de retorno. Un ejemplo en Go es la función strconv.Atoi() que convierte una string en un int.

Ver el siguiente ejemplo:

i := 2 // Declaración corta de variables(1)
valor, error := strconv.Atoi(i) // resultado del valor int y el mensaje de error (en caso de que falle el proceso de conversión)

En la primera sección (1) se utiliza la declaración corta de variables.

Funciones que devuelven múltiples valores.

Ver el siguiente ejemplo:

func multiplicarValores(valor int) (valorDeParametro int, valorMultiplicado int){
  valorDeParametro = valor // 1
  valorMultiplicado = valor * 10 // 2
  return
}

Este ejemplo ilustra cómo se pueden devolver dos valores int a través de una sola función. En el ejemplo anterior, se pasan un valor int como parámetro y devolverá un valor int (1) que se el parámetro y el otro valor int es el parámetro multiplicado por 10 (2).

Devuelve más de 2 valores

En Go, una función puede devolver más de dos valores en comparación con el ejemplo anterior. No necesitan crear una estructura dedicada para recibir más de dos valores a la vez de una función. El siguiente ejemplo devuelve cuatro valores, dos valores int, un float64 y una string:

func devolverCuatroValores() (int, int, float64, string){
  return 1,2,1.0,"valor de tipo string"
}

Ejemplo práctico

Para este tema, desarrollamos una simple aplicación que cubre esta característica en Go. En este ejemplo, vamos a utilizar los siguientes paquetes: fmt, os y strconv.

Fmt

El paquete fmt implementa I/O formatada que permite imprimir texto en la consola. Para una explicación en profundidad, lea la documentación del Paquete fmt.

Paquete Os

El paquete os proporciona una interfaz independiente de la plataforma para la funcionalidad del sistema operativo. Esta basado en un diseño Unix, pero como manejo errores es Go. Para obtener más información sobre este paquete, lea esta documentación.

Paquete Strconv

El paquete strconv proporciona funcionalidades de conversión de string basadas en los tipos básicos en Go. Para obtener más información sobre este paquete, lea la documentación.

Devuelve dos valores de tipo string

En este ejemplo, implementaremos una simple función que devuelve múltiples valores del tipo string, al igual que el siguiente ejemplo:

func multiRetorno() (valor1 string, valor2 string) {
  valor1 = "valores de retorno 1 de tipo string"
  valor2 = "valores de retorno 2 de tipo string"
  return
}

En este ejemplo, la función devuelve dos valores de tipo string valor1 y valor2. Estos valores serán asignados en la función, ve sección 1 y 2. La palabra return sin ningún argumento automáticamente señala al función para devolver los valores asignados en el orden de la definición en la función. Esta característica en Go es conocida como Named returned values.

Important: Se recomienda utilizar esta función tanto como sea posible para prevenir diferentes tipos de problemas luego en su aplicación.

Devuelve dos valores de tipo int

La función en el ejemplo anterior devuelve dos valores de tipo string. En el siguiente ejemplo, implementaremos una función que devuelve dos valores int:

func multiplicarValores(valor int) (valorDeParametro int, valorMultiplicado int) {
  valorDeParametro = valor
  valorMultiplicado = valor * 10
  return
}

En este ejemplo, la función necesito un parámetro y devolverá dos valores del tipo int, un será el valor del parámetro y el otro será el parámetro multiplicado por 10.

Valores de diferentes tipos

En el siguiente ejemplo, implementaremos una función que devuelve múltiples valores (más de dos) de diferentes tipos:

func multiplicarValorDeDifferenteTipos(valor int) (int, int, string) {
  return valor, valor * 10, "calculado"
}

Esta función devuelve dos valores de tipo int y un valor de tipo string. En este ejemplo, el parámetro será asignado como el primero valor de retorno, el segundo valor de retorno será el parámetro multiplicado por 10 y por último un valor de tipo string.

Ejecutando estas funciones Go

Como puedes observar en los artículos anteriores, cada aplicación Go tiene una función principal (main), que es el punto de entrada principal de la aplicación. Para ejecutar nuestra aplicación para ver como funciones, necesitamos implementar la función principal. En este caso así será nuestro función principal:

func main(){

  (1)
  fmt.Println("\n|------------- Multi retorno ------------------|")
  valor1, valor2 := multiRetorno()(1.1)
  fmt.Println("Valor 1: "+valor1,"\nValor 2: "+ valor2)
  fmt.Println("|------------------------------------------------|")

  (2)
   argument := os.Args
   if len(argument) != 2 {
     fmt.Println("El programa necesita al menos 1 argumento para
     realizar el calculación")(2.3)
     return (2.4)
   }

  (3)
  argumento, error := strconv.Atoi(argument[1]) (3.1)
    if error != nil { (3.2)
      fmt.Println(error) (3.3)// Mensaje de error
      return (3.4)
  }

  (4)
fmt.Println("\n|------------- Multi retorno de tipo int ------------------|")
  argumento, valorMultiplicado := multiplicarValores(argumento) (4.1)
  argumentoConvertidoEnString := strconv.Itoa(argumento)(4.2)
   ValorMultiplicadoConvertidoEnString := strconv.Itoa(valorMultiplicado)(4.3)

   fmt.Println("Valor del argumento (int): "+argumentoConvertidoEnString) (4.4)
   fmt.Println("Argumento de multiplicación (int): "+ValorMultiplicadoConvertidoEnString) (4.5)
   fmt.Println("|-------------------------------------------------|")

 (5)
// Este ejemplo demuestra retorno de múltiples valores de diferentes tipos
   fmt.Println("\n|------------ Retorno múltiple de different tipos --------------------|")
   valorDeArgumento, valorMultiplicadoPor10, resultadoDeLaTarea := multiplicarValorDeDifferenteTipos(argumento) (5.1)

   valorDeArgumentoConvertidoEnString := strconv.Itoa(valorDeArgumento) (5.2)
   valorMultiplicadoPor10ConvertidoEnString := strconv.Itoa(valorMultiplicadoPor10) (5.3)

   fmt.Println("Valor del argumento de tipo int : "+valorDeArgumentoConvertidoEnString)
   fmt.Println("Valor del argumento multiplicado y convertido en un tipo int: "+valorMultiplicadoPor10ConvertidoEnString)
   fmt.Println("Resultado de la tarea en tipo string: "+resultadoDeLaTarea)
   fmt.Println("|------------------------------------------------------------------|")

Sección 1

La primera sección de la función principal es una función que devuelve dos valores de string. Esta es la forma correcta de implementarlo para recuperar dos valores de tipo string de una sola función en Go. La sección 1.1 devuelve dos valores string. La línea que sigue imprime el resultado en la consola 1.2.

Sección 2

En esta sección, vamos a recopilar los valores del argumento (2.1) utilizando la función os.Args que proporciona acceso a argumentos de línea de comandos. Antes de que podamos recuperar los valores de los argumentos, debemos verificar si no es igual a nil. Si el valor es equal a nil significa que no hay argumento(s) (2.2). En caso de que es igual a nil, el programa imprimirá un mensaje en la consola (2.3). Por último, la palabra return señala finalizar la ejecución del programa (2.4).

Sección 3

En la tercera sección, convertiremos el argumento de tipo int en el índice 0 (índice 1 en os.Args) en una valor de tipo string (3.1). La línea que sigue verifica si se ha producido algún error durante el proceso de conversión (3.2). Tenga en cuenta que strconv.Atoi es una función interna de Go que devuelve múltiples valores. En caso de que ocurra un error, sera imprimirá en la consola (3.3). Al igual que en la sección anterior, la palabra return señala finaliza el programa (3.4).

Sección 4

Esta sección es casi igual a la sección anterior, pero en este caso, estamos tratando con una función que devuelven dos valores de tipo int. En este caso recuperaremos múltiples valores de tipo int de la función valorMultiplicado (4.1). En este caso, debemos convertir el valor de tipo int en una string usando strconv.Itoa (4.2). Se puede aplicar lo mismo para los valores multiplicados (4.3). Las secciones 4.4 y 4.5 solo imprimen los resultados en la consola.

Sección 5

La última sección cubrirá situaciones donde se encuentra más de 2 valores de retorno, ve la función multiplicarValorDeDifferenteTipos. Esta función necesita un parámetro de tipo int (5.1). El resultado consiste de dos valores int y un valor string. El primer valor es el parámetro (valorDeArgumento) que sera convertido en un tipo string (5.2). Los valores multiplicados también se convertirán en un tipo string (5.3). El resto de los códigos solo imprime los resultados en la consola.

Ver nuestro proyecto multiReturn para ver los códigos.

Para clonar y ejecutar nuestro códigos en macOS/OSX, lea este articulo.

Para clonar y ejecutar nuestro códigos en Ubuntu (Linux), lea este articulo.

Para clonar y ejecutar nuestro códigos en Windows, lea este articulo.

Resumen

Devolver varios valores es una característica en Go que es muy útil y que brinda mucha flexibilidad sin ningún paso complejo en el medio. Otra característica útil es el Named returned values que prevenir diferentes tipos de errores luego en su aplicación. En este artículo, cubrimos algunos casos de uso que puede encontrar en la práctica, como devolver múltiples valores de tipo string, int y valores de diferentes tipos. Dicha característica es muy útil cuando se trata de crear aplicaciones de servicios web en Go. Los servicios web es un otro tema que será tratada en un artículo posterior.

Recursos relevantes:

Síguenos: