Introduction to Swift Programming

• Swift provides fundamental data types like Int, Double, Bool, and String.
• It also offers powerful collection types: Array, Set, and Dictionary.
• Swift uses variables to store values; constants are variables whose values cannot be changed after being set.
• Swift introduces advanced types such as tuples, which group multiple values, and optionals, which handle the absence of a value.
• Swift is a type-safe language, preventing the use of incorrect value types.

Constants and Variables

• Constants and variables must be declared before use.
• Constants are declared with let, and variables with var.
• If a stored value won't change, declare it as a constant using let.
• You can provide values when you declare a constant/variable, or assign the value later.
• Mutliple constants/variables can be declared on a single line, separated by commas.

Type Annotations

• Add type annotations when declaring a constant or variable to clarify the stored values.
• Write a type annotation by placing a colon after the constant or variable name, followed by the type name.
• Multiple related variables of the same time can be defined on a single line using commas and a single type annotation after the final variable name.

Naming Constants and Variables

• Constant and variable names can contain almost any character, including Unicode.
• Names cannot contain whitespace characters, math symbols, arrows, private-use Unicode scalars, or line/box-drawing characters.
• Names cannot begin with a number; numbers are allowed elsewhere in the name.
• Once declared, can't redeclare a constant/variable with the same name, or change it to store a value of a different type.
• Can't change a constant into a variable or a variable into a constant.
• Existing variables can change to another value of a compatible type.

Printing Constants and Variables

• The current value of a constant/variable can be printed with the print(_:separator:terminator:) function.
• Swift uses string interpolation to include the name of a constant/variable as a placeholder in a longer string; wrap the name in parentheses and escape it with a backslash.

Comments

• Can include nonexecutable texts to add notes and reminders to your code.
• Single-line comments begin with two forward-slashes (//).
• Multiline comments start with a forward-slash followed by an asterisk (/*).
• Multiline comments can be nested inside other multiline comments.

Semicolons

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

Integers

• Integers are whole numbers with no fractional component.
• Can be signed (positive, zero, negative) or unsigned (positive or zero).
• Swift provides signed and unsigned integers in 8, 16, 32, and 64 bit forms.
• An 8-bit unsigned integer is of type UInt8, with a 32-bit signed integer of type Int32.

Integer Bounds

• Can access the minimum and maximum values of each integer type with its min and max properties.

Int

• Swift provides the Int integer type, which has the same size as the current platform’s native word size: 32-bit platform, Int is the same size as Int32, on a 64-bit platform, Int is the same size as Int64.
• Always use Int for integer values unless you need to work with a specific size.

UInt

• Swift also provides an unsigned integer type, UInt, which has the same size as the current platform’s native word size: On a 32-bit platform, UInt is the same size as UInt32 and on a 64-bit platform, UInt is the same size as UInt64.

Floating-Point Numbers

• Floating-point numbers are numbers with a fractional component.
• Floating-point types can represent a much wider range of values than integer types.
• 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 that encourages being clear about the types of values your code works with.
• Swift performs type checks when compiling and flags mismatched types as errors.
• If you don’t specify a value type, Swift uses type inference to determine the appropriate type.
• Type inference works by examining the values you provide.
• Type inference is particularly useful when you declare a constant or variable with an initial value; done by assigning a literal value to the constant or variable.
• If you don’t specify a type for a floating-point literal, Swift infers that you want to create a Double.
• If you combine integer and floating-point literals in an expression, a type of Double will be inferred from the context.

Numeric Literals

• Integer literals can be written as: decimal number (no prefix), binary number (0b prefix), octal number (0o prefix), hexadecimal number (0x prefix).
• Floating-point literals can be decimal (no prefix) or hexadecimal (0x prefix, always have a number (or hexadecimal number) on both sides of the decimal point with and exponoent indicated by an uppercase or lowercase p.
• Decimal floats can have an optional exponent, indicated by an uppercase or lowercase e.
• Numeric literals can contain extra formatting to make them easier to read; integers and floats padded with extra zeros and can contain underscores to help with readability.

Numeric Type Conversion

• Use other integer types only when they’re specifically needed for the task at hand to catch any accidental value overflows and documents the nature of the data being used.
• To convert one specific number type to another, initialize a new number of the desired type with the existing value.
• Conversions between integer and floating-point numeric types must be made explicit.
• Floating-point to integer conversion must also 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.
• Useful when you want to refer to an existing type by a name that's contextually appropriate.

Booleans

• Swift has a basic Boolean type called Bool.
• Boolean values are referred to as logical, because they can only ever be true or false.
• Swift provides two Boolean constant values, true and false.
• Can't need to declare constants/variables as Bool if you set them to true or false as soon as you create them.
• Swift's type safety prevents non-Boolean values from being substituted for Bool.

Tuples

• Tuples group multiple values into a single compound value.
• Values within a tuple can be of any type and don't have to be of the same type as each other.
• You can decompose a tuple's contents into separate constants or variables.
• If you only need some of the tuple's values, ignore parts of the tuple with an underscore (_) when you decompose the tuple.
• Can name the individual elements in a tuple when the tuple is defined.

Optionals

• You use optionals in situations where a value may be absent.
• As an example of a value that might be missing, Swift’s Int type has an initializer that tries to convert a String value into an Int value.
• To write an optional type, write a question mark (?) after the name of the type that the optional contains — for example, the type of an optional Int is Int?.

Nil

• Set an optional variable to a valueless state by assigning it the special value nil.
• If you define an optional variable without providing a default value, the variable is automatically set to nil.
• Can test whether an optional contains a value by comparing the optional against nil via (==) or (!=).
• Cant use nil with non-optional constants/variables
• If a constant/variable needs to work with the absence of a value under certain conditions, declare it as an optional value of the appropriate type.
• Separate optional and non-optional values to explicitly mark what information can be missing, and make it easier to write that handle missing values.

Optional Binding

• Optional binding finds out whether an optional contains a value, and if so, to make that value available as a temporary constant/variable.
• Optional binding can be used with if, guard, and while statements to check for a value inside an optional, and to extract that value into a constant/variable, as part of a single action.
• Write an optional binding for an if statement by writing if let and providing a name to bind to.
• 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.
• A shorter spelling can unwrap an optional value by unwrapping the constant/variable you're unwrapping.
• Constants/variables created with optional bindings in an if statement are only available within the body with the if statement.

Providing a Fallback Value

• Supply a default value when handling a missing value using the nil-coalescing operator (??).
• If the optional on the left of the ?? isn't nil, that value is unwrapped and used. Otherwise, the value on the right of ?? is used.

Force Unwrapping

• Add an exclamation mark (!) to the end of the optional's name to accesses the underlying value when nil represents an unrecoverable failure.
• Force unwrapping a nil value triggers a runtime error.
• Is a shorter spelling of fatalError(_:file:line:)
• Force wrapping depends on the convertedNumber always containing a value.

Implicitly Unwrapped Optionals

• Sometimes it's clear from a program's structure that an optional will always have a value after that value is first set, remove the need to check and unwrap the optional's value every time it's accessed.
• Called implicitly unwrapped optionals and are written by adding an exclamation Point (!String)
• Don’t use an implicitly unwrapped optional when there’s a possibility of a variable becoming nil at a later point.
• Used as a normal optional value.
• If an implicitly unwrapped optional is nil and you try to access its wrapped value, you’ll trigger a runtime error.
• Can check whether an implicitly unwrapped optional is nil the same way you check a normal optional.

Error Handling

• Respond to error conditions your program may encounter during execution.
• Errors allow you to determine the underlying course of failure, and if necessary, propagate the error to another part of your program.
• A function "throws" an error when it encounters an error condition.
• The function's caller can then "catch" the error and respond appropriately.
• Indicating that a function can throw an errror with the throws keyword as part of its declaration.
• When you call a function that can throw an error, you prepend the try keyword to the expression.
• Swift automatically propagates errors out of their current scope until they're handled by a catch clause.
• A do statment creates a new containing scope, which allows errors to be propagated to one or more catch clauses

Assertions and Preconditions

• Checks that happen at runtime, used to ensure that an esseantial condition is satisfied before executing any further code.
• If the Boolean condition in the assertion/precondition evaluates to true, code execution continues as usual and false causes code execution to end and the app to terminate.
• Can verify expectations at runtime, assertions/preconditions become a form of documentation within the code

Debugging with Assertions

• Write an assertion by calling the assert(_:_:file:line:) function from the Swift standard library.
• Pass this function an expression that evaluates to true or false and a message to display if the result of the condition is false.
• Can omit the assertion message.
• Use the assertionFailure(_:file:line:) to indicate that an assertion has failed if the code already checks the condition.

Enforcing Preconditions

• Use a precondition whenever a condition has the potential to be false, but must definitely be true for your code to continue execution.
• Call the precondition(_:_:file:line:) function to write a precondition
• Pass an expression that evaluates to true or false and a message to display if the result of the condition is false.
• You can also call the preconditionFailure(_:file:line:) function to indicate that a failure has occurred.