मैं क्या लागू करना चाहता हूं:
class func getSomeObject() -> [SomeObject]? {
let objects = Realm().objects(SomeObject)
return objects.count > 0 ? objects : nil
}
मैं वस्तु को वापस कैसे ला सकता हूं जैसे [SomeObject]
कि Results
?
मैं क्या लागू करना चाहता हूं:
class func getSomeObject() -> [SomeObject]? {
let objects = Realm().objects(SomeObject)
return objects.count > 0 ? objects : nil
}
मैं वस्तु को वापस कैसे ला सकता हूं जैसे [SomeObject]
कि Results
?
जवाबों:
अजीब, जवाब बहुत सीधा है। यहाँ है मैं इसे कैसे करते हैं:
let array = Array(results) // la fin
Array
साथ स्विफ्ट का निर्माण होता है।
यदि आप बिल्कुल अपने Results
को परिवर्तित करना चाहते हैं Array
, तो ध्यान रखें कि Results
आलसी होने के बाद भी प्रदर्शन और मेमोरी ओवरहेड है। लेकिन आप इसे एक पंक्ति में कर सकते हैं, जैसे results.map { $0 }
कि स्विफ्ट 2.0 (या map(results) { $0 }
1.2) में।
map { $0 }
LazyMapRandomAccessCollection
स्विफ्ट 3 में लौटेंगे , इसलिए @Mazyod का जवाब बेहतर है।
मुझे एक उपाय मिला। परिणाम पर विस्तार बनाया गया।
extension Results {
func toArray<T>(ofType: T.Type) -> [T] {
var array = [T]()
for i in 0 ..< count {
if let result = self[i] as? T {
array.append(result)
}
}
return array
}
}
और जैसे का उपयोग कर
class func getSomeObject() -> [SomeObject]? {
let objects = Realm().objects(SomeObject).toArray(SomeObject) as [SomeObject]
return objects.count > 0 ? objects : nil
}
for var i = 0; i < count; i++
के साथ प्रतिस्थापित किया जाना चाहिएfor i in 0 ..< count
स्विफ्ट 4.2 के साथ यह विस्तार की तरह सरल है:
extension Results {
func toArray() -> [Element] {
return compactMap {
$0
}
}
}
सभी आवश्यक जेनरिक जानकारी पहले से ही एक हिस्सा है Results
जिसका हम विस्तार करते हैं।
यह एक पंक्ति में स्विफ्ट 3 केResults
विस्तार के साथ एरे में परिवर्तित होने का एक और तरीका है ।
extension Results {
func toArray() -> [T] {
return self.map { $0 }
}
}
के लिए स्विफ्ट 4 और Xcode 9.2
extension Results {
func toArray<T>(type: T.Type) -> [T] {
return flatMap { $0 as? T }
}
}
Xcode 10 के साथ flatMap
पदावनत किया जाता है जिसका उपयोग आप compactMap
मैपिंग के लिए कर सकते हैं ।
extension Results {
func toArray<T>(type: T.Type) -> [T] {
return compactMap { $0 as? T }
}
}
स्विफ्ट 3
extension Results {
func toArray<T>(ofType: T.Type) -> [T] {
var array = [T]()
for i in 0 ..< count {
if let result = self[i] as? T {
array.append(result)
}
}
return array
}
}
प्रयोग
class func getSomeObject() -> [SomeObject]? {
let defaultRealm = try! Realm()
let objects = defaultRealm.objects(SomeObject.self).toArray(ofType : SomeObject.self) as [SomeObject]
return objects.count > 0 ? objects : nil
}
वैकल्पिक: जेनरिक का उपयोग करना
class func getSomeObject() -> [T]? {
let objects = Realm().objects(T.self as! Object.Type).toArray(ofType : T.self) as [T]
return objects.count > 0 ? objects : nil
}
परिणाम को ऐरे में बदलना अच्छा नहीं है, क्योंकि परिणाम आलसी हैं। लेकिन अगर आपको इसकी कोशिश करनी है:
func toArray<T>(ofType: T.Type) -> [T] {
return flatMap { $0 as? T }
}
लेकिन बेहतर तरीका यह है कि आपको जहां भी आवश्यकता हो, परिणाम पारित करें। इसके अलावा आप Array के बजाय Results को List में बदल सकते हैं।
List(realm.objects(class))
अगर पहला फंक काम नहीं कर रहा है तो आप इसे आज़मा सकते हैं:
var refrenceBook:[RefrenceProtocol] = []
let faceTypes = Array(realm.objects(FaceType))
refrenceBook = faceTypes.map({$0 as FaceType})
मुझे यकीन नहीं है, अगर ऐसा करने के लिए कोई कुशल तरीका है।
लेकिन आप इसे एक स्विफ्ट सरणी बनाकर कर सकते हैं और इसे लूप में जोड़ सकते हैं।
class func getSomeObject() -> [SomeObject]? {
var someObjects: [SomeObject] = []
let objects = Realm().objects(SomeObject)
for object in objects{
someObjects += [object]
}
return objects.count > 0 ? someObjects : nil
}
अगर आपको लगता है कि यह बहुत धीमा है। मैं आपको Results
सीधे Realm ऑब्जेक्ट के आसपास से गुजरने की सलाह देता हूं ।
extension Results {
func materialize() -> [Element] {
return Array(self)
}
}