[Pour les débutants] Pouvons nous enduire comme Swift!

Swift est l'une des langues modernes. On peut dire que c'est l'une des dernières langues car elle est mise à jour chaque année (bien qu'il soit difficile de s'en occuper à chaque fois ...).

Cette fois, je présenterai des cartes, des filtres et forEach qui sont souvent utilisés dans les langues modernes. Je l'utilise souvent dans d'autres langues, donc je pense que cela vaut la peine de s'en souvenir.

Une fois que vous vous y serez habitué, vous commencerez à vous demander si un processus peut être exprimé à l'aide de map.

map

Exemple

struct User {
    let id: String
    let name: String
}

let users = [
    User(id: "111", name: "aaa"),
    User(id: "112", name: "bbb"),
    User(id: "113", name: "ccc"),
    User(id: "114", name: "ddd"),
    User(id: "115", name: "eee"),
    User(id: "116", name: "fff"),
]

var result = [String]()
for user in users {
    result.append(user.id)
}

print(result)
// ["111", "112", "113", "114", "115", "116"]

Un tableau de type String est créé en collectant les ID utilisateur. Je pense que j'apprendrai à le revêtir ainsi dans les cours universitaires.

Mais avec Swift, vous pouvez écrire un code plus court.

struct User {
    let id: String
    let name: String
}

let users = [
    User(id: "111", name: "aaa"),
    User(id: "112", name: "bbb"),
    User(id: "113", name: "ccc"),
    User(id: "114", name: "ddd"),
    User(id: "115", name: "eee"),
    User(id: "116", name: "fff"),
]

let result = users.map { $0.id }

print(result)
// ["111", "112", "113", "114", "115", "116"]

Vous pouvez écrire en une seule ligne en utilisant map! Si vous n'êtes pas sûr de "$ 0", veuillez vérifier ici

let result = users.map { user in
    user.id
}

Je pense que vous pouvez le comprendre par cette méthode de description (similaire à for ~ in). Si vous omettez «user in», vous pouvez l'exprimer comme «$ 0».

Conclusion

** map peut faire du traitement sur chaque élément et retourner le résultat sous forme de tableau! ** **

compactMap

Exemple

struct User {
    let id: String
    let name: String
}

let users = [
    User(id: "111", name: "aaa"),
    User(id: "112", name: "bbb"),
    User(id: "113", name: "ccc"),
    User(id: "a114", name: "ddd"),
    User(id: "a115", name: "eee"),
    User(id: "a116", name: "fff"),
]

let stringUserIdList = users.map { $0.id }
var result = [Int]()
for stringUserId in stringUserIdList {
    if let id = Int(stringUserId) {
        result.append(id)
    }
}

print(result)
// [111, 112, 113]

Auparavant, j'ai créé facilement un tableau de chaînes en utilisant map. Cependant, vous souhaiterez peut-être convertir id en «Int» au lieu de String pour créer un tableau. S'il est laissé tel quel, le code source sera long après tout.

Utilisez compactMap dans de tels cas.

let result = users
    .compactMap { Int($0.id) }

print(result)
// [111, 112, 113]

users.map {Int ($ 0.id)} renvoie un tableau de Int?. Bien sûr, si vous essayez de lancer de String en Int, vous ne pourrez pas lancer 100%, donc Int? Sera retourné.

Mais «compactMap» supprime le «nil». Par conséquent, le type renvoyé sera un tableau de Int.

Conclusion

** compactMap peut effectuer des traitements sur chaque élément et renvoyer le résultat sous forme de tableau sans nil! ** **

flatMap

Exemple

let users = [
    [
        User(id: "101", name: "man1"),
        User(id: "102", name: "man2"),
        User(id: "103", name: "man3"),
        User(id: "104", name: "man4"),
        User(id: "105", name: "man5")
    ],
    [
        User(id: "201", name: "women1"),
        User(id: "202", name: "women2"),
        User(id: "203", name: "women3"),
        User(id: "204", name: "women4"),
        User(id: "205", name: "women5")
    ]
]
var result = [String]()

//Le nom du genre n'est pas bon...
for gender in users {
    for user in gender {
        result.append(user.id)
    }
}

print(result)
// ["101, "102", "103", "104", "105", "201", "202", "203", "204", "205"]

De cette façon, supposons que vous ayez une séquence associative dans laquelle les hommes et les femmes sont séparés. Lors de l'extraction de tous les identifiants de ces utilisateurs, je pense qu'il sera implémenté comme ça.

Bien sûr, l'instruction for est répétée deux fois ... Mais utiliser flatMap facilite les choses!

let result = users
    .flatMap { $0 }
    .map { $0.id }

print(result)
// ["101, "102", "103", "104", "105", "201", "202", "203", "204", "205"]

«flatMap» le rend littéralement plat.

Conclusion

** flatMap aplatit les éléments profonds de la hiérarchie! ** **

Avantages de map, compactMap, flatMap

Pour votre information ...

Dans les versions précédentes de Swift, compactMap n'existait pas. Certes, «flatMap» avait aussi la fonction de «compactMap», donc il semble que c'était très compliqué.

La dernière version résout ce problème, alors utilisez-la souvent!

filter

Exemple

struct User {
    /// ID
    let id: String
    ///Nom
    let name: String
    ///Sexe 1: homme, 2: femme, 0: autre
    let gender: Int
    ///la taille
    let height: Float
}

let users = [
    User(id: "001",
         name: "Tanjiro",
         gender: 1,
         height: 165),
    User(id: "102",
         name: "Nezuko",
         gender: 2,
         height: 153.0),
    User(id: "103",
         name: "Quand",
         gender: 1,
         height: 165.5),
    User(id: "104",
          name: "Inosuke",
          gender: 1,
          height: 164.0)
]
//Obtenez seulement des hommes
var mens = [User]()
//Obtenez uniquement les utilisateurs de moins de 164 cm
var result = [User]()
for user in users {
    if user.gender == 1 {
        mens.append(user)
    }
    if user.height <= 164.0 {
        result.append(user)
    }
}
print(mens)
print(result)

Comme quand j'ai présenté la carte Une variable (tableau) pour stocker le résultat acquis est préparée, et ce qui est passé par l'instruction if dans l'instruction for est stocké dans la variable.

Vous pouvez écrire un peu plus cool avec filter.

//Obtenez seulement des hommes
let result = users.filter { $0.gender == 1 }
//Obtenez uniquement les hommes de moins de 164 cm
let result = users
    .filter { $0.gender == 1 }
    .filter { $0.height <= 164.0 }

Utilisons-le positivement! !!

forEach

Le but de l'utilisation est le même que «for ~ in». Si vous voulez l'abréger, vous utilisez souvent forEach.


// for~in
for user in users {
    print(user)
}

// forEach
users.forEach { print($0) }

Conclusion

** forEach peut faire quelque chose avec chaque élément! ** **

Recommended Posts

[Pour les débutants] Pouvons nous enduire comme Swift!
[Pour les débutants] On dit que le rubis est rubis, mais qu'en est-il?
[Astuces] Comment résoudre les problèmes avec XCode et Swift pour les débutants
(Pour les débutants) Collection d'éléments de vue Swift UI
Apprenons l'instruction SQL SELECT pour les débutants
[Ruby] Comment utiliser slice pour les débutants
[Pour les débutants] Comment déboguer avec Eclipse
Les débutants rapides ont essayé d'implémenter la logique micro-ondes!
[Swift / Pour les débutants] Écrivez intelligemment avec l'inférence de type
Messages qui peuvent être utiles pour les débutants JNI
[Pour les débutants] Comment implémenter la fonction de suppression
Les débutants rapides ont essayé de mettre en œuvre la logique des distributeurs automatiques!
[Pour les super débutants] Comment utiliser l'autofocus: vrai
[Introduction à Java] Bases de l'arithmétique Java (pour les débutants)
Utilisons Java New FileIO! (Introduction, pour les débutants)
[Pour les débutants] Où vérifier lorsqu'une classe est introuvable au moment de la compilation