Section 1
Preview this deck
Adding Protocol Conformance with an Extension
Front
| 5 | 0 | ||
| 4 | 0 | ||
| 3 | 0 | ||
| 2 | 0 | ||
| 1 | 0 |
Active users
0
All-time users
0
Favorites
0
Last updated
6 years ago
Date created
Mar 1, 2020
Cards (142)
Section 1
(50 cards)
Adding Protocol Conformance with an Extension
extending an existing type to adopt and conform to a new protocol, even if you do not have access to the source code for the existing type.
protocol inheritance
A protocol can inherit one or more other protocols and can add further requirements on top of the requirements it inherits
subclass initializer first step
Setting the value of properties that the subclass declares.
what do classes, structures and enumerations can have
properties and methods
optional protocol requirements
These requirements do not have to be implemented by types that conform to the protocol.
subclass initializer third step
Changing the value of properties defined by the superclass
difference between class and structure/enumeration
class is reference type, structure and enumeration are value types
Initializer Chaining Rule 3
Convenience initializers must ultimately end up calling a designated initializer.
type parameter
specify and name a placeholder type, and are written immediately after the function's name, between a pair of matching angle brackets (such as <T>).
type constraint
used to enforce certain type constraints on the types that can be used with generic functions and generic types.
optional chaining syntax
var test: int? test?.incr() returns nil test!.incr() throws exception
constant stored property
defined by let
designated initializer syntax
init(parameters){statements}
Protocol Composition syntax
protocol<SomeProtocol, AnotherProtocol> this is a type.
subscripts
accessing elements of list, collections and arrays by index
Initializer Chaining Rule 2
Convenience initializers must call another initializer available in the same class
Protocol Composition
combining multiple protocols into a single requirement with a protocol composition.
optional protocol syntax
„@optional func incrementForCount(count: Int) -> Int
Automatic Initializer Inheritance Rule 1
If your subclass doesn't define any designated initializers, it automatically inherits all of its superclass designated initializers.
keys and values of dictionaries copied by value or by reference
if key or value is value type then copied by value else copied by reference
convenient initializer syntax
convenience init(parameters){statements}
generic type
type with type parameter
generics
enables you to write flexible, reusable functions and types that can work with any type, subject to requirements that you define
backing store
stored properties have no backing store
Initializer Chaining Rule 1
Designated initializers must call a designated initializer from their immediate superclass.
protocol
A protocol defines a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality.
Initializer delegation
Designated initializers must always delegate up. Convenience initializers must always delegate across.
Two-Phase Initialization Second Step
each class is given the opportunity to customize its stored properties further
can constant properties be modified
no, only during initialization
external parameter name
only visible to calling function
dictionaries and arrays class or structure
dictionaries and arrays are structures (value types)
how is delegation implemented
by defining a protocol that encapsulates the delegated responsibilities, such that a conforming type (known as a delegate) is guaranteed to provide the functionality that has been delegated
Automatic Initializer Inheritance Rule 2
If your subclass provides an implementation of all of its superclass designated initializers—either by inheriting them as per rule 1, or by providing a custom implementation as part of its definition—then it automatically inherits all of the superclass convenience initializers.
property observers can only be defined for which property type ?
stored property (not computed property)
lazy stored property
defined by @lazy var varName = value initialized only when first accessed
Designated initializer
primary initializer for a class
Initializer Inheritance
subclasses do not not inherit their superclass initializers by default
optional chaining
process for querying and calling properties, methods, and subscripts on an optional that might currently be nil
subclass initializer second step
Calling the superclass's initializer.
Two-Phase Initialization First Step
each stored property is assigned an initial value by the class that introduced it
generic function
function with type parameter
what element has a raw values, member values and associated values
enumerations
delegation
design pattern that enables a class or structure to hand off (or delegate) some of its responsibilities to an instance of another type
which type of properties can have getters and setters
computed properties
property observer
observe and respond to changes in a property's value
variable stored property
defined by var
Initialization
process of preparing an instance of a class, structure, or enumeration for use
willSet and didSet called in initialization ?
no not called in initialization
local parameter name
only visible in method or function definition
Convenience initializers
secondary, supporting initializers for a class
Section 2
(50 cards)
optional an if
You can use an if statement to find out whether an optional contains a value. If an optional does have a value, it evaluates to true; if it has no value at all, it evaluates to false
inout parameters
func swapTwoInts(inout a: Int, inout b: Int) { let temporaryA = a a = b b = temporaryA } var someInt = 3 var anotherInt = 107 swapTwoInts(&someInt, &anotherInt)
string value or reference type
value type
optional binding sample
if let actualNumber = possibleNumber.toInt() { println("\(possibleNumber) has an integer value of \(actualNumber)") } else { println("\(possibleNumber) could not be converted to an integer") }
tuple naming individual elements
let http200Status = (statusCode: 200, description: "OK")
++i or i++ best practice
++i is recommended if specific behavior of i++ is not needed.
numeric type conversion
let twoThousand: UInt16 = 2_000 let one: UInt8 = 1 let twoThousandAndOne = twoThousand + UInt16(one)
nested function
define functions inside the bodies of other functions
labeled statements
You can nest loops and switch statements inside other loops and switch statements in Swift to create complex control flow structures. It is sometimes useful to be explicit about which loop or switch statement you want a break statement to terminate. break gameLoop
switch where clause
A switch case can use a where clause to check for additional conditions
tuple decomposing
let http404Error = (404, "Not Found") let (statusCode, statusMessage) = http404Error or by index println("The status code is \(http404Error.0)")
identity operators
=== and !== to test whether two object references both refer to the same object instance
function definition
func halfOpenRangeLength(start: Int, end: Int) -> Int { return end - start }
switch tuple matching
case (1,2): case(1, _) _ any possible value
optional
An optional says: There is a value, and it equals x or There isn't a value at all
tuple sample
(404, "Not Found")
optional binding
find out whether an optional contains a value, and if so, to make that value available as a temporary constant or variable
shorthand external parameter name
used for both: internal and external parameter name # func containsCharacter(#string: String, #characterToFind: Character) -> Bool { for character in string { if character == characterToFind { return true } } return false }
closed range operator
... z.B. for index in 1...4
return value for no return value
empty tuple: ()
assertions
An assertion is a runtime check that a logical condition definitely evaluates to true
type alias
typealias AudioSample = UInt16
type cast operator
as, as? as? returns optional form of type
switch range matching
case 1...3:
optional binding syntax
if let constantName = someOptional { statements }
logical and &&
with short circuit
half-closed range operator
a..b for i in 0..names.count
switch where syntax
case let (x, y) where x == y: example is tuple matching
no void keyword
func sayGoodbye(personName: String) { println("Goodbye, \(personName)!") }
function tpye 2
func printHelloWorld() { println("hello, world") } () -> ()
mutable string
assign string to variable: var s = "string"
implicitly unwrapped optional
You can think of an implicitly unwrapped optional as giving permission for the optional to be unwrapped automatically whenever it is used
implicitly unwrapped optional sample
let assumedString: String! = "An implicitly unwrapped optional string." println(assumedString)
forced unwrapping sample
if convertedNumber { println("\(possibleNumber) has an integer value of \(convertedNumber!)") } else { println("\(possibleNumber) could not be converted to an integer") }
switch value binding syntax
case (0, let y): remark: this is tuple matching
exhaustive switch
every switch statement must be exhaustive use default catch-all case
assertion sample
let age = -3 assert(age >= 0, "A person's age cannot be less than zero")
variable parameter
can be changed inside function but change is not visible outside of function
forced unwrapping
I know that this optional definitely has a value; please use it
function type
func addTwoInts(a: Int, b: Int) -> Int { return a + b } func multiplyTwoInts(a: Int, b: Int) -> Int { return a * b } (Int, Int) -> Int
function type 3
var mathFunction: (Int, Int) -> Int = addTwoInts
variadic parameters
defined by ... after type of parameter func arithmeticMean(numbers: Double...) -> Double { var total: Double = 0 for number in numbers { total += number } return total / Double(numbers.count) }
string interpolation
insert constants, variables, literals, and expressions into longer strings
max Int number
Int.max
tuple
group multiple values into a single compound value
type check operator
is
logical or ||
with short circuit
literal
a value that appears directly in the source code
switch value bindings
can bind the value or values it matches to temporary constants or variables, for use in the body of the case
closed range operator
a...b for index in 1...5
Section 3
(42 cards)