Passaggio di una matrice a una funzione con numero variabile di argomenti in Swift

In Swift Programming Language , dice:

Le funzioni possono anche prendere un numero variabile di argomenti, raccogliendoli in una matrice.

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

Quando chiamo tale funzione con un elenco di numeri separati da virgola (`sumOf (1, 2, 3, 4), sono resi disponibili come una matrice all’interno della funzione.

Domanda: cosa succede se ho già una serie di numeri che voglio passare a questa funzione?

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

Ciò non riesce con un errore del compilatore, “Imansible trovare un overload per ‘__conversion’ che accetti gli argomenti forniti”. C’è un modo per trasformare una matrice esistente in una lista di elementi che posso passare ad una funzione variadica?

    Lo splatting non è ancora nella lingua , come confermato dagli sviluppatori. Per ora la soluzione è utilizzare un sovraccarico o attendere se non è ansible aggiungere sovraccarichi.

    Ecco un lavoro che ho trovato. So che non è esattamente quello che vuoi, ma sembra che funzioni.

    Passaggio 1: dichiara la funzione che desideri con una matrice invece di argomenti variadici:

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

    Passaggio 2: chiama questo dalla tua funzione variadica:

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

    Passaggio 3: chiama in un modo qualsiasi:

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

    Sembra strano, ma sta funzionando nei miei test. Fammi sapere se questo causa problemi imprevisti per chiunque. Swift sembra essere in grado di separare la differenza tra le due chiamate con lo stesso nome di funzione.

    Inoltre, con questo metodo se Apple aggiorna la lingua come suggerisce la risposta di @ manojid, dovrai solo aggiornare queste funzioni. Altrimenti, dovrai passare e rinominare molto.

    Puoi lanciare la funzione:

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

    Puoi usare una funzione di supporto come tale:

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

    L’ho fatto (Wrapper + Identity Mapping):

     func addBarButtonItems(types: REWEBarButtonItemType...) { addBarButtonItems(types: types.map { $0 }) } func addBarButtonItems(types: [REWEBarButtonItemType]) { // actual implementation } 

    So che questa risposta non risponde alla tua domanda esatta, ma ritengo che sia degna di nota. Anch’io stavo iniziando a giocare con Swift e mi sono subito imbattuto in una domanda simile. La risposta di Manojlds è migliore per la tua domanda, sono d’accordo, ma ancora una volta, un’altra soluzione che mi è venuta in mente. Anche a me piace che anche Logan sia meglio.

    Nel mio caso volevo solo passare un array:

     func sumOf(numbers: Array) -> 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]) 

    Volevo solo condividere, nel caso che qualcun altro stesse pensando come me. La maggior parte delle volte preferirei passare la matrice in questo modo, ma non credo ancora che sia “Veloce”. 🙂