Unit 1: Getting Started|Introduction

Building apps, and programming in general, is all about working with data. As a developer, you'll need to understand how to handle and store data using clearly defined types.

In this lesson, you'll learn how constants and variables enable you to name pieces of data so they can be used later in your program. You'll learn to define constants for values that don't change and to define variables for values that do change.

You'll also learn about types, which are like blueprints for working with data. Different types can be used and stored in constants or variables. You'll learn what types are included in Swift and how Swift types can help you write better code.

What You'll Learn

How to represent numbers, strings, and Boolean values using native Swift types
When to use a constant and when to use a variable
How to assign values to constants and variables
How type inference helps you write clean code
How type safety helps you write safe code

Vocabulary

Related Resources

Swift Programming Language Guide: Constants and Variables

Guide

Constants and variables associate a name (like age or name) with a value of a particular type (like the number 29 or the string "John"). You can then use the name to refer to that value many times in your program. Once it's set, the value of a constant is immutable, which means that it cannot be changed. In contrast, the value of a variable is mutable and can be changed at any time.

By defining a constant or variable, you're asking the compiler to allocate storage for the value in memory on the device that will run the program. You're also asking it to associate the constant or variable name with the assigned value so you can access the value later.

Constants

When you want to name a value that won't change during the lifetime of the program, you'll use a constant.

You define constants in Swift using the let keyword.

let name = "John"

The code above creates a new constant called name and assigns the value "John" to the constant. If you want to access that value in later lines of code, you can use name to reference the constant directly. This quick reference is especially helpful when you have one value that you use many times in a program.

let name = "John"
print(name)

This code would print "John" to the console.

Because name is a constant, you can't give it a new value after assigning it. For example, the following code won't run:

let name = "John"
name = "James"

Variables

When you want to name a value that may change during the lifetime of the app, you'll use a variable.

You define variables using the var keyword.

var age = 29
print(age)

The code above would print 29 to the console.

Because age is a variable, you can assign a new value in later lines of code. The following code compiles with no errors.

var age = 29
age = 30
print(age)

This code would print 30 to the console.

You can assign constants and variables from other constants and variables. This functionality is useful when you want to copy a value to one or more other variables.

let defaultScore = 100
var playerOneScore = defaultScore
var playerTwoScore = defaultScore

print(playerOneScore)
print(playerTwoScore)

playerOneScore = 200
print(playerOneScore)

The console would read:

100
100
200

Constant or Variable?

You just learned to use a constant when the value won't change and a variable when the value might change.

But there's a nuance here that's worth learning. Even though certain values might be variable, you can represent them with a constant because they won't change during the lifetime of a single execution of the code.

Imagine you're calculating information about the distance traveled on a trip. The program can be reused to track many trips over time, but it only tracks one trip at a time. How would you represent the following data in your code?

Starting location—This is a GPS coordinate of where you started your trip. Once you begin tracking a trip in your program, the location won't change. You'll represent this value with a constant.
Destination—This GPS coordinate is where you want to arrive. Your app can be used for many destinations, so you may think this would be represented with a variable. But once your program begins tracking a trip, the destination won't change. You'll represent this value with a constant.
Current location—The GPS coordinate of your current location will change whenever you move. So you'll represent this value with a variable.
Distance traveled—How far have you traveled from your starting point? This value changes as you move. You'll represent it with another variable.
Remaining distance—How far must you travel to arrive at your destination? The remaining distance changes as you move. You'll represent this value with a variable.

Constants and variables perform very similar jobs. You may think it would be easier to use variables for everything and ignore constants altogether. Technically your code could work this way. So why should you use constants at all?

First, if you set a value to a constant, the compiler understands that it should never be changed. This means you won't be able to build or run your program if you try to change the constant's value. In this way, the compiler enforces safety.

Second, there are special optimizations that the compiler can make for constant values. When you use constants for values that won't change, the compiler can make low-level assumptions about how to store the value. These adjustments allow your program to execute faster.

Third, it's the idiomatic, or accepted, way to do things in Swift.

As you learn more about building software, you'll come to appreciate best practices for consistently writing clean, readable code. This is especially important when working on a team with other developers. You'll also discover that following best practices will make it easier for you to remember what your code does, especially when you want to make changes later on.

If you want to be a great developer, you'll need to follow shared patterns and conventions. This course will guide you toward the best practices for writing Swift.

Naming Constants and Variables

There are rules for naming constants or variables. The compiler enforces the rules, so you won't be able to build and run your program if you break them.

Names can't contain mathematical symbols.
Names can't contain spaces.
Names can't begin with a number.

Other than these three rules, you can name a constant or variable whatever you like.

let π = 3.14159
let 一百 = 100
let 🎲 = 6
let mañana = "Tomorrow"
let anzahlDerBücher = 15 //numberOfBooks

In addition to the rules, there are some important best practices for naming constants and variables:

Constant and variable names should be clear and descriptive, making it easy to understand the code when you come back to it later. For example, firstName is better than n and restaurantsNearCurrentCity is better than nearby.
To be clear and descriptive, you'll often want to use multiple words in a name. When you put two or more words together, the convention is to use camel case. Lowercase the first letter in the name, and then capitalize the first letter of each new word. You've probably noticed examples of this: defaultScore is the camel case treatment for combining default and score. Camel case is easier to read than all the words compressed together. For example, defaultScore is clearer than defaultscore and restaurauntsNearCurrentCity is clearer than restaurantsnearcurrentcity. Camel case also allows assistive devices to better delineate word boundaries.

Comments

Did you notice that the translation for anzahlDerBücher was written off to the side? As code becomes more complex, it can be useful to leave little notes for yourself, as well as other developers who might read your code. These comments are created by placing two forward slashes in front of the text. When your code is compiled, the comments will be ignored, so write as many as you find helpful.

// Setting pi to a rough estimate
let π = 3.14

If you need multiple lines for your comment, you can also place as much text as you'd like between /* and */ and it will be ignored by the Swift compiler.

/* The digits of pi are infinite,
so instead I chose a close approximation.*/
let π = 3.14

Comments are most frequently used to explain difficult sections of code, provide copyright information at the top of a file, and to provide dating information (when the file was created and/or modified).

Types

Each constant or variable in Swift has a type that describes its kind of value. In the examples you've seen, 29 is an integer that's represented by the Swift type Int. Likewise, "John" is a character string represented by the Swift type String.

Swift includes many predefined types you can use to more easily write clean code. Whether your program needs to include numbers, strings, or Boolean (true or false) values, you can use types to represent a specific kind of information.

Here are a few of the most common types in Swift.

Name	Type	Purpose	Example
Integer	`Int`	Represents whole numbers, or integers	`4`
Double	`Double`	Represents numbers requiring decimal points, or real numbers	`13.45`
Boolean	`Bool`	Represents `true` or `false` values	`true`
String	`String`	Represents text	`"Once upon a time..."`

Swift also supports collection types, which group multiple values into a single constant or variable. One collection type is named an Array, which stores an ordered list of values. Another collection type is named a Dictionary, which has keys that help you look up specific values. You'll learn more about collections in a future lesson.

The Swift standard library includes all the types above, so you can always use them.

In addition, you can define your own types in Swift by creating a type definition. Consider a simple Person type:

struct Person {
  var firstName: String
  var lastName: String

  func sayHello() {
    print("Hello there! My name is \(firstName) \(lastName).")
  }
}

You can think about a type definition as a blueprint. A blueprint designates how to construct a building but isn’t a building itself. However, you can create many buildings from a single blueprint.

A type definition declares the information it stores (properties) and its capabilities or actions (methods). In this case, a Person stores String information in two properties, firstName and lastName, and has one action, the method sayHello(). You’re probably unfamiliar with all the syntax above, but that's OK.

The example above describes how the type Person should look and perform. When you create a type and assign it to a variable or constant, you’re creating a version or instance of the type. Thus, an instance is a value. Consider the following code:

let aPerson = Person(firstName: "Jacob", lastName: "Edwards")
let anotherPerson = Person(firstName: "Candace", lastName: "Salinas")

aPerson.sayHello()
anotherPerson.sayHello()

Hello there! My name is Jacob Edwards.
Hello there! My name is Candace Salinas.

This code creates two instances of the Person type. One instance represents a Person named Jacob Edwards, and the other instance represents a person named Candace Salinas.

You'll learn more about defining types in a future lesson.

Type Safety

Swift is considered a type-safe language. Type-safe languages encourage or require you to be clear about the types of values your code can work with. For example, if part of your code expects an Int, you can't pass it a Double or a String.

When compiling your code, Swift performs type checking on all your constants and variables and flags any mismatched types as errors. If you mismatch types, you can’t run your program.

let playerName = "Julian"
var playerScore = 1000
var gameOver = false

playerScore = playerName
// Will be flagged for mismatched types, will not compile.

Because type safety enforces the type a constant or variable can hold, assigning a String to a variable that only holds an Int doesn't make sense. You’ll learn how Swift figured out the types shortly.

Type safety also applies to variables, constants, and literal values that represent data that may seem compatible. For example, Swift recognizes Int and Double as completely different types, even though they both represent numbers.

var wholeNumber = 30
var numberWithDecimals = 17.5

wholeNumber = numberWithDecimals
// Will be flagged for mismatched types, will not compile.

In the case above, both variables are numeric types, but wholeNumber will be an Int and numberWithDecimals will be a Double. In Swift, you can’t assign a value of one type to a variable of another type.

When working with numbers, you may find that you need to assign a very large value to a variable or constant. This can be difficult to read, since it is hard to see how many zeros there are in 1000000000. Fortunately, Swift allows you to put underscores in your numbers as a way of formatting for easier reading.

var largeUglyNumber = 1000000000
var largePrettyNumber = 1_000_000_000

Type Inference

You may have noticed that you don't have to specify the type of value when you declare a constant or variable. This is called type inference. Swift uses type inference to make assumptions about the type based on the value assigned to the constant or variable.

let cityName = "San Francisco"
// "San Francisco" is obviously a `String`, so the compiler automatically assigns the type of cityName to a `String`.

let pi = 3.1415927
// 3.1415927 is a number with decimal points, so the compiler automatically assigns the type `pi` to a `Double`.

Once you assign a value to a constant or variable, the type is set and can't be changed. This is true even for variables. The value of a variable may change, but not its type.

You might find cases where it’s useful, or even required, to explicitly specify the type of a constant or variable. This is referred to as a type annotation. To specify a type, add a colon (:), a space, and the type name following the constant or variable name.

let cityName: String = "San Francisco"

let pi: Double = 3.1415927

You can use a type annotation with different number types. The Swift compiler will adjust the value to match the type.

let number: Double = 3
print(number)

Console Output

3.0

There are three common cases for using a type annotation:

When you create a constant or variable but haven't yet assigned it a value.

let firstName: String
//...
firstName = "Layne"

When you create a constant or variable that could be inferred as more than one type.

let middleInitial: Character = "J"
// "J" would be inferred as a `String`, but we want a `Character`

var remainingDistance: Double = 30
// `30` would be inferred as an `Int`, but the variable should support decimal numbers for accuracy as the number decreases.

When you want to write your own type definition.

struct Car {
  var make: String
  var model: String
  var year: Int
}

Required Values

Whenever you define a constant or variable, you must either specify a type using a type annotation or assign it a value that the compiler can use to infer the type.

var x
// This would result in an error.

Even when you use a type annotation, your code can't work with a constant or variable if you haven't yet assigned it a value.

var x: Int
print(x)
// This would result in an error.

Once the value is assigned, the constant or variable becomes available.

var x: Int
x = 10
print(x)

Lab

Open and complete the exercises in Lab - Constants and Variables.playground.