Übergeben eines Arrays an eine Funktion mit variabler Anzahl von Argumenten in Swift

In der Swift-Programmiersprache heißt es:

Funktionen können auch eine variable Anzahl von Argumenten annehmen und diese in einem Array sammeln.

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

Wenn ich eine solche Funktion mit einer durch Kommas getrennten Liste von Zahlen (`sumOf (1, 2, 3, 4)) aufrufe, werden sie als Array innerhalb der Funktion verfügbar gemacht.

Frage: Was ist, wenn ich bereits ein Array von Zahlen habe, die ich an diese Funktion übergeben möchte?

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

Dies schlägt mit dem Compilerfehler fehl, "Es konnte keine Überladung für '__conversion' gefunden werden, die die angegebenen Argumente akzeptiert". Gibt es eine Möglichkeit, ein vorhandenes Array in eine Liste von Elementen umzuwandeln, die ich an eine variable Funktion übergeben kann?

Splatting ist noch nicht in der Sprache , wie von den Entwicklern bestätigt. Problemumgehung besteht derzeit darin, eine Überladung zu verwenden oder zu warten, wenn Sie keine Überladungen hinzufügen können.

Hier ist eine Arbeit, die ich gefunden habe. Ich weiß, es ist nicht genau das, was Sie wollen, aber es scheint zu funktionieren.

Schritt 1: Deklarieren Sie die gewünschte Funktion mit einem Array anstelle von variadischen Argumenten:

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

Schritt 2: Rufen Sie dies innerhalb Ihrer variadischen Funktion auf:

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

Schritt 3: Rufen Sie so oder so an:

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

Es scheint seltsam, aber es funktioniert in meinen Tests. Lassen Sie mich wissen, ob dies für jemanden unvorhergesehene Probleme verursacht. Swift scheint in der Lage zu sein, den Unterschied zwischen den beiden Aufrufen mit demselben Funktionsnamen zu trennen.

Wenn Apple bei dieser Methode die Sprache gemäß der Antwort von @ manojid aktualisiert, müssen Sie nur diese Funktionen aktualisieren. Andernfalls müssen Sie viel umbenennen.

Sie können die Funktion umwandeln:

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

Sie können eine Hilfsfunktion als solche verwenden:

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

Ich weiß, dass diese Antwort Ihre genaue Frage nicht beantwortet, aber ich denke, es ist erwähnenswert. Auch ich begann mit Swift zu spielen und stieß sofort auf eine ähnliche Frage. Manojlds Antwort ist besser für Ihre Frage, ich stimme zu, aber auch hier eine andere Problemumgehung, die ich mir ausgedacht habe. Ich mag Logans auch besser.

In meinem Fall wollte ich nur ein Array übergeben:

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])

Ich wollte nur teilen, falls jemand anders wie ich dachte. Die meiste Zeit würde ich es vorziehen, das Array so zu übergeben, aber ich denke das "Swiftly" noch nicht. :) :)

Ich habe dies getan (Wrapper + Identity Mapping):

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

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

Swift 5

Dies ist ein Ansatz mit einer @dynamicCallableFunktion, mit der eine Überlastung unsafeBitCastvermieden werden kann. Sie sollten jedoch einen bestimmten structAufruf vornehmen :

@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