Swift - Higher-Order Functions

Previous
Next

A higher-order function is a special type of function; it takes one or more functions as arguments or can return a function as its result. They can easily manipulate and transform the data of the given collections without creating any extra user-defined function. Below are the higher-order functions provided by the Swift language −

  • forEach()
  • map()
  • compactMap()
  • flatMap()
  • filter()
  • reduce()
  • sort()
  • sorted()

All the higher-order functions are based on closure but don't worry you don't need to be a master of closure. They are easy to use and also reduce the size of the code in the project and can be reusable.

The forEach() Function

The ForEach() function is quite similar to the for-in loop. It will iterate through all the elements in a collection (eg array) and not return anything. Remember that you cannot use continue and break inside the forEach() function to exit the currently executing statement.

Syntax

Following is the syntax of the forEach() function −

func forEach(_x: (Self.Element)throws-> Void) rethrows

Parameter

x represents a closure that takes an item of the given sequence as a parameter.

Example

Swift program to display all the elements of the array using the forEach() function.

import Foundation

let numbersInWord = ["One", "Two", "Three", "Four", "Five", "Six"]
numbersInWord.forEach { 
   element in print(element)
}

Output

It will produce the following output −

One
Two
Three
Four
Five
Six

The map() Function

The map function works by performing an operation on all the elements of a collection and returning a new collection with the results of that operation. This function is designed to transform an object from one type to another type (as well as the same type).

Syntax

Following is the syntax of the map() function −

func map<T>(_ mTransform: (Self.Element) throws -> T) rethrows -> [T]

Parameter

The mTransform is a mapping closure. It accepts elements from the given sequence and returns a transformed value of the same or different type.

Return Value

It will return a transformed array.

Example

Swift program to convert int to a string using the map() function.

import Foundation

let numbers = [1, 2, 3, 4, 5, 6, 7]
let numbersInString = numbers.map { 
   number in String(number)
}
print("numbersInString: \(numbersInString)")

Output

It will produce the following output −

numbersInString: ["1", "2", "3", "4", "5", "6", "7"]

The compactMap() Function

Iterating through the elements in an array, compactMap() returns an updated array only containing elements that satisfy the condition stated within its body. The array will be updated without any elements that result in a nil value. Or we can say that the compactMap() loops through all the elements in the array and returns non-nil values.

Syntax

Following is the syntax of the compactMap() function −

Func compactMap<ElementOfResult>(_ mTransform: 
(Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

Parameter

The mTransform is a closure. It accepts elements from the given sequence and returns an optional value.

Return Value

It will return a transformed array of non-nil values.

Example

Swift program to convert string array to an integer array using the comapctMap() function.

import Foundation

let numbersInString = ["1", "x2", "3", "4", nil, "five5"]
let validNumbers = numbersInString.compactMap { 
   stringValue in
   Int(stringValue ?? "")
}
print("validNumbers: \(validNumbers)")

Output

It will produce the following output −

validNumbers: [1, 3, 4]

The flatMap() Function

The flatMap() function allows us to transform a set of arrays into a single set that contains all of the elements. It concatenates the elements of specified collections into a resultant collection.

Syntax

Following is the syntax of the flatMap() function −

func map<SegmentOfResult>(_ mTransform: 
(Self.Element) throws -> SegmentOfResult) rethrows -> 
[SegmentOfResult.Element] where SegmentOfResult : Sequence

Parameter

The mTransform is a closure. It accepts elements from the given sequence and returns a sequence.

Return Value

It will return a flattened array.

Example

Swift program to convert a multi-dimensional array into a one-dimensional array using the flatMap() function.

import Foundation

let marks = [[3, 4, 5], [2, 5, 3], [1, 2, 2], [5, 5, 4], [3, 5, 3]]
let allMarks = marks.flatMap { 
   marksArray -> [Int] in
   marksArray
}
print("allMarks: \(allMarks)")

Output

It will produce the following output −

allMarks: [3, 4, 5, 2, 5, 3, 1, 2, 2, 5, 5, 4, 3, 5, 3]

The filter() Function

The filter() will iterate through all elements in an array and will return an updated array only with the elements that satisfy the condition written inside the body of the filter. It is an essential function. While you write code, many times you need to filter out collections to produce a filtered collection based on a condition.

The return type of the closure is a Bool value; items in the resulting array are those that satisfy the condition inside the body;

Syntax

Following is the syntax of the filter() function −

func filter(_ resultantCollection: (Self.Element) throws -> Bool) rethrows -> Self

Parameter

The resultantCollection is a closure. It accepts elements from the given sequence and returns a boolean value which indicates whether the element should included in the resultant collection or not.

Return Value

It will return a collection that contains only those items that satisfy the condition inside the body.

Example

Swift program to display only positive numbers from the given array using the filter() function.

import Foundation

let numbers = [-12, 23, -1, 56, 9, -2, 0, 14, 8]
let positives = numbers.filter { 
   number in
   number > 0
}
print("positives: \(positives)")

Output

It will produce the following output −

positives: [23, 56, 9, 14, 8]

The reduce() Function

The reduce() function will iterate through all elements in an array and return an object with the combined value of all elements.

Syntax

Following is the syntax of the reduce() function −

func reduce<Result>(_initialRes: Result, _nestRes: (Result, Self.Element) throws -> T) 
rethrows -> Result) rethrows->Result

Parameter

This function takes two parameters −

  • The parameter initialRes is used to store initial accumulating value which is further passed to the nextRes at the first time the closure is executed.

  • The nextRes is a closure that is used to combine accumulating value and an element of the sequence into a new accumulating value, which is further used in the next call of the nextRes closure.

Return Value

It will return the final value. Or if the sequence contains no items then it will return initialRes.

Example

Swift program to find the sum of the array elements using the reduce() function.

import Foundation

let numbers = [1, 5, 2, 10, 6]
let sum = numbers.reduce(0) { 
   (result, number) -> Int in
   result + number
}
print("sum:", sum)

Output

It will produce the following output −

sum: 24

The sort() Function

The sort() function will sort all elements of the given collection in ascending order. It can also sort elements in descending order.

Syntax

Following is the syntax of the sort() function −

func sort()

Parameter

It does not take any parameters.

Return Value

It will return a sorted collection.

Example

Swift program to sort the elements of the array using the sort() function.

import Foundation

var numbers = [1, 5, 2, 10, 6]
numbers.sort()
print("Sorted numbers: \(numbers)")

Output

It will produce the following output −

Sorted numbers: [1, 2, 5, 6, 10]

The sorted() Function

The sorted() function will sort all elements according to the condition written inside the body of the closure and return a new sorted array. It can sort elements in ascending and descending order.

Syntax

Following is the syntax of the sorted() function −

func sorted()

Parameter

It does not take any parameters.

Return Value

It will return a sorted collection.

Example

Swift program to sort the elements of the array using the sorted() function.

import Foundation

var numbers = [1, 5, 2, 10, 6]
let sorted_values = numbers.sorted()
print("Sorted numbers: \(sorted_values)")

Output

It will produce the following output −

Sorted numbers: [1, 2, 5, 6, 10]
Print Page
Previous
Next
Advertisements