ios - লগর - সি প্রোগ্রামিং ভাষায় switch কি




অ্যারে ধরনের এবং দ্রুত ফাংশন পরামিতি হিসাবে প্রোটোকল ব্যবহার (5)

আপনি একটি জেনেরিক ক্লাস তৈরি করতে চান, একটি টাইপ সীমাবদ্ধতার সাথে এটির সাথে ব্যবহৃত ক্লাসগুলির জন্য SomeProtocol সাথে সামঞ্জস্য করা SomeProtocol , যেমন:

class SomeClass<T: SomeProtocol> {
    typealias ElementType = T
    var protocols = [ElementType]()

    func addElement(element: ElementType) {
        self.protocols.append(element)
    }

    func removeElement(element: ElementType) {
        if let index = find(self.protocols, element) {
            self.protocols.removeAtIndex(index)
        }
    }
}

আমি এমন একটি ক্লাস তৈরি করতে চাই যা নির্দিষ্ট প্রোটোকল অনুসারে বস্তুগুলি সংরক্ষণ করতে পারে। বস্তু একটি টাইপ করা অ্যারে সংরক্ষণ করা উচিত। সুইফ্টস ডকুমেন্টেশন প্রোটোকলের মতে প্রকার হিসাবে ব্যবহার করা যেতে পারে:

এটি একটি প্রকারের কারণ, আপনি বিভিন্ন ধরণের প্রোটোকল ব্যবহার করতে পারেন যেখানে অন্যান্য প্রকারের অনুমতি রয়েছে, সহ:

  • একটি ফাংশন, পদ্ধতি, বা initializer একটি পরামিতি টাইপ বা রিটার্ন টাইপ হিসাবে
  • একটি ধ্রুবক, পরিবর্তনশীল, বা সম্পত্তি ধরনের হিসাবে
  • একটি অ্যারে, অভিধান, বা অন্যান্য ধারক আইটেম হিসাবে টাইপ

তবে নিম্নলিখিত কম্পাইলার ত্রুটি উৎপন্ন:

প্রোটোকল 'SomeProtocol' শুধুমাত্র একটি জেনেরিক সীমাবদ্ধতা হিসাবে ব্যবহার করা যেতে পারে কারণ এটি স্ব বা সংশ্লিষ্ট টাইপ প্রয়োজনীয়তা আছে

আপনি কিভাবে এই সমাধান করা অনুমিত হয়:

protocol SomeProtocol: Equatable {
    func bla()
}

class SomeClass {

    var protocols = [SomeProtocol]()

    func addElement(element: SomeProtocol) {
        self.protocols.append(element)
    }

    func removeElement(element: SomeProtocol) {
        if let index = find(self.protocols, element) {
            self.protocols.removeAtIndex(index)
        }
    }
}

আপনি সুইফটের প্রোটোকলগুলির সাথে একটি সমস্যাটির একটি বৈকল্পিক আঘাত করেছেন যার জন্য এখনও কোনও ভাল সমাধান নেই।

এটি সুইফ্টে সাজানো কিনা তা চেক করতে অ্যারে প্রসারিত দেখুন ? , এটি আপনার নির্দিষ্ট সমস্যার জন্য উপযুক্ত হতে পারে এমন আশেপাশে কীভাবে কাজ করতে হবে তার পরামর্শ রয়েছে (আপনার প্রশ্নটি খুবই সাধারণ, সম্ভবত আপনি এই উত্তরগুলি ব্যবহার করে একটি সমাধান পেতে পারেন)।


আমি ব্লগের পোস্টে একটি বিশুদ্ধ-বিশুদ্ধ সুইফ্ট সমাধান পাইনি: http://blog.inferis.org/blog/2015/05/27/swift-an-array-of-protocols/

এটি isEqual() সাথে উপস্থাপিত হওয়ার isEqual() সাথে isEqual() । সুতরাং Equatable প্রোটোকল এবং তার ডিফল্ট ব্যবহার == আপনি উপাদানটি খুঁজে পেতে এবং এটি সরাতে আপনার নিজস্ব ফাংশন লিখতে পারেন।

এখানে আপনার find(array, element) -> Int? বাস্তবায়ন হয় find(array, element) -> Int? ফাংশন:

protocol SomeProtocol: NSObjectProtocol {

}

func find(protocols: [SomeProtocol], element: SomeProtocol) -> Int? {
    for (index, object) in protocols.enumerated() {
        if (object.isEqual(element)) {
            return index
        }
    }

    return nil
}

দ্রষ্টব্য: এই ক্ষেত্রে SomeProtocol সাথে আপনার বস্তু SomeProtocol থেকে উত্তরাধিকারী হতে NSObject


আমি যে সীমাবদ্ধ সমাধানটি পাই তা হল প্রোটোকলটি শুধুমাত্র ক্লাসের প্রোটোকল হিসাবে চিহ্নিত করা। এটি আপনাকে '===' অপারেটর ব্যবহার করে বস্তুর তুলনা করার অনুমতি দেবে। আমি বুঝতে পারি যে এটি structs, ইত্যাদি জন্য কাজ করবে না, কিন্তু এটা আমার ক্ষেত্রে যথেষ্ট ভাল ছিল।

protocol SomeProtocol: class {
    func bla()
}

class SomeClass {

    var protocols = [SomeProtocol]()

    func addElement(element: SomeProtocol) {
        self.protocols.append(element)
    }

    func removeElement(element: SomeProtocol) {
        for i in 0...protocols.count {
            if protocols[i] === element {
                protocols.removeAtIndex(i)
                return
            }
        }
    }

}

সুইফ্ট-এ প্রোটোকলগুলির একটি বিশেষ শ্রেণী রয়েছে যা এটি প্রয়োগ করার ক্ষেত্রে পলিমোফিজম প্রদান করে না। এই প্রোটোকলগুলি তাদের সংজ্ঞাগুলিতে Self বা associatedtype Equatable কীওয়ার্ড ব্যবহার করে (এবং Equatable তাদের মধ্যে একটি)।

কিছু ক্ষেত্রে আপনার সংগ্রহ homomorphic করতে একটি টাইপ মুছে ফেলা মোড়ানো ব্যবহার করা সম্ভব। নীচে একটি উদাহরণ।

// This protocol doesn't provide polymorphism over the types which implement it.
protocol X: Equatable {
    var x: Int { get }
}

// We can't use such protocols as types, only as generic-constraints.
func ==<T: X>(a: T, b: T) -> Bool {
    return a.x == b.x
}

// A type-erased wrapper can help overcome this limitation in some cases.
struct AnyX {
    private let _x: () -> Int
    var x: Int { return _x() }

    init<T: X>(_ some: T) {
        _x = { some.x }
    }
}

// Usage Example

struct XY: X {
    var x: Int
    var y: Int
}

struct XZ: X {
    var x: Int
    var z: Int
}

let xy = XY(x: 1, y: 2)
let xz = XZ(x: 3, z: 4)

//let xs = [xy, xz] // error
let xs = [AnyX(xy), AnyX(xz)]
xs.forEach { print($0.x) } // 1 3




swift-protocols