DEV Community

Cover image for Closure(Handy methods)
DanielJang
DanielJang

Posted on

Closure(Handy methods)

We could see Concept of Closure from Closure (Concept)

Collections have several handy methods by using closure syntax.
Let’s study how Closure can be useful when dealing with collections.

forEach

  • forEach doesn’t return anything

syntax:

anyArrays.forEach { elementOfArray in
  print(elementOfArray)
}

//Same performance as for ~ in loop
for elementOfArray in anyArrays {
  print(elementOfArray)
}
Enter fullscreen mode Exit fullscreen mode

Example:

var nameArray = ["Daniel", "Billy", "Gon"]
nameArray.forEach { name in
    print(name)
}
//or
nameArray.forEach { print($0) }
/*Result
 Daniel
 Billy
 Gon*/


var integerArray = [1, 2, 3]
integerArray.forEach{ print($0) }
/*Result
 1
 2
 3*/
Enter fullscreen mode Exit fullscreen mode


map

  • map returns an array

syntax:

let returnedArray = anyArrays.map { elementOfArray in
  statements
}
Enter fullscreen mode Exit fullscreen mode

Example 1 : below example return new string array from string array

var nameArray = ["Daniel", "Billy", "Gon"]
let returnedNameArray = nameArray.map { name in
    name.uppercased()   //TIP: you can remove return keyword when statement is singline in curly brace
}
//or same as below
let returnedNameArray = nameArray.map { $0.uppercased() }

//Result: returnedNameArray = ["DANIEL", "BILLY", "GON"]
Enter fullscreen mode Exit fullscreen mode

Example 2: below example return new string array from integer array (i.e. based on your statement you can convert your original array to other type’s array 🤩

let numbers = [2, 4, 6]
let stringNumbers = numbers.map { number -> String in   
    "count is \(number)"  //TIP: return keyword is removed becuase of statement is singline
}
//or
let stringNumbers = numbers.map { number in   
    "count is \(number)"
}
//or
let stringNumbers = numbers.map {  "count is \($0)"  }

//Reesult: stringNumbers = ["count is 2", "count is 4", "count is 6"]
Enter fullscreen mode Exit fullscreen mode


compactMap

  • compactMap return array without “nil” value

syntax:

let returnedArray = anyArrays.compactMap { elementOfArray in
  statements
}
Enter fullscreen mode Exit fullscreen mode

Example:

let stringArray = ["3.14", "20.5", "Daniel"]

let integerArray = stringArray.compactMap{ element in
    Double(element)
}

//Result: integerArray = [3.14, 20.5]
// stringArray have 3 element
// first element(3.14) can be converted to Double by Double("3.14")
// second element(20.5) can be converted to Double by Double("20.5")
// BUT third element "Daniel" cannot be converted to Double. Double("Daniel") is nil value 
Enter fullscreen mode Exit fullscreen mode


flatMap

  • return combined single dimension array from multi dimension input array

syntax:

let returnedArray = anyArrays.flatMap { elementOfArray in
  statements
}
Enter fullscreen mode Exit fullscreen mode

Example:

let multiDimensionArray = [ ["Apple", "Tomato", "Banana"], ["100", "200", "300"] ]
let combinedArray = multiDimensionArray.flatMap { $0 }

//Result: combinedArray = ["Apple", "Tomato", "Banana", "100", "200", "300"]
Enter fullscreen mode Exit fullscreen mode


filter

  • return array with passed elements when condition statement is true in closure

syntax:

let returnedArray = anyArrays.filter { elementOfArray in
  condition statements
}
Enter fullscreen mode Exit fullscreen mode

Example:

let inputScore = [ 34, 14, 68, 70, 23, 90, 95]
let passedScore = inputScore.filter { score in
    score > 50
}

//Result: passedScore = [68, 70, 90, 95]
Enter fullscreen mode Exit fullscreen mode


reduce

  • return “Result” can be any types
  • reduce have 2 arguments, first is initial vlaue and sencond is closure with return Result
  • Closure which is second argument has return data type same as initialValue’s data type
  • Closure returns Result and closure’s first value get the return value until last element
  • closure:(Result,Any) -> Result)

syntax:

let returnedValue = anyArrays.reduce(initialValue: Result, closure:(Result,Element) -> Result)
Enter fullscreen mode Exit fullscreen mode

Example:

let inputScore = [ 34, 14, 68, 70, 23, 90, 95]
//first argument(0) is initial valye and second argument is closure
//total is as stored property with 0 initial value
//score is element of inputScore array
let sumScore = inputScore.reduce(0, { total, score in  
    total + score
})

//Let's change format by trailling closure
let sumScore = inputScore.reduce(0) { total, score in  
    total + score
}

//Result: sumScore = 394
Enter fullscreen mode Exit fullscreen mode


reduce(into:)

  • return “Result” can be any types
  • reduce have 2 arguments, first is initial vlaue and sencond is closure without return Result(Closure doesn’t return anything)
  • Closure’s first argument has “inout” label. That means the argument is mutable(we will store value to the first argument “Result”
  • “initialValue”’s data type and first argument’s data type of “closure” are same.

syntax:

let returnedValue = anyArrays.reduce(initialValue: Result, closure:(inout Result, Element) -> ( ))
Enter fullscreen mode Exit fullscreen mode

Example:

var inputDic = [1: 3.5, 2: 6, 3: 4.4]

// [] is initial array, element is element of inputDic
var outputArray = inputDic.reduce(into: []) { partialResult, element in   
    partialResult.append(Double(element.key) * Double(element.value))
}

//Result: outputArray = [3.5, 12.0, 13.200000000000001]
Enter fullscreen mode Exit fullscreen mode


sort

  • sorting ascending order
  • reassign return array to input array itself

syntax:

inputArray.sort()
Enter fullscreen mode Exit fullscreen mode

Example:

var numbers = [3, 5, 1, 4, 6, 2]
numbers.sort()

//Result: numbers = [1, 2, 3, 4, 5, 6]
Enter fullscreen mode Exit fullscreen mode


sort(by:)

  • sorting by “by” argument(closure)
  • reassign return array to input array itself

syntax:

inputArray.sort(by: (element, element) throws -> Bool)
//or
inputArray.sort { element, element in
  condition statement
}
Enter fullscreen mode Exit fullscreen mode

Example

var numbers = [3, 5, 1, 4, 6, 2]
numbers.sort { a, b in
    a > b
}
//or
numbers.sort { $0 > $1 }
//or
number.sort(by: >)

//Result: numbers = [6, 5, 4, 3, 2, 1]
Enter fullscreen mode Exit fullscreen mode

sorted

  • sorting ascending order
  • assign return array to new array
  • original input array value is no-change

syntax:

let newArray = inputArray.sorted()
Enter fullscreen mode Exit fullscreen mode

Example:

var numbers = [3, 5, 1, 4, 6, 2]
let newNumbers = numbers.sorted()
//Result
//numbers = [3, 5, 1, 4, 6, 2]
//newNumbers = [1, 2, 3, 4, 5, 6]
Enter fullscreen mode Exit fullscreen mode


sorted(by:)

  • sorting by “by” argument(closure)
  • assign return array to new array
  • original input array value is no-change

syntax:

let newArray = inputArray.sorted(by: (element, element) throws -> Bool)
//or
let newArray = inputArray.sorted{ element, element in
  condition statement
}
Enter fullscreen mode Exit fullscreen mode

Example:

var numbers = [3, 5, 1, 4, 6, 2]

let newNumbers = numbers.sorted { a, b in
    a > b
}
//or
let newNumbers = numbers.sorted { $0 > $1 }
//or
let newNumbers = numbers.sorted(by: >)

//Result
//numbers = [3, 5, 1, 4, 6, 2]
//newNumbers = [6, 5, 4, 3, 2, 1]
Enter fullscreen mode Exit fullscreen mode

Yea~~~~ Done !!!

Discussion (0)