Go on. Explore!

lvl 0 • 0 xp

Swift Programming Language

(0)

43 cards

()

5			0
4			0
3			0
2			0
1			0

Active users

All-time users

Last updated

Date created

Cards (43)

Swift Programming Language

Preview this deck

create a nested function

0.0

Cards (43)

create a nested function

func f1 () -> Int { var y = 10 func f2() { y += 5 } f2() return y }

Functions are a first-class type. This means that functions can be passed as arguments and/or return values

TRUE

create a new variable that will be assigned a string array later

var a = [ ]

create a new string array

let a = String[]()

create for-in loop to iterate 3 times

for i in 0..3 { ... }

switch's case statements do not need break

TRUE

create a function that returns another function as its value

func f1() -> (Int -> Int) { func f2(n: Int) -> Int { return 1 + n } return f2 }

You can refer to parameters by number instead of by name—this approach is especially useful in very short closures.

TRUE

declare an optional

var optionalString: String? = "Hello"

the constructor method for a class is named 'init'

class c { var name: String init(name: String) { self.name = name }

"create for-in loop to iterate over items in a dictionary by providing a pair of names to use for each key-value pair."

let d = [ "x":[1,2,3], "y":[4,5,6], "z":[7,8,9] ] for (k,n) in x { for m in n {...} }

create a function that returns a tuple

func f() -> (Int, Int, Int) { return (1,2,3)}

create a function that takes another function as one of its arguments

func matches(condition: Int -> Bool) -> Bool { if condition(item) { return true } return false }

add a new key and value to a dictionary

d1["newkey"] = "newvalue"

name four reserved words that cause loops

for-in, for, while, and do-while

example of switch statement

let vegetable = "red pepper" switch vegetable { case "celery": let a = 1 case "cucumber", "watercress": let b = 2 case let x where x.hasSuffix("pepper"): let c = 3 default: let d = 4 }

A closure passed as the last argument to a function can appear immediately after the parentheses.

sort([1, 5, 3, 12, 2]) { $0 > $1 }

use if let on an optional

var optionalName: String? = "John" if let name = optionalName { greeting = "Hello, \(name)" }

You have several options for writing closures more concisely. When a closure's type is already known, such as the callback for a delegate, you can omit the type of its parameters, its return type, or both.

TRUE

statements do not need a semicolon at the end

TRUE

code at the global scope is the main() function

TRUE

name two reserved words that are conditionals

if and switch

declare a variable

var v

Functions are actually a special case of closures. You can write a closure without a name by surrounding code with braces { }. Use 'in' to separate the arguments and return type from the body.

numbers.map({ (number: Int) -> Int in let result = 3 * number return result })

Values are never implicitly converted to another type

TRUE. example: let s = label + String(int1)

declare a constant

let c

example of for-in loop

let scores = [2,6,8] for score in scores { .... }

create a constant that is explicitly typed

let c : Double = 70

check if optional is nil

optionalString == nil

create a new variable that will be assigned a dictionary value later

var d = [ : ]

use if and let together to work with a variable whose value might be missing

if let x = obj1 { x.name = "abc" }

create an instance of a class by putting parentheses after the class name

var shape = Shape()

"You use for-in to iterate over items in a dictionary by providing a pair of names to use for each key-value pair."

let nums= [ "Prime": [2, 3, 5, 7, 11, 13], "Fibonacci": [1, 1, 2, 3, 5, 8], "Square": [1, 4, 9, 16, 25], ] var largest = 0 for (kind, numbers) in nums{ for number in numbers { if number > largest { largest = number } } }

Use deinit to create a deinitializer if you need to perform some cleanup before the object is deallocated

TRUE

create a function that takes a variable number of arguments

func f(numbers: Int...) { }

write a string that has an integer variable in it

"I have \(apples) apples."

Create a single statement closure that implicitly returns the value of its only statement.

numbers.map({ number in 3 * number })

declare and initialize a dictionary