Swift - Modern & Expressive, or Magical Unicorn?

Modern & Expressive or Magical Unicorn?
Mike Jones - @FlashGen
Swift…

@flashgen | #reasonsto
A point of reference, of
sorts…

var myNamevar = “Mike Jones”:String ;

var myName = “Mike Jones”

var myName:String = “Mike Jones”;

let myName = “Mike Jones”

Loops
for var i = 0; i < 10; i++
{
println(i)
}

Loops
for i in 0..<10
{
println(i)
}

Loops
var myArray = [1,2,3,4,5]
for item in myArray
{
println(item)
}

Loops
var i = 1
while i < 10
{
println(i)
i++
}

Loops
var i = 10
do
{
println(i)
i++
}
while i < 10

Conditionals

If…else
var num = 10
if num < 20
{
println(“less than 20")
}
else
{
println("not less than 20")
}

Switch…Case
var value = 10
switch value
{
case 10:
println("Yay! just right")
case 20:
println("a bit too high")
default:
println("Nothing to see here")
}

Switch…Case
var value = 6
switch value
{
case 1...9:
println("Too low")
case 10:
println("Yay! just right")
case 20:
println("a bit too high")
default:
println("Nothing to see here")
}

Optionals…

Optionals
var optionalInteger: Int?
var optionalInteger: Optional<Int>

Optionals
var impUnwrappedString:String!
var impUnwrappedString:ImplicitlyUnwrappedOptional<String>

Optionals
var myString = “hello”
var myInt = myString.toInt()

Optionals
var myString = “hello”
// myInt = nil

Optionals
var myString = “3”

Optionals
// myInt = 3

Optionals
var myInt:Int = myString.toInt()

Optionals
var myInt:Int = myString.toInt()
// Object of type Optional is not unwrapped

Optionals
var myInt:Int = myString.toInt()!

Optionals
var myInt:Int = myString.toInt()!
// myInt = 3

Optionals
var myString = "hello"
var myInt:Int = myString.toInt()!.advancedBy(5)

Optionals
var myString = "hello"
var myInt:Int = myString.toInt()!.advancedBy(5)
// This fails

Optionals
var myString = "5"
var myOtherInt:Int = 0;
if let myInt = myString.toInt()?.advancedBy(5)
{
myOtherInt = myInt;
}
else
{
println("It's nil")
}

Functions & Closures

Functions
func myFunc(valA:Int, valB:Int) -> Int
{
return valA + valB
}
var myInt = myFunc(4, 4);

Functions
func myFunc(#valA:Int, #valB:Int) -> Int
{
return valA + valB
}
var myInt = myFunc(valA:4, valB:4);

Functions
func myFunc(myAge valA:Int, yourAge valB:Int) -> Int
{
return valA + valB
}
var ourAgesCombined = myFunc(myAge:4, yourAge:4);

Tuples
func sayHello(greeting:String, name:String) -> (String, String)
{
return (greeting + " " + name, “Pleased to meet you :)”)
}
var mygreeting = sayHello("Hello", "Reasons");
mygreeting.0; // Hello Reasons
mygreeting.1; // Pleased to meet you :)

Tuples
func sayHello(greeting:String, name:String) ->
(fullGreeting:String, response:String)
{
return (greeting + " " + name, “Pleased to meet you :)”)
}
var mygreeting = sayHello("Hello", "Reasons");
mygreeting.fullGreeting; // Hello Reasons
mygreeting.response; // Pleased to meet you :)

Tuples
{
return (greeting + " " + name, "Pleased to meet you :)")
}
let (fullGreeting, response) = sayHello("Hello", "Reasons");
fullGreeting; // Hello Reasons
response; // Pleased to meet you :)

Tuples
{
return (greeting + " " + name, "Pleased to meet you :)")
}
let (fullGreeting, _) = sayHello("Hello", "Reasons");
fullGreeting; // Hello Reasons

Variadic Functions
func addNumbers(numbers:Int...) -> Int
{
var total = 0;
for num in numbers
{
total += num
}
return total;
}
addNumbers(1,2,3,4,5) // 15
addNumbers(1,2,3) // 6

Function Types
func myFunc(valA:Int, valB:Int) -> Int
{
return valA + valB
}
var myIntFunc :(Int, Int) -> Int = myFunc
myIntFunc(4,4)

Closures
var namesArray = ["Mike", "Jason", "Dennis", "Darren", "John"];
func sortAlphabetically (s1:String, s2:String) -> Bool
{
return s1 < s2;
}
let myFriends = sorted(namesArray, sortAlphabetically)

Closures
var namesArray = ["Mike", "Darren", "Dennis", "Jason", "Macca"];
let myFriends = sorted(namesArray,
{ (s1:String, s2:String) -> Bool in
return s1 < s2;
})

in…out
var month = 9
var year = 2015
func swapTwoInts(inout a: Int, inout b: Int)
{
let tempA = a
a = b
b = tempA
}
swapTwoInts(&month, &year)
// month = 2015, year = 9

Structs, Classes,
Protocols & Extensions

Structs

Structs
struct Person
{
var firstName: String = "Mike";
var lastName: String = "Jones";
}
let myPerson = Person()

Classes
class Person
{
var firstName: String;
var lastName: String;
init(fName:String, lName:String)
{
firstName = fName;
lastName = lName;
}
}
let myPerson = Person(fName:"Mike", lName:"Jones")

Classes
class Person
{
init(fName:String="John", lName:String="Smith")
{
firstName = fName;
lastName = lName;
}
}
let myPerson = Person(fName:"Mike", lName:”Jones”)
// fName = "Mike", lName = "Jones"
let myDefaultPerson = Person()
// fName = "John", lName = "Smith"

Classes
class Person
{
{
firstName = fName;
lastName = lName;
}
convenience init()
{
self.init(fName: "John", lName: "Smith");
}
}
let myPerson = Person() // fName = "John", lName = "Smith"

Classes
class Person
{
{
firstName = fName;
lastName = lName;
}
deinit
{
// Clean up here
}
}

Classes
class Person
{
var fullName:String
{
get
{
return self.firstName + " " + self.lastName
}
}
// …
}

Inheritance
class Employee: Person
{
var jobDescription :String = "I'm a developer";
func whatAreYouDoing() -> String
{
return "I'm working."
}
}

Inheritance
public class Manager: Employee
{
override var jobDescription :String
{
get
{
return super.jobDescription
}
set(value)
{
super.jobDescription = value;
}
}
override func whatAreYouDoing() -> String
{
return "Very little - I'm the boss!"
}
}

Protocols

Protocols
protocol UnicornsProt
{
var unicornHerd:Int? { get set }
func howManyUnicornsDoYouOwn() -> Int?
}

Protocols
class Person: UnicornsProt
{
var unicornHerd: Int?;
func howManyUnicornsDoYouOwn() -> Int?
{
return unicornHerd;
}
}

Extensions

Extensions
extension Person
{
public var unicorns:String { return "UNICORNS!" }
public func moreUnicorns() -> String
{
return “MORE " + unicorns;
}
}

Generics…

Generics
var myArray :Array<String>
var myDict :Dictionary<String, Person>
var myOptionalInt :Optional<Int>

Generics
func swapTwoInts(inout a: Int, inout b: Int)
{
let tempA = a
a = b
b = tempA
}
func swapTwoStrings(inout a: String, inout b: String)
{
let tempA = a
a = b
b = tempA
}
func swapTwoDoubles(inout a: Double, inout b: Double)
{
let tempA = a
a = b
b = tempA
}

Generics
var month = 9
var year = 2015
var greeting = "Hello Reasons"
var response = "Pleased to meet you :)"
func swapTwoValues<T>(inout a: T, inout b: T)
{
let tempA = a
a = b
b = tempA
}
swapTwoValues(&month, &year)
// month = 2015, year = 9
swapTwoValues(&greeting, &response)
// greeting = "Pleased to meet you :)
// response = "Hello Reasons

one more thing…

Swift 2.0

Open Source

Apple Developer Program
http://developer.apple.com

Thank You

Mike Jones
pixadecimal.com
blog.flashgen.com
@FlashGen

Swift - Modern & Expressive, or Magical Unicorn?

Swift - Modern & Expressive, or Magical Unicorn?

Recommended

More Related Content

What's hot

What's hot(20)

Viewers also liked

Viewers also liked(11)

Similar to Swift - Modern & Expressive, or Magical Unicorn?

Similar to Swift - Modern & Expressive, or Magical Unicorn?(20)

Recently uploaded

Recently uploaded(20)

Swift - Modern & Expressive, or Magical Unicorn?

Editor's Notes