Swift déballe en toute sécurité les chaînes et les ints optinaux

Question

Lorsque je suis sur le point de lancer ma séquence pour la deuxième vue, j'envoie également quelques valeurs comme ceci :

if let aTime = ads[indexPath.row]["unix_t"].int {
    toView.time = aTime
}

if let aTitle = ads[indexPath.row]["title"].string {
    toView.title = aTitle
}

Dans le deuxième VC, j'ai déclaré les variables comme :

var time: Int?
var title: String?

et c'est ainsi que je déballe les valeurs :

if time != nil {
   timeLabel.text = String(time!)
}

if title != nil {
   titleLabel.text = title!
}

Tout cela fonctionne, je n'obtiens jamais d'erreur causée par des variables non enveloppées ou des valeurs nulles. Mais y a-t-il un moyen plus simple de le faire ?

En ce moment, j'ai l'impression que je vérifie trop.

Answer 1

Je peux penser à trois alternatives.

1. if/let . Très similaire à votre option actuelle, mais vous n'avez pas besoin de déballer implicitement.

   if let time = time {
       timeLabel.text = "\(time)"
   }
   
   if let title = title {
       titleLabel.text = title
   }

   Vous pouvez même les déballer sur la même ligne. L'inconvénient est que si l'un d'entre eux est nil alors aucune des deux étiquettes ne sera mise en place.

   if let time = time, let title = title {
       timeLabel.text = "\(time)"
       titleLabel.text = title
   }

2. guard/let . Si elles sont dans une fonction comme setupViews() vous pouvez alors mettre en ligne votre déballage comme suit :

   func setupViews() {
       guard let time = time, let title = title else { return }
       timeLabel.text = "\(time)"
       titleLabel.text = title
   }

3. Vous pouvez utiliser les valeurs par défaut et les ?? opérateur à déballer rapidement.

   timeLabel.text = "\(time ?? 0)"
   titleLabel.text = title ?? ""

Answer 2

Vous pouvez utiliser le Nil Coalescing Operator également comme indiqué dans le Docs :

L'opérateur de coalescence nil (a ? ? b) déballe une option a si elle contient une valeur, ou renvoie une valeur par défaut b si a est nil. L'expression a est toujours de type optionnel. L'expression b doit correspondre au type qui est stocké dans a.

L'opérateur de coalescence nil est un raccourci pour le code ci-dessous :

a != nil ? a! : b

Answer 3

if let time = time {
    timeLabel.text = "\(time)"
}

if let title = title {
    titleLabel.text = title
}

C'est la même chose qu'avec votre JSON

Answer 4

Oui, vous vérifiez trop (deux fois).

Puisque seules les valeurs non optionnelles sont transmises, vous pouvez déclarer les variables non optionnelles.

var time = 0
var title = ""

et définir les étiquettes

timeLabel.text = "\(time)"
titleLabel.text = title

Le système de type fort de Swift recommande fortement de considérer en premier lieu

Puis-je le faire sans option ?

et - s'il n'y a pas d'autre option - utilisez les optionnels.

Answer 5

Vous n'avez pas besoin de vérifier la condition "nil" dans la première vue. Veuillez suivre le code ci-dessous :

toView.time = ads[indexPath.row]["unix_t"] as? Int

toView.title = ads[indexPath.row]["title"] as? String

Les variables de temps et de titre dans la deuxième vue sont optionnelles. Ainsi, lorsque vous attribuez une valeur à toView.time et toView.title, il attribuera soit la valeur de type time et title respectivement, soit nil.