Swift

Introduction to Swift Programming

Swift is a powerful and intuitive programming language for macOS, iOS, watchOS, and tvOS. It is designed to work with Apple's Cocoa and Cocoa Touch frameworks and is intended to be more resilient to erroneous code.

Basics

Hello, World!

print("Hello, World!")

Variables and Constants

• Variables are declared using var and can be changed.
• Constants are declared using let and cannot be changed.

var myVariable = 42 myVariable = 50 let myConstant = 42

Data Types

Swift supports various data types including Int, Float, Double, Bool, String, Array, and Dictionary.

let integer: Int = 42 let double: Double = 3.14 let boolean: Bool = true let string: String = "Hello, Swift" let array: [Int] = [1, 2, 3] let dictionary: [String: String] = ["key1": "value1", "key2": "value2"]

Type Inference

Swift infers the type of variables and constants if the type is not explicitly specified.

let inferredInteger = 42 // Inferred as Int let inferredDouble = 3.14 // Inferred as Double

Control Flow

If-Else Statements

let score = 85 if score > 90 { print("Grade: A") } else if score > 80 { print("Grade: B") } else { print("Grade: C") }

Switch Statements

let character: Character = "a" switch character { case "a": print("It's an A") case "b", "c": print("It's a B or C") default: print("It's something else") }

Loops

• For-in Loop

for index in 1...5 { print(index) }

While Loop

var counter = 5 while counter > 0 { print(counter) counter -= 1 }

Functions

Defining and Calling Functions

func greet(name: String) -> String { return "Hello, \(name)!" } let greeting = greet(name: "World") print(greeting) // Hello, World!

Functions with Multiple Parameters

func add(a: Int, b: Int) -> Int { return a + b } let sum = add(a: 3, b: 5) print(sum) // 8

Functions without Return Values

func printGreeting(name: String) { print("Hello, \(name)!") } printGreeting(name: "Swift")

Closures

Closures are self-contained blocks of functionality that can be passed around and used in your code.

let addClosure = { (a: Int, b: Int) -> Int in return a + b } let result = addClosure(3, 5) print(result) // 8

Object-Oriented Programming

Classes and Structures

• Class: Reference type
• Structure: Value type

class Person { var name: String var age: Int init(name: String, age: Int) { self.name = name self.age = age } func greet() -> String { return "Hello, my name is \(name) and I am \(age) years old." } } let person = Person(name: "John", age: 30) print(person.greet())

Inheritance

class Employee: Person { var jobTitle: String init(name: String, age: Int, jobTitle: String) { self.jobTitle = jobTitle super.init(name: name, age: age) } override func greet() -> String { return "Hello, my name is \(name), I am \(age) years old, and I work as a \(jobTitle)." } } let employee = Employee(name: "Jane", age: 25, jobTitle: "Software Engineer") print(employee.greet())

Enumerations

Enumerations define a common type for a group of related values and enable you to work with those values in a type-safe way.

enum CompassPoint { case north case south case east case west } let direction = CompassPoint.north

Optionals

Optionals are used to handle the absence of a value.

var optionalString: String? = "Hello" print(optionalString) // Optional("Hello") optionalString = nil print(optionalString) // nil

Unwrapping Optionals

• Forced Unwrapping

if optionalString != nil { print(optionalString!) // Hello }

• Optional Binding

if let unwrappedString = optionalString { print(unwrappedString) // Hello }

• Nil Coalescing

let defaultString = optionalString ?? "Default Value" print(defaultString) // Default Value

Error Handling

Swift provides error handling to manage unexpected conditions.

Throwing and Catching Errors

enum NetworkError: Error { case badURL case timeout case unknown } func fetchData(from url: String) throws { if url.isEmpty { throw NetworkError.badURL } // Simulate a network request } do { try fetchData(from: "") } catch NetworkError.badURL { print("Bad URL") } catch { print("An unknown error occurred") }

Conclusion

Swift is a robust language that supports a variety of programming paradigms, including object-oriented and functional programming. This guide covers the basics, but Swift has many more features and capabilities to explore. Happy coding!

Advanced Swift Concepts

Advanced Functions

Function Types

Functions in Swift are first-class citizens, which means they can be assigned to variables, passed as arguments, and returned from other functions.

func multiply(a: Int, b: Int) -> Int { return a * b } let mathFunction: (Int, Int) -> Int = multiply print(mathFunction(2, 3)) // 6

• Functions as Parameters

func performOperation(_ a: Int, _ b: Int, operation: (Int, Int) -> Int) -> Int { return operation(a, b) } let result = performOperation(4, 2, operation: multiply) print(result) // 8

• Functions as Return Types

func chooseOperation(isMultiply: Bool) -> (Int, Int) -> Int { return isMultiply ? multiply : { $0 + $1 } } let chosenOperation = chooseOperation(isMultiply: true) print(chosenOperation(2, 3)) // 6

Generics

Generics allow you to write flexible and reusable functions and types that can work with any type.

func swapValues<T>(_ a: inout T, _ b: inout T) { let temp = a a = b b = temp } var x = 5 var y = 10 swapValues(&x, &y) print("x: \(x), y: \(y)") // x: 10, y: 5

Extensions

Extensions add new functionality to an existing class, structure, enumeration, or protocol.

extension Int { func squared() -> Int { return self * self } } print(5.squared()) // 25

Protocols

Protocols define a blueprint of methods, properties, and other requirements for particular tasks or functionality.

protocol Greetable { var name: String { get } func greet() -> String } class Friend: Greetable { var name: String init(name: String) { self.name = name } func greet() -> String { return "Hello, \(name)!" } } let friend = Friend(name: "John") print(friend.greet()) // Hello, John!

Protocol Extensions

Protocol extensions provide default implementations of methods and properties to conforming types.

extension Greetable { func greetFormally() -> String { return "Good day, \(name)." } } print(friend.greetFormally()) // Good day, John.

Error Handling

Defining Errors

You can define custom errors by conforming to the Error protocol.

enum FileError: Error { case fileNotFound case unreadable case encodingFailed }

Propagating Errors Using throws

Functions and methods can propagate errors by marking them with the throws keyword.

func readFile(filename: String) throws -> String { if filename == "" { throw FileError.fileNotFound } // Simulate reading file content return "File content" }

Handling Errors Using do-catch

You can handle errors using a do-catch block.

do { let content = try readFile(filename: "example.txt") print(content) } catch FileError.fileNotFound { print("File not found") } catch { print("An unknown error occurred") }

Advanced Types

Type Aliases

Type aliases define an alternative name for an existing type.

typealias AudioSample = UInt16 var maxAmplitude = AudioSample.max

Nested Types

Types can be nested within other types.

struct Car { struct Engine { var horsepower: Int } var engine: Engine } let carEngine = Car.Engine(horsepower: 200) print(carEngine.horsepower) // 200

Memory Management

Automatic Reference Counting (ARC)

Swift uses ARC to manage the memory of class instances.

class Person { var name: String init(name: String) { self.name = name } deinit { print("\(name) is being deinitialized") } } var person1: Person? = Person(name: "John") var person2 = person1 person1 = nil person2 = nil

Strong, Weak, and Unowned References

• Strong references keep a firm hold on the referenced object.
• Weak references do not keep a firm hold on the referenced object and are used to avoid strong reference cycles.
• Unowned references assume the referenced object always has a value during its lifetime.

class Owner { var car: Car? } class Car { weak var owner: Owner? } let owner = Owner() let car = Car() owner.car = car car.owner = owner

Concurrency

Grand Central Dispatch (GCD)

GCD is a low-level API for managing concurrent code execution on multicore hardware.

let queue = DispatchQueue.global(qos: .userInitiated) queue.async { print("Performing task in background") DispatchQueue.main.async { print("Returning to main thread") } }

Swift Concurrency with async/await (Introduced in Swift 5.5)

The async and await keywords simplify asynchronous programming.

func fetchData() async -> String { // Simulate network delay try? await Task.sleep(nanoseconds: 1_000_000_000) return "Fetched Data" } Task { let data = await fetchData() print(data) }

Conclusion

Swift is a versatile language designed for performance and safety. From basic syntax to advanced features like generics, protocols, and concurrency, Swift provides powerful tools to build robust applications. Keep exploring and practicing to master Swift!