Передача массива в функцию с переменным числом аргументов в Swift

В языке программирования Swift говорится:

Функции также могут принимать переменное количество аргументов, собирая их в массив.

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

Когда я вызываю такую ​​функцию с разделенным запятыми списком чисел (`sumOf (1, 2, 3, 4)), они становятся доступными в виде массива внутри функции.

Вопрос: что если у меня уже есть массив чисел, который я хочу передать этой функции?

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

Это приводит к ошибке компилятора: «Не удалось найти перегрузку для« __conversion », которая принимает предоставленные аргументы». Есть ли способ превратить существующий массив в список элементов, которые я могу передать в функцию с переменным числом аргументов?

Splatting еще не в языке , что подтверждается разработчиками. Обходной путь на данный момент заключается в использовании перегрузки или ожидания, если вы не можете добавить перегрузки.

Вот работа, которую я нашел. Я знаю, что это не совсем то, что вы хотите, но, похоже, работает.

Шаг 1: Объявите функцию, которую вы хотите, с массивом вместо переменных аргументов:

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

Шаг 2: Вызовите это из своей функции вариации:

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

Шаг 3: Звоните в любую сторону:

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

Это кажется странным, но это работает в моих тестах. Дайте мне знать, если это приведет к непредвиденным проблемам для кого-либо. Swift, кажется, способен разделить разницу между двумя вызовами с одинаковым именем функции.

Кроме того, с помощью этого метода, если Apple обновляет язык в соответствии с ответом @ manojid, вам нужно будет только обновить эти функции. В противном случае вам придется пройти и сделать много переименований.

Вы можете разыграть функцию:

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

Вы можете использовать вспомогательную функцию как таковую:

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

Я знаю, что этот ответ не отвечает на ваш точный вопрос, но я чувствую, что стоит отметить. Я тоже начал играть со Свифтом и сразу столкнулся с похожим вопросом. Ответ Манойлда лучше на ваш вопрос, я согласен, но, опять же, я нашел другой обходной путь. Мне тоже нравится Логан.

В моем случае я просто хотел передать массив:

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

Просто хотел поделиться, на случай, если кто-то еще подумает, как я. Большую часть времени я бы предпочел передать массив таким образом, но пока не думаю, что это «быстро». :)

Я сделал это (Wrapper + Identity Mapping):

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

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

Swift 5

Это подход с @dynamicCallableфункцией, которая позволяет избежать перегрузки или же unsafeBitCastвы должны сделать конкретный structвызов:

@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