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
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».
compactMap
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.
flatMap
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.
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
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) }
Recommended Posts