Cuando trabajamos con funciones en Go, una de las habilidades fundamentales que debemos dominar es cómo pasarles parámetros para que puedan procesar datos de entrada y generar resultados personalizados. Las funciones no solo dividen nuestro código en partes manejables, sino que también nos permiten crear valores que podemos almacenar y usar en cálculos posteriores.
Para que una función acepte parámetros, simplemente los declaramos dentro de los paréntesis que siguen al nombre de la función. Cada parámetro debe tener un nombre, que funciona como una variable local dentro de la función, y un tipo que especifica qué clase de dato esperamos recibir. Por ejemplo, si queremos que una función llamada saludar reciba un nombre, podemos definirla así:
func saludar(nombre string) {
fmt.Println(nombre)
}
Aquí, nombre es el parámetro de tipo string. Cuando llamamos a esta función, debemos pasarle un argumento que sea una cadena de caracteres, como "pepito". Si intentamos llamar a saludar() sin argumentos o con un tipo incorrecto, el compilador nos mostrará un error, ya que Go verifica que el número y tipo de parámetros coincidan con la definición de la función.
Un detalle interesante es que el nombre del parámetro dentro de la función puede ser diferente al nombre de la variable que usamos al llamar a la función. Por ejemplo:
func saludar(nom string) {
fmt.Println(nom)
}
func main() {
nombre := "pepito"
saludar(nombre)
}
Aquí, aunque la variable externa se llama nombre, dentro de la función se recibe como nom. Lo importante es que el valor que se pasa se asigna correctamente al parámetro local.
Además, las funciones pueden aceptar múltiples parámetros, separados por comas. Por ejemplo, si queremos que saludar reciba un saludo y un nombre, podemos definirla así:
func saludar(nombre string, saludo string) {
fmt.Println(saludo, ",", nombre)
}
Al llamar a esta función, debemos pasar dos cadenas de caracteres, por ejemplo:
saludar("pepito", "buenos días")
Esto imprimirá: buenos días , pepito. Si olvidamos pasar alguno de los parámetros o si el tipo no coincide, el compilador nos avisará con un error.
Go también nos permite simplificar la declaración de parámetros cuando varios consecutivos tienen el mismo tipo. En lugar de escribir el tipo para cada parámetro, podemos agruparlos así:
func saludar(nombre, saludo string) {
fmt.Println(saludo, ",", nombre)
}
Esto es especialmente útil para mantener el código más limpio y legible. No todos los lenguajes de programación ofrecen esta característica, por lo que es bueno aprovecharla cuando diseñamos nuestras funciones en Go.
En resumen, al definir funciones en Go, debemos especificar claramente los parámetros que aceptan, con sus nombres y tipos, y al llamarlas, asegurarnos de pasar los argumentos correctos en número y tipo. Esta verificación en tiempo de compilación ayuda a evitar errores y hace que nuestro código sea más robusto y fácil de mantener.