unrecognized - swift 3 selector with parameters

Descripción de la sintaxis de Selector Swift 2.2-#selector()

Question

Estoy cambiando la sintaxis de mi proyecto hacia Swift 2.2 (que xCode me ayuda a hacer automáticamente); sin embargo, no entiendo la nueva sintaxis #selector() .

Como ejemplo:

timer = NSTimer.scheduledTimerWithTimeInterval(1.0, target: self, 
             selector: #selector(MyVC.timerCalled(_:)), //new selector syntax!
             userInfo: nil, repeats: true)

Esto tiene el selector #selector(MyVC.timerCalled(_:)) selector #selector(MyVC.timerCalled(_:))

¿Qué significa el _: significa? ¿Puedes agregar otras variables en este selector? Diga, #MyVC.timerCalled(_:whateverVar) .

La información general sobre lo que es diferente en esta sintaxis en comparación con la implementación basada en cadenas de versiones anteriores de Swift es muy apreciada.

Answer 1

Considere a continuación el código para agregar objetivo a botón en swift 3 usando #selector

button.addTarget(self, action: #selector(self.buttonAction(sender:)),
                       for: UIControlEvents.touchUpInside)

 func buttonAction(sender:UIButton!){

 }

Esta sintaxis funcionó para mí al migrar a veloz 3

Answer 2

El bit entre paréntesis es un mecanismo para identificar la lista de argumentos para el selector que desea.

Te recomiendo que veas la propuesta de nombramiento general de Swift Evolution. Cubre casos en los que tiene una cantidad de funciones que solo difieren en sus etiquetas de parámetros y necesitan referirse a ellas. El ejemplo de ese documento es:

extension UIView {
  func insertSubview(view: UIView, at index: Int)
  func insertSubview(view: UIView, aboveSubview siblingSubview: UIView)
  func insertSubview(view: UIView, belowSubview siblingSubview: UIView)
}

Si desea obtener un valor de función para uno de ellos, el resultado es ambiguo:

let fn = someView.insertSubview // ambiguous: could be any of the three methods

La solución implementada es agregar las etiquetas de los argumentos, sin ningún tipo de información, al código que genera el valor de la función para eliminar la ambigüedad que desea:

let fn = someView.insertSubview(_:at:)
let fn1 = someView.insertSubview(_:aboveSubview:)

Vea cómo se agregan las etiquetas en los parens?

Esta propuesta jugó un papel en la que se aplica más directamente a su pregunta:

Hacer referencia al selector Objective-C de un método

En este caso particular, el selector al que desea referirse es timerCalled: que es una función de un parámetro que no tiene etiqueta. Por lo tanto (_ :). El guión bajo significa que la etiqueta no está especificada y los dos puntos.

Answer 3

Esta es la forma en que se representan las firmas de métodos de Swift en la documentación, y ahora está empezando a utilizarse en nuevas características del lenguaje, como la sintaxis #selector() para expresar los métodos por sus listas de argumentos.

Cada dos puntos (:) representa un parámetro de método. Para los parámetros con nombre, los dos puntos están precedidos por el nombre del parámetro externo; para los parámetros sin nombre, se usa un guión bajo ( _ ).

Por ejemplo, MyVC.timerCalled(_:)) indica un método en el tipo MyVC con un parámetro sin nombre, que podría declararse así:

func timerCalled(timer: NSTimer) { ... }

(Tenga en cuenta que el timer es el nombre del parámetro interno , ya que por defecto el primer parámetro de un método no tiene nombre)

El tipo ( MyVC en su ejemplo) también se puede omitir si está dentro del mismo alcance de la declaración #selector() .

Un ejemplo más complejo podría verse así:

let sel = #selector(aMethodWithSeveralParameters(_:secondParam:thirdParam:))

...

func aMethodWithSeveralParameters(firstParam: Int, secondParam: Int, thirdParam: Int) { ... }

Answer 4

Swift 2.2 ha dejado de usar los selectores Stringified: en swift 2.0, utilizamos para escribir el selector como una cadena, es decir, "buttonClicked" . La desventaja de este enfoque es que el compilador no puede verificar si el método existe realmente o no en el momento de la compilación (incluso si lo ha escrito mal).

EX: 1

func buttonClicked(){
}

Entonces, el método anterior en el nuevo enfoque se puede llamar como #selector(buttonClicked)

EX: 2

func buttonClicked(stringValue : String){
}

Entonces, el método anterior en el nuevo enfoque se puede llamar como #selector(buttonClicked(_:))

EX: 3

func buttonClicked(stringValue : String, indexValue : Int){
}

Entonces, el método anterior con parámetros en el nuevo enfoque se puede llamar como #selector(buttonClicked(_:indexValue:))