For Loops and Switches in Swift - swift

Question

I'm (relatively) new to programming. I was working through Apple's "Introduction to App Development" and since there isn't an answer booklet of some sort I've had to work things out on my own. However there are some things I'm a bit confused about:
There is a problem I'm working on:
This playground has a Chicken type built in to it. A Chicken has a breed and temper property, and both properties are enums.
Here is an array of chickens:
chickens = [{silkie, grumpy}...]
The task is to calculate how many chickens of the breed "leghorn" and temper "hilarious" there are in the array. I've come up with the following code:
var chickenOfInterestCount = 0
for chicken in chickens {
switch chicken.temper {
case .hilarious:
switch chicken.breed {
case .leghorn:
chickenOfInterestCount += 1
default:
chickenOfInterestCount += 0
}
default:
chickenOfInterestCount += 0
}
}
chickenOfInterestCount
It works, but I wonder if there is a more efficient way to do this? Can I make the switch check each chicken for {leghorn, hilarious} and count the number of required chickens directly, rather than using a nested switch? (All of my attempts to try this myself were squashed by scary looking error messages, so I'm guessing no) Following from that, how do for loops work?
When I originally learned for loops, I was under the impression that integers were used to loop through, e.g. the first loop was i = 0, and the code inside performed, then the second loop was i = 1, etc, where "i" could really be anything, and the idea would be the same. Here, "chicken" is used. Why is it that I can set the condition to chicken.temper? What does chicken mean here? Does a for loop respect the type of the array it is looping through? So is what is actually happening here something like "take the 0th Chicken in the array of chickens, call that a 'chicken', then check its temper"?

Answer 1

Well, the first thing I'll mention is that your approach works. As you suspect, it's not the most elegant approach - but you're already instinctively aware of this.
The filter functionality in Swift is powerful and efficient, and Dilan's example will set you in the right direction to begin exploring this. But you'll want to develop a good understanding of control flow on its own - aside from functional programming features like map, reduce, and filter.
For this situation if you're only looking for one combination of breed and temperament, then probably a basic if statement is cleaner than using switch.
var chickenOfInterestCount = 0
for chicken in chickens {
if chicken.breed == .leghorn && chicken.temper == .hilarious {
chickenOfInterestCount += 1
}
}
chickenOfInterestCount
Switch is more useful when you have to do something for each case - it ends up being much cleaner than multiple if / else if statements.
var bantamCount = 0
var leghornCount = 0
var unknownBreedCount = 0
var chillCount = 0
var hilariousCount = 0
var unknownTemperCount = 0
for chicken in chickens {
switch chicken.breed {
case .bantam:
bantamCount += 1
case .leghorn:
leghornCount += 1
default:
unknownBreedCount += 1
}
switch chicken.temper {
case .chill:
chillCount += 1
case .hilarious:
hilariousCount += 1
default:
unknownTemperCount += 1
}
}
Also on your question:
So is what is actually happening here something like "take the 0th Chicken in the array of chickens, call that a 'chicken', then check its temper"?
As Ben pointed out, you're reasoning about this correctly. Within the scope of the loop, there's a var called chicken that is an instance of Chicken (presumably - not sure what you named this Class or Struct) and is a member of the chickens array.

Answer 2

The Swift-y thing to do in these situations is to break out map(), reduce(), compactMap(), and filter()--in your case, filter():
let chickens: [Chicken] = [ silkie, grumpy, dopey, foghorn ]
let hilariousLeghorns = chickens.filter {
$0.breed == .leghorn
&& $0.temper == .hilarious
}
let chickenOfInterestCount = hilariousLeghorns.count
(Thank you for making your example funny!)
In your pseudo-code, your for-loop is a little nest-y, and that can be hard to read. (Mine is probably not much easier--I'd love a code review!) You are in fact declaring a chicken which is going to be assigned the value of each element of chickens in turn. You can do this with any Sequence, like an array, a map, or a set.
To get a old-school for loop, you can loop through a range:
for i in 1...5 {
print(i)
}
This does the same thing: i is assigned the values 1, 2, 3, 4, and 5, in turn, looping 5 times.

Answer 3

Welcome to Programming.This is the model for your scenario .
struct Chicken{
let id:Int
let breed:String
let temper:String
}
enum Breed{
static let leghorn = "leghorn"
static let other = "other"
}
enum Temper{
static let hilarious = "hilarious"
static let other = "other"
}
var chickens:[Chicken] = []
chickens.append(Chicken(id: 1, breed:.leghorn, temper:.hilarious))
chickens.append(Chicken(id: 2, breed:.other, temper:.hilarious))
chickens.append(Chicken(id: 3, breed:.leghorn, temper:.other))
You can get your result from one line with Swift.Use Filter function.This is like for loop and $0 mean current element.It is loop through your array and find elements that satisfy your condition.
print(chickens.filter({$0.breed == .leghorn && $0.temper == .hilarious}).count)
Apple Documentation
Extra info