Closure का Syntax

let closureName = { (param: Type) -> ReturnType in
    return value
}

functionName(argument, using: { (param: Type) -> ReturnType in
    return value
})

// Declare a constant `multiply`, set to `{ (a: Int, b: Int) -> Int in`
let multiply = { (a: Int, b: Int) -> Int in
    // Return `a * b` from this function
    return a * b
}
// Print `multiply(3, 4)` to the console
print(multiply(3, 4))

// Define the function `operate` taking `a`, `b`, `operation` and returning an Int
func operate(_ a: Int, _ b: Int, using operation: (Int, Int) -> Int) -> Int {
    // Return `operation(a, b)` from this function
    return operation(a, b)
}
let result = operate(5, 6, using: { (x: Int, y: Int) -> Int in
    // Return `x + y` from this function
    return x + y
})
// Print `result` to the console
print(result)

Closure का Shorthand Syntax · Trailing Closures क्या हैं · Values को Capture करना · Escaping Closures क्या हैं

1. in keyword भूल जाना जो किसी closure के parameter list और return type को इसकी body से अलग करता है।
2. किसी closure के अंदर अनावश्यक type annotations लिखना जब Swift इन्हें पहले से context से infer कर सकता है।
3. Closure syntax { (params) -> ReturnType in ... } को किसी function की func declaration के साथ confuse करना; closures कभी func keyword उपयोग नहीं करते।

• एक closure { (parameters) -> ReturnType in statements } लिखा जाता है।
• Closures को variables को assign किया जा सकता है और बिल्कुल functions की तरह call किया जा सकता है।
• किसी closure के अंदर type annotations अक्सर अनावश्यक होते हैं क्योंकि Swift इन्हें context से infer करता है।
• Closures अपने आस-पास के scope से variables capture और reference करते हैं।