web-dev-qa-db-fra.com

Pourquoi utiliser des n-uplets quand on peut utiliser tableau pour renvoyer plusieurs valeurs dans swift

Aujourd'hui, je passais en revue quelques concepts de base de Swift et je travaillais avec quelques exemples pour comprendre ces concepts. À l'heure actuelle, j'ai terminé l'étude des n-uplets.

J'ai un doute, c'est-à-dire, quelle est la nécessité d'utiliser des n-uplets? Ya j'ai fait quelques recherches sur ceci est ce que j'ai eu:

Nous pouvons être en mesure de renvoyer plusieurs valeurs d'une fonction. Ok mais nous pouvons aussi le faire en retournant un tableau.

Array ok mais nous pouvons renvoyer plusieurs valeurs de types différents. Ok bien, mais cela peut aussi être fait avec un tableau de AnyObject comme ceci:

    func calculateStatistics (scores:[Int])->[AnyObject]
{
    var min = scores[0]
    var max = scores[0]
    var sum = 0

    for score in scores
    {
        if score > max{
            max = score
        }
        else if score < min{
            min = score
        }
        sum += score
    }
    return [min,max,"Hello"]
}

let statistics = calculateStatistics([25,39,78,66,74,80])

var min = statistics[0]
var max = statistics[1]
var msg = statistics[2] // Contains hello

Nous pouvons nommer les objets présents dans les tuples. Ok mais je peux utiliser un dictionnaire de AnyObject.

Je ne dis pas cela Pourquoi utiliser des n-uplets quand nous avons ceci. Mais il devrait y avoir quelque chose que seul Tuple peut être capable de faire ou il est facile de le faire uniquement avec des tuples. De plus, les personnes qui ont créé Swift n'auraient pas impliqué des nuplets à Swift s'il n'y avait pas eu de bonne raison. Il aurait donc dû y avoir une bonne raison pour les impliquer.

Alors, s'il vous plaît, laissez-moi savoir s'il y a des cas particuliers où les n-uplets sont le meilleur choix.

Merci d'avance.

iosswiftios8tuples
26
iamyogish

Les tuples sont des structures anonymes qui peuvent être utilisées de nombreuses manières. L'une d'elles est de faciliter le retour de plusieurs valeurs d'une fonction.

Les avantages de l'utilisation d'un tuple au lieu d'un tableau sont les suivants:

  • plusieurs types peuvent être stockés dans un tuple, alors que dans un tableau, vous êtes limité à un seul type (sauf si vous utilisez [AnyObject])
  • nombre fixe de valeurs: vous ne pouvez pas transmettre moins ou plus de paramètres que prévu, alors que dans un tableau, vous pouvez placer un nombre quelconque d'arguments
  • fortement typé: si des paramètres de types différents sont passés dans de mauvaises positions, le compilateur le détectera, alors que l'utilisation d'un tableau ne se produira pas
  • refactoring: si le nombre de paramètres, ou leur type, change, le compilateur produira une erreur de compilation pertinente, alors qu'avec les tableaux qui passeront inaperçus
  • named: il est possible d'associer un nom à chaque paramètre

  • l'affectation est plus facile et plus flexible - par exemple, la valeur de retour peut être assignée à un tuple:

    let Tuple = functionReturningTuple()

    ou tous les paramètres peuvent être extraits automatiquement et affectés à des variables

    let (param1, param2, param3) = functionReturningTuple()

    et il est possible d'ignorer certaines valeurs

    let (param1, _, _) = functionReturningTuple()

  • similarité avec les paramètres de fonction: lorsqu'une fonction est appelée, les paramètres que vous transmettez sont en fait un tuple. Exemple:

    // Swift 2
func doSomething(number: Int, text: String) {
    println("\(number): \(text)")
}

doSomething(1, "one")

// Swift 3    
func doSomething(number: Int, text: String) {
    print("\(number): \(text)")
}

doSomething(number: 1, text: "one")

    (Obsolète dans Swift 2) La fonction peut également être appelée en tant que:

    let params = (1, "one")
doSomething(params)

Cette liste n'est probablement pas exhaustive, mais je pense qu'il y en a assez pour vous faire préférer des n-uplets aux tableaux pour retourner plusieurs valeurs

59
Antonio

Par exemple, considérons cet exemple simple:

enum MyType {
    case A, B, C
}

func foo() -> (MyType, Int, String) {
    // ...
    return (.B, 42, "bar")
}

let (type, amount, desc) = foo()

En utilisant Array, vous obtiendrez le même résultat:

func foo() -> [Any] {
    // ...
    return [MyType.B, 42, "bar"]
}

let result = foo()
let type = result[0] as MyType, amount = result[1] as Int, desc = result[2] as String

Le tuple est beaucoup plus simple et sûr, n'est-ce pas?

11
rintaro

Le tuple est une structure de données plus légère qu'un tableau hétérogène. Bien qu'ils soient très similaires, en accédant aux éléments par index, l'avantage est que les n-uplets peuvent être construits très facilement dans Swift. Et l'intention d'introduire/interpoler cette structure de données (Tuple) est Plusieurs types de retour. Renvoyer plusieurs données de l'appelé avec un minimum d'effort, c'est l'avantage d'avoir Tuples. J'espère que cela t'aides!

5
Suresh Kumar Durairaj

Un tuple est idéalement utilisé pour renvoyer plusieurs données nommées d'une fonction pour une utilisation temporaire. Si la portée du tuple est persistante dans un programme, vous pouvez modéliser cette structure de données en tant que classe ou structure. 

0
Kevin Wiggins