Intro toswift1

Introduction to Swift
Apple’s Objective-C Replacement

Agenda
- Who am I?
- How Apple arrived at Swift
- What’s new in Swift
- Swift’s syntax & basics
- Resources
What we will cover

Who am I?
- iOS + .NET Developer
- Write on all things development
- Game Developer (Speciﬁcally, Unity)
- Founded Dreaming In Binary
- Developer at HealthMEDX
Jordan Morgan

Apple’s road to Swift
Created in 1983 by Brad Cox & Tom Love
Built right on top of C
Added Object Oriented ideas (classes, objects, etc)
Objective-C is created

2 years later, Jobs licenses it for NeXT (NeXTSTEP)
1996, Jobs is back at Apple and NeXT is acquired
Object Oriented libraries separated out from the OS as an API
called OpenStep
1997, Apples includes NeXT OS and APIs into new OS -
“Rhapsody”. This became Mac OS X.
This is where we get “NS” from - NeXT Step
Objective-C is engrained into Apple’s technology stack

Objective-C became the native language for iOS/OS X
Improved and iterated upon over the years
Works ﬁne - but starts to show its age
Objective-C peaks

- Objective-C is not easy to learn
- Syntax is unusual and unfamiliar
- C is mixed in and heavily used in Foundation
- C baggage (.h & .m ﬁles, for example)
- No generics (leads to tedious casts)
- Overloading not supported
Objective-C’s weaknesses

Keeps the best of Objective-C, such as named
parameters
Brings in modern programming language
advancements
Syntax is familiar - similar to PHP, Python, and
Rust
In comes Swift!

What’s new in Swift
Type inference
Cool new features
var aString:String = "String variable"
keyword name type initial value

var 😼 = "Catface"
Type Inference
var anotherString = "Another string variable"
Variables can be unicode characters
Omit the type - it’s inferred to be a String

String is lightweight like a C string
Powerful as an NSString
Concatenating is no longer a chore
Types
var twitterURL = "(kTwitterURL) + (twitterHandle)";
NSURL *twitterURL = [[NSURL alloc] initWithString:
[kTwitterURL stringByAppendingString:twitterHandle]];

var speakers = 20
var attendees = 300
var audience = "On average, there will be
(attendees / speakers) people at each session."
String Interpolation
Can even have expressions evaluated
No need for a mutable or immutable typed Strings

The let keyword deﬁnes a constant
Constants
let speakers = 20
let attendees = 300
let audience = "On average, there will be
(attendees / speakers) people at each session."
- Opt for immutability
- Forces you to think about your declarations
- Safer for multithreaded environments
- Optimization gains

- Variables always initialized before use
- But what about nil?
- Objective - C nil = Pointer to a non existent object
- Swift nil = Absence of a value of a certain type
- Optionals - more on that later
Variable Initialization

- Closures uniﬁed with function pointers
- Generics
- Tuples
- No more semicolons (though you can)
- and more
Other notable additions

If Statements
No parentheses required
Some basic and minor changes
Braces always required
if 1 < 2
{
println("True")
}
else
{
println("False")
}

Collections
They can work with any type - primitives included
Concise and powerful:
NSArray *numAr = @[[NSNumber numberWithInt:0]];
Array and Dictionary
let numAr = [1]
let names: [String] = ["Jordan", "Jansyn"]
Specify the type if you want:

Collections
Array
Literal declarations
Dictionary
let names = ["Jordan", "Jansyn", "Bennett"]
let namesAndAges = ["Jordan":25, "Jansyn":25,
"Bennett": 1]
No more “@“ in front of strings either

Collections
Easy to modify
Modify a collection with append(<T>):
var modify = [“Jordan”]
modify.appened(“Jansyn”)
//["Jordan","Jansyn"]
Specify index
var modify = ["Jordan"]
modify[0] = "Jansyn"
//["Jansyn"]
Use range operators
var modify = ["Jordan","Jansyn"]
modify[0...1] = ["Bennett","Whitney"]
//["Bennett","Whitney"]

Collections
Just deﬁne a new key
Modify a dictionary
var morganFam = ["Jordan":25]
morganFam["Jansyn"] = 25
Editing value works the same way
var morganFam = ["Jordan":25]
morganFam["Jansyn"] = 26

Collections
If you want a collection with more than one type :
Varied types
var multiTyped: [AnyObject] = ["foo", 01, true, 44.5]
That said, try to keep them strongly typed
For most intents and purposes, AnyObject is
analogous to id

Loops
for i in 0..<2
{
println(i)
}
//Output: 0,1
Ranges
Half open range Closed range
for i in 0...2
{
println(i)
}
//Output: 0,1,2

Loops
Easily loop through characters in a string
Flexible
let abc = "abc"
for char in abc
{
println(char)
}
In Objective-C :
NSString *myStrings = @"abc";
for (NSInteger charIdx=0; charIdx < myStrings.length; charIdx++)
{
NSLog(@"%C", [myStrings characterAtIndex:charIdx]);
}

Loops
Exclude value from the range (use _)
Loops cont.
let base = 3
let power = 10
var answer = 1
for _ in 1...power
{
answer *= base
}
Iterating over collections
let morganFam = ["Jordan":25,"Jansyn":25,"Bennett":1]
//KVPs from dictionary come back as tuples
for (name,age) in morganFam
{
println("(name) is (age) years old.")
}

Loops
Condition - increment looping
Traditional C-style iteration
for var idx = 0; idx < MAX; idx++
{
println("Index is (idx)")
}
No parentheses
Initialization with var and not let
While loops are here too

Switch Statements
No implicit fall through
Fallthrough
You can still “break” out before execution if ﬁnished
If you want to fallthrough, you can use fallthrough

Switch Statements
You can get cute with them
Switches cont.
let anInt = 40
switch anInt
{
case 0, 1, 2:
println("Tiny")
case 3...5:
println("Medium")
case 6..<39:
println("Large")
case _ where anInt % 2 == 1:
println("It's odd")
case _ where anInt % 2 == 0:
println("Nope, it's not odd, it's even")
default:
break
}

Switch Statements
The old days
Compared to Objective-C
NSString *morganFamMember = @"Jordan";
if ([morganFamMember isEqualToString:@"Jansyn"])
{
NSLog(@"It's mom!");
}
else if([morganFamMember isEqualToString:@"Bennett"])
{
NSLog(@"It's the baby boy!");
}
else if([morganFamMember isEqualToString:@"Whit"])
{
NSLog(@"It's Jordan's sister!");
}
else if([morganFamMember isEqualToString:@"Jordan"])
{
NSLog(@"It's dad!");
}
else
{
NSLog(@"We don't know who it is.");
}
The new days
let morganFamMember = "Jordan"
switch morganFamMember
{
case "Jansyn":
println("It's mom!”)
case "Bennett":
println("It's the baby boy!")
case "Whit":
println("It's Jordan's sister!")
case "Jordan":
println("It's dad!")
default:
println("We don't know who it is.")
}
Objective-C doesn’t support Switch with NSString

Optionals
We want the value - or to know it wasn’t found
A core concept of Swift
Optionals have ? by them
Means we get a value back - or nothing at all

Optionals
We could use magic numbers (i.e. -1)
Cont.
let jansynsAge:Int? = morganFam["Jansyn"]
NSNotFound if in Objective-C
Returns nil -or no value, or an int (Need to specify type)

Optionals
So if it’s there, how do we get it?
Unwrapping
let jansynsAge:Int? = morganFam["Jansyn"]
if jansynsAge == nil
{
println("Jansyn is apparently timeless.")
}
else
{
let foundAge = jansynsAge!
println("Jansyn is (foundAge) years old.")
}
Unwrap the value (i.e. the !)
No need to specify the type, the compiler knows

Optionals
This is a common pattern, shorthand is like so (no !):
Short syntax
if let foundAge = jansynsAge
{
println("Jansyn is (foundAge) years old.")
}
If you know the value is there, you can unwrap it directly:
var name: String? = "Jordan"
let anotherJordan = name!
println(anotherJordan)
You’re crashing if you’re wrong
If forced unwrapped, you don’t need to set it to a var.

Optional Chaining
What if you want a value that could be housed around
other nil values?
Query multiple optionals
class Residence
{
var street:String?
}
class Person
{
var humbleAbode:Residence?
}
var aPerson = Person()

Optional Chaining
Use ? operator to use optional chaining
Cont.
class Residence
{
var street:String?
}
class Person
{
var humbleAbode:Residence?
}
var aPerson = Person()
if let theStreet = aPerson.humbleAbode?.street
{
println("The street is (theStreet)")
}
else
{
println("Person has no street")
}
Remember, any optional must be unwrapped via !

Functions
Deﬁned with func keyword
Overview
func printName()
{
println("It's Jordan")
}
Named parameters, like Objective-C
func printName(name:String)
{
println("It's (name)”)
}

Functions
Denote return type with ->
Return types
func printNameWithGreeting(name:String) -> String
{
return "It's (name), how ya doin' today?"
}
Deﬁne default values
func printNameWithGreeting(name:String = "Jansyn") -> String
{
return "It's (name), how ya doin' today?"
}

Functions
Return tuples
Multiple return types
func nameAndAge() -> (String, Int)
{
return ("Jordan",25)
}
Decompose them to access values
let (name,age) = nameAndAge()
println("(name) is (age) years old.")

Functions
Give meaningful names to return values
Name multiple return values
func nameAndAge() -> (name:String, age:Int)
{
return ("Jordan",25)
}
let Jordan = nameAndAge()
println("(Jordan.name) is (Jordan.age) years old.")
//Jordan is 25 years old.

Closures
Much like blocks in Objective-C
Similar functionality
Contain some code, you can pass them around
Lambdas or anonymous functions
let aClosure =
{
println("This is a closure")
}
Compiler sees it like this:
let aClosure: () -> () =
{
}

Closures
Notice that’s similar to a function’s signature
Syntax
let aClosure: () -> () =
{
}
func aClosure: () -> () =
{
}
Functions are just named closures

Closures
Deﬁne in the formal parameter list
Passed as a parameter
func doTaskRepeated(count: Int, theTask: () -> ())
{
for i in 0..<count
{
theTask()
}
}
Calling it
doTaskRepeated(10, {
println("A complex and awesome task.")
})

Closures
Deﬁne closure as the last parameter in formal parameter
list
Trailing closure
doTaskRepeated(10) {
println("A complex and awesome task.")
}
Looks like control ﬂow statement

Classes
No more import because Swift has no implementation ﬁle
Much like Java and .NET
No need to explicitly deﬁne a base class
class Person
{
}

Classes
class Jordan
{
let name = "Jordan"
}
Properties
Swift provides the backing store for you
By default, all entities have internal access
class Jordan
{
let name = "Jordan"
private let movieMostWatchedPastMonth = "Frozen"
}

Classes
Use internal, or nothing at all
Exposing properties
class Jordan
{
let name = "Jordan"
internal var age = 25
private let movieMostWatchedPastMonth = "Frozen"
}
let aJordan = Jordan()
//Grew up quick during this talk
aJordan.age = 35
Notice you don’t need “new” in front of the type

Classes
You can deﬁne custom getters and setters
Computed properties
class Jordan
{
let name = "Jordan"
var myLocation:(x:Float,y:Float)
{
get
{
return (10,30)
}
set
{
self.myLocation.x = newValue.x
self.myLocation.y = newValue.y
}
}
}
…can even use tuples
Create a read only computed property - just omit setter

Classes
init() keyword
Initialization
class Jordan
{
let name = "Jordan"
var age = 25
init()
{
//No need to return self
}
}
Can also initialize constant values
class Jordan
{
let name = "Jordan"
let hobby = ""
init()
{
//No need to return self
}
init(hobby:String)
{
self.hobby = hobby
}
}
var aJordan = Jordan(hobby: "Basketball")
- if you are inheriting, call super.init()

Classes
Fires just before and right after value changes
Property Observers
class Bennett
{
private let setCurfew = 9 //p.m.
var curfew : Int
{
willSet
{
if curfew > setCurfew
{
println("GROUNDED")
}
}
didSet
{
if curfew < setCurfew
{
println("I am glad you obey.")
}
}
}
init()
{
self.curfew = setCurfew
}
}

Classes
Work the same way as functions
Methods
Only need to use self when property has the same
name as a parameter in the function’s signature
class Bennett
{
var nickName = "Benny"
func changeNickName(nickName: String)
{
self.nickName = nickName
println("Bennett's new nickname is (self.nickName)")
}
}

Classes
You don’t even need to specify one
A note on initializers
super.init needs to happen last in custom initializers
Sole purpose is to initialize values for the class

Structs
Still works the same way
Not much has changed
- Doesn’t support inheritance
- Value types
Think of them as you do in your OOP language of choice

Enumerations
Value types
Enums
They can have raw values (like in C)
enum BestNFLTeams:Int
{
case StLouisRams = 1, Patriots, Bucs, Chiefs
}
BestNFLTeams.StLouisRams.toRaw()
//Prints 1, obviously

Enumerations
Don’t always need underlying values
enum Directions
{
case North, South, East, West
}
//Compiler infers Directions as type
var directionToGo = Directions.North
Also, compiler will again infer the type
let lbl = UILabel()
lbl.textAlignment = .Right
Value type constants have all constant members
Reference type constants can have mutable members

Enumerations
Associate values within an enum
Associated Values
enum RamsVictory
{
case ByOnePoint
case ByPoints(Int)
}
var ramsWinBig = RamsVictory.ByPoints(24)
Even custom properties
enum RamsVictory
{
case ByOnePoint, ByPoints(Int)
var winSummary:String{
switch self{
case .ByOnePoint:
return "Rams by one."
case .ByPoints(let points):
return "Rams win big by (points)!"
}
}
}
var ramsWinBig = RamsVictory.ByOnePoint
println(ramsWinBig.winSummary) //Rams by one.
ramsWinBig = RamsVictory.ByPoints(14)
println(ramsWinBig.winSummary) //Rams win big by 14!

Access Modifiers
Three modifiers
Recently Added
- Private - Available only from within source file
- Internal - Available to entire module that includes
the definition (i.e. app or framework)
- Public - Intended for use with APIs, means entity
can be accessed by any file that imports the
module

There’s much more
Interoperability with Objective-C
Lots of new features
Extensions
Automatic Reference Counting
Pattern Matching
Functional Programming

Resources
- www.dreaminginbinary.co
- The Swift Programming Language (iBook)
- The Swift Blog
- WWDC Videos
- @dibsoftware
- @jordanmorgan10
- facebook/dreaminginbinary

Intro toswift1

More Related Content

What's hot

Viewers also liked

Similar to Intro toswift1

Intro toswift1