Swift Basics: Data Types, Constants, and Variables

• Swift's fundamental data types include Int, Double, Bool, and String.
• Swift provides Array, Set, and Dictionary collection types.
• Variables store and refer to values by name and can be changed.
• Constants are variables whose values cannot be changed after being set and are declared with the let keyword.
• Tuples group multiple values, potentially of different types, into a single compound value.
• Optional types handle the absence of a value, indicating whether a value exists (x) or doesn't exist at all.
• Swift is a type-safe language, preventing code from misusing types.

Constants and Variables

• Constants’ values cannot be changed after they are initially set.
• Variables can be assigned different values after their initial assignment.
• Constants are declared using the keyword let, while variables are declared using the keyword var.
• If a stored value won't change, declare it as a constant using let.
• Multiple constants or variables can be declared on a single line if separated by commas: var x = 0.0, y = 0.0, z = 0.0

Type Annotations

• Type annotations specify the type of value a constant or variable can store.
• A type annotation is written by placing a colon after the constant or variable name, followed by a space and the type name: var welcomeMessage: String
• Multiple related variables of the same type can be defined on a single line with a single type annotation after the final variable name: var red, green, blue: Double

Naming Constants and Variables

• Constant and variable names can contain almost any character, including Unicode.
• Names cannot contain whitespace characters, mathematical symbols, arrows, private-use Unicode scalar values, or line- and box-drawing characters.
• Names cannot begin with a number, although numbers may be included elsewhere within the name.
• Once declared with a certain type, a constant or variable cannot be redeclared with the same name or changed to store values of a different type.
• Values of existing variables can be changed to another value of a compatible type.

Printing Constants and Variables

• The print(_:separator:terminator:) function outputs the value of a constant or variable.
• String interpolation includes the name of a constant or variable as a placeholder in a string with a backslash and parentheses: \(variableName).
• Comments are nonexecutable text included in code as notes or reminders and are ignored by the Swift compiler.
• Single-line comments begin with two forward slashes (//).
• Multiline comments start with a forward slash followed by an asterisk (``) and can be nested.

Semicolons

• Swift does not require semicolons after each statement, but they are required to write multiple separate statements on a single line.

Integers

• Integers are whole numbers without fractional components, which can be signed or unsigned.
• Swift provides signed and unsigned integers in 8, 16, 32, and 64 bit forms.
• An 8-bit unsigned integer is of type UInt8, and a 32-bit signed integer is of type Int32.

Integer Bounds

• The minimum and maximum values of each integer type can be accessed with its min and max properties.

Int

• Int has the same size as the current platform's native word size (32-bit on 32-bit platforms, 64-bit on 64-bit platforms).

UInt

• UInt is an unsigned integer type with the same size as the current platform's native word size (32-bit on 32-bit platforms, 64-bit on 64-bit platforms).

Floating-Point Numbers

• Floating-point numbers contain a fractional component.
• Double represents a 64-bit floating-point number.
• Float represents a 32-bit floating-point number.

Type Safety and Type Inference

• Swift is a type-safe language, performing type checks during compilation and flagging mismatched types as errors.
• Type inference allows the compiler to deduce the type of an expression automatically by examining the provided values.
• If you don’t specify a type for a floating-point literal, Swift infers that you want to create a Double.

Numeric Literals

• Integer literals can be written as decimal (no prefix), binary (0b prefix), octal (0o prefix), or hexadecimal (0x prefix).
• Floating-point literals can be decimal (no prefix) or hexadecimal (0x prefix) and must have a number on both sides of the decimal point.
• Decimal floats can have an optional exponent (e or E), while hexadecimal floats must have an exponent (p or P).
• Numeric literals can contain extra formatting like padding with zeros or underscores for readability.

Numeric Type Conversion

• The Int type should be used for general-purpose integer constants and variables to ensure interoperability.

Integer Conversion

• Each numeric type can store a different range of values, requiring explicit type conversion.
• To convert one number type to another, initialize a new number of the desired type with the existing value like so: UInt16(one).

Integer and Floating-Point Conversion

• Conversions between integer and floating-point numeric types must be made explicit.
• Floating-point values are always truncated when used to initialize a new integer value.

Type Aliases

• Type aliases define an alternative name for an existing type using the typealias keyword.
• typealias AudioSample = UInt16 creates a type alias, so you can call AudioSample instead of UInt16

Booleans

• Bool represents a Boolean type, where values are either true or false.
• orangesAreOrange and turnipsAreDelicious have been inferred as Bool because they were initialized with a Boolean literal values.
• Swift's type safety prevents non-Boolean values from being substituted for Bool.

Tuples

• Tuples group multiple values into a single compound value, where types can be different.
• Tuple contents can be decomposed into separate constants or variables: let (statusCode, statusMessage) = http404Error
• Use underscores (_) to ignore parts of a tuple: let (justTheStatusCode, _) = http404Error
• Access individual element values in a tuple using index numbers starting at zero: http404Error.0
• Elements in a tuple can be named when the tuple is defined: let http200Status = (statusCode: 200, description: "OK")
• Element names can be used to access values: http200Status.statusCode
• Tuples are useful as return values of functions.

Optionals

• Optionals handle situations where a value may be absent represented by ?.
• Optionals represent either a value of a specified type or no value at all.
• An optional Int (Int?) contains either some Int value or no value at all.

nil

• An optional variable can be set to a valueless state by assigning it the value nil.
• If an optional variable is defined without a default value, it's automatically set to nil.
• An if statement to find out whether an optional contains a value can be used by comparing against nil.
• nil cannot be used with non-optional constants or variables.
• After unwrapping the value, code that works with that value doesn't need to check for nil.

Optional Binding

• Optional binding checks if an optional contains a value and makes it available as a temporary constant or variable.
• Optional binding can be used with if, guard, and while statements.
• if let actualNumber = Int(possibleNumber) { ... }
• If you don’t need to refer to the original, optional constant or variable after accessing the value it contains, you can use the same name for the new constant or variable
• Inside the body of the if statement, writing myNumber refers to that new non-optional constant
• if let myNumber { ... } the new, unwrapped constant or variable implicitly uses the same name as the optional value.
• You can use both constants and variables with optional binding: if var myNumber
• Multiple optional bindings and Boolean conditions can be included in a single if statement, separated by commas.

Providing a Fallback Value

• The nil-coalescing operator (??) provides a default value if an optional is nil, unwrapping and using the optional's value otherwise.

Force Unwrapping

• Force unwrapping the optional’s value by adding an exclamation mark (!) to the end of the optional's name.
• Force unwrapping a nil value triggers a runtime error.
• The ! is a shorter spelling of fatalError(_:file:line:).

Implicitly Unwrapped Optionals

• Implicitly unwrapped optionals are defined by placing an exclamation point (!) rather than a question mark (?) after the type that you want to make optional.
• Don’t use an implicitly unwrapped optional when there’s a possibility of a variable becoming nil at a later point.
• When you use an implicitly unwrapped optional value, Swift first tries to use it as an ordinary optional value; if it can’t be used as an optional, Swift force-unwraps the value.
• Checking whether an implicitly unwrapped optional is nil is the same as checking a normal optional.
• Implicitly unwrapped optionals can be used with optional binding.

Error Handling

• Error handling responds to error conditions encountered during program execution.
• Functions indicate they can throw an error by including the throws keyword: func canThrowAnError() throws
• Call a function that can throw an error, by prepending the try keyword to the expression: try canThrowAnError()
• Errors are automatically propagated until handled by a catch clause.
• A do statement creates a new scope, allowing errors to be propagated to catch clauses.

Assertions and Preconditions

• Assertions and preconditions are checks that ensure essential conditions are satisfied at runtime.
• Code execution continues if the Boolean condition evaluates to true; otherwise, the program terminates.
• Assertions are checked only in debug builds, while preconditions are checked in both debug and production builds.

Debugging with Assertions

• An assertion is written by calling the assert(_:_:file:line:) function.
• Omit the assertion message when it would just repeat the condition as prose.
• If the code already checks the condition, the assertionFailure(_:file:line:) function indicates that an assertion has failed.

Enforcing Preconditions

• Use a precondition whenever a condition must definitely be true for your code to continue execution.
• A precondition is written by calling the precondition(_:_:file:line:) function.
• The preconditionFailure(_:file:line:) function indicates that a failure has occurred.