接受元组的Swift函数

只要元组的类型匹配，就可以将元组传递到函数中吗

当我尝试它时，我在参数错误中得到一个

缺少的参数：

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

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

myFunction(myTuple)

在元组中，似乎必须对它们进行命名，然后引用它们：

所以你的代码应该是

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个可用参数中的1个，并且引导的类型错误！这相当于将类型存储在元组中，然后将它们取出进行函数调用。但是，如果希望函数实际将元组作为参数，请参见以下内容：

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

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

    }

    tupleFunc(myTuple)

是的，但这是错误的结构：您传递的是三个变量，分别是
a
、
b
和
c
，而不是包含这些组件的元组

你需要用括号括起来：

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

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

myFunction(myTuple)

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


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

因此，您的代码没有问题，您唯一需要做的就是将元组转换为不可变元组（即使用
let
而不是
var
）：

还有一个外部名称示例：

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

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

myFunction(myTuple)

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

在任何情况下，下面介绍如何将元组作为参数传递。而且，为了更好的衡量，如何可变地实现这一点

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

尽管在Swift 2.2中被弃用，但这是可能的：

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


这种语法被亲切地称为“tuple-splat语法”，与惯用的Swift的自文档化、可读性风格相反，因此在swift2.2中被弃用

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

希望它能帮助你
 您可以使用以下功能：Swift允许您将带有任意数量参数（但不带inout参数）的函数（f1）作为（TIn）->类型的参数传递给另一个函数。在这种情况下，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))

preference组applyargumentpreference{
higherThan：位移位接收
}
中缀运算符兜售{
返回f（arg）
}
func sum（a:Int，b:Int）->Int{
返回a+b
}
打印（sum称为
隐式元组splat
的功能在swift 3中被删除

您可以找到有关删除建议的更详细说明

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

func f1（a:（Int，Int））{…}
设x=（1，2）
f1（x）
func f2（a:T）->T{…}
设x=（1，2）
f2（x）
这不是传递一个元组，而是传递一个元组的组件。虽然这在这里产生了相同的效果，但我认为这不是OP要问的。你知道关于这种行为的任何官方文件吗？不，我没有发现任何提及-我发现了randomlyOK，谢谢。似乎“元组值不能命名”一般情况下是错误的：命名函数参数需要命名元组元素。@rintaro:正确，您是对的-外部名称必须匹配。我已经更新了我的答案。感谢您指出这与OP的情况不同。我来这里的搜索与您相同。您应该单独提出这个问题（并回答自己）通过间接地回答问题，您还可以将
typealias
定义为元组，并将其作为函数参数传递。
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)

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