Passer un tableau à une fonction avec un nombre variable d'arguments dans Swift

Dans le langage de programmation Swift , il est dit:

Les fonctions peuvent également prendre un nombre variable d'arguments, les rassemblant dans un tableau.

  func sumOf(numbers: Int...) -> Int {
      ...
  }

Quand j'appelle une telle fonction avec une liste de nombres séparés par des virgules (`sumOf (1, 2, 3, 4), ils sont rendus disponibles sous forme de tableau à l'intérieur de la fonction.

Question: que faire si j'ai déjà un tableau de nombres que je souhaite transmettre à cette fonction?

let numbers = [1, 2, 3, 4]
sumOf(numbers)

Cela échoue avec une erreur du compilateur, «Impossible de trouver une surcharge pour '__conversion' qui accepte les arguments fournis». Existe-t-il un moyen de transformer un tableau existant en une liste d'éléments que je peux passer à une fonction variadique?

Splatting n'est pas encore dans la langue , comme l'ont confirmé les développeurs. Pour l'instant, la solution de contournement consiste à utiliser une surcharge ou à attendre si vous ne pouvez pas ajouter de surcharges.

Voici un travail que j'ai trouvé. Je sais que ce n'est pas exactement ce que vous voulez, mais cela semble fonctionner.

Étape 1: Déclarez la fonction que vous souhaitez avec un tableau au lieu d'arguments variadiques:

func sumOf(numbers: [Int]) -> Int {
    var total = 0
    for i in numbers {
        total += i
    }
    return total
}

Étape 2: Appelez ceci depuis votre fonction variadic:

func sumOf(numbers: Int...) -> Int {
    return sumOf(numbers)
}

Étape 3: Appelez dans les deux sens:

var variadicSum = sumOf(1, 2, 3, 4, 5)
var arraySum = sumOf([1, 2, 3, 4, 5])

Cela semble étrange, mais cela fonctionne dans mes tests. Faites-moi savoir si cela pose des problèmes imprévus à quelqu'un. Swift semble être en mesure de séparer la différence entre les deux appels avec le même nom de fonction.

De plus, avec cette méthode, si Apple met à jour la langue comme le suggère la réponse de @ manojid, vous n'aurez qu'à mettre à jour ces fonctions. Sinon, vous devrez passer par et faire beaucoup de renommage.

Vous pouvez lancer la fonction:

typealias Function = [Int] -> Int
let sumOfArray = unsafeBitCast(sumOf, Function.self)
sumOfArray([1, 2, 3])

Vous pouvez utiliser une fonction d'assistance en tant que telle:

func sumOf (numbers : [Int])  -> Int { return numbers.reduce(0, combine: +) }
func sumOf (numbers : Int...) -> Int { return sumOf (numbers) }

Je sais que cette réponse ne répond pas exactement à votre question, mais je pense qu’il vaut la peine de le noter. Moi aussi, je commençais à jouer avec Swift et je suis immédiatement tombé sur une question similaire. La réponse de Manojld est meilleure pour votre question, je suis d'accord, mais encore une fois, une autre solution de contournement que j'ai trouvée. Il se trouve que j'aime mieux Logan aussi.

Dans mon cas, je voulais juste passer un tableau:

func sumOf(numbers: Array<Int>) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}

var someNums = [8,7,2,9,12]
sumOf(someNums)
sumOf([10, 15, 20])

Je voulais juste partager, au cas où quelqu'un d'autre penserait comme moi. La plupart du temps, je préférerais passer le tableau comme ça, mais je ne pense pas encore le "Swiftly". :)

J'ai fait ceci (Wrapper + Identity Mapping):

func addBarButtonItems(types: REWEBarButtonItemType...) {
    addBarButtonItems(types: types.map { $0 })
}

func addBarButtonItems(types: [REWEBarButtonItemType]) {
    // actual implementation
}

Swift 5

C'est une approche avec @dynamicCallablefonctionnalité qui permet d'éviter la surcharge ou unsafeBitCastmais il faut faire un structappel spécifique :

@dynamicCallable
struct SumOf {
    func dynamicallyCall(withArguments args: [Int]) -> Int {
        return args.reduce(0, +)
    }
}

let sum = SumOf()

// Use a dynamic method call.
sum(1, 2, 3) // 6

// Call the underlying method directly.
sum.dynamicallyCall(withArguments: [1, 2, 3]) // 6