Variables, constants, and data types

Section 1.3: Swift: Variables, Constants, and Data Types

Welcome to the world of data in Swift! In this section, we'll dive into the fundamental building blocks of Swift programming: variables, constants, and data types. These concepts are crucial for storing, managing, and manipulating information within your apps.

Variables: The Changeable Containers

Think of variables as labeled boxes where you can store different types of data. The data within a variable can be changed throughout your program's execution.

Declaring Variables:

To create a variable, you use the var keyword followed by the variable name and its type. Here's the basic syntax:

Swift

var variableName: DataType = initialValue

Example:

Swift

var greeting: String = "Hello, world!"

var score: Int = 95

var price: Double = 19.99

Changing Variable Values:

You can easily change the value of a variable by assigning a new value to it.

Swift

greeting = "Welcome to Swift!"

score = 88

price = 24.95

Constants: The Unchanging Guardians

Constants are similar to variables, but their values cannot be changed once they are set. Use constants to store values that remain fixed throughout your program's execution.

Declaring Constants:

To create a constant, you use the let keyword followed by the constant name and its type.

Swift

let constantName: DataType = initialValue

Example:

Swift

let pi: Double = 3.14159

let companyName: String = "Apple Inc."

Data Types: Classifying Information

Every value in Swift has a specific data type, which determines the kind of data it can hold and the operations you can perform on it. Swift is a strongly typed language, meaning you need to declare the data type of each variable and constant.

Common Data Types:

Int: Represents whole numbers (e.g., 10, -5, 0).

Double: Represents floating-point numbers (e.g., 3.14, -0.5).

String: Represents a sequence of characters (e.g., "Hello, world!").

Bool: Represents a Boolean value (true or false).

Type Inference: Swift's Smart Deduction

Swift is smart enough to infer the data type of a variable or constant based on the initial value you assign to it. This means you don't always have to explicitly specify the type.

Example:

Swift

var age = 25  // Swift infers 'age' as Int

let message = "Hello!" // Swift infers 'message' as String

Type Annotation: Explicitly Stating the Type

While type inference is convenient, sometimes you might want to explicitly declare the data type for clarity or to catch potential errors.

Example:

Swift

var studentName: String = "John Doe"

let maximumAttempts: Int = 3

Key Takeaways:

Variables (var) store data that can change.

Constants (let) store data that remains fixed.

Data types classify information (e.g., Int, Double, String, Bool).

Type inference allows Swift to deduce the data type automatically.

Type annotation lets you explicitly specify the data type.

Understanding variables, constants, and data types is fundamental for building any Swift application. These concepts lay the groundwork for storing and manipulating information in a structured and efficient manner.

Course Syllabus