Làm thế nào để bạn kiểm tra các hàm và các bao đóng cho bằng nhau?

Cuốn sách nói rằng "các hàm và các bao đóng là các kiểu tham chiếu". Vì vậy, làm thế nào để bạn tìm ra nếu các tài liệu tham khảo là bằng nhau? == và === không hoạt động.

func a() { }
let å = a
let b = å === å // Could not find an overload for === that accepts the supplied arguments

Chris Lattner đã viết trên diễn đàn nhà phát triển:

Đây là một tính năng mà chúng tôi cố ý không muốn hỗ trợ. Có nhiều thứ sẽ khiến sự bình đẳng con trỏ của các chức năng (theo nghĩa hệ thống kiểu nhanh chóng, bao gồm một số loại đóng) không thành công hoặc thay đổi tùy thuộc vào tối ưu hóa. Nếu "===" được xác định trên các hàm, trình biên dịch sẽ không được phép hợp nhất các phần thân phương thức giống hệt nhau, chia sẻ phần thu thập và thực hiện một số tối ưu hóa nắm bắt nhất định trong các bao đóng. Hơn nữa, sự bình đẳng kiểu này sẽ cực kỳ đáng ngạc nhiên trong một số ngữ cảnh chung chung, nơi bạn có thể nhận được các thu hồi tái lập để điều chỉnh chữ ký thực tế của một hàm thành chữ ký mà loại hàm mong đợi.

https://devforums.apple.com/message/1035180#1035180

Điều này có nghĩa là bạn thậm chí không nên cố gắng so sánh các lần đóng để có sự bình đẳng vì việc tối ưu hóa có thể ảnh hưởng đến kết quả.

Tôi đã tìm kiếm rất nhiều. Dường như không có cách nào để so sánh con trỏ hàm. Giải pháp tốt nhất tôi nhận được là đóng gói hàm hoặc đóng trong một đối tượng có thể băm. Giống:

var handler:Handler = Handler(callback: { (message:String) in
            //handler body
}))

Cách đơn giản nhất là chỉ định loại khối là @objc_blockvà bây giờ bạn có thể truyền nó tới AnyObject có thể so sánh với ===. Thí dụ:

    typealias Ftype = @objc_block (s:String) -> ()

    let f : Ftype = {
        ss in
        println(ss)
    }
    let ff : Ftype = {
        sss in
        println(sss)
    }
    let obj1 = unsafeBitCast(f, AnyObject.self)
    let obj2 = unsafeBitCast(ff, AnyObject.self)
    let obj3 = unsafeBitCast(f, AnyObject.self)

    println(obj1 === obj2) // false
    println(obj1 === obj3) // true

Tôi cũng đang tìm kiếm câu trả lời. Và cuối cùng tôi đã tìm thấy nó.

• https://gist.github.com/dankogai/b03319ce427544beb5a4

Những gì bạn cần là con trỏ hàm thực sự và ngữ cảnh của nó ẩn trong đối tượng hàm.

func peekFunc<A,R>(f:A->R)->(fp:Int, ctx:Int) {
    typealias IntInt = (Int, Int)
    let (hi, lo) = unsafeBitCast(f, IntInt.self)
    let offset = sizeof(Int) == 8 ? 16 : 12
    let ptr  = UnsafePointer<Int>(lo+offset)
    return (ptr.memory, ptr.successor().memory)
}
@infix func === <A,R>(lhs:A->R,rhs:A->R)->Bool {
    let (tl, tr) = (peekFunc(lhs), peekFunc(rhs))
    return tl.0 == tr.0 && tl.1 == tr.1
}

Và đây là bản demo:

// simple functions
func genericId<T>(t:T)->T { return t }
func incr(i:Int)->Int { return i + 1 }
var f:Int->Int = genericId
var g = f;      println("(f === g) == \(f === g)")
f = genericId;  println("(f === g) == \(f === g)")
f = g;          println("(f === g) == \(f === g)")
// closures
func mkcounter()->()->Int {
    var count = 0;
    return { count++ }
}
var c0 = mkcounter()
var c1 = mkcounter()
var c2 = c0
println("peekFunc(c0) == \(peekFunc(c0))")
println("peekFunc(c1) == \(peekFunc(c1))")
println("peekFunc(c2) == \(peekFunc(c2))")
println("(c0() == c1()) == \(c0() == c1())") // true : both are called once
println("(c0() == c2()) == \(c0() == c2())") // false: because c0() means c2()
println("(c0 === c1) == \(c0 === c1)")
println("(c0 === c2) == \(c0 === c2)")

Xem các URL bên dưới để biết lý do và cách hoạt động:

• https://github.com/rodionovd/SWRoute/wiki/Function-hooking-in-Swift
• https://github.com/rodionovd/SWRoute/blob/master/SWRoute/rd_get_func_impl.c

Như bạn thấy, nó chỉ có khả năng kiểm tra danh tính (thử nghiệm thứ 2 cho kết quả false). Nhưng điều đó phải đủ tốt.

Đây là một câu hỏi tuyệt vời và trong khi Chris Lattner cố tình không muốn hỗ trợ tính năng này, tôi cũng như nhiều nhà phát triển, cũng không thể bỏ qua cảm giác của mình đến từ các ngôn ngữ khác, nơi đây là một nhiệm vụ tầm thường. Có rất nhiều unsafeBitCaství dụ, hầu hết trong số chúng không hiển thị hình ảnh đầy đủ, đây là một ví dụ chi tiết hơn :

typealias SwfBlock = () -> ()
typealias ObjBlock = @convention(block) () -> ()

func testSwfBlock(a: SwfBlock, _ b: SwfBlock) -> String {
    let objA = unsafeBitCast(a as ObjBlock, AnyObject.self)
    let objB = unsafeBitCast(b as ObjBlock, AnyObject.self)
    return "a is ObjBlock: \(a is ObjBlock), b is ObjBlock: \(b is ObjBlock), objA === objB: \(objA === objB)"
}

func testObjBlock(a: ObjBlock, _ b: ObjBlock) -> String {
    let objA = unsafeBitCast(a, AnyObject.self)
    let objB = unsafeBitCast(b, AnyObject.self)
    return "a is ObjBlock: \(a is ObjBlock), b is ObjBlock: \(b is ObjBlock), objA === objB: \(objA === objB)"
}

func testAnyBlock(a: Any?, _ b: Any?) -> String {
    if !(a is ObjBlock) || !(b is ObjBlock) {
        return "a nor b are ObjBlock, they are not equal"
    }
    let objA = unsafeBitCast(a as! ObjBlock, AnyObject.self)
    let objB = unsafeBitCast(b as! ObjBlock, AnyObject.self)
    return "a is ObjBlock: \(a is ObjBlock), b is ObjBlock: \(b is ObjBlock), objA === objB: \(objA === objB)"
}

class Foo
{
    lazy var swfBlock: ObjBlock = self.swf
    func swf() { print("swf") }
    @objc func obj() { print("obj") }
}

let swfBlock: SwfBlock = { print("swf") }
let objBlock: ObjBlock = { print("obj") }
let foo: Foo = Foo()

print(testSwfBlock(swfBlock, swfBlock)) // a is ObjBlock: false, b is ObjBlock: false, objA === objB: false
print(testSwfBlock(objBlock, objBlock)) // a is ObjBlock: false, b is ObjBlock: false, objA === objB: false

print(testObjBlock(swfBlock, swfBlock)) // a is ObjBlock: true, b is ObjBlock: true, objA === objB: false
print(testObjBlock(objBlock, objBlock)) // a is ObjBlock: true, b is ObjBlock: true, objA === objB: true

print(testAnyBlock(swfBlock, swfBlock)) // a nor b are ObjBlock, they are not equal
print(testAnyBlock(objBlock, objBlock)) // a is ObjBlock: true, b is ObjBlock: true, objA === objB: true

print(testObjBlock(foo.swf, foo.swf)) // a is ObjBlock: true, b is ObjBlock: true, objA === objB: false
print(testSwfBlock(foo.obj, foo.obj)) // a is ObjBlock: false, b is ObjBlock: false, objA === objB: false
print(testAnyBlock(foo.swf, foo.swf)) // a nor b are ObjBlock, they are not equal
print(testAnyBlock(foo.swfBlock, foo.swfBlock)) // a is ObjBlock: true, b is ObjBlock: true, objA === objB: true

Phần thú vị là cách nhanh chóng chuyển SwfBlock sang ObjBlock, nhưng trong thực tế, hai khối SwfBlock được truyền sẽ luôn có giá trị khác nhau, trong khi ObjBlocks thì không. Khi chúng ta chuyển ObjBlock sang SwfBlock, điều tương tự cũng xảy ra với chúng, chúng trở thành hai giá trị khác nhau. Vì vậy, để bảo vệ tài liệu tham khảo, nên tránh kiểu ép kiểu này.

Tôi vẫn đang hiểu toàn bộ chủ đề này, nhưng một điều tôi mong ước là khả năng sử dụng @convention(block)trên các phương thức class / struct, vì vậy tôi đã gửi một yêu cầu tính năng cần bỏ phiếu hoặc giải thích lý do tại sao đó là một ý tưởng tồi. Tôi cũng có cảm giác rằng cách tiếp cận này có thể xấu tất cả cùng nhau, nếu vậy, bất cứ ai có thể giải thích tại sao?

Đây là một giải pháp khả thi (về mặt khái niệm giống như câu trả lời 'tuncay'). Vấn đề là xác định một lớp bao bọc một số chức năng (ví dụ: Command):

Nhanh:

typealias Callback = (Any...)->Void
class Command {
    init(_ fn: @escaping Callback) {
        self.fn_ = fn
    }

    var exec : (_ args: Any...)->Void {
        get {
            return fn_
        }
    }
    var fn_ :Callback
}

let cmd1 = Command { _ in print("hello")}
let cmd2 = cmd1
let cmd3 = Command { (_ args: Any...) in
    print(args.count)
}

cmd1.exec()
cmd2.exec()
cmd3.exec(1, 2, "str")

cmd1 === cmd2 // true
cmd1 === cmd3 // false

Java:

interface Command {
    void exec(Object... args);
}
Command cmd1 = new Command() {
    public void exec(Object... args) [
       // do something
    }
}
Command cmd2 = cmd1;
Command cmd3 = new Command() {
   public void exec(Object... args) {
      // do something else
   }
}

cmd1 == cmd2 // true
cmd1 == cmd3 // false

Chà, đã 2 ngày rồi và chưa có ai giải quyết được vấn đề, vì vậy tôi sẽ thay đổi nhận xét của mình thành một câu trả lời:

Theo như tôi có thể nói, bạn không thể kiểm tra tính bình đẳng hoặc nhận dạng của các hàm (như ví dụ của bạn) và kính đo (ví dụ MyClass.self:):

Nhưng - và đây chỉ là một ý tưởng - tôi không thể không nhận thấy rằng wheremệnh đề trong generic dường như có thể kiểm tra sự bình đẳng của các loại. Vì vậy, có thể bạn có thể tận dụng điều đó, ít nhất là để kiểm tra danh tính?

Không phải là một giải pháp chung, nhưng nếu một người đang cố gắng triển khai một mẫu trình xử lý, thì tôi đã trả về một "id" của hàm trong quá trình đăng ký để tôi có thể sử dụng nó để hủy đăng ký sau này (đây là một cách giải quyết cho câu hỏi ban đầu đối với trường hợp "người nghe" như thường thì việc hủy đăng ký đi xuống để kiểm tra các hàm xem có bình đẳng không, điều này ít nhất là không "tầm thường" như các câu trả lời khác).

Vì vậy, một cái gì đó như thế này:

class OfflineManager {
    var networkChangedListeners = [String:((Bool) -> Void)]()

    func registerOnNetworkAvailabilityChangedListener(_ listener: @escaping ((Bool) -> Void)) -> String{
        let listenerId = UUID().uuidString;
        networkChangedListeners[listenerId] = listener;
        return listenerId;
    }
    func unregisterOnNetworkAvailabilityChangedListener(_ listenerId: String){
        networkChangedListeners.removeValue(forKey: listenerId);
    }
}

Bây giờ bạn chỉ cần lưu trữ keytrả về bởi chức năng "đăng ký" và chuyển nó khi hủy đăng ký.

Giải pháp của tôi là bọc các hàm thành lớp mở rộng NSObject

class Function<Type>: NSObject {
    let value: (Type) -> Void

    init(_ function: @escaping (Type) -> Void) {
        value = function
    }
}

Tôi biết tôi đang trả lời câu hỏi này muộn sáu năm, nhưng tôi nghĩ điều đó đáng để xem xét động lực đằng sau câu hỏi. Người hỏi nhận xét:

Tuy nhiên, không thể xóa các bao đóng khỏi danh sách gọi bằng tham chiếu, chúng ta cần tạo lớp trình bao bọc của riêng mình. Đó là một lực cản và không cần thiết.

Vì vậy, tôi đoán người hỏi muốn duy trì một danh sách gọi lại, như thế này:

class CallbackList {
    private var callbacks: [() -> ()] = []

    func call() {
        callbacks.forEach { $0() }
    }

    func addCallback(_ callback: @escaping () -> ()) {
        callbacks.append(callback)
    }

    func removeCallback(_ callback: @escaping () -> ()) {
        callbacks.removeAll(where: { $0 == callback })
    }
}

Nhưng chúng ta không thể viết removeCallbacktheo cách đó, bởi vì ==nó không hoạt động cho các hàm. (Cũng không ===.)

Đây là một cách khác để quản lý danh sách gọi lại của bạn. Trả về một đối tượng đăng ký từ addCallbackvà sử dụng đối tượng đăng ký để xóa lệnh gọi lại. Vào năm 2020, chúng ta có thể sử dụng Combine's AnyCancellableđể đăng ký.

API sửa đổi trông giống như sau:

class CallbackList {
    private var callbacks: [NSObject: () -> ()] = [:]

    func call() {
        callbacks.values.forEach { $0() }
    }

    func addCallback(_ callback: @escaping () -> ()) -> AnyCancellable {
        let key = NSObject()
        callbacks[key] = callback
        return .init { self.callbacks.removeValue(forKey: key) }
    }
}

Bây giờ, khi bạn thêm một cuộc gọi lại, bạn không cần phải giữ nó lại để chuyển đến removeCallbacksau. Không có removeCallbackphương pháp nào . Thay vào đó, bạn lưu AnyCancellablevà gọi cancelphương thức của nó để loại bỏ lệnh gọi lại. Thậm chí tốt hơn, nếu bạn lưu trữ thuộc tính AnyCancellabletrong một cá thể, thì nó sẽ tự động hủy khi cá thể bị hủy.