objective - que es self en swift

Clase anonima en swift

Question

¿Existe una sintaxis o técnica equivalente para la clase Anónima en Swift? Solo para aclarar la clase anónima en el ejemplo de Java aquí: http://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html

¡Gracias!

Answer 1

Esto es lo que terminé haciendo (patrón de observador). Puede usar cierres de una manera similar a como usaría clases anónimas en Java. Con obvias limitaciones por supuesto.

class Subject {
   // array of closures
   var observers: [() -> Void] = []

   // @escaping says the closure will be called after the method returns
   func register(observer: @escaping () -> Void) {
       observers.append(observer)
   }

   func triggerEvent() {
       observers.forEach { observer in
            observer()
       }
   }
}

var subj = Subject()
// you can use a trailing closure
subj.register() {
    print("observerd")
}

// or you can assign a closure to a variable so you can maybe use the reference to removeObserver() if you choose to implement that method
var namedObserver: () -> Void = {
    print("named observer")
}
subj.register(observer: namedObserver)

subj.triggerEvent()
// output:
// observerd
// named observer

Answer 2

No hay sintaxis de clase anónima en Swift. Pero, puedes crear una clase dentro de una clase y métodos de clase:

class ViewController: UIViewController {

    class anonymousSwiftClass {
        func add(number1:Int, number2:Int) -> Int {
            return number1+number2;
        }
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.

        class innerSwiftClass {
            func sub(number1:Int, number2:Int) -> Int {
                return number1-number2;
            }
        }

        var inner = innerSwiftClass();
        println(inner.sub(2, number2: 3));

        var anonymous = anonymousSwiftClass();
        println(anonymous.add(2, number2: 3));
    }
}

Answer 3

No hay una sintaxis equivalente, que yo sepa.

Con respecto a las técnicas equivalentes, en teoría podría usar cierres y definir estructuras y clases dentro de ellos. Lamentablemente, no puedo hacer que esto funcione en un campo de juego o proyecto sin hacer que se bloquee. Lo más probable es que esto no esté listo para ser utilizado en la versión beta actual.

Algo como...

protocol SomeProtocol {
    func hello()
}

let closure : () -> () = {
    class NotSoAnonymousClass : SomeProtocol {
        func hello() {
            println("Hello")
        }
    }
    let object = NotSoAnonymousClass()
    object.hello()
}

... actualmente produce este error:

invalid linkage type for global declaration
%swift.full_heapmetadata* @_TMdCFIv4Test7closureFT_T_iU_FT_T_L_19NotSoAnonymousClass
LLVM ERROR: Broken module found, compilation aborted!
Command /Applications/Xcode6-Beta.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/swift failed with exit code 1

Answer 4

Por ejemplo, el patrón de escucha / adaptador de Java se traduciría a Swift de la siguiente manera:

protocol EventListener {
    func handleEvent(event: Int) -> ()
}

class Adapter : EventListener {
    func handleEvent(event: Int) -> () {
    }
}

var instance: EventListener = {
    class NotSoAnonymous : Adapter {
        override func handleEvent(event: Int) {
            println("Event: /(event)")
        }
    }

    return NotSoAnonymous()
}()

instance.handleEvent(10)

(Bloqueo del compilador en Beta 2)

El problema es que siempre hay que especificar un nombre. No creo que Apple alguna vez introduzca clases anónimas (y estructuras, etc.) porque sería bastante difícil tener una sintaxis que no coincida con los cierres finales.

También en la programación anónima las cosas son malas. Nombrar cosas ayuda a los lectores a entender el código.

Answer 5

También puede crear una clase vacía básica que actúa como un protocolo simple y pasar un cierre a la función init que anula cualquier cosa que desee, como esto:

class EmptyClass {

    var someFunc: () -> () = { }

    init(overrides: EmptyClass -> EmptyClass) {
        overrides(self)
    }
}

// Now you initialize ''EmptyClass'' with a closure that sets
// whatever variable properties you want to override:

let workingClass = EmptyClass { ec in
    ec.someFunc = { println("It worked!") }
    return ec
}

workingClass.someFunc()  // Outputs: "It worked!"

No es técnicamente "anónimo" pero funciona de la misma manera. Se le otorga un shell vacío de una clase, y luego lo completa o invalida los parámetros que desee cuando lo inicializa con un cierre.

Básicamente es lo mismo, excepto que en lugar de cumplir con las expectativas de un protocolo, está anulando las propiedades de una clase.