A Modest Introduction to Swift

A Modest
Introduction
To Swift
pdx.pm

10 Mar 2016
John SJ Anderson

@genehack

Went Open Source

at version 2.2

Originally targeted
MacOS, iOS,

watchOS, and tvOS

With expanded platform
support, oﬀers obvious
"single-language stack"
advantages a la Node

How many MacOS / iOS
users do we have here?

How many MacOS / iOS
developers do we have?

The dirty little secret of
developing for Apple

From In The Beginning
Was The Command Line
by Neal Stephenson

Weird Pascal-based
naming and calling
conventions

Swift is the Mac of Apple
programming languages

Comments
/* this is a
multi-line
comment */

Comments
/* this is a
_nested_
multi-line comment, */
which is cool! */

Variables
var foo = 1
var bar: Int
var baz = "whee!"

Variables
let bar = 1
bar += 1 // compile time error!

Variables
let bar // also a compile time error
/*
You canNOT have an uninitialized and
untyped variable. You also can't use
an initialized variable _at all_
*/

Flow Control
let n = 1
if n > 1 {
print("we got a big N here")
}

Flow Control
let arr = [ 1, 2, 3, 4]
var sum = 0
for elem in arr {
sum += elem
}
// sum now is 10

Flow Control
for index in 1 ... 10 {
# do something 10 times
}

Flow Control
for index in 1 ..< 10 {
# do something 9 times
}

Flow Control
var countDown = 5
while countDown > 0 {
countDown--
}

Flow Control
var countUp = 0
repeat {
countUp++
} while countUp < 5

Flow Control
let sample = 2
switch sample {
case 0:
print("Is 0")
case 2:
print("Is 2")
default: // mandatory when cases not exclusive
print("Not 0 or 2, is it.")
}

Flow Control
let sample = "foo"
switch sample {
case "foo":
print("Is foo")
case "bar":
print("Is bar")
print("Not foo or bar, is it.")
}

Flow Control
let sample = ("foo", 2)
switch sample {
case ("foo", 2):
print("Is foo, 2")
case ("bar", _):
print("Is bar")
print(" ¯_( )_/¯ ")
}

Flow Control
let sample = ("foo", 2)
switch sample {
case ("foo", "bar"):
print("Is foo, bar")
case (let one, let two):
print("Is (one) and (two)")
print(" ¯_( )_/¯ ")
}

Strings
var myString = "this is a string"
if myString.isEmpty {
// do something
}
myString += "and this is a longer string"

Typing
var foo = 1 // foo is an Int
var bar: Int // bar is an uninit'd Int
var baz = Int()
if baz is Int {
print("Nice Int you got there")
}

Casts
var foo = 1 // foo is an Int
var bar = String(foo) // "1"
var maybeBaz = stringishThing as? String
// maybeBaz is an optionally typed String
var forceBaz = stringishThing as! String

Optional Types
// When a variable may not have a value
var bar: Int?
// test
if bar != nil {
// has a value
}

Optional Types
// unwrap the value to use
if bar != nil {
bar! += 2
}
// unwrapping nil --> runtime exception!

if-let
var bar: Int?
if let foo = bar {
// bar had a value & foo now does too
}
else {
// bar was nil
}

if-var
var bar: Int?
if var foo = bar {
// bar had a value & foo now does too
// foo is mutable
foo++
}
else {
// bar was nil
}

Tuples
let tuple = ("foo", 42)
let first = tuple.0 // "foo"
let labeledTuple = (one: "foo", two: 42)
let second = labeledTuple.two // 42

Arrays
let nums = [1, 2, 3]
var strs : [String]
// _can_ mix & match
let mixed = [1, "foo"]
// but you probably shouldn't

Dictionary
let orCityCounties = [
"Salem": "Marion",
"West Salem": "Polk",
]
// orCityCounties has type
// [String:String]

Dictionary
// again can mix & match
let orCityCounties = [
"Salem": "Marion",
"West Salem": 2,
]
// orCityCounties has type
// [String:NSObject]

Enumerations
enum SalemMeetups {
case HackSalem
case PortlandPerlMongers
}
var thisMeetup = SalemMeetups.HackSalem
// thisMeetup is type SalemMeetups

Sets
var petSet :Set = [ "cat", "dog",
"fish", "dog"]
petSet.count // returns 3

Functions
func obExample () {
print("Hello, Salem!")
}

Functions
func obExample (who :String) {
print("Hello, (who)!")
}

Functions
func obExample (who :String) -> String {
return "Hello, (who)!"
}

Functions
func obExample (who :String = "Salem")
-> String {
return "Hello, (who)!"
}
obExample("Oregon") // "Hello, Oregon!"
obExample() // "Hello, Salem!"

Functions
func obExample (what :String = "Hello",
who :String = "Salem")
-> String {
return "(what), (who)!"
}
obExample() // "Hello, Salem!"
obExample("bye") // "bye, Salem!"
obExample("bye",who:"felicia") // "bye, felicia"
obExample("bye", "salem") // COMPILE ERROR

Functions
func obExample (what :String = "Hello",
_ who :String = "Salem")
-> String {
return "(what), (who)!"
}
obExample("bye") // "bye, Salem!"
obExample("bye",who:"felicia") // COMPILE ERROR
obExample("bye", "salem") // "bye, salem!"

Functions
func variadiacExample (nums: Int...) {
// do something with nums
}

Functions are ﬁrst-class citizens

Closures
let numbers = [2,1,56,32,120,13]
var sorted = numbers.sort({
(n1: Int, n2: Int) -> Bool in return n2 > n1
})
// sorted = [1, 2, 13, 32, 56, 120]

Closures
let numbers = [2,1,56,32,120,13]
// inferred param & return types
var sorted = numbers.sort({n1, n2 in return n2 > n1})
// sorted = [1, 2, 13, 32, 56, 120]

Closures
let numbers = [2,1,56,32,120,13]
// positionally named parameters
var sorted = numbers.sort({return $0 > $1})
// sorted = [1, 2, 13, 32, 56, 120]

Closures
let numbers = [2,1,56,32,120,13]
// when closure is last param, parens optional
var sorted = numbers.sort { $0 > $1 }
// sorted = [1, 2, 13, 32, 56, 120]

OOP is
also
well
supported
I'm just
well out
of time…

https://developer.apple.com/swift

A Modest Introduction to Swift

Related slideshows

More Related Content

A Modest Introduction to Swift