Question

只要它们的类型匹配，是否可以将元组传递给函数？

当我尝试时，我收到missing argument in parameter错误：

var myTuple = ("Text",10,"More Text")

func myFunction(a:String, b:Int, c:String) {
    // etc...
}

myFunction(myTuple)

Answer 1

虽然在Swift 2.2中被弃用了，但仍有可能：

在Swift 2.1及更早版本中，可以使用精心设计的元组来填充函数的参数。因此，如果你有一个带有两个参数的函数，只要元组具有正确的类型和元素名称，你就可以使用两元素元组调用它。

...

这种语法 - 被亲切地称为“元组splat语法” - 是惯用的Swift的自我记录，可读样式的对立面，所以它在Swift 2.2中已被弃用。

https://swift.org/blog/swift-2-2-new-features/

Answer 2

我来到这里想要知道如何将元组作为函数参数传递。这里的答案集中在一个不同的案例上。我并不完全清楚OP的目的是什么。

在任何情况下，这里是如何将元组作为参数传递。并且，为了更好的衡量，如何可变地进行。

func acceptTuple(tuple : (Int, String)) {
    print("The Int is: \(tuple.0)")
    print("The String is '\(tuple.1)'")
}

acceptTuple((45, "zebras"))
// Outputs:
// The Int is: 45
// The String is 'zebras'

func acceptTuples(tuples : (Int, String) ...) {
    var index = 0

    // note: you can't use the (index, tuple) pattern in the for loop,
    // the compiler thinks you're trying to unpack the tuple, hence
    /// use of a manual index 

    for tuple in tuples {
        print("[\(index)] - Int is: \(tuple.0)")
        print("[\(index)] - String is '\(tuple.1)'")
        index++
    }
}

acceptTuples((45, "zebras"), (17, "armadillos"), (12, "caterpillars"))

//Outputs
//[0] - Int is: 45
//[0] - String is 'zebras'
//[1] - Int is: 17
//[1] - String is 'armadillos'
//[2] - Int is: 12
//[2] - String is 'caterpillars'

传递元组可以是一种快速方便的方法，使您不必创建包装等。例如，我有一个用例，我传递一组标记和参数来创建游戏级别。元组使这个很好而紧凑：

// function signature
class func makeLevel(target: String, tokens: (TokenType, String)...) -> GameLevel
// The function is in the class Level. TokenType here is an Enum. 
// example use:
let level = Level("Zoo Station", tokens:
            (.Label, "Zebra"),
            (.Bat, "LeftShape"),
            (.RayTube, "HighPowered"),
            (.Bat, "RightShape"),
            (.GravityWell, "4"),
            (.Accelerator, "Alpha"))

Answer 3

是的，在这些条件下可以：

元组必须是不可变的
元组中值的数量，类型及其顺序必须与函数预期的参数匹配
命名参数必须与函数签名中的外部名称匹配
非命名参数必须与函数签名中没有外部名称的参数匹配

所以，你的代码没问题，你唯一需要做的就是把元组变成一个不可变的元组（即使用let而不是var）：

let myTuple = ("Text", 10, "More Text")

func myFunction(a:String, b:Int, c:String) {
    // etc...
}

myFunction(myTuple)

使用外部名称的另一个示例：

let myTuple = ("Text", paramB: 10, paramC: "More Text")

func myFunction(a:String, paramB b:Int,  paramC c:String) {
    // etc...
}

myFunction(myTuple)

Answer 4

在你的元组中，似乎你必须为它们命名，然后将它们称为：

所以你的代码应该是

var myTuple = (val1: "Text", val2: 10, val3: "More Text")

    func myFunction(a:String, b:Int, c:String) {
        // etc...
    }


    myFunction(myTuple.val1, myTuple.val2, myTuple.val3)

元组命名值（val1，val2，val3）你设置然后引用，当你传入myTuple时，你的函数myFunction（），看起来好像你只是填充了3个可用的争论中的一个 - 和错误的类型启动！这相当于将类型存储在元组中，然后将它们取出进行函数调用。但是，如果您希望函数实际将元组作为参数，请参见下文：

var myTuple = (val1: "Text", val2: 10, val3: "More Text")

    func tupleFunc(a:(String, Int, String)) {

    }

    tupleFunc(myTuple)

Answer 5

是的，但这是错误的结构：您传递了三个名为a，b和c的变量，而不是这些组件的元组。

你需要括号围绕整个事情：

var myTuple = ("Text", 10, "More Text")

func myFunction(a:(x: String, y: Int, z: String)) {
    println(a)
}

myFunction(myTuple)

Answer 6

在swift 3.0中，我们不应该将元组直接传递给函数。如果我们这样做，它会将错误消息显示为“此类型已在swift 3.0中删除”

func sum(x: Int, y: Int) -> Int
return x+y } 

let params = (x: 1, y: 1)
let x = params.0
let y = params.1
sum(x: x, y: y)

希望它可以帮到你!!

Answer 7

您可以使用以下功能：Swift允许您使用任意数量的参数（但没有inout参数）传递函数（f1）作为类型（TIn）的参数 - ＆gt; TOut到另一个功能。在这种情况下，TIn将表示函数f1：

的参数中的元组

precedencegroup ApplyArgumentPrecedence {
    higherThan: BitwiseShiftPrecedence 
}

infix operator <- :ApplyArgumentPrecedence

func <-<TIn, TOut>(f: ((TIn) -> TOut), arg: TIn) -> TOut {
    return f(arg)
}

func sum(_ a: Int, _ b: Int) -> Int {
  return a + b
}

print(sum <- (40, 2))

Answer 8

迅速删除了名为implicit tuple splat的功能。

您可以找到有关搬迁建议here

的更多详细说明

一些建议继续使用元组作为参数：

func f1(_ a : (Int, Int)) { ... }
let x = (1, 2)
f1(x)


func f2<T>(_ a : T) -> T { ... }
let x = (1, 2)
f2(x)

Swift函数接受元组

8 个答案: