AB Dev Hub

Posted on Dec 12

The Ultimate Guide to iOS Development: Variables, Data Types, and Basic Operations in Swift (Part 3)

#ios #swift #development #codenewbie

Welcome to AB Dev Hub!

In this article, we’re diving into the third part of our Swift programming series: Variables, Data Types, and Basic Operations. Whether you’re just starting your journey in iOS development or brushing up on the fundamentals, this lesson will help you build a solid foundation.

You’ll learn:

How to declare and use variables and constants.
The key data types in Swift and when to use them.
Performing essential operations like arithmetic and string manipulation.
Using the print() function for debugging and formatted output.

Let’s get started and make coding in Swift simple and enjoyable!

1. Variables and Constants in Swift

⚠️ Little tip before we start! Don't take my word for it—try every example you see in this article in your playground and check how it works. Who knows, maybe I'm trying to trick you

⚠️ P.S. Of course, I'm only talking about the examples – you can trust me 100% on everything else. 😅

Declaring Variables with `var`

Think of variables as reusable chalkboards: you can erase and update their values whenever needed. In Swift, you declare a variable using the var keyword. This is perfect for values that need to change as your program runs.

Example:

var healthPoints = 100
print(healthPoints) // Output: 100

// The hero takes damage
healthPoints -= 20
print(healthPoints) // Output: 80

In this example, the variable healthPoints starts at 100, but we adjust it as the hero loses health. It’s mutable, flexible, and great for scenarios where values evolve.

Declaring Constants with `let`

Constants, on the other hand, are the immovable rocks of your code. They are declared with the let keyword and cannot change once set. This makes them ideal for values that should remain consistent.

Example:

let speedOfLight = 299_792_458 // in meters per second
print(speedOfLight) // Output: 299792458

// Trying to change it would cause an error
// speedOfLight = 300_000_000 // Error: Cannot assign to value: 'speedOfLight' is a 'let' constant

Using constants prevents accidental changes to critical values, ensuring your program’s integrity.

Choosing Between `var` and `let`

To decide whether to use a variable or a constant, ask yourself:

Does this value change? Use var.
Does this value stay the same? Use let.

Example of Both:

let dailyWaterGoal = 2000 // milliliters
var waterConsumed = 0

// Drinking water throughout the day
waterConsumed += 500
print("Water consumed: \\(waterConsumed) ml") // Output: Water consumed: 500 ml

// Goal remains unchanged
print("Daily water goal: \\(dailyWaterGoal) ml") // Output: Daily water goal: 2000 ml

Here, dailyWaterGoal is constant because the goal doesn’t change, while waterConsumed is a variable since it updates as you drink water.

Why This Matters

Using let wherever possible leads to:

Better code clarity: It’s clear which values are fixed and which can change.
Fewer bugs: Constants prevent accidental changes.
Improved performance: Swift optimizes constants better than variables.

A good rule of thumb: default to let and use var only when you know a value will change.

2. Exploring Basic Data Types in Swift

When learning a new programming language, one of the first steps is understanding its basic building blocks. In Swift, data types are essential because they define what kind of values a variable or constant can hold. Let’s explore Swift's fundamental data types with simple examples that make it easy to grasp.

1. Character: The Building Block of Text

A Character is a single letter, number, symbol, or even an emoji. It’s like the smallest unit of text.


let firstLetter: Character = "A"
let punctuation: Character = "!"
let smileyFace: Character = "😊"

💡 **Example in action**: Imagine creating a code where each character represents a secret message:

let secretCode: Character = "X"
print("Your secret code is \(secretCode).")

💡In iOS development, you'll rarely use this type, but it's still important to know about it.

2. String: A Line of Characters

When you combine multiple characters, you get a String. Strings are used to represent words, sentences, or even paragraphs.

let greeting = "Hello, world!"
let favoriteFood = "Pizza"

You can combine strings using the + operator or string interpolation:

let name = "Chris"
let surname = "Rock"
let fullName = name + " " + surname
let welcomeMessage = "Hello, \(fullName)! Welcome to Swift programming."

💡 Example in action: Create a personalized thank-you note:

let sender = "Alex"
let receiver = "Taylor"
let message = "Dear \(receiver), thank you for your support! - \(sender)"
print(message)

3. Int: Whole Numbers

An Int (short for integer) is a number without a decimal point. You can use it to count, measure, or compare values.

let age = 25
let temperature = -10
let numberOfBooks = 42

💡 Example in action: Count the number of steps you climbed today:

let stepsUp = 120
let stepsDown = 80
let totalSteps = stepsUp + stepsDown
print("You climbed \(totalSteps) steps today.")

4. Double and Float: Numbers with Decimals

Swift uses Double for high-precision numbers and Float for less precise ones. These types are perfect for measurements and calculations requiring fractions.

let pi: Double = 3.14159
let weight: Float = 68.5

💡 Example in action: Calculate the distance you ran based on your speed and time:

let speed = 10.5 // kilometers per hour
let time = 1.5 // hours
let distance = speed * time
print("You ran \(distance) kilometers.")

💡 Little tip before we continue:

`Double` vs `Float` in Swift: Precision & Usage

Precision:
- Float: ~6–7 decimal digits.
- Double: ~15–16 decimal digits.
Memory:
- Float: 32 bits.
- Double: 64 bits.
Usage:
- Use Double for most cases (default in Swift, higher precision).
- Use Float when memory is critical, and precision isn't a priority (if you want to use it you need to show the compiler that type of your object is Float, by using : Float after the name of your constant or variable)
Example:

let floatValue: Float = 0.123456789 // 0.12345679 (rounded)
let doubleValue = 0.123456789 // 0.123456789 (all digits)

💡 Tip: Both are prone to rounding errors due to floating-point arithmetic.

5. Bool: True or False

A Bool (short for Boolean) represents a binary value: true or false. It’s often used to make decisions in your code.

let isRaining = false
let isWeekend = true

💡 Example in action: Decide if you should stay indoors based on the weather:

let isSunny = true
let isHoliday = true
let shouldGoOutside = isSunny && isHoliday
print("Should you go outside? \(shouldGoOutside)")

What is `&&` in Swift?

⚠️ We'll learn about other operators in more detail in the upcoming articles, but since we've encountered this one for the first time here, let me explain it right away

&& is the logical "AND" operator in Swift.
It checks two conditions and returns true only if both are true.

Usage Example:

let isSunny = true
let isWeekend = true
let canGoHiking = isSunny && isWeekend
print(canGoHiking) // true

If either condition is false, the result is false.

let isRaining = true
let hasUmbrella = false
print(isRaining && hasUmbrella) // false

💡 Tip: && stops checking as soon as the first condition is false (short-circuit evaluation).

6. Type Safety and Type Inference

Swift is a type-safe language, meaning it ensures you only work with the right types. For example, you cannot mix Int and String without converting one to match the other.

let apples = 5
let oranges = "3"
// let totalFruit = apples + oranges // This will cause an error!

Instead, you need to convert the String to an Int You can do this using the type initializer and passing to it the value to which you want to try to bring your object, of course, if it is available:

⚠️⚠️⚠️ Here, we encountered the if let construct. For now, don’t worry about it—we’ll dive into conditionals and how they work in a future article. Stay tuned! 🚀

// 👍👍👍 that will work
if let orangeCount = Int(oranges) {
    let totalFruit = apples + orangeCount
    print("You have \(totalFruit) fruits.")
}

// 👎👎👎 that will not work
let stringOrangeCount = "three"
if let orangeCount = Int(stringOrangeCount) {
    let totalFruit = apples + orangeCount
    print("You have \(totalFruit) fruits.")
}

Swift also uses type inference, which means it can often figure out the type of a variable based on the value you assign:

let score = 100 // Swift knows this is an Int
let piValue = 3.14 // Swift knows this is a Double

Wrapping Up

Character for single letters or symbols.
String for longer text.
Int for whole numbers.
Double and Float for numbers with decimals.
Bool for true or false values.

These types will help you build logic, calculate numbers, and manage information in your Swift programs. Mastering these basics is your first step toward becoming a Swift pro.

3. Understanding Arithmetic Operations, Operators, and String Concatenation in Swift

Swift is a powerful and intuitive programming language that makes math and string manipulation simple and fun. We will look through some arithmetic operators, compound operators like += and -=, and string concatenation in Swift. We’ll also touch on the magical print() function, which is your best friend when writing code.

Arithmetic Operations in Swift

Arithmetic operations in Swift are just like the math you learned in school. Swift supports the following basic operations:

Operator	Description	Example	Result
`+`	Addition	`5 + 3`	`8`
`-`	Subtraction	`10 - 7`	`3`
`*`	Multiplication	`4 * 2`	`8`
`/`	Division	`20 / 5`	`4`
`%`	Modulo (remainder)	`9 % 4`	`1`

Here’s an example of these operators in action:

let apples = 4
let oranges = 6
let totalFruits = apples + oranges
print("I have \(totalFruits) fruits in total.") // Output: I have 10 fruits in total.

Notice how we used + to calculate the total number of fruits.

Compound Assignment Operators

Swift provides shorthand operators to make your code cleaner. These are especially useful for updating variables. The most common ones are:

+= (Addition assignment): Adds a value to a variable.
-= (Subtraction assignment): Subtracts a value from a variable.
*= (Multiplication assignment): Multiplies a variable by a value.
/= (Division assignment): Divides a variable by a value.

Here’s how they work:

var score = 10
score += 5  // Same as: score = score + 5
print("Score after bonus: \(score)") // Output: Score after bonus: 15

score -= 3  // Same as: score = score - 3
print("Score after penalty: \(score)") // Output: Score after penalty: 12

These operators save you from repetitive typing and make your code more concise.

String Concatenation in Swift

String concatenation is the process of joining two or more strings together. In Swift, you can do this using the + operator or string interpolation.

Using the `+` Operator:

let firstName = "John"
let lastName = "Doe"
let fullName = firstName + " " + lastName
print("Full name: \(fullName)") // Output: Full name: John Doe

Using String Interpolation:

String interpolation allows you to insert variables or expressions directly into a string by wrapping them in \().

let age = 25
print("Hello, my name is \(fullName) and I am \(age) years old.")
// Output: Hello, my name is John Doe and I am 25 years old.

The Power of `print()`

The print() function is a simple yet powerful tool for displaying output in Swift. It helps you see what's happening in your code, making debugging easier.

Basic Usage:

print("Hello, world!")
// Output: Hello, world!

Printing Variables:

You can pass variables or expressions directly to print():

let number = 1
print("The answer to life, the universe, and everything is \(number).")
// Output: The answer to life, the universe, and everything is 1.

Multiple Items:

print() can also handle multiple items separated by commas:

print("I have", apples, "apples and", oranges, "oranges.")
// Output: I have 4 apples and 6 oranges.

Practice Makes Perfect

Here’s a quick exercise to try:

Create a program where you keep track of money saved in a piggy bank.
Start with $20.
Use += to add $15 from your birthday gift.
Use -= to subtract $10 spent on snacks.
Print the final balance using print().

⚠️ Before second part of Practice ⚠️

Printing Multiline Strings with `"""`

In Swift, you can create multiline strings using triple quotation marks ("""). This is useful for formatting text neatly and making it easier to read. Multiline strings preserve line breaks and indentation as you write them.

Example:

let hockeyRules = """
Welcome to the hockey game!
Each team starts with 6 players on the field.
Players can be penalized and removed during the game.
"""

print(hockeyRules)
// Output:
// Welcome to the hockey game!
// Each team starts with 6 players on the field.
// Players can be penalized and removed during the game.

You can also insert variables into multiline strings using string interpolation (\(variable)), just like in regular strings.

Hockey Match Task

Now that you know about multiline strings, here’s a fun task about a hockey match:

Scenario Setup:

Two teams, the Red Rockets and the Blue Blizzards, are playing hockey. Each team starts with 6 players on the field.
Game Events:
- By the middle of the game:
  - 2 players from the Red Rockets and 1 player from the Blue Blizzards were penalized and removed.
  - The score is 3 for the Red Rockets and 2 for the Blue Blizzards.
- By the end of the game:
  - 1 more player is penalized from each team.
  - The final score is 4 for the Red Rockets and 5 for the Blue Blizzards.
Your Task:

Write a Swift program to calculate:

- The number of players left on the field for each team at the end of the match.
- The score of both teams at the middle and end of the game.
- Print all the details in a neat, multiline string.

Solution Example

(⛔️Refer to this only after you've tried solving the task on your own.⛔️)

Here’s how you might solve it:

// Initial setup
let initialPlayers = 6
var redPenalties = 0
var bluePenalties = 0
var redScore = 0
var blueScore = 0

// Events by the middle of the game
redPenalties += 2
bluePenalties += 1
redScore += 3
blueScore += 2

// Middle of the game summary
let middleGameSummary = """
Middle of the Game:
  Red Rockets Score: \(redScore)
  Blue Blizzards Score: \(blueScore)
"""

// Events by the end of the game
redPenalties += 1
bluePenalties += 1
redScore += 1
blueScore += 3

// Calculate remaining players
let redPlayersLeft = initialPlayers - redPenalties
let bluePlayersLeft = initialPlayers - bluePenalties

// End of the game summary
let endGameSummary = """
End of the Game:
  Red Rockets Final Score: \(redScore)
  Blue Blizzards Final Score: \(blueScore)
Players Remaining on the Field:
  Red Rockets: \(redPlayersLeft)
  Blue Blizzards: \(bluePlayersLeft)
"""

// Print the complete match summary
print("""
Hockey Match Summary:

\(middleGameSummary)

\(endGameSummary)
""")

Expected Output

Hockey Match Summary:

- Middle of the Game:
  Red Rockets Score: 3
  Blue Blizzards Score: 2

- End of the Game:
  Red Rockets Final Score: 4
  Blue Blizzards Final Score: 5

Players Remaining on the Field:
  Red Rockets: 3
  Blue Blizzards: 4

Feel free to tweak the numbers and penalties to experiment further maybe something with divider or multiplier. This task helps reinforce concepts like basic arithmetic, variable manipulation, and printing formatted output!

By now, you should have a solid understanding of arithmetic operations, compound operators, and string concatenation in Swift. Go ahead and practice these concepts in your code, and remember to use print() to see your results come to life in playground!

Hey there, developers! 👨‍💻

I hope you enjoyed today’s deep dive into Swift. If you found it helpful, I’d love your support to help grow this project further. Here’s how you can make a difference:

🌟 Follow me on these platforms:

Each follow means the world to me—it helps me reach more aspiring developers like you and motivates me to keep creating quality content!

☕ Buy Me a Coffee

If you’d like to go the extra mile, you can support me through Buy me a coffee. Your contribution fuels the creation of new lessons, tutorials, and other awesome resources. I deeply appreciate your generosity—it keeps AB Dev Hub thriving!

What’s Next?

In our next lesson, we’ll continue exploring the Swift programming language. We’ll explore control flow in Swift, including conditional statements, switch cases, loops, and an introduction to optionals.

Thank you for being a part of this community. Let’s keep coding, learning, and building together! 💻✨