Section 1
Preview this deck
enum
Front
| 5 | 0 | ||
| 4 | 0 | ||
| 3 | 0 | ||
| 2 | 0 | ||
| 1 | 0 |
Active users
0
All-time users
0
Favorites
0
Last updated
7 years ago
Date created
Mar 1, 2020
Cards (205)
Section 1
(50 cards)
enum
let cat = ""; print(cat)
write two separate statements let cat = "" and print(cat) on a single line
class
static func
Defines a type method. (for enums, structs )
static | keyword
- defines type methods / properties (structs, enums)
type method
a method that can be called via the type name without creating a class instance. Car.drive() You indicate _ by writing the static keyword before the method's func keyword. Classes may also use the class keyword to allow subclasses to override the superclass's implementation of that method.
Int32
type represented 32-bit number with no fractional component
reference type
Instances share a single copy of the data, and the type is usually defined as a class. Use when: -Comparing instance identity with === makes sense -You want to create shared, mutable state
class func
Defines a type method. (for class )
mutating | keyword
x = "Value"
set variable x of type String to string value "Value"
var x:String
provid type annotation for variable x, to indicate that the variable can store String values
computed property
- a function disguised as a property - used as a property, but it actually recalculates every single time it's called
Int16.max
access maximum value of 16-bit integer
Int64
type represented 64-bit number with no fractional component
Double
type represented a 64-bit floating-point number
instance method
UInt
unsigned integer type, which has the same size as the current platform's native word size
*/
multicomments end
Int
integer type, which has the same size as the current platform's native word size
Float
type represented a 32-bit floating-point number
print("x = \(x)")
insert current value of variable x in string "x = " with string interpolation
final | keyword
- prevents a method, property, or subscript from being overridden. You can mark an entire class as __ by writing the __ modifier before the class keyword in its class definition. Any attempt to subclass a __ class is reported as a compile-time error.
Function Parameter Names
These parameter names are only used within the body of the __ itself, and cannot be used when calling the function. These kinds of parameter names are known as local parameter names, because they are only available for use within the __'s body.
let
keyword for declaring constants
var
keyword for declaring variables
Int8
type represented 8-bit number with no fractional component
type property
- requires a default value - or be an optional (?) - or force unwrapped optional (!)
Methods
__ are functions that are associated with a particular type. Classes, structures, and enumerations can all define instance __, which encapsulate specific tasks and functionality for working with an instance of a given type.
Double(x)
integer value x to Double
print(_:separator:terminator:)
definition of print function
/*
multicomments start
Self vs self
Self - själva klasstypen, för att använda den typens function/class method self - själva objektet/ instansen (av en viss typ av class)?
var x, y, z: Double
define multiple related variables of the type Double on a sinlge line
Int16
type represented 16-bit number with no fractional component
stored instance property
non-computed property
static var
//
start of single line comments
private(set)
defer
here's some what I want you to do later, no matter what. - work will be executed as the method is exiting
print(x, terminator: "")
print current value variable x without a line break after
Int8.min
access minimum value of 8-bit integer
struct
UInt8
type represented unsigned 8-bit number with no fractional component
value type
Each instance keeps a unique copy of its data, usually defined as a struct, enum, or tuple. Acting as a unique instance of that data. Use when: - Comparing instance data with == makes sense -You want copies to have independent state -The data will be used in code across multiple threads
print(x)
print current value of variable x
class | keyword
- defines a type method / computed type property (protocols, class)
class var
Functions
Self-contained chunks of code that perform a specific task. You give a __ a name that identifies what it does, and this name is used to "call" the function to perform its task when needed.
function
Section 2
(50 cards)
true, false
Boolean constant values
\u{n}
arbitrary Unicode scalar n in string
for char in string {}
access individual Characters char for String string by iterating over the string with for statement
let x = (y: 1, z: "1")
declare variable x with tuple,name the individual elements in tuple y: 1, z: "1"
assert(_:_:file:line:)
definition of assert function
+,-,*,/
arithmetic operators
if let y = x {}
optional binding of optional's variable x with variable y in if statements
x...
one side range from x
String(["x","y","z"])
construct string by passing an array of characters "x","y","z"
tuple
group multiple values of any type into single compound value
nil
value of valueless state variable
x ?? b
nil-coalescing operator
condition ? true_statement : false_statement
ternary conditional operator for condition, true_statement and false_statement
"""x"""
multiline string literal "x"
x.y
access the value of named element y of tuple let x = (y: 1, z: "1")
<
comparison operator less than
x..<y
half-open range operator from x to y exclusive
typealias new_type = UInt16
define alternative name new_type for existing type UInt16
>
comparison operator greater than
1-8
number of hexadimical digits in Unicode scalar
&&
logical operator and
let x: Int!
declare optinal variable x of Int type for implicit unwrapping
do { try x() } catch {}
error handling of x function
>=
comparison operator greater than or equal to
...x
one side range to x
"x"
string literal "x"
!=
comparison operator not equal to
Int?
type represented optional type of Int
line feed in string
var x: (Int, String)
declare variable x of tuple groups together an Int and a String
\\
backslash in string
bool
type represented basic Boolean
\0
null character in string
x!
forced unwrapping of optional's value x
func x() throws {}
declare function x that can throw an error
+=,-=
compound assignment operators
precondition(_:_:file:line:)
definition of precondition function
=
assignment operator
var x = String()
declare variable x with initialization a new String
\r
carriage return in string
!
logical operator not
x + y
concatenate string x with character y
==
comparison operator equal to
\t
horizontal tab in string
\
escape character in strings
var x = ""
declare variable x as empty string assing an empty string literal
%
remainder operator
<=
comparison operator less than or equal to
Character
type represented character
x...y
close range operator from x to y inclusive
Section 3
(50 cards)
for item in x {}
iterate over array x with the for statement
[1, 2]
Array literals with elements 1, 2
x.append(1)
add a new item 1 to the end of array x
x.isEmpty
property for checking whether the count of set x is equal to 0
for (index, item) in x.enumerated() {}
iterate over array x with the for statement getting the integer index for each item
x.sorted()
method of set x that return the set's elements as an array using < operator
x.remove(:at 0)
remove item from set x at index 0
x.union(y)
method to create a new set with all of the values in both sets x and y
x.remove(:at 0)
remove item from array x at index 0
x.index(of: "!")
get index of "!" character in string xyz
x.subtracting(y)
method of set x to create a new set with values not in set y
set
collection of the same type values with no difined ordering
Set<Character>()
create an empty set
[Int]()
Creating empty array of Int short syntax
x.remove(at: x.startIndex)
remove single character from string x at index startIndex
x.hasPrefix("xyz")
check whether a string x has prefix "xyz"
x.removeSubrange(x.startIndex...x.index(x.endIndex, offsetBy: -2))
remove a substring from string x at range from first index to endIndex - 2
x.endIndex
property of string x to access the position after the last Character
x.intersection(y)
method to create a new set with only the values common to both sets x and y
x.isSuperset(of: y)
method to determine whether a set contains all of the values in set y
x.startIndex
property of string x to access the position of the first Character
x.insert(1, at: 0)
insert 1 into set x at index 0
x.isEmpty
property for checking whether the count of array x is equal to 0
x[..<x.index(x.startIndex, offsetBy: 3]
get substring from string x that include 2 first character of string x
[0, 2, 4, 34].filter({$0 > 20})
get new array with items from [0, 2, 4, 34] that greater then 20
x.indices
property of string x to access all of the inidces of individual chatacter in string
x.isStrictSuperset(of: y)
method to determine whether a set contains all of the values in set y, but sets x and y not equal
Array<Double>
Array type Double full syntax
[0, 2, 4, 34].reduce({$0 > $1})
reduce array [0, 2, 4, 34] to one single value
[1, 2, 3, 4]
result of [1, 2] + [3, 4]
x.insert(1, at: 0)
insert 1 into array x at index 0
x[i]
get item indexed i by subscript syntax for array x
x.contains(1)
check whether set x containst item 1
x.count
property of string x to retrieve a count of the character values in string
+=
alternative for append item in an array
x[x.startIndex]
get start Character from string x
x.isSubset(of: y)
method to determine whether all the values of set x are contained in set y
Set<Type>
set type syntax
x.count
get number of items in set x
x.isStrictSubset(of: y)
method to determine whether all the values of set x are contained in set y, but sets x and y not equal
x.symmetricDifference(y)
method to create a new set with values in either set x or y, but not both
x.hasSuffix("xyz")
check whether a string x has suffix "xyz"
x.count
porperty of array x to find out number of items in array
x.removeLast()
remove last item from array x
x.splice([0, 1], atIndex: 0)
insert array [0, 1] into array x at index 0
x.index(_ :offsetBy:befor:after:)
method of string x which corresponds to the position of each Character in the string
[Double]
Array type Double short syntax
x.removeAll()
remove all items from set
[0, 2, 4, 34].map({String($0)})
get new array with items from [0, 2, 4, 34] make them type of String
Array(repeating: 0.0, count: 3)
Creating array of Double with default value 0.0 with 3 elements
Section 4
(50 cards)
func x(arg_x x: Int) {}
difine function with parameter x of type Int with argument label arg_x without return value
enum x: Int { case y}
enumeration x with case y with Type of rowValue of type Int
guard condition {} else {}
guard syntax
x.isDisjoin(with: y)
method to determine whether two set have no values in common
{x, y in body}
closure function takes two values x, y with body inferring types form context
case "a", "A":
make switch with single case for both "a" and "A"
enum x { case y case z}
define enumeration with cases y and z
if condition {} elese if {} else {}
if statement for condition
#available(iOS 10, macOS 10.12, *)
availability condition for platform name iOS 10, version macOS 10.12, *
_
ommited argument label for first parameter in function
x.count
get number of items in dictionary x
Dictionary<key, value>
Dictionary syntax with key and value
x.isEmpty
property for checking whether the count of dictionary x is equal to 0
[String: Int]()
create emepty dictionary of type String for key and Int for value short syntax
x[y]
subscript syntax for dictionary x, key y
func x(_ y: Double) {}
define function x with variadic parameter y of type Double with ommmited argument lable without return value
break label_name
break labeled statement label_name
func x(y: inout Double) {}
define funciton x with inout parameter y of type Double
Dictionary
collectin stores associations between keys of the same type and values of the same type
case (let x, 0):
switch with case matching tuple (a, b) where a bind to x and b equal 0
func x() -> (y: Int, z: String) {}
define function without parameters with multipel return values y or type Int, and z of type String
x[y] = z
add new item in dictionary x with key y value z
for i in 1..5 {}
use for-in loop with numeric ranges
break
statement for end execution of an entire control flow statement
Dictionary<String, Int>()
create empty dictionary of type String for key and Int for value full syntax
[key: value]
Short hand syntax for Dictionary with key and value
(Int, Int) -> String
function type takes two Int value and return String
x.updateValue(z, forKey: y)
update value in dictionary x set value z for key y
fallthrough
C-like switch behavior
{$0 > $1}
closure function takes two values x, y return the value of statement x > y, short hand syntax
continue
statement for stop current loop and start again at the beginning of the next iteration through the loop
case 5..<12:
switch with case matching interval from 5 to 12 exclusive
case let (x, y) where x == y:
switch with case matching tuple (a, b) where a bind to x and b bind to y and x == y
enum x {case y, z}
enumeration x with cases y, z on a single line
label_name: while condition {}
labeled statement while with condition
repeat {} while condition
repeate statement for condition
for (key, value) in x {}
iterate over dictionary by key, value with for statement
["x" : 1, "y" : 2]
dictionary literal with items "x" : 1, "y" : 2
func x(_ y: Int = ) {}
define function x with parameter y of type Int with ommited argument label with default parameter value
enum x {case x(Double)}
enumeration x with case x with associated value of type Double
switch value {case value: statement default: break}
switch start for value
case (1, 1):
switch with case matching tuple
while condition {}
while statement with condition
x.removeValue(forKey: y)
remove item form dictionary x where key equal y
{(Int, Int) -> String in body}
closure function takes two Int value and return String with body}
func x() {}
define function x without paramters and return value
@escping () -> Void
escaping closure without parematers and return value
enum x: Int { case y = 5 }
enumeration enumeration x with case y with Type of rowValue of type Int assigned raw value 5
func x(y: Int) -> Int {}
define function x with parameter y of type Int with return value of type Int
stride(form:to/through:by)
function for ger integer range from other types
Section 5
(5 cards)