{"id":2138,"date":"2016-11-21T20:58:00","date_gmt":"2016-11-22T02:58:00","guid":{"rendered":"http:\/\/jamesonquave.com\/blog\/?p=2138"},"modified":"2016-12-04T20:34:14","modified_gmt":"2016-12-05T02:34:14","slug":"swift-3-tutorial-fundamentals","status":"publish","type":"post","link":"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/","title":{"rendered":"Swift 3 Tutorial – Fundamentals"},"content":{"rendered":"

Swift 3 Tutorial<\/h1>\n

\"Swift<\/p>\n

In this Swift 3 tutorial, we’ll focus on how beginners may approach going from complete beginner to having a basic grasp on Swift, and we’ll be working with Swift 3. We chose to write this tutorial because newcomers will find many tutorials out there that are out of date, so it’s not appropriate to simply write a “what’s new in Swift 3” post. Instead we’ll approach this from the perspective of someone who has some programming experience in at least one other language, and we’ll teach you what’s unique about Swift, and how to use it effectively. Ready? Let’s go!<\/p>\n

\n

Constants and Variables<\/h3>\n

Any Swift variable is either a constant or not. Not to be confused with the type of the variable, such as Float or Int, constants and variables are just ways to describe terms that hold a value which can change (are mutable), and constants that can not be changed (becuase they are immutable).<\/p>\n

To define a constant, use the let keyword.<\/p>\n

Example:<\/p>\n

let<\/code> name = <\/code>\"Jameson\"<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
If you were to try and change the value of name, you would be unable to do so, and the Swift compiler would produce an error.<\/p>\n
let<\/code> name = <\/code>\"Jameson\"<\/code><\/div>
name = <\/code>\"Bob\"<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
error: cannot assign to value: <\/code>'name'<\/code> is<\/code> a <\/code>'let'<\/code> constant<\/code><\/div>
name = <\/code>\"Bob\"<\/code><\/div>
~~~~ ^<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
On the other hand, by using the var keyword, we define a variable that can change:<\/p>\n
var<\/code> name = <\/code>\"Jameson\"<\/code><\/div>
name = <\/code>\"Bob\"<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
This code does not produce an error.<\/p>\n
In general, you should always default to using the let<\/code> keyword, unless you know you need a var<\/code> keyword. This leads to code that is ultimately safer. If you define a constant, and later attempt to modify it, you will get an error and at that time can determine if you should switch to use the var<\/code> keyword, or if the error is giving you a hint that maybe you should rethink the current logic flow. In general, immutability is preferred over mutability; it simply leads to less programmers errors and makes it easier to reason about your code.<\/p>\n
\n
Basic Types<\/h3>\n
In Swift, a type is indicated by declaring a variable, then putting a colon, folowed by the type name. For example to declare an integer, which is of Swift type Int<\/code>, you could use the following:<\/p>\n
let<\/code> age: <\/code>Int<\/code> = 5<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Or similarly, if you want to declare a string:<\/p>\n
let<\/code> name: <\/code>String<\/code> = <\/code>\"Jameson\"<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Swift supports type inference, so you can usually omit the type information, and let the compiler determine what the type should be based on it’s initial value.<\/p>\n
let<\/code> age = 5<\/code><\/div>
let<\/code> name = <\/code>\"Jameson\"<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
The types for age<\/code> and name<\/code> are still Int<\/code> and String<\/code> respectively, but we can skip the type annotation, because it is obvious that 5<\/code> is an Int<\/code>, and \"Jameson\"<\/code> is a String<\/code>.<\/p>\n
Remember, the let<\/code> keyword simply makes these values constant. If we expected the value of age to change, but not name, we might write these declarations like so:<\/p>\n
var<\/code> age = 5<\/code><\/div>
let<\/code> name = <\/code>\"Jameson\"<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Now if we want to update the age<\/code> value, it’s possible to do:<\/p>\n
var<\/code> age = 5<\/code><\/div>
let<\/code> name = <\/code>\"Jameson\"<\/code><\/div>
age = 25<\/code><\/div>
print<\/code>(age)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
25<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
\n
Working with Strings<\/h3>\n
It’s frequently useful to print a command to the console or otherwise evaluate a String<\/code> containing other variables. For example, I might want to form a sentence with my variables age<\/code> and name<\/code> and print it to the console. I can do this using the +<\/code> operator between each String<\/code>.<\/p>\n
let<\/code> age = <\/code>\"15\"<\/code><\/div>
let<\/code> name = <\/code>\"Robb\"<\/code><\/div>
 <\/div>
let<\/code> sentence = name + <\/code>\" is \"<\/code> + age<\/code><\/div>
print<\/code>(sentence)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Robb<\/code> is<\/code> 15<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
A shortcut for this is to write your String<\/code> as you normally would without the +<\/code> operator seperating each string, and put each variable inside of a set of parentheses, preceeded by a backslash \\<\/code>.<\/p>\n
let<\/code> sentence = <\/code>\"\\(name) is \\(age)\"<\/code><\/div>
print<\/code>(sentence)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Robb<\/code> is<\/code> 15<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
As you can see this has the same effect, but is much easier to read and compose sentences.<\/p>\n
One thing you may have noticed is that age<\/code> is now of type String<\/code> because it was assigned the value \"15\"<\/code> instead of just 15<\/code> without the quotes. This is because concatenating a String<\/code> and an Int<\/code> will not automatically cast the Int<\/code> to String<\/code>, which is a neccessary step before concatenating is possible.<\/p>\n
Or in other words, this code will produce an error:<\/p>\n
let<\/code> age = 15<\/code><\/div>
let<\/code> name = <\/code>\"Robb\"<\/code><\/div>
 <\/div>
let<\/code> sentence = name + <\/code>\" is \"<\/code> + age<\/code><\/div>
print<\/code>(sentence)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Error<\/code>: <\/code>Binary<\/code> operator<\/code> '+'<\/code> cannot be applied to operands of type <\/code>'String'<\/code> and <\/code>'Int'<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
So what we have to do is get age<\/code> converted to a String<\/code> before using it here. Thing is done by casting<\/code> the variable. Simply call the String constructor and pass in the Int<\/code> value:<\/p>\n
let<\/code> age = 15<\/code><\/div>
let<\/code> name = <\/code>\"Robb\"<\/code><\/div>
 <\/div>
let<\/code> stringAge = <\/code>String<\/code>(age)<\/code><\/div>
 <\/div>
let<\/code> sentence = name + <\/code>\" is \"<\/code> + stringAge<\/code><\/div>
print<\/code>(sentence)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Robb<\/code> is<\/code> 15<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
We created a new variable called stringAge<\/code> here, but we also could have performed the cast in-place, because the string interpolation will evaluate each expression separately, and the same goes for the contents of the parenthesis when interpolating strings that way:<\/p>\n
let<\/code> age = 15<\/code><\/div>
let<\/code> name = <\/code>\"Robb\"<\/code><\/div>
 <\/div>
let<\/code> sentence = name + <\/code>\" is \"<\/code> + <\/code>String<\/code>(age)<\/code><\/div>
print<\/code>(sentence)<\/code><\/div>
print<\/code>(<\/code>\"\\(name) enjoys being \\(String(age))\"<\/code>)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Robb<\/code> is<\/code> 15<\/code><\/div>
Robb<\/code> enjoys being<\/code><\/div>
15<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
\n
Optionals<\/h3>\n
In Swift, there is also the concept of the optional<\/em>. An optional is just a variable that can be nil, null, or otherwise not set to any value. In general, you can think of any variable in most other programming languages as being an optional. The “optionality” of a variable is declared by appending a question mark (?) on to the end of the type name in a type annotation. So continuing the example above, where we know age and name will always be set, we might want to add another variable that could be nil<\/code>, because it is possible that it just isn’t present. Let’s use favoriteColor<\/code> as an example. Many people have a favorite color, but it’s possible someone doesn’t, or we just don’t have the data. We would declare this variable as an optional, and not assign it to any value.<\/p>\n
var<\/code> favoriteColor: <\/code>String<\/code>?<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Implicit in the declaration of an optional with no value set, is the assignment to nil. We can verify this by examining the value of favoriteColor after declaring it as an optional by printing it to the console using the print()<\/code> function.<\/p>\n
var<\/code> favoriteColor: <\/code>String<\/code>?<\/code><\/div>
print<\/code>(favoriteColor)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
nil<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
We can later assign something to favoriteColor<\/code> and see that it is no longer nil<\/code>.<\/p>\n
var<\/code> favoriteColor: <\/code>String<\/code>?<\/code><\/div>
favoriteColor = <\/code>\"Blue\"<\/code><\/div>
print<\/code>(favoriteColor)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Optional<\/code>(<\/code>\"Blue\"<\/code>)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Note that instead of just getting the string \"Blue\"<\/code>, we get Optional(\"Blue\")<\/code>. This is because the value is still “wrapped” inside of the optional.<\/p>\n
You can think of optionals like a birthday gift. The box the gift comes in, wrapped up in some paper with pretty balloons on it, could actually be empty. A rather cruel gift to give someone on their birthday, but it’s possible to do. It could also have something inside of it. But either way, if we pick it up and look at it, what we have is not the thing inside of of it in our hands, but it’s just the wrapped box itself.<\/p>\n
If we want to get at the thing inside, we need to unwrap the gift first. This is the same way optionals work. When we pass around optional variables and interact with them, we’re really working with a container that may or may not have anything inside of it. Similar to our gift, the optional must be unwrapped<\/strong> before it can be used.<\/p>\n
Declaring our optional with no value is valid Swift and will compile just fine. But, if we tried to declare this variable without the optional syntax, it would present an error.<\/p>\n
There are also variables in Swift that are not optional. They always<\/em> have a value. If you tried to assign nil to a non-optional variable, you will get a compiler error:<\/p>\n
var<\/code> favoriteColor = <\/code>\"Blue\"<\/code><\/div>
favoriteColor = <\/code>nil<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
error: <\/code>nil<\/code> cannot be assigned to type <\/code>'String'<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Similarly, non-optional values can not be assigned to nil during their declaration:<\/p>\n
var<\/code> favoriteColor: <\/code>String<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
error: variables must have an initial value<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
\n
Unwrapping Optionals<\/h3>\n
So we know what optionals are, and that they allow for a variable to become nil, and we know that optionals are containers rather than values themeselves. So, in our programs when we want to access the contents of an optional, how do we do it? There are several ways so let’s go over them now.<\/p>\n
First, and most commonly, you will unwrap optionals using optional binding<\/em>. In optional binding, you will assign a new variable to the value of an optional within an if statement. If the optional contains a value, this variable will be set, and the code block following this statement will be executed.<\/p>\n
Let’s look at an example. Here we will declare two optionals, one called favoriteAnimal<\/code> which is set to Fox<\/code>, and one set to favoriteSong<\/code>, which we will not set (it will remain nil<\/code>)<\/p>\n
var<\/code> favoriteAnimal: <\/code>String<\/code>?<\/code><\/div>
var<\/code> favoriteSong: <\/code>String<\/code>?<\/code><\/div>
 <\/div>
favoriteAnimal = <\/code>\"Fox\"<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Let’s employ optional binding to discover if each variable is set, and if so we’ll print a sentence containing the value to the console. First we’ll do it with favoriteAnimal<\/code>.<\/p>\n
if<\/code> let<\/code> unwrappedFavoriteAnimal = favoriteAnimal {<\/code><\/div>
    <\/code>print<\/code>(<\/code>\"Favorite animal is: \"<\/code> + unwrappedFavoriteAnimal)<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Favorite<\/code> animal <\/code>is<\/code>: <\/code>Fox<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
In the event that the value is not set, we simply will trigger whatever is in the else<\/code> block, or nothing at all if an else<\/code> block isn’t specified.<\/p>\n
if<\/code> let<\/code> unwrappedFavoriteSong = favoriteSong {<\/code><\/div>
    <\/code>print<\/code>(<\/code>\"Favorite song is: \"<\/code> + unwrappedFavoriteSong)<\/code><\/div>
}<\/code><\/div>
else<\/code> {<\/code><\/div>
    <\/code>print<\/code>(<\/code>\"I don't know what your favorite song is!\"<\/code>)<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
I don't know what your favorite song <\/code>is<\/code>!<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
If we need to unwrap multiple optionals, and we require all of them to proceed with a bit of logic, we need to check each one:<\/p>\n
var<\/code> favoriteAnimal: <\/code>String<\/code>?<\/code><\/div>
var<\/code> favoriteSong: <\/code>String<\/code>?<\/code><\/div>
 <\/div>
favoriteAnimal = <\/code>\"Fox\"<\/code><\/div>
favoriteSong = <\/code>\"Shake it Off\"<\/code><\/div>
 <\/div>
if<\/code> let<\/code> unwrappedFavoriteSong = favoriteSong {<\/code><\/div>
    <\/code>if<\/code> let<\/code> unwrappedFavoriteAnimal = favoriteAnimal {<\/code><\/div>
        <\/code>print<\/code>(unwrappedFavoriteSong + <\/code>\" \"<\/code> + unwrappedFavoriteAnimal)<\/code><\/div>
    <\/code>}<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
This gets kind of messy kind of fast, so Swift offers a shortcut to unwrap multiple variables at once:<\/p>\n
var<\/code> favoriteAnimal: <\/code>String<\/code>?<\/code><\/div>
var<\/code> favoriteSong: <\/code>String<\/code>?<\/code><\/div>
 <\/div>
favoriteAnimal = <\/code>\"Fox\"<\/code><\/div>
favoriteSong = <\/code>\"Shake it Off\"<\/code><\/div>
 <\/div>
if<\/code> let<\/code> unwrappedFavoriteSong = favoriteSong,<\/code><\/div>
    <\/code>let<\/code> unwrappedFavoriteAnimal = favoriteAnimal {<\/code><\/div>
    <\/code>print<\/code>(unwrappedFavoriteSong + <\/code>\" \"<\/code> + unwrappedFavoriteAnimal)<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
\n
Collections<\/h3>\n
Swift has multiple collection types, the most common of which being arrays, sets, and dictionaries.<\/p>\n
Array<\/strong><\/p>\n
Let’s take a look at an example of an Array<\/code><\/p>\n
let<\/code> starks: [<\/code>String<\/code>] = [<\/code>\"Eddard\"<\/code>, <\/code>\"Catelyn\"<\/code>, <\/code>\"Robb\"<\/code>, <\/code>\"Sansa\"<\/code>]<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Here we have a basic Array<\/code>, which is of type [String]<\/code>. The square brackets indicate that this is an array of String<\/code> objects, rather than just being a single String<\/code>. As usual, Swift can infer this type data too, just by examining the initial assignment:<\/p>\n
let<\/code> starks = [<\/code>\"Robb\"<\/code>, <\/code>\"Sansa\"<\/code>, <\/code>\"Arya\"<\/code>, <\/code>\"Jon\"<\/code>]<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
We can access elements of this array in a variety of ways, such as using an Int<\/code> index, calling the various collections methods.<\/p>\n
let<\/code> starks = [<\/code>\"Robb\"<\/code>, <\/code>\"Sansa\"<\/code>, <\/code>\"Arya\"<\/code>, <\/code>\"Jon\"<\/code>]<\/code><\/div>
 <\/div>
print<\/code>( starks[0] )<\/code><\/div>
print<\/code>( starks[2] )<\/code><\/div>
print<\/code>( starks.first! )<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Robb<\/code><\/div>
Arya<\/code><\/div>
Robb<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
You’ll note that arrays are zero-indexed, so the first element in the array \"Robb\"<\/code> is accessed using starks[0]<\/code><\/p>\n
Additionally, you may notice that while the first<\/code> method returns an optional (and therefore is being force-unwrapped with the !<\/code> symbol), the indexed accessors does not return an optional. If you try to access an index in an array that is not present, your program will fail at runtime! So always check the length of arrays when accessing by index:<\/p>\n
if<\/code> starks.count >= 4 {<\/code><\/div>
    <\/code>print<\/code>( starks[3] )<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
There are ways to make this type of checking automated, but it is not done by default for performance reasons.<\/p>\n
Hashable Types \/ Dictionary<\/strong><\/p>\n
Dictionaries are able to store values based on a key, typically the key is of type String<\/code>, but it could actually be many different Swift types. In this example we create a basic Dictionary<\/code> with String<\/code> keys and Int<\/code> values for the age of each person:<\/p>\n
let<\/code> ages = [<\/code>\"Robb\"<\/code>: 15, <\/code>\"Sansa\"<\/code>: 12, <\/code>\"Arya\"<\/code>: 10, <\/code>\"Jon\"<\/code>: 15]<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
We can access these values by their String<\/code> keys:<\/p>\n
print<\/code>( ages[<\/code>\"Arya\"<\/code>]! )<\/code><\/div>
print<\/code>( ages[<\/code>\"Jon\"<\/code>]! )<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
10<\/code><\/div>
15<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Note that we’re unwrapping these because they are optional values, and could potentailly be nil. It is generally safer to use optional binding to unwrap the value from a Dictionary<\/code>, especially if you have reason to believe the value could often be nil<\/code>.<\/p>\n
if<\/code> let<\/code> aryasAge = ages[<\/code>\"Arya\"<\/code>] {<\/code><\/div>
    <\/code>print<\/code>(<\/code>\"Arya is \\(aryasAge) years old\"<\/code>)<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Arya<\/code> is<\/code> 10 years old<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
We can also store arrays inside of dictionaries, or dictionaries inside of arrays, or a mix of both.<\/p>\n
let<\/code> families = [<\/code><\/div>
    <\/code>\"Stark\"<\/code>: [<\/code>\"Robb\"<\/code>: 15, <\/code>\"Sansa\"<\/code>: 12, <\/code>\"Arya\"<\/code>: 10, <\/code>\"Jon\"<\/code>: 15],<\/code><\/div>
    <\/code>\"Baratheon\"<\/code>: [<\/code>\"Joffrey\"<\/code>: 13, <\/code>\"Tommen\"<\/code>: 8]<\/code><\/div>
]<\/code><\/div>
let<\/code> tommensAge = families[<\/code>\"Baratheon\"<\/code>]![<\/code>\"Tommen\"<\/code>]!<\/code><\/div>
print<\/code>(<\/code>\"Tommen is \\(tommensAge) years old\"<\/code>)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Tommen<\/code> is<\/code> 8 years old<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
The type of houses<\/code> here would be [String: [String: Int]]<\/code>
\nOr in other words it is a dictionary with a String<\/code> key, and it’s values are [String: Int]<\/code>, another dictionary with String<\/code> keys and Int<\/code> values.<\/p>\n
Set<\/strong><\/p>\n
A Swift 3 Set<\/code> is similar to an Array<\/code>, except the values in a Set<\/code> are unique<\/em> and unordered<\/em>.<\/p>\n
Initializing a Set<\/code> looks almost exactly like intitializing an Array<\/code>, the only different is the type:<\/p>\n
let<\/code> colors: <\/code>Set<\/code><<\/code>String<\/code>> = [<\/code>\"Blue\"<\/code>, <\/code>\"Red\"<\/code>, <\/code>\"Orange\"<\/code>, <\/code>\"Blue\"<\/code>]<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
This code creates a new set of type String<\/code>. The greater than \/ less than symbols <<\/code> and ><\/code> are used to indicate Swift generic types, including the types of a Set<\/code> as shown here.<\/p>\n
You’ll notice we included \"Blue\"<\/code> twice in our list, but if we print out the contents of colors<\/code>, we only see it once:<\/p>\n
let<\/code> colors: <\/code>Set<\/code><<\/code>String<\/code>> = [<\/code>\"Blue\"<\/code>, <\/code>\"Red\"<\/code>, <\/code>\"Orange\"<\/code>, <\/code>\"Blue\"<\/code>]<\/code><\/div>
print<\/code>(colors)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
[<\/code>\"Orange\"<\/code>, <\/code>\"Red\"<\/code>, <\/code>\"Blue\"<\/code>]<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
You may also notice that the ordering is inconsistent. Sets do not maintain any particular order for their contents.<\/p>\n
We can not access members of a Set<\/code> using indexes as we can with arrays, but instead we use the methods built-in to the Set<\/code> type to add and remove objects. We can also call the contains<\/code> method to check if the Set<\/code> includes something.<\/p>\n
var<\/code> colors: <\/code>Set<\/code><<\/code>String<\/code>> = [<\/code>\"Blue\"<\/code>, <\/code>\"Red\"<\/code>, <\/code>\"Orange\"<\/code>, <\/code>\"Blue\"<\/code>]<\/code><\/div>
colors.insert(<\/code>\"Black\"<\/code>)<\/code><\/div>
colors.insert(<\/code>\"Black\"<\/code>)<\/code><\/div>
colors.remove(<\/code>\"Red\"<\/code>)<\/code><\/div>
print<\/code>(colors)<\/code><\/div>
print<\/code>(colors.contains(<\/code>\"Black\"<\/code>))<\/code><\/div>
print<\/code>(colors.contains(<\/code>\"Red\"<\/code>))<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
[<\/code>\"Black\"<\/code>, <\/code>\"Orange\"<\/code>, <\/code>\"Blue\"<\/code>]<\/code><\/div>
true<\/code><\/div>
false<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Constructing sets of objects is a common way to catalogue what is included or excluded in a list of things, as long as there is no need to order or have duplicates of the objects.<\/p>\n
There are many methods I have not mentioned, and I would encourage you to read through Apple’s documentation on each of these three classes to further familiarize yourself with them.<\/p>\n
Tuples<\/strong><\/p>\n
Tuples are not technicaly a collection, but instead simply multiple variables that can be passed around with a single identifier.<\/p>\n
let<\/code> fullName = (<\/code>\"Jameson\"<\/code>, <\/code>\"Quave\"<\/code>)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
The type of the tuple<\/code> here is (String, String)<\/code>, and we can manually access each numbered tuple element using dot-syntax, followed by the index:<\/p>\n
let<\/code> fullName = (<\/code>\"Jameson\"<\/code>, <\/code>\"Quave\"<\/code>)<\/code><\/div>
print<\/code>(fullName.1)<\/code><\/div>
print<\/code>(fullName.0)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Quave<\/code><\/div>
Jameson<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Tuples can also be deconstructed in to new variable names:<\/p>\n
let<\/code> (first, last) = (<\/code>\"Jameson\"<\/code>, <\/code>\"Quave\"<\/code>)<\/code><\/div>
print<\/code>(first)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Jameson<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Since we’re not using the last name here, we could just ignore that value by using an underscore _<\/code> and still deconstruct the first name:<\/p>\n
let<\/code> (first, _) = (<\/code>\"Jameson\"<\/code>, <\/code>\"Quave\"<\/code>)<\/code><\/div>
print<\/code>(first)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Jameson<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Tuples are useful when you have a method that you want to return multiple values.<\/p>\n
Control Flow<\/h3>\n
Control flow in Swift looks pretty similar to other languages. At the most basic level we have the if<\/code> and else<\/code> statements.<\/p>\n
if<\/code> 10 > 5 {<\/code><\/div>
  <\/code>print<\/code>(<\/code>\"10 is greater than 5.\"<\/code>)<\/code><\/div>
}<\/code><\/div>
else<\/code> {<\/code><\/div>
    <\/code>print<\/code>(<\/code>\"10 is not greater than five.\"<\/code>)<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
10 <\/code>is<\/code> greater than 5<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
You can alternatively put your conditions for an if statement in parenthesis:<\/p>\n
if<\/code> (10 > 5) {<\/code><\/div>
...<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Swift also support the switch statement, and checks at compile for whether or not you have exhaustively covered all possibilities. If you do not (or can not) specifically handle all possibiities, then you can use the default:<\/code> case to handle everything not explicitly handled.<\/p>\n
let<\/code> name = <\/code>\"Jameson\"<\/code><\/div>
switch<\/code>(name) {<\/code><\/div>
case<\/code> \"Joe\"<\/code>:<\/code><\/div>
  <\/code>print<\/code>(<\/code>\"Name is Joe\"<\/code>)<\/code><\/div>
case<\/code> \"Jameson\"<\/code>:<\/code><\/div>
  <\/code>print<\/code>(<\/code>\"This is Jameson\"<\/code>)<\/code><\/div>
default<\/code>:<\/code><\/div>
  <\/code>print<\/code>(<\/code>\"I don't know of this person!\"<\/code>)<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
This<\/code> is<\/code> Jameson<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Here because the value of name<\/code> is \"This is Jameson\"<\/code>, we match the 2nd case and execute the line<\/p>\n
...<\/code><\/div>
  <\/code>print<\/code>(<\/code>\"This is Jameson\"<\/code>)<\/code><\/div>
...<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
If however we set the name to be something not present in our list of cases, such as \"Jason\"<\/code>, the switch would fall back to the default<\/code> case.<\/p>\n
let<\/code> name = <\/code>\"Jason\"<\/code><\/div>
switch<\/code>(name) {<\/code><\/div>
case<\/code> \"Joe\"<\/code>:<\/code><\/div>
  <\/code>print<\/code>(<\/code>\"Name is Joe\"<\/code>)<\/code><\/div>
case<\/code> \"Jameson\"<\/code>:<\/code><\/div>
  <\/code>print<\/code>(<\/code>\"This is Jameson\"<\/code>)<\/code><\/div>
default<\/code>:<\/code><\/div>
  <\/code>print<\/code>(<\/code>\"I don't know of this person!\"<\/code>)<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
I don't know of this person!<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Loops and Collections<\/strong><\/p>\n
Swift 3 does not support the classical C-style for loops you may be used to, and instead opts for enumeration and for-each style loops for the for element in array<\/code> syntax.<\/p>\n
For example if we have an array names<\/code>, and we want to print each one seperately, we can do so with a for loop:<\/p>\n
let<\/code> names = [<\/code>\"Robb\"<\/code>, <\/code>\"Sansa\"<\/code>, <\/code>\"Arya\"<\/code>, <\/code>\"Jon\"<\/code>]<\/code><\/div>
 <\/div>
for<\/code> name <\/code>in<\/code> names {<\/code><\/div>
    <\/code>print<\/code>(<\/code>\"Name: \\(name)\"<\/code>)<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Name<\/code>: <\/code>Robb<\/code><\/div>
Name<\/code>: <\/code>Sansa<\/code><\/div>
Name<\/code>: <\/code>Arya<\/code><\/div>
Name<\/code>: <\/code>Jon<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
This is great if you happen to want to loop over an array, but without C-style arrays, how would we loop over a series of numbers? The answer comes in the form of Swift’s Range<\/code> and Stride<\/code>. Let’s say we wanted to count to 10, by threes, we could do that by using a Range<\/code> from 1 to 10 using the syntax 1...10<\/code>. Then we could only print each number that is evenly divisible by three by using the modulo %<\/code> operator and checking for a remainder of 0.<\/p>\n
for<\/code> i <\/code>in<\/code> 1...10 {<\/code><\/div>
    <\/code>if<\/code> i % 3 == 0 {<\/code><\/div>
        <\/code>print<\/code>(i)<\/code><\/div>
    <\/code>}<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
3<\/code><\/div>
6<\/code><\/div>
9<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
There is another option however, to only iterate every third item (or any arbitrary delta), known as a stride<\/code>. A stride<\/code> can be created using a variety of methods, but the most common is stride(from: , to:, by:)<\/code> where the from<\/code> value is where the stride starts, to<\/code> is where it ends, and by<\/code> is how much each value changes to approach the to<\/code>. If that sounds a little confusing just look at this code sample<\/p>\n
let<\/code> byThrees = stride(from: 3, to: 10, by: 3)<\/code><\/div>
for<\/code> n <\/code>in<\/code> byThrees {<\/code><\/div>
    <\/code>print<\/code>(n)<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
3<\/code><\/div>
6<\/code><\/div>
9<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
It’s almost readable in english, you might say you are “counting” from 3 to 10 by 3. Here we create a stride<\/code> and store it in a variable named byThrees<\/code>, but we could use it directly in the loop as well:<\/p>\n
for<\/code> n <\/code>in<\/code> stride(from: 3, to: 10, by: 3) {<\/code><\/div>
    <\/code>print<\/code>(n)<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
3<\/code><\/div>
6<\/code><\/div>
9<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Collections also all have an indices<\/code> property that can be used to loops. This returns an array of the indices a collection has, useful for iterating or filtering some but not all of a collection. For example, back in our name collection we may want only the first three names, which we can retrieve like so:<\/p>\n
let<\/code> names = [<\/code>\"Robb\"<\/code>, <\/code>\"Sansa\"<\/code>, <\/code>\"Arya\"<\/code>, <\/code>\"Jon\"<\/code>]<\/code><\/div>
for<\/code> nameIndex <\/code>in<\/code> names.indices {<\/code><\/div>
    <\/code>if<\/code>(nameIndex < 3) {<\/code><\/div>
        <\/code>print<\/code>(names[nameIndex])<\/code><\/div>
    <\/code>}<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
Robb<\/code>, <\/code>Sansa<\/code>, <\/code>Arya<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
There is also the enumerate<\/code> method on collections, that allow you to get both the index and value from an array as you loop over it:<\/p>\n
let<\/code> names = [<\/code>\"Robb\"<\/code>, <\/code>\"Sansa\"<\/code>, <\/code>\"Arya\"<\/code>, <\/code>\"Jon\"<\/code>]<\/code><\/div>
for<\/code> (index, name) <\/code>in<\/code> names.enumerated() {<\/code><\/div>
    <\/code>print<\/code>(<\/code>\"\\(index): \\(name)\"<\/code>)<\/code><\/div>
}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
0: <\/code>Robb<\/code><\/div>
1: <\/code>Sansa<\/code><\/div>
2: <\/code>Arya<\/code><\/div>
3: <\/code>Jon<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\n
There are still more ways to enumerate loop over objects in Swift 3, but these are the most commonly used.<\/p>\n
You may notice in our for loop we are assigning to two variables at once, both index<\/code> and name<\/code>. These are seperated by commas and surrounded by parenthesis in orer to delineate there are two named variable we expect returned from the enumerated()<\/code> method. These are techincally deconstructed tuples<\/code>.<\/p>\n
This concluded the fundamentals portion of the Swift 3 tutorial. Next, I’ll show you how to use what you’ve learned here in real-world scenarios. Keep up with these posts by subscribing below. You’ll be emailed when I make new posts, and post video tutorials and other neat stuff, never spam \ud83d\ude42<\/p>\n","protected":false},"excerpt":{"rendered":"
Swift 3 Tutorial In this Swift 3 tutorial, we’ll focus on how beginners may approach going from complete beginner to having a basic grasp on Swift, and we’ll be working with Swift 3. We chose to write this tutorial because newcomers will find many tutorials out there that are out of date, so it’s not…<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_links_to":"","_links_to_target":""},"categories":[10,89,91],"tags":[34,33,92,36],"yoast_head":"\nSwift 3 Tutorial - Fundamentals - Jameson Quave<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Swift 3 Tutorial - Fundamentals - Jameson Quave\" \/>\n<meta property=\"og:description\" content=\"Swift 3 Tutorial In this Swift 3 tutorial, we’ll focus on how beginners may approach going from complete beginner to having a basic grasp on Swift, and we’ll be working with Swift 3. We chose to write this tutorial because newcomers will find many tutorials out there that are out of date, so it’s not...\" \/>\n<meta property=\"og:url\" content=\"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/\" \/>\n<meta property=\"og:site_name\" content=\"Jameson Quave\" \/>\n<meta property=\"article:published_time\" content=\"2016-11-22T02:58:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2016-12-05T02:34:14+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/i2.wp.com\/tctechcrunch2011.files.wordpress.com\/2014\/06\/img_0256.jpg?w=584&ssl=1\" \/>\n<meta name=\"author\" content=\"Jameson Quave\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Jameson Quave\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"17 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/\",\"url\":\"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/\",\"name\":\"Swift 3 Tutorial - Fundamentals - Jameson Quave\",\"isPartOf\":{\"@id\":\"https:\/\/jamesonquave.com\/blog\/#website\"},\"datePublished\":\"2016-11-22T02:58:00+00:00\",\"dateModified\":\"2016-12-05T02:34:14+00:00\",\"author\":{\"@id\":\"https:\/\/jamesonquave.com\/blog\/#\/schema\/person\/db6184f355c7f4e3b876d0f228c2fcfc\"},\"breadcrumb\":{\"@id\":\"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/jamesonquave.com\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Swift 3 Tutorial – Fundamentals\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/jamesonquave.com\/blog\/#website\",\"url\":\"https:\/\/jamesonquave.com\/blog\/\",\"name\":\"Jameson Quave\",\"description\":\"Using computer technology to educate, and improve lives.\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/jamesonquave.com\/blog\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/jamesonquave.com\/blog\/#\/schema\/person\/db6184f355c7f4e3b876d0f228c2fcfc\",\"name\":\"Jameson Quave\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/jamesonquave.com\/blog\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/d9786c83345117d560bbeab0e1f26814?s=96&d=retro&r=pg\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/d9786c83345117d560bbeab0e1f26814?s=96&d=retro&r=pg\",\"caption\":\"Jameson Quave\"},\"sameAs\":[\"http:\/\/jamesonquave.com\"],\"url\":\"https:\/\/jamesonquave.com\/blog\/author\/jquave\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Swift 3 Tutorial - Fundamentals - Jameson Quave","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/","og_locale":"en_US","og_type":"article","og_title":"Swift 3 Tutorial - Fundamentals - Jameson Quave","og_description":"Swift 3 Tutorial In this Swift 3 tutorial, we’ll focus on how beginners may approach going from complete beginner to having a basic grasp on Swift, and we’ll be working with Swift 3. We chose to write this tutorial because newcomers will find many tutorials out there that are out of date, so it’s not...","og_url":"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/","og_site_name":"Jameson Quave","article_published_time":"2016-11-22T02:58:00+00:00","article_modified_time":"2016-12-05T02:34:14+00:00","og_image":[{"url":"http:\/\/i2.wp.com\/tctechcrunch2011.files.wordpress.com\/2014\/06\/img_0256.jpg?w=584&ssl=1"}],"author":"Jameson Quave","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Jameson Quave","Est. reading time":"17 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/","url":"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/","name":"Swift 3 Tutorial - Fundamentals - Jameson Quave","isPartOf":{"@id":"https:\/\/jamesonquave.com\/blog\/#website"},"datePublished":"2016-11-22T02:58:00+00:00","dateModified":"2016-12-05T02:34:14+00:00","author":{"@id":"https:\/\/jamesonquave.com\/blog\/#\/schema\/person\/db6184f355c7f4e3b876d0f228c2fcfc"},"breadcrumb":{"@id":"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/jamesonquave.com\/blog\/swift-3-tutorial-fundamentals\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/jamesonquave.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Swift 3 Tutorial – Fundamentals"}]},{"@type":"WebSite","@id":"https:\/\/jamesonquave.com\/blog\/#website","url":"https:\/\/jamesonquave.com\/blog\/","name":"Jameson Quave","description":"Using computer technology to educate, and improve lives.","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/jamesonquave.com\/blog\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/jamesonquave.com\/blog\/#\/schema\/person\/db6184f355c7f4e3b876d0f228c2fcfc","name":"Jameson Quave","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/jamesonquave.com\/blog\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/d9786c83345117d560bbeab0e1f26814?s=96&d=retro&r=pg","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/d9786c83345117d560bbeab0e1f26814?s=96&d=retro&r=pg","caption":"Jameson Quave"},"sameAs":["http:\/\/jamesonquave.com"],"url":"https:\/\/jamesonquave.com\/blog\/author\/jquave\/"}]}},"_links":{"self":[{"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/posts\/2138"}],"collection":[{"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/comments?post=2138"}],"version-history":[{"count":6,"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/posts\/2138\/revisions"}],"predecessor-version":[{"id":2203,"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/posts\/2138\/revisions\/2203"}],"wp:attachment":[{"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/media?parent=2138"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/categories?post=2138"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/tags?post=2138"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}