मैं json डेटा के अपने स्रोत के रूप में swapi.co का उपयोग कर रहा हूं और मेरी प्रतिक्रिया निम्न की तरह दिखती है: https://swapi .co/api/people/

"पात्रों" की मेरी सरणी में संरचना है

// MARK: - CharactersResult
struct CharactersResult: Codable {
    let name, height, mass, hairColor: String
    let skinColor, eyeColor, birthYear: String
    let gender: Gender
    let homeworld: String
    let films, species, vehicles, starships: [String]
    let created, edited: String
    let url: String

    enum CodingKeys: String, CodingKey {
        case name, height, mass
        case hairColor = "hair_color"
        case skinColor = "skin_color"
        case eyeColor = "eye_color"
        case birthYear = "birth_year"
        case gender, homeworld, films, species, vehicles, starships, created, edited, url
    }
}

मैं अपनी सरणी से सबसे छोटा वर्ण और सबसे बड़ा प्राप्त करना चाहता हूं। मेरा कार्य है:

func getCharacters(urlToGet: String){
            do{
                if let url = URL(string: urlToGet) {
                    URLSession.shared.dataTask(with: url) { data, response, error in
                        if let data = data {
                            do {
                                let jsonCharacters = try JSONDecoder().decode(Characters.self, from: data)



                                self.characters = self.characters + jsonCharacters.results

                                self.nextPageUrlForCharacters = jsonCharacters.next

                                self.updatePicker()

                            } catch let error {
                                print(error)


                            }
                        }
                        }.resume()

                }
            }
        }

मेरा मुख्य प्रश्न यह है कि छँटाई कहाँ करनी है और सबसे छोटा और सबसे बड़ा चरित्र पाने का सबसे कारगर तरीका क्या है।

2
Dima M 3 सितंबर 2019, 21:15
आप अपने सभी परिणाम प्राप्त करना चाहते हैं और फिर सबसे छोटा या सबसे बड़ा प्राप्त करने के लिए reduce फ़ंक्शन का उपयोग करना चाहते हैं। लंबाई से आप क्या समझते हैं? क्या एक अक्षर परिणाम छोटा या लंबा बनाता है?
 – 
Alex
3 सितंबर 2019, 21:28

2 जवाब

सबसे बढ़िया उत्तर

मान लें कि सबसे छोटा और सबसे बड़ा वर्ण की ऊंचाई से संबंधित है (तब सबसे छोटा और सबसे लंबा अधिक उपयुक्त हैं), उस संरचना सदस्य द्वारा सरणी को क्रमबद्ध करें। चूंकि मान String है, आपको .numeric विकल्प जोड़ना होगा।

अवरोही क्रम सबसे बड़े मान से शुरू होता है

let sortedCharacters = self.characters.sorted{$0.height.compare($1.height, options: .numeric) == .orderedDescending}
let tallestCharacter = sortedCharacters.first
let shortestCharacter = sortedCharacters.last

साइड नोट: यदि आप convertFromSnakeCase कुंजी डिकोडिंग रणनीति जोड़ते हैं, तो आप CodingKeys से छुटकारा पा सकते हैं।

3
vadian 3 सितंबर 2019, 22:19

आपके कोड का यह सरलीकृत संस्करण दिखाता है कि कैसे एक मनमानी कुंजी द्वारा क्रमबद्ध करना है, जब तक कि वह कुंजी Comparable है (इसलिए मैंने आपकी height और mass गुण दोनों Ints के बजाय String):

struct MovieCharacter: Codable {
    let name: String
    let height: Int
    let mass: Int
}

let fred = MovieCharacter(name: "Fred", height: 123, mass: 99)
let wilma = MovieCharacter(name: "Wilma", height: 158, mass: 47)

let chars = [fred, wilma]

let heaviestToLightest = chars.sorted { $0.mass > $1.mass }
// Prints "Fred, Wilma"
print(heaviestToLightest.map { $0.name }.joined(separator: ", "))

let tallestToShortest = chars.sorted { $0.height > $1.height }
// prints "Wilma, Fred"
print(tallestToShortest.map { $0.name }.joined(separator: ", "))

क्रम को बदलने के लिए, परिणाम पर >' in the comparison closure. If you want to know the "most" and "least" of a particular order, use.पहलेand.last` को उलट दें।

इसके अलावा, अपने आप को CodingKeys एनम को बनाए रखने से बचाने के लिए, JSONDecoder के .keyDecodingStrategy का उपयोग करें:

let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let characters = try decoder.decode(Characters.self, from: jsonData)
0
Chris 3 सितंबर 2019, 21:48