Introduction to Swift programming language.

Introduction to Swift
@RoelCastano
June 23, 2014

Swift vs Objective-C
#include <stdio.h>
int main() 
{ 
printf(“hello, worldn”); 
return 0; 
}
println(“hello, world”)

Variables
let dogName: String = “Cinnamon”
!
var age: Double = 8.5
!
var inferredType = “String”
!
let 🐝 = “Bee”
for character in “string” {
println(character)
}
// s
// t
// r
// i
// n
// g
!
———————————————-
!
let a = 3, b = 5
let stringResult = “(a) times (b) is (a * b)”

more strings
var variableSting = “Apple”
variableString += “ and Pixar”
// variableString is now “Apple and Pixar”
!
let constantString = “Apple”
constantString += “ and Microsoft”
// constant can’t be changed
!
//casting 
let label = "The width is " 
let width = 94_000_00 
let widthLabel: String = label + String(width)
!

Optionals and TypeAlias
//Optionals
!
var dogAge = "123".toInt()
if dogAge { //is either nil or Int
dogAge! //now it is an Int
}
!
var someValue: String?
someValue = "Fido"
!
someValue = nil
//typealias
!
typealias 👬 = Double
var size: 👬 = 12.2
!
typealias Point = (Int, Int)
let origin: Point = (0, 0)

Tuples
//unnamed tuples
var luckyNumbers: = (3, 8, 21)
luckyNumbers.2
//21
!
//named tuples
var myDog:(Int, Int, Bool) = (age: 8, isAFemale: true)
var (age,_) = myDog
age
//6
!
!

Arrays
/*
Notes:
These arrays can only be of one types, not like
NSArray or NSDictionary, which can have any object.
*/
!
//array (String[] optional)
let emptyArray = String[]()
!
var shoppingList: String[] = ["catfish", "water", "tulips", "blue paint"] //prefered
var numberList: Array<Int> = [1,2,3,4,5]
var numberList2 = [11,22,33,44,55] //preferred
!
shoppingList.append("milk")
!
for (index, object) in enumerate(shoppingList){
println("The object #(index) is a (object)")
}
!
var possibleNames = Array(count: 10, repeatedValue: "BRO")

Dictionaries
//dictionary
let emptyDictionary = Dictionary<String, Float>()
!
var occupations = [
"Malcolm": "Captain",
"Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"
occupations.updateValue("Chief", forKey:"Malcolm")
occupations.removeValueForKey("Kaylee")
occupations
!
var employees = Array(occupations.keys)
!
for (name, occupation) in occupations
{
println("Name: (name) n Occupation: (occupation)")
}
!

If-Else and Switch
// If-Else
!
var optionalString: String? =
"Hello"
optionalString == nil
!
var optionalName: String? = nil
var greeting = "Hello!"
if let name = optionalName {
greeting = "Hello, (name)"
} else {
let name = String("Some Name")
}
// Switch
!
let vegetable = "red pepper"
switch vegetable {
!
case “celery":
let vegetableComment = "Add some
raisins and make ants on a log.”
!
case "cucumber", "watercress":
let vegetableComment = "That would
make a good tea sandwich.”
!
case let x where x.hasSuffix("pepper"):
let vegetableComment = "Is it a
spicy (x)?”
!
default:
let vegetableComment = "Everything
tastes good in soup.”
}

For Loop
let interestingNumbers = [
"Prime": [2, 3, 5, 7, 11, 13],
"Fibonacci": [1, 1, 2, 3, 5,
8],
"Square": [1, 4, 9, 16, 25],
]
var largest = 0
var largestKind:String? = nil
for (kind, numbers) in
interestingNumbers {
for number in numbers {
if number > largest {
largest = number
largestKind = kind
}
}
}
largest //25
largestKind //square
var firstForLoop = 0
for i in 0..3 {
firstForLoop += i
}
firstForLoop // 3
!
————————————————————————————————
!
var firstForLoop = 0
for i in 0...3 {
secondForLoop += i
}
secondForLoop // 6

Functions
func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
var vowels = 0, consonants = 0, others = 0
for character in string {
switch String(character).lowercaseString {
case "a", "e", "i", "o", "u":
++vowels
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
"n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
++consonants
default:
++others
}
}
return (vowels, consonants, others)
}
!
let total = count("some arbitrary string!")
let finalString = "(total.vowels) vowels and (total.consonants)
consonants"
// prints "6 vowels and 13 consonants"

Functions and Generics
func swapTwoInts(inout a: Int, inout b: Int) {
let temporaryA = a
a = b
b = temporaryA
}
!
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
let newInts = "someInt is now (someInt), and anotherInt is now
(anotherInt)"
// prints "someInt is now 107, and anotherInt is now 3"

Generics
!
func swapTwoValues<T>(inout a: T, inout b: T) {
let temporaryA = a
a = b
b = temporaryA
}
!
var designer = "Lentes"
var programmer = "Alice"
swapTwoValues(&designer, &programmer)
let newTeam = "designer is now (designer), and programmer is
now (programmer)"
// prints "designer is now Alice, and programmer is now Lentes"

Structures vs Classes
Consider Structure when:
Encapsulate simple data values
Values would be copied rather
than referenced.
Any properties stored by the
structure are themselves value
types.
Ex. Geometric Shapes,
Coordinates, Person.
Consider Classes when:
Inheritance should be used.
Need more than one
reference to the same
instance
Check or Interpret the type
of a class at runtime
Ex. Real life complex objects.

Classes
class Vehicle {
var numberOfWheels: Int
var maxPassengers: Int
func description() -> String {
return "(numberOfWheels) wheels; up to (maxPassengers) passengers"
}
init() {
numberOfWheels = 0
maxPassengers = 1
}
}
class Bicycle: Vehicle {
init() {
super.init()
numberOfWheels = 2
}
}
class Tandem: Bicycle {
init() {
super.init()
maxPassengers = 2
}
}
let tandem = Tandem()
println("Tandem:
(tandem.description())”)
// Tandem: 2 wheels; up to 2
passengers

Method Overriding
class Car: Vehicle {
var speed: Double = 0.0
init() {
super.init()
maxPassengers = 5
numberOfWheels = 4
}
override func description() -> String {
return super.description() + "; "
+ "traveling at (speed) mph"
}
}
let car = Car()
println("Car: (car.description())")
// Car: 4 wheels; up to 5 passengers; traveling at 0.0 mph

Property Overriding
class SpeedLimitedCar: Car {
override var speed: Double {
get {
return super.speed
}
set {
super.speed = min(newValue, 40.0)
}
}
}
!
let limitedCar = SpeedLimitedCar()
limitedCar.speed = 60.0
println("SpeedLimitedCar: (limitedCar.description())")
// SpeedLimitedCar: 4 wheels; up to 5 passengers; traveling at 40.0 mph

Structs
struct Color {
let red = 0.0, green = 0.0, blue = 0.0
init(red: Double, green: Double, blue: Double) {
self.red = red
self.green = green
self.blue = blue
}
}
!
!
let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)
!

Protocols
protocol FullyNamed {
var fullName: String { get }
}
!
struct Person: FullyNamed {
var fullName: String
}
!
let john = Person(fullName: "John Appleseed")
// john.fullName is "John Appleseed"
!

more protocols
!
!
protocol RandomNumberGenerator {
func random() -> Double
}
!
class Dice {
let sides: Int
let generator: RandomNumberGenerator
init(sides: Int, generator: RandomNumberGenerator) {
self.sides = sides
self.generator = generator
}
func roll() -> Int {
return Int(generator.random() * Double(sides)) + 1
}
}
!
protocol TextRepresentable {
func asText() -> String
}
!
extension Dice: TextRepresentable {
func asText() -> String {
return "A (sides)-sided dice"
}
}

Facts
First app built on Swift was the WWDC App.
You can use Swift, C, and Objective-C in parallel.
The book “The Swift Programming Language” was
downloaded 370,000 times on one day.

References
Swift Tutorial Part 3: Tuples, Protocols, Delegates, and
Table Views. http://www.raywenderlich.com/75289/swift-
tutorial-part-3-tuples-protocols-delegates-table-views
An Introduction To Object-Oriented Programming in Swift.
http://blog.codeclimate.com/blog/2014/06/19/oo-swift/
A Few Interesting Things In Swift http://
www.slideshare.net/SmartLogic/a-few-interesting-
things-in-swift

Introduction to Swift programming language.

More Related Content

What's hot(20)

Similar to Introduction to Swift programming language.(20)

More from Icalia Labs(16)

Recently uploaded(20)

Introduction to Swift programming language.