El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Funciones

Siguiente ►
►

Las funciones son bloques de código reutilizables que realizan una tarea específica. En Go, las funciones son fundamentales para estructurar y organizar el código de manera eficiente. En esta sección, aprenderemos cómo definir y utilizar funciones en Go, así como algunos conceptos avanzados relacionados con ellas.

Contenido

  1. Definición de Funciones
  2. Parámetros y Valores de Retorno
  3. Funciones Anónimas y Closures
  4. Funciones como Valores y Tipos
  5. Ejercicios Prácticos
  6. Resumen

Definición de Funciones

En Go, una función se define utilizando la palabra clave func, seguida del nombre de la función, una lista de parámetros entre paréntesis, y el tipo de valor de retorno (si lo hay). El cuerpo de la función se encierra entre llaves {}.

Ejemplo Básico

package main

import "fmt"

// Definición de una función simple que no toma parámetros y no retorna valores
func sayHello() {
    fmt.Println("Hello, World!")
}

func main() {
    // Llamada a la función sayHello
    sayHello()
}

En este ejemplo, la función sayHello imprime "Hello, World!" en la consola.

Parámetros y Valores de Retorno

Las funciones en Go pueden aceptar parámetros y devolver valores. Los parámetros se definen dentro de los paréntesis después del nombre de la función, y los valores de retorno se especifican después de los paréntesis de parámetros.

Ejemplo con Parámetros y Valores de Retorno

package main

import "fmt"

// Definición de una función que toma dos enteros como parámetros y retorna su suma
func add(a int, b int) int {
    return a + b
}

func main() {
    // Llamada a la función add con argumentos 3 y 4
    result := add(3, 4)
    fmt.Println("Result:", result) // Imprime: Result: 7
}

En este ejemplo, la función add toma dos enteros a y b como parámetros y retorna su suma.

Múltiples Valores de Retorno

Go permite que las funciones devuelvan múltiples valores.

package main

import "fmt"

// Definición de una función que retorna dos valores
func divide(a int, b int) (int, int) {
    quotient := a / b
    remainder := a % b
    return quotient, remainder
}

func main() {
    // Llamada a la función divide
    q, r := divide(10, 3)
    fmt.Println("Quotient:", q)   // Imprime: Quotient: 3
    fmt.Println("Remainder:", r)  // Imprime: Remainder: 1
}

En este ejemplo, la función divide retorna el cociente y el residuo de la división de a por b.

Funciones Anónimas y Closures

Las funciones anónimas son funciones sin nombre que se pueden definir y utilizar en el lugar donde se necesitan. Los closures son funciones anónimas que capturan variables del entorno en el que fueron definidas.

Ejemplo de Función Anónima

package main

import "fmt"

func main() {
    // Definición de una función anónima y su llamada inmediata
    func() {
        fmt.Println("Hello from anonymous function!")
    }()
}

Ejemplo de Closure

package main

import "fmt"

func main() {
    // Definición de una función que retorna un closure
    increment := func() func() int {
        i := 0
        return func() int {
            i++
            return i
        }
    }()

    fmt.Println(increment()) // Imprime: 1
    fmt.Println(increment()) // Imprime: 2
    fmt.Println(increment()) // Imprime: 3
}

En este ejemplo, la función anónima captura la variable i y la incrementa cada vez que se llama.

Funciones como Valores y Tipos

En Go, las funciones son ciudadanos de primera clase, lo que significa que se pueden asignar a variables, pasar como argumentos a otras funciones y devolver desde funciones.

Ejemplo de Funciones como Valores

package main

import "fmt"

// Definición de una función que toma otra función como parámetro
func applyOperation(a int, b int, operation func(int, int) int) int {
    return operation(a, b)
}

func main() {
    add := func(a int, b int) int {
        return a + b
    }

    result := applyOperation(5, 3, add)
    fmt.Println("Result:", result) // Imprime: Result: 8
}

En este ejemplo, la función applyOperation toma otra función operation como parámetro y la aplica a a y b.

Ejercicios Prácticos

Ejercicio 1: Función de Multiplicación

Escribe una función llamada multiply que tome dos enteros como parámetros y retorne su producto.

package main

import "fmt"

func multiply(a int, b int) int {
    return a * b
}

func main() {
    result := multiply(4, 5)
    fmt.Println("Result:", result) // Imprime: Result: 20
}

Ejercicio 2: Función de Saludo Personalizado

Escribe una función llamada greet que tome un nombre como parámetro y retorne un saludo personalizado.

package main

import "fmt"

func greet(name string) string {
    return "Hello, " + name + "!"
}

func main() {
    message := greet("Alice")
    fmt.Println(message) // Imprime: Hello, Alice!
}

Ejercicio 3: Función de División con Manejo de Errores

Escribe una función llamada safeDivide que tome dos enteros como parámetros y retorne el cociente y un error si el divisor es cero.

package main

import (
    "errors"
    "fmt"
)

func safeDivide(a int, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := safeDivide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}

Resumen

En esta sección, hemos aprendido sobre:

  • La definición de funciones en Go.
  • Cómo pasar parámetros y retornar valores.
  • El uso de funciones anónimas y closures.
  • Cómo tratar las funciones como valores y tipos.

Las funciones son una herramienta poderosa en Go que te permite escribir código modular y reutilizable. En la siguiente sección, exploraremos las estructuras de datos avanzadas, comenzando con arreglos y slices.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados