Swift differs from Objective-C in several key aspects: 1) Type safety and inference, 2) Optionals for safe handling of nil values, 3) Modern syntax without @ symbols, 4) Tuples and multiple return values, 5) Protocol-oriented programming approach, 6) Built-in error handling, 7) Advanced pattern matching, 8) Generics support, 9) No header files needed, and 10) Better memory management with ARC.
Pattern Matching in Swift includes: 1) Switch statement patterns, 2) Case let bindings, 3) Where clauses for conditions, 4) Tuple pattern matching, 5) Type casting patterns (is, as), 6) Expression pattern matching. It's powerful for control flow and data extraction, especially with enums and complex types.
Swift provides five access levels: 1) open - accessible outside module, can be subclassed, 2) public - accessible outside module, 3) internal - default, module-level access, 4) fileprivate - file-level access, 5) private - scope-level access. Access control helps enforce encapsulation and defines module interface boundaries.
Subscripts provide shorthand access to collections: 1) Custom getter/setter syntax, 2) Multiple parameter support, 3) Type and instance subscripts, 4) Overloading capabilities, 5) Generic subscripts, 6) Optional return types. They're commonly used in collections and custom sequence types.
Swift Strings are unique: 1) Unicode-correct by default, 2) Value type semantics, 3) Character-based iteration, 4) Complex grapheme cluster handling, 5) String interpolation features, 6) Performance optimizations. Understanding these differences is crucial for proper text handling.
Tuples group multiple values: 1) Named or unnamed elements, 2) Multiple return values from functions, 3) Pattern matching support, 4) Decomposition in assignments, 5) Type inference with tuples, 6) Limited to fixed size. They're useful for temporary grouping of related values without defining a formal structure.
Swift memory management involves: 1) Automatic Reference Counting (ARC), 2) Strong, weak, and unowned references, 3) Reference cycles prevention, 4) Value type stack allocation, 5) Reference type heap allocation, 6) Capture lists in closures. Understanding these concepts is crucial for preventing memory leaks.
Result Builders enable DSL creation: 1) Custom syntax for building complex objects, 2) SwiftUI view construction, 3) Compile-time building of results, 4) Support for conditional and loop statements, 5) Custom builder attributes, 6) Type-safe DSL creation. They're fundamental to SwiftUI's declarative syntax.
Lazy properties provide delayed initialization: 1) Initialized only when first accessed, 2) Must be variable (var), 3) Not thread-safe by default, 4) Useful for expensive computations, 5) Can reference self safely, 6) Cannot have property observers. They optimize memory usage and startup time.
Property Wrappers add behavior to properties: 1) Encapsulate common property patterns, 2) Reduce boilerplate code, 3) Support custom getter/setter logic, 4) Enable property observation, 5) Allow for computed property behavior, 6) Support dependency injection. Common examples include @State in SwiftUI and custom wrappers for persistence.
Extensions add functionality to existing types: 1) Add computed properties, 2) Define instance/type methods, 3) Provide new initializers, 4) Make types conform to protocols, 5) Add nested types, 6) Organize code by functionality. They can't override existing functionality but can add new features to any type, including system types.
Operator overloading features: 1) Custom operator definitions, 2) Precedence group specification, 3) Infix, prefix, and postfix operators, 4) Protocol conformance for operators, 5) Type-safe operator implementation, 6) Standard library operator patterns. This enables custom operations for user-defined types.
Property observers monitor changes: 1) willSet executes before change, 2) didSet executes after change, 3) Access to old/new values, 4) Cannot be used with computed properties, 5) Support for inheritance, 6) Useful for UI updates and validation. They enable reactive property behavior.
String interpolation features: 1) Basic value insertion with \(), 2) Custom interpolation definitions, 3) Formatted value presentation, 4) Expression evaluation, 5) Multi-line string support, 6) Localization integration. It provides flexible string formatting and composition.
Protocol requirements include: 1) Method signatures, 2) Property specifications, 3) Static/class requirements, 4) Optional requirements with @objc, 5) Associated type constraints, 6) Default implementations via extensions. This enables flexible protocol-oriented design.
Optionals in Swift represent values that may or may not exist. Unwrapping methods include: 1) Force unwrapping (!), 2) Optional binding (if let/guard let), 3) Optional chaining (?.), 4) Nil coalescing operator (??), 5) Implicit unwrapping (!). Best practices include avoiding force unwrapping and using optional binding for safety. Optional binding provides safe unwrapping with control flow, while optional chaining allows safe access to properties and methods.
Closures are self-contained blocks of functionality: 1) Can capture and store references to variables/constants, 2) Support trailing closure syntax, 3) Have shorthand argument names, 4) Can be used as function parameters, 5) Support multiple closure parameters, 6) Allow for escaping and non-escaping variants. They're commonly used in async operations, callbacks, and higher-order functions.
Generics enable flexible, reusable code: 1) Type-safe abstract types, 2) Generic functions and types, 3) Type constraints and protocols, 4) Associated types in protocols, 5) Generic where clauses, 6) Type erasure concepts. They reduce code duplication while maintaining type safety and enabling collection types.
Method Dispatch determines how methods are called: 1) Static dispatch for value types, 2) Dynamic dispatch for class methods, 3) Table dispatch for protocol methods, 4) Direct dispatch optimizations, 5) Message dispatch in Objective-C interop, 6) Performance implications of each. Understanding dispatch affects performance and inheritance behavior.
Keypaths provide type-safe references to properties: 1) KeyPath for read-only properties, 2) WritableKeyPath for mutable properties, 3) ReferenceWritableKeyPath for reference types, 4) Key path expressions with \, 5) Key path subscripting, 6) Dynamic member lookup integration. They're useful for dynamic property access and functional programming patterns.
Variadic parameters accept multiple values: 1) Denoted by ... after type, 2) Treated as array inside function, 3) Only one per function signature, 4) Can be combined with regular parameters, 5) Support type inference, 6) Useful for flexible APIs. They enable flexible function parameter counts.
Value types (struct, enum) create a new copy when assigned, while reference types (class) share the same instance. Key differences: 1) Value types are copied on assignment, 2) Reference types are passed by reference, 3) Value types support mutating keyword, 4) Reference types can inherit, 5) Value types are preferred for data models, 6) Reference types are better for shared resources. Understanding this difference is crucial for memory management and program design.
Type Inference allows Swift to automatically deduce variable types: 1) Compiler analyzes initialization value, 2) Determines appropriate type at compile time, 3) Reduces explicit type annotations, 4) Works with complex types and generics, 5) Maintains type safety, 6) Improves code readability. While convenient, explicit type annotation can improve code clarity and compile time.
Swift supports various property types: 1) Stored properties (var/let), 2) Computed properties (get/set), 3) Property observers (willSet/didSet), 4) Type properties (static/class), 5) Lazy properties (lazy var), 6) Property wrappers (@propertyWrapper). Each serves different purposes in managing object state and behavior.
Swift error handling includes: 1) Error protocol conformance, 2) throws keyword for error-prone functions, 3) do-try-catch blocks, 4) try? and try! operators, 5) Error propagation through functions, 6) Custom error types and handling, 7) Result type for functional error handling, 8) async/await error handling integration. This provides type-safe error management.
Static vs Class methods differ in: 1) static cannot be overridden in subclasses, 2) class allows overriding in subclasses, 3) static is resolved at compile time, 4) class uses dynamic dispatch, 5) static is preferred for utility functions, 6) class is used when inheritance is needed. This affects inheritance and method dispatch behavior.
Type casting mechanisms include: 1) is operator for type checking, 2) as? for conditional downcasting, 3) as! for forced downcasting, 4) as for upcasting, 5) Type casting patterns in switch, 6) Any and AnyObject handling. Safe type casting is crucial for runtime type safety.
Phantom types provide compile-time safety: 1) Generic type parameters unused at runtime, 2) Type-level state encoding, 3) Compile-time validation, 4) Unit type safety, 5) State machine implementation, 6) API design constraints. They enable advanced type-safety patterns.
