Intro to Swift: Constants and Variables
Tags: ios, swift, codenewbie, challenge
Published: 2019-09-25 21:36:55

---
description: The lesson introduces you to the Swift programming language and mainly covers constants and variables and the print statement.
---
This lesson is a companion to my Twitter ✨Intro to Swift✨ crash course - Check it out! 👌

{% twitter 1176952198334439425 %}

The lesson introduces you to the Swift programming language and mainly covers constants and variables and the print statement.

Objectives for this lesson:
* Learn to use Xcode to create a playground
* Learn to use `print()` to output text to the console
* Learn to use constants (`let`) to store values
* Learn to use variables (`var`) to store and change values
* Learn when to use `var` vs `let`
* Learn to use different types of variables and constants, including `Int`, `Float`, `Bool`, etc.


The lesson concludes with the following Challenge:

 > Create variables and constants for various parts about you, such as your name, your hometown, your favorite color and food, and anything else you think someone would be interested to know about you. Think about which of these should be variables, and which should be constants. Try to come up with at least 8 constants and variables in total.

 >Print each of these using `print()` statements and inserting the variable or constant in the parentheses. 

*Note: This lessons follows along Lambda School's iOS 101 precourse work. For additional information on Lambda School's iOS Development course, [click here](https://lambdaschool.com/courses/ios-development).*   

#Learn to use Xcode to create a playground

Xcode includes a feature called playgrounds. Playgrounds provides a testing ground that renders developer code in real time.

To start a new playground, open Xcode and select "Get started with a playground." Don't have macOS or Xcode? No worries, head on over to [repl.it](https://repl.it)

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/9hnzspp43wl4bb19x90e.png)

#Learn to use `print()` to output text to the console


In its simplest form, a print statement looks like this:

```swift
print("Text you want to output here")
```

In Xcode, the `print()` function prints its output in Xcode’s “console” pane, as seen below.

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/e6z306s81gqxkvm32zp0.png)

##Learn to use constants (`let`) to store values

Constants associate a name (such as `numberOfPizzaSlicesEaten` or `welcomeMessage`) with a value of a particular type (such as the number 4 or the string "Hello"). The value of a constant can’t be changed once it’s set.

Constants must be declared before they’re used. You declare constants with the `let` keyword:

```swift
let numberOfPizzaSlicesEaten = 8
```

This code can be read as: "Declare a new constant called `numberOfPizzaSlicesEaten`, and give it a value of 8." 

A note about naming: You can name constants anything you like, with a few small restrictions. The biggest one to remember is that constant names can’t start with a number (though they can contain a number elsewhere). The names you choose for your constants are important. Writing code that is easy for you (and other humans) to read and understand is a vital part of being a good programmer. So choose names that are concise but very clearly convey the purpose of a constant. You should avoid the temptation to abbreviate names. An example of a poorly written constant:

```swift
let numberOfZaSlicesEaten = 8
```

You may understand that "Za" means "Pizza" - however, it may be difficult for another person reviewing your code to understand the reference. Also, no self-respecting person uses "za." 🍕

#Learn to use variables (`var`) to store and change values

Like a constant, variables associate a name with a value of a particular type.  Unlike a constant, variables can be given new values as the program runs. To create a variable, use a `var` statement.

Here’s an example of how constants and variables can be used to track the number of pizza slices a user has eaten:

```swift
let numberOfPizzaSlicesEaten = 8
var currentPizzaSlice = 2
```
In this example, the maximum number of allowed pizza slices to be eaten is declared as a constant, because the maximum value never changes. The current pizza slice counter is declared as a variable, because this value must be incremented after each slice is eaten.



#Learn when to use `var` vs `let`

Rule of thumb: If you have a value that needs to change, you should use a variable. If you have a value that never changes, use a constant.

You might think that always using variables makes sense, because you can change them if you need to, or leave them the same. In fact, many languages don’t have constants, and only use variables. However, this is not a good idea in practice.

In fact, as you read and write more and more Swift you’ll notice that variables are actually quite rarely used. As a rule of thumb, you should always make your values constants with `let`. If, and only if, you actually need a value that can change, should you change your value to a variable.

> If you have a value that needs to change, you should use a variable. If you have a value that never changes, use a constant.

#Learn to use different types of variables and constants, including Int, Float, Bool, etc.

Normally, [Swift is able to figure out, or infer the type of a value based on context](https://docs.swift.org/swift-book/LanguageGuide/TheBasics.html#ID322). It’s clear that 42 is an integer, or `Int`, not a string. Similarly, “Hello” is obviously not a number, it’s a `String`. This feature is called type inference and is one of the things that makes Swift concise and nice to write. 

You can provide a type annotation when you declare a constant or variable, to be clear about the kind of values the constant or variable can store. Write a type annotation by placing a colon after the constant or variable name, followed by a space, followed by the name of the type to use.

###String
This example provides a type annotation for a variable called `typeOfPizzaEaten`, to indicate that the variable can store String values:

```swift
var typeOfPizzaEaten: String = "margherita"
```

The colon in the declaration means “…of type…,” so the code above can be read as: “Declare a variable called `typeOfPizzaEaten` that is of type `String`, and give it the value `"margherita"`.”

The phrase “of type String” means “can store any String value.” Think of it as meaning “the type of thing” (or “the kind of thing”) that can be stored.

###Number Types

There are actually multiple number types, including `Int`, `UInt`, `Float`, and `Double`. `Int` is short for integer and is a whole number that can be either positive or negative. `UInt` is an unsigned integer, and is a whole number but it can only be positive. In other words, it can’t have a minus sign. You’ll see both types used in Swift, but `Int` is more common, and is the default. `Float` and `Double` are both kinds of floating point numbers. 

Floating point numbers are numbers with a decimal point like 3.14. The difference between `Float` and `Double` is their precision, and the maximum value they can store. `Double` is more precise and can store larger numbers than a `Float`. However, it also takes up twice as much memory space as a `Float`. You’ll see both types used in Swift, but `Double` is more common, and is the default.

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/2mje90cgigxirncg5agi.png)

###Boolean

Another common type is `Bool`, which is short for boolean. Boolean values can only be either true or false. We could create a boolean variable like so:

```swift
let pizzaIsAwesome = true
```

#Challenge

Let's put our knowledge of constants, variables, and type annotations together, and see if we can complete the Challenge:

 > Create variables and constants for various parts about you, such as your name, your hometown, your favorite color and food, and anything else you think someone would be interested to know about you. Think about which of these should be variables, and which should be constants. Try to come up with at least 8 constants and variables in total.

 >Print each of these using `print()` statements and inserting the variable or constant in the parentheses. 

Give it a shot before scrolling down! 😉

```swift
var myAge: UInt = 78 
let myFavoriteColor: String = "Aquamarine Blue"
let myFavoriteFood: String = "Sushi"
let firstName: String = "Arthur"
let lastName: String = "Curry"
let birthYear: Int = 1941
let homeTown: String = "Atlantis"
let university: String = "School of Hard Knocks"
let occupation: String = "Lighthouse Keeper"

print(firstName)
print(lastName)
print(birthYear)
print(myFavoriteFood)
print(myFavoriteColor)
print(homeTown)
print(university)
print(occupation)

```
#Bonus Challenge

Now it's your turn!

> Create a constant called `introduction`. This should be a readable sentence or paragraph that includes all of the constants and variables you made and combines them into a single string.

> Hints: Look up string interpolation in Swift to learn how to turn variables into text. Google is your friend here. 😉

> Note: We will cover [string interpolation](https://docs.swift.org/swift-book/LanguageGuide/StringsAndCharacters.html#ID292) in detail in a later lesson, so don't worry if you don't already know it, or find it confusing at first.


####Like this post?

You can find more by following me on twitter 😄: [@joshuarutkowski](https://twitter.com/joshuarutkowski)

Thanks for reading!