Recientemente he recibido una duda de uno de mis alumnos.
Creo que por la importancia de la misma, es conveniente crear un articulo que explique este asunto.
Es importante entender cual es la regla que se sigue para poner los Nombres de parámetros en Swift.
¿Hay que escribir o indicar el nombre de los parámetros en Swift?
Si nos fijamos en el siguiente método, se omite el nombre del primer parámetro, pero no el resto.
timer = NSTimer.scheduledTimerWithTimeInterval (0.10, target: self, selector: «cambiaProgreso:», userInfo: nil, repeats: true)
La documentación de Apple nos dice lo siguiente:
“Swift gives the first parameter name in a method a local parameter name by default, and gives the second and subsequent parameter names both local and external parameter names by default. This convention matches the typical naming and calling convention you will be familiar with from writing Objective-C methods, and makes for expressive method calls without the need to qualify your parameter names.”
O lo que es lo mismo, que para que los que venimos de Objective-C, Swift nos resulte más familiar, hay que indicar el nombre externo del segundo y sucesivos nombres de parámetros, pero no del primero, que no es necesario.
Seguimos con Objective-C o lo queremos borrar del mapa
En Objective-C siempre que usábamos un método de inicialización, o un método de clase, debíamos incluir el nombre de sus parámetros externos sí o sí.
Claro, esto era una de las cosas que dividía a los desarrolladores en dos bandos, los que odiaban que el lenguaje fuera tan descriptivo, y los que amaban Objective-C precisamente por esto, por lo descriptivo del mismo.
Apple con Swift quiere que escribamos menos código, quiere que su nuevo lenguaje sea más parecido a Java o a cualquier otro que a Objective-C, pero creo que no está siendo lo suficientemente clara al respecto.
Intentaré aclarar un poco este asunto.
Funciones Simples
En el caso de simples funciones, no es necesario indicar el nombre externo de los parámetros, sin embargo pueden incluirse para hacer el código más legible, de hecho Apple lo recomienda, y aquí es dónde en mi opinión, no queda muy clara la cosa.
Apple dice: sólo indica el nombre externo del parámetro si la función o método ofrece dudas en relación a ese parámetro, de lo contrario, es decir si ese parámetro no ofrece dudas de lo que es, omite el nombre externo del parámetro.
Apple también dice: para hacer tu código más legible por otros, indica siempre que puedas el nombre externo de los parámetros.
Pero pongamos un ejemplo, imaginaos que tenemos la siguiente función:
func dosEnteros (Int, Int) {
}
Podemos llamar a esta función de la siguiente manera:
dosEnteros (10, 20)
Sin embargo si en la propia declaración establecemos un nombre de parámetro para cada uno de los parámetros, como por ejemplo esto:
func dosEnteros (s: Int, b: Int) {
println(«i=\(s) j=\(b)»)
}
Podemos llamar a esta función de la siguiente manera:
dosEnteros (10, b: 20)
Pero si intentamos llamarla de esta forma el compilador nos mostrará un error:
dosEnteros (10, 20)
Como ves, el nombre del primer parámetro se puede omitir, no así el segundo.
Crear nombres de parámetros externos
Para crear nombres de parámetros externos pondremos un nombre antes del nombre interno del parámetro.
Por ejemplo:
func dosEnteros (primerParametro i: Int, segundoParametro j: Int) {
}
En la función anterior primerParametro y segundoParametro serían los nombres externos, y s: y b: los nombres internos.
Al crear la función con nombres externos, cuándo llamemos a nuestra función lo debemos hacer de la siguiente manera:
dosEnteros (primerParametro: 10, segundoParametro: 20)
Sin embargo el compilador nos lanzará un error si intentamos llamar a nuestra función del siguiente modo:
dosEnteros (10, segundoParametro: 20)
Es decir que si nuestra función tiene nombres de parámetros externos, en este caso no aplica la regla de omitir el nombre del primer parámetro :-O
Usar el nombre del parámetro interno como nombre externo
Apple nos dice que si el nombre del parámetro interno es muy descriptivo, podemos usarlo como parámetro externo.
Esto lo haremos anteponiendo el símbolo # delante del nombre del parámetro interno.
Por ejemplo:
func dosEnteros(#i: Int, j: Int) {
}
Y llamaríamos a nuestra función de la siguiente forma:
dosEnteros (i: 10, j: 20)
Sin embargo, en funciones, solo podremos hacer esto con el nombre del primer parámetro, pues si intentamos esto:
func dosEnteros(#i: Int, #j: Int) {
}
El compilador nos dará una advertencia.
Así pues esta sería una buena opción si al llamar a la función, queremos escribir el nombre de todos los parámetros incluido el primero.
Métodos de clase
En los métodos de clase se sigue la misma convención, es decir, el nombre del primer parámetro se omite, no así el segundo o sucesivos.
Sirva de ejemplo el caso visto anteriormente:
timer = NSTimer.scheduledTimerWithTimeInterval (0.10, target: self, selector: «cambiaProgreso:», userInfo: nil, repeats: true)
Es decir es obligatorio poner el nombre del segundo y sucesivos nombres de parámetros, no así el primero.
Imaginad que tenemos la siguiente clase con un método que cambia unos valores de la clase:
class Cuadrado {
var ancho: Int = 0
var alto: Int = 0
func cambiaTamanio(an:Int, al:Int) {
ancho = an
alto = al
}
}
Para llamar al método cambiaTamanio para dar unos valores diferentes a ancho y alto, lo podemos hacer así:
var r = Cuadrado()
r.cambiaTamanio(10, al:10)
Fíjate como el nombre del primer parámetro se omite, no así el segundo.
Una buena práctica sería añadir el nombre del primer parámetro a nuestro método, algo así:
func cambiaTamanioAncho (an:Int, al:Int) {
ancho = an
alto = al
}
Entonces podríamos llamarlo así:
var r = Cuadrado()
r.cambiaTamanioAncho(10, al:10)
El nombre del método indica que el primer parámetro es el ancho.
Al igual que en las funciones, podemos establecer nombres de parámetros externos.
func cambiaTamanio(ancho an:Int, alto al:Int) {
ancho = an
alto = al
}
Y llamar a nuestro método así:
var r = Cuadrado()
r.cambiaTamanio(ancho: 10, alto:10)
Métodos de inicialización
Hay una excepción a la hora de omitir el nombre del primer parámetro, y es en los métodos de inicialización.
Si creamos un método de inicialización dentro de una clase como por ejemplo:
class Cuadrado {
var ancho: Int = 0
var alto: Int = 0
init(an:Int,al:Int) {
ancho = an
alto = al
}
}
Al llamar al método lo haremos así:
var r = Cuadrado (an:10, al:23)
Conclusión
Como ves se siguen convenciones diferentes dependiendo de cómo declaremos nuestras funciones y métodos.
Además hay diferencias en cuanto a si estamos trabajando con un método de clase o un método de inicialización.
A día de hoy es así, sin embargo Apple hace cambios en cada nueva versión de Swift, cambios que suelen llegar con cada nueva versión de xCode.
Esperemos por fin tener un lenguaje estable, de forma que no tengamos que estar desaprendiendo lo aprendido 😉
Cualquier duda, déjame un comentario.
