Section 1
Preview this deck
Empty Strings
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 (63)
Section 1
(50 cards)
Empty Strings
initialize with "" or String() check with .isEmpty()
break
ends execution of control flow statement
Iterating over a set
for-in for iterating without order for item in setname.sort() {} for iterating with order
print(_:separator:terminator:)
separator -- string between printing arguments (def: " ")
terminator -- string that ends printed output (def:
)
Accessing and Modifying Sets
.count (read-only) gives size .isEmpty tells if empty .insert(_: ) adds item .remove(_: ) returns item if removed or nil if not -- check with optional binding
String Mutability
Strings with "var" are mutable, "let" are not
UInt8, UInt16, UInt32, UInt64
Unsigned integer
Error Handling
define function that causes error func name() throws { } call function (or other code that might throw error) and catch do { try name() } catch Error.someError { //other code }
Modifying arrays
.append(element) to add to end [0] = ["String"] [1...4] = ["h", "e", "l"] changes indices 1-3 AND removes 4 insert(_: atIndex: ) inserts an obj at specific index removeAtIndex(_: ) removes object at index, returns that object removeLast() -- faster for last item removing, doesn't query .count
Integer and Floating Point Conversion
When using literals, it doesn't need to be explicit, but when using variables, need to use constructors: Double(num) for example
typealias
Creates new ALIAS (not a class extending) for a type: Ex. typealias AudioSample = UInt8
naming variables/constants
cannot contain whitespace, math symbols, arrows, private use code points, can't start with a number
unary minus operator: -
changes sign of number
Characters
access with .characters property for iteration add to string with .append(charactervar) create as any type get length of string with characters.count
String Equality
use == to check for canonical equivalence (basically, do they look the same in english)
Half Open Range Operator : a...<b
from a to b, not including b
iterating through arrays
for(var i = 0; i < arr.characters.count; i++) traditional for item in arr enhanced for (index, value) in arr.enumerate() enhanced w/index
constant
declare with "let" use if variable will never change
assert
var age = 3; Ex. assert(age >= 0, "A person's age can't be less than 0") STOPS execution of code if condition false, prints error When to use: whenever a condition has the potential to be false, but must definitely be true in order for your code to continue execution
Accessing Tuple values
1. Can use indices var intstring = (404, "error") intstring.0 -> gives you 404 2. Can decompose var (num, str) = intstring or if you just want one var (num, _) = intstring
repeat-while
repeat { } while condition
getting key and value lists
[Type](dictname.keys) [Type](dictname.values)
continue
stops exec current iteration and goes to next
Hash values for Sets
Objects in a set must be Hashable -- implements gettable Int property called hashValue and implements the == operator
Range Operator: a...b
from a to b inclusive
Iterating through a dictionary
for (key, value) in dictname { // do what your heart tells you } can iterate through dictname.keys or dictname.values as well
Optional
Either contains a value or contains nil; Ex Int(string) returns Int?
Accessing and Modifying a Dictionary
use .count for size and .isEmpty for empty checking Adding: dictname["key"] = "value" OR dictname.updateValue("value", forKey: "key") --> returns old value as optional so you can check if update happened Removing: dictname["key"] = nil OR dictname.removeValueForKey(_: ) --> returns removed or nil
String indices
each character has index (like character array) but not with integer values .startIndex returns first index (like) .predecessor() index before .successor() index after .startIndex.advancedBy(integernum) -> start + that integer .endIndex = .characters.count // so don't use this in a subscript argument
switch cases
no implicit fallthrough, need to match all possible cases (with or without a default), use where to check additional conditions can accept ranges as cases with Tuples: (_, 0) <- left is a wildcard case can have ranges in Tuples too! a case can bind a var like case let x: \\code or case (let x, 0): \\for a tuple or case let (x, y): \\ also for tuple
fallthrough
adds fallthrough to switch case, since switch does not have implicit fallthrough
unary plus operator: +
doesn't do anything
Tuples
Lets you combine different types into one compound type: Ex. var intstring = (404, "error") can name types like var intstring : (status: Int, message: String) = (404, "error"), can even typealias that with the named params
String interpolation
var statement = "statement" print("hello, this is a \(statement)")
Array Instantiation
Ex. var someInts = [Int]() or can use [] --> gives no type though or var someInts = [Int](count: 3, repeatedValue: 0) or var someInts = [1, 2, 3]
Nil Coalescing Operator: ??
a ?? b => a != nil ? a! : b explanation: if a is not nil, a is unwrapped and returned, else b is returned used for concision
hasPrefix and hasSuffix
check if string starts with or ends with a string
remainder operator: %
a % b => a = (b x multiplier) + remainder ex. -9 % 4 = -1 bc -9 = (4 x -2) + -1 b's sign doesn't change answer can also operate on floating point numbers
nil
Valueless state (not a pointer to a nonexistent object) var name:Type? sets name to nil before it is initialized
Optional Binding
if let name = someoptional { // use name, which is limited to the scope of this if statement } can use multiple and check Boolean condition with where
Set
A set stores distinct values of the same type in a collection with no defined ordering instantiated with Set<Element>() or (if type annotated) ["item, ... ] with array literal implies that after type defined setting it equal to [] makes an empty set
type annotation
var varname : Type means "of type Type" can give multiple variables same type var one, two, three : Int
Float
32-bit floating point
variable types
first initialization defines type, cannot change after
Int
Swift default integer type that takes word size of platform (Int32 for 32-bit, Int64 for 64-bit) Int8, Int32, Int16, Int64
Double
64-bit floating point
Dictionary
type name is Dictionary<Key, Value> but can initialize with var dict = [Int : String]() ^ example can make empty after type defined with [:] dictionary literal: [key 1: value 1, key 2: value 2, key 3: value 3] also works
Check for empty arrays
.isEmpty
Set operations
.intersect(_: ) .union(_: ) .subtract(_: ) .exclusiveOr(_: ) basically the opposite of intersect .isSubsetOf(_: ) .isSupersetOf(_: ) .isDisjointWith(_: ) .isStrictSubsetOf(_: ) or .isStrictSupersetOf(_: )
Booleans
true or false non-booleans can't be used as conditional statements var i = 1; ex. if i {} would not compile
Section 2
(13 cards)