Data Flashcards
How is a dictionary different from an array?
It’s all down to how you access data: arrays must be accessed using the index of each element, whereas dictionaries can be accessed using something you define – strings are very common. Make sure and give practical examples of where each would be used.
What are the main differences between classes and structs in Swift?
Your answer ought to include a discussion of value types (like structs) and reference types (like classes), but also the fact that classes allow inheritance.
For bonus points you could mention that classes have deinit() methods and structs do not.
What are tuples and why are they useful?
Tuples are a bit like anonymous structs, and are helpful for returning multiple values from a method in a type-safe way, among other things. Make sure you go on to provide some explanation of where they might be useful, such as returning two values from an array.
What does the Codable protocol do?
This protocol was introduced in Swift 4 to let us quickly and safely convert custom Swift types to and from JSON, XML, and similar.
talk about customization points such as key and date decoding strategies, the CodingKey protocol, and more, so that you’re able to show you can handle a range of input and output styles.
What is the difference between an array and a set?
sets can’t contain duplicates and are unordered, so lookup is significantly faster. Note: this might sound like a trivial question, but the “significantly faster” part is critical – sets can be thousands of times faster than arrays depending on how many elements they contain. If you can, go on to give specific examples of where a set would be a better idea than an array.
What’s the importance of key decoding strategies when using Codable?
“key decoding strategies let us handle difference between JSON keys and property names in our Decodable struct” – then provide some kind of practical sample. For example, you might say that it’s common for JSON keys to use snake_case for key names, whereas in Swift we prefer camelCase, so we need to use a key decoding strategy to convert between the two.
When using arrays, what’s the difference between map() and compactMap()?
Remember to give practical examples as well as outlining the core differences. So, you might start by saying the map() transforms a sequence using a function we specify, whereas compactMap() does that same step but then unwraps its optionals and discards any nil values. For example, converting an array of strings into integers works better with compactMap(), because creating an Int from a String is failable.
Why is immutability important?
Immutability is baked deep into Swift, and Xcode even warns if var was used when let was possible. It’s important because it’s like a programming contract: we’re saying This Thing Should Not Change, so if we try to change it the compiler will refuse.
What are one-sided ranges and when would you use them?
So, you might say that one-sided ranges are ranges where you don’t specify the start or end of the range, meaning that Swift will automatically make the range start from the start of the collection or the end of the collection. They are useful when you want to read from a certain position to the end of a collection, such as if you want to skip the first 10 users in an array.
What does it mean when we say “strings are collections in Swift”?
This statement means that Swift’s String type conform to the Collection protocol, which allows us to loop over characters, count how long the string is, map the characters, select random characters, and more.
What is a UUID, and when might you use it?
UUID stands for “universally unique identifier”, which is a long string of hexadecimal numbers stored in a single type.
UUIDs are helpful for ensuring some value is guaranteed to be unique, for example you might need a unique filename when saving something.
What’s the difference between a value type and a reference type?
The best way to frame this discussion is likely to be classes vs structs: an instance of a class can have multiple owners, but an instance of a struct cannot.
When would you use Swift’s Result type?
Start with a brief introduction to what Result does, saying that it’s an enum encapsulating success and failure, both with associated values so you can attach extra information. I would then dive into the “when would you use it” part of the question – talking about asynchronous code is your best bet, particularly in comparison to how things like URLSession would often pass both a value and an error even when only one should exist at a time.
What is type erasure and when would you use it?
Type erasure allows us to throw away some type information, for example to say that an array of strings is actually just AnySequence – it’s a sequence containing strings, but we don’t know exactly what kind of sequence.
This is particularly useful when types are long and complex, which is often the case with Combine. So, rather than having a return type that is 500 characters long, we can just say AnyPublisher – it’s a publisher that will provide SomeType and never throw an error, but we don’t care exactly what publisher it is
