Please enable JavaScript.

Coggle requires JavaScript to display documents.

swift (lang (class / struct (Protocols (Initializer (required init), Class…

- - - - prefix
      - postfix
    - - infix
        
        arithmetic shift
        
        signed integers have the same sign after they are shifted to the right
        
        a &+ b / &- / &*
        
        a ?? b
        
        a...b
        
        a... / ...b
        
        a..<b
        
        ..<b
    - - a ? b : c
    - - static func +
      - static prefix func -
      - static func +=
      - prefix operator +++
  - - - a single extended grapheme cluster
      - let combinedEAcute: Character = "\u{65}\u{301}"
      - let c:Character = "c"
  - - - [Int] / Array<Int>
    - - Set<Character>
    - - [Int: String]
  - - - func someFunction(argumentLabel parameterName: Int) {}
      - func someFunction(_ firstParameterName: Int, secondParameterName: Int) {}
      - If a parameter has an argument label, the argument must be labeled when you call the function.
    - - func arithmeticMean(_ numbers: Double...) -> Double {}
      - A function may have at most one variadic parameter.
    - - func swapTwoInts(_ a: inout Int, _ b: inout Int) {}
      - swapTwoInts(&someInt, &anotherInt)
      - parameters are constants by default
      - In-out parameters cannot have default values, and variadic parameters cannot be marked as inout.
  - - - Global functions are closures that have a name and do not capture any values.
      - Nested functions are closures that have a name and can capture values from their enclosing function.
      - Closure expressions are unnamed closures written in a lightweight syntax that can capture values from their surrounding context.
    - - { (s1: String, s2: String) -> Bool in return s1 > s2 }
      - { s1, s2 in return s1 > s2 }
      - { s1, s2 in s1 > s2 }
      - { $0 > $1 }
    - - names.sorted( { $0 > $1 } )
      - names.sorted() { $0 > $1 }
      - names.sorted { $0 > $1 }
    - - func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {}
    - - let customerProvider = { customersInLine.remove(at: 0) }
      - func serve(customer customerProvider: @autoclosure () -> String) {}
        
        serve(customer: customersInLine.remove(at: 0))
  - - - Only throwing functions can propagate errors.
    - - A defer statement defers execution until the current scope is exited.
  - - - func swapTwoValues<T>(_ a: inout T, _ b: inout T) {}
    - - func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {}
  - - - stored property
        
        lazy stored property / lazy var
        
        property is created when the property is first accessed
        
        property observer
        
        willSet
        
        didSet
      - computed property / var / get / set
        
        read-only computed property
      - stored variables
        
        Local constants and variables are never computed lazily.
        
        Global constants and variables are always computed lazily.
      - type property
        
        must always give stored type properties a default value
        
        static
    - - mutating
      - type method
        
        static
      - self
    - - subscript
    - - For class instances, a constant property can be modified during initialization only by the class that introduces it. It cannot be modified by a subclass.
      - default initializer
      - initializer delegation
      - designated initializers
        
        init
      - convenience initializers
        
        convenience init
      - Subclasses can modify inherited variable properties during initialization, but can not modify inherited constant properties.
      - Failable Initializers
        
        init?
        
        init!
      - Required Initializers
        
        required init
    - - Extensions add new functionality to an existing class, structure, enumeration, or protocol type.
      - Extensions can add new computed properties, but they cannot add stored properties, or add property observers to existing properties.
      - Extensions can add new functionality to a type, but they cannot override existing functionality.
      - mutating / self
    - - Property
      - Method
      - Initializer
        
        required init
      - delegate
      - Types do not automatically adopt a protocol just by satisfying its requirements. They must always explicitly declare their adoption of the protocol.
      - Protocol Inheritance
      - Class-Only Protocols
        
        AnyObject
      - Protocol Composition
      - Protocol Extensions
    - - Any class that does not inherit from another class is known as a base class.
      - override
        
        final
        
        super
      - super.init will be called after init called if super.init not called inside init.
    - - is
      - as
      - Any / AnyObject
    - - deinit
    - - unowned reference
        
        If you try to access the value of an unowned reference after that instance has been deallocated, you’ll get a runtime error.
      - weak reference