arrays - यह जांचने के लिए कि कोई तत्व किसी सरणी में है या नहीं




swift (8)

इस एक्सटेंशन का प्रयोग करें:

extension Array {
    func contains<T where T : Equatable>(obj: T) -> Bool {
        return self.filter({$0 as? T == obj}).count > 0
    }
}

इस रूप में उपयोग करें:

array.contains(1)

स्विफ्ट 2/3 के लिए अपडेट किया गया

ध्यान दें कि स्विफ्ट 3 (या यहां तक ​​कि 2) के रूप में, एक्सटेंशन अब आवश्यक नहीं है क्योंकि ग्लोबल फ़ंक्शन को Array पर विस्तार विधि की एक जोड़ी में बनाया गया है, जो आपको इनमें से किसी एक को करने की अनुमति देता है:

let a = [ 1, 2, 3, 4 ]

a.contains(2)           // => true, only usable if Element : Equatable

a.contains { $0 < 1 }   // => false

स्विफ्ट में, मैं कैसे जांच सकता हूं कि सरणी में कोई तत्व मौजूद है या नहीं? एक्सकोड में contain , include , या has , और पुस्तक के माध्यम से एक त्वरित खोज के लिए कोई सुझाव नहीं है कुछ भी नहीं। कोई विचार यह कैसे जांचें? मुझे पता है कि एक विधि find है जो इंडेक्स नंबर लौटाती है, लेकिन क्या ऐसी कोई विधि है जो रूबी के #include? बूलियन लौटाती है #include? ?

मुझे जो चाहिए वह उदाहरण:

var elements = [1,2,3,4,5]
if elements.contains(5) {
  //do something
}

इसे पूरा करने का सबसे आसान तरीका सरणी पर फ़िल्टर का उपयोग करना है।

let result = elements.filter { $0==5 }

result मौजूद तत्व होगा यदि यह मौजूद है और यदि तत्व मौजूद नहीं है तो खाली होगा। इसलिए बस यह जांचना कि क्या खाली है, आपको बताएगा कि तत्व सरणी में मौजूद है या नहीं। मैं निम्नलिखित का उपयोग करूंगा:

if result.isEmpty {
    // element does not exist in array
} else {
    // element exists
}

बस अगर कोई यह ढूंढने की कोशिश कर रहा है कि कोई UICollectionView चयनित लोगों में से एक है (जैसे UICollectionView या UITableView cellForItemAtIndexPath फ़ंक्शंस में):

    var isSelectedItem = false
    if let selectedIndexPaths = collectionView.indexPathsForSelectedItems() as? [NSIndexPath]{
        if contains(selectedIndexPaths, indexPath) {
            isSelectedItem = true
        }
    }

मैंने फ़िल्टर का इस्तेमाल किया।

let results = elements.filter { el in el == 5 }
if results.count > 0 {
    // any matching items are in results
} else {
    // not found
}

यदि आप चाहते हैं, तो आप इसे संपीड़ित कर सकते हैं

if elements.filter({ el in el == 5 }).count > 0 {
}

उम्मीद है की वो मदद करदे।

स्विफ्ट 2 के लिए अद्यतन करें

डिफ़ॉल्ट कार्यान्वयन के लिए Hurray!

if elements.contains(5) {
    // any matching items are in results
} else {
    // not found
}

यदि उपयोगकर्ता को विशेष सरणी तत्व मिलते हैं तो नीचे कोड को पूर्णांक मान के समान उपयोग करें।

var arrelemnts = ["sachin", "test", "test1", "test3"]

 if arrelemnts.contains("test"){
    print("found")   }else{
    print("not found")   }

यहां आने वाले लोगों के लिए एक सरणी से किसी ऑब्जेक्ट को ढूंढना और निकालना:

स्विफ्ट 1

if let index = find(itemList, item) {
    itemList.removeAtIndex(index)
}

स्विफ्ट 2

if let index = itemList.indexOf(item) {
    itemList.removeAtIndex(index)
}

स्विफ्ट 3, 4

if let index = itemList.index(of: item) {
    itemList.remove(at: index)
}

स्विफ्ट 2.1 के रूप में NSArrays containsObject ऑब्जेक्ट containsObject है जिसका उपयोग इस प्रकार किया जा सकता है:

if myArray.containsObject(objectImCheckingFor){
    //myArray has the objectImCheckingFor
}

(स्विफ्ट 3)

जांचें कि कोई तत्व किसी सरणी में मौजूद है (कुछ मानदंडों को पूरा करता है), और यदि ऐसा है, तो पहले ऐसे तत्व के साथ काम करना जारी रखें

यदि इरादा है:

  1. यह जांचने के लिए कि कोई तत्व किसी सरणी में मौजूद है (/ कुछ बुलियन मानदंडों को पूरा करता है, आवश्यक रूप से समानता परीक्षण नहीं)
  2. और यदि ऐसा है, तो पहले ऐसे तत्व के साथ आगे बढ़ें और काम करें,

फिर contains(_:) करने का विकल्प contains(_:) ब्लूप्रिंटेड Sequence रूप में first(where:) Sequence :

let elements = [1, 2, 3, 4, 5]

if let firstSuchElement = elements.first(where: { $0 == 4 }) {
    print(firstSuchElement) // 4
    // ...
}

इस संक्रमित उदाहरण में, इसका उपयोग मूर्खतापूर्ण प्रतीत हो सकता है, लेकिन यह बहुत उपयोगी है अगर किसी भी तत्व को पूरा करने वाले किसी भी तत्व के अस्तित्व के लिए गैर-मौलिक तत्व प्रकारों के सरणी पूछताछ करना बहुत उपयोगी है। उदाहरण के लिए

struct Person {
    let age: Int
    let name: String
    init(_ age: Int, _ name: String) {
        self.age = age
        self.name = name
    }
}

let persons = [Person(17, "Fred"),   Person(16, "Susan"),
               Person(19, "Hannah"), Person(18, "Sarah"),
               Person(23, "Sam"),    Person(18, "Jane")]

if let eligableDriver = persons.first(where: { $0.age >= 18 }) {
    print("\(eligableDriver.name) can possibly drive the rental car in Sweden.")
    // ...
} // Hannah can possibly drive the rental car in Sweden.

let daniel = Person(18, "Daniel")
if let sameAgeAsDaniel = persons.first(where: { $0.age == daniel.age }) {
    print("\(sameAgeAsDaniel.name) is the same age as \(daniel.name).")
    // ...
} // Sarah is the same age as Daniel.

.filter { ... some condition }.first का उपयोग कर किसी भी जंजीर संचालन। first(where:) अनुकूल रूप से first(where:) साथ प्रतिस्थापित किया जा सकता है। उत्तरार्द्ध बेहतर इरादा दिखाता है, और .filter संभावित गैर-आलसी उपकरणों पर प्रदर्शन के फायदे हैं, क्योंकि यह .filter को पार करने वाले (संभावित) पहले तत्व को निकालने से पहले पूर्ण सरणी पारित करेगा।

जांचें कि कोई तत्व किसी सरणी में मौजूद है (कुछ मानदंडों को पूरा करता है), और यदि ऐसा है, तो पहले ऐसे तत्व को हटा दें

प्रश्नों के नीचे एक टिप्पणी:

मैं सरणी से firstSuchElement को कैसे हटा सकता हूं?

ऊपर दिए गए एक समान उपयोग मामले को पहले तत्व को निकालना है जो किसी दिए गए अनुमान को पूरा करता है। ऐसा करने के लिए, index(where:) Collection विधि (जो सरणी संग्रह के लिए आसानी से उपलब्ध है) का उपयोग भविष्य को पूरा करने वाले पहले तत्व की अनुक्रमणिका को खोजने के लिए किया जा सकता है, जिसके बाद सूचकांक को remove(at:) साथ उपयोग किया जा सकता है remove(at:) Array विधि (संभव है; यह दिया गया है कि यह मौजूद है) उस तत्व को हटा दें।

var elements = ["a", "b", "c", "d", "e", "a", "b", "c"]

if let indexOfFirstSuchElement = elements.index(where: { $0 == "c" }) {
    elements.remove(at: indexOfFirstSuchElement)
    print(elements) // ["a", "b", "d", "e", "a", "b", "c"]
}

या, यदि आप सरणी से तत्व को निकालना चाहते हैं और साथ काम करना चाहते हैं, तो Optional : s map(_:) विधि को सशर्त रूप से लागू map(_:) .some(...) index(where:) से लौटें index(where:) ) परिणाम का उपयोग करें index(where:) सरणी से हटाए गए तत्व को हटाने और कैप्चर करने के लिए (वैकल्पिक बाध्यकारी खंड के भीतर)।

var elements = ["a", "b", "c", "d", "e", "a", "b", "c"]

if let firstSuchElement = elements.index(where: { $0 == "c" })
    .map({ elements.remove(at: $0) }) {

    // if we enter here, the first such element have now been
    // remove from the array
    print(elements) // ["a", "b", "d", "e", "a", "b", "c"]

    // and we may work with it
    print(firstSuchElement) // c
}

ध्यान दें कि सरणी सदस्यों के ऊपर दिए गए उदाहरण में सरल मान प्रकार ( String इंस्टेंस) हैं, इसलिए दिए गए सदस्य को खोजने के लिए एक अनुमान का उपयोग करना कुछ हद तक अधिक है, क्योंकि हम सरल index(of:) विधि index(of:) उपयोग करके समानता के लिए परीक्षण कर सकते हैं जैसा कि @ डॉगकोफी के जवाब में दिखाया गया है। यदि Person उदाहरण के ऊपर उपरोक्त खोज-और-हटाने दृष्टिकोण लागू करते हैं, हालांकि, index(where:) का उपयोग करना index(where:) भविष्यवाणी के साथ उचित है (क्योंकि हम अब समानता के लिए परीक्षण नहीं करते हैं बल्कि आपूर्ति किए गए अनुमान को पूरा करने के लिए)।





swift