In Swift arrays you can do:
var myArray = [1,2,3,4]
myArray.forEach() { print($0 * 2) }
myArray.map() { print($0 * 2) }
They both do the same thing. The only difference is .map also returns an array of voids as well, [(),(),(),()], which gets unused. Does that mean .map performs worse than .forEach when it's not assigning to anything?
In Swift as per Apple's definition,
mapis used for returning an array containing the results of mapping the given closure over the sequence’s elements
whereas,
forEachcalls the given closure on each element in the sequence in the same order as a for-in loop.
Both got two different purposes in Swift. Even though in your example map works fine, it doesn't mean that you should be using map in this case.
map eg:-
let values = [1.0, 2.0, 3.0, 4.0]
let squares = values.map {$0 * $0}
[1.0, 4.0, 9.0, 16.0] //squares has this array now, use it somewhere
forEach eg:-
let values = [1.0, 2.0, 3.0, 4.0]
values.forEach() { print($0 * 2) }
prints below numbers. There are no arrays returned this time.
2.0
4.0
6.0
8.0
In short to answer your questions, yes the array generated from map is wasted and hence forEach is what you should use in this case.
Update:
OP has commented that when he tested, the performance was better for map compared to forEach. Here is what I tried in a playground and found. For me forEach performed better than map as shown in image. forEach took 51.31 seconds where as map took 51.59 seconds which is 0.28 seconds difference. I don't claim that forEach is better based on this, but both has similar performance attributes and which one to use, depends on the particular use case.
for-in in that case since internally that is what used anyways.forEach is faster compared to map. Clearly, there is no definite answer for which one is faster then since it could change easily again for another usecase.
According to Apple Doc
.map
The map(_:) method calls the closure expression once for each item in the array. You do not need to specify the type of the closure’s input parameter, number, because the type can be inferred from the values in the array to be mapped.
.forEach(_:) Apple Doc
Calls the given closure on each element in the sequence in the same order as a for-in loop.
var myArray = [1,2,3,4]
var sampleArray = [1,2,3,4]
//myArray = myArray.forEach() { ($0 * 2) }//Not allowed
sampleArray = sampleArray.map() { ($0 * 2) }
print("sampleArray array is \(sampleArray)")//sampleArray array is [2, 4, 6, 8]
.map is faster than .forEach.
Just by a hair. Note that assigning .map to _ as pictured causes the closure to be required not to return a value.
A wild compiler optimization appears!
mapare discarded. Conversely, there is a strong argument for ensuring that allmapoperations are only for the result - and not used for any [write] side-effects. With that in mind, there is only one 'semantically correct' option regardless of any 'performance'. These simple Not Tricky Coding Choices (TM) are key to reducing frustration/wtf for those who work on the code after you.map, they are generating an array for a call. Then how does compiler optimizes? My understanding of_is that it just ignores the returned value.for elem in myArray.filter() { $0 != 42 } {...