Swift is a programming language for iOS and OS X development created by Apple. Designed to coexist with Objective-C and to be more resilient against erroneous code, Swift was introduced in 2014 at Apple's developer conference WWDC. It is built with the LLVM compiler included in Xcode 6 beta.
Here you can learn Apple Swift in 10 minutes.
//
// MARK: Basics
//
// Xcode supports landmarks to annotate your code and lists them in the jump bar
// MARK: Section mark
// TODO: Do something soon
// FIXME Fix this code
println("Hello, world")
var myVariable = 42
let øπΩ = "value" // unicode variable names
let myConstant = 3.1415926
let convenience = "keyword" // contextual variable name
let weak = "keyword"; let override = "another keyword" // statements can be separated by a semi-colon
let `class` = "keyword" // backticks allow keywords to be used as variable names
let explicitDouble: Double = 70
let intValue = 0007 // 7
let largeIntValue = 77_000 // 77000
let label = "some text " + String(myVariable) // Casting
let piText = "Pi = \(myConstant), Pi 2 = \(myConstant * 2)" // String interpolation
var optionalString: String? = "optional" // Can be nil
optionalString = nil
/*
Comment here
/*
Nested comments are also supported
*/
*/
//
// MARK: Collections
//
// Array
var shoppingList = ["catfish", "water", "lemons"]
shoppingList[1] = "bottle of water"
let emptyArray = [String]()
// Dictionary
var occupations = [
"Malcolm": "Captain",
"kaylee": "Mechanic"
]
occupations["Jayne"] = "Public Relations"
let emptyDictionary = [String: Float]()
//
// MARK: Control Flow
//
// for loop (array)
let myArray = [1, 1, 2, 3, 5]
for value in myArray {
if value == 1 {
println("One!")
} else {
println("Not one!")
}
}
// for loop (dictionary)
var dict = ["one": 1, "two": 2]
for (key, value) in dict {
println("\(key): \(value)")
}
// for loop (range)
for i in -1...1 { // [-1, 0, 1]
println(i)
}
// use ..< to exclude the last number
// while loop
var i = 1
while i < 1000 {
i *= 2
}
// do-while loop
do {
println("hello")
} while 1 == 2
// 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: // required (in order to cover all possible input)
let vegetableComment = "Everything tastes good in soup."
}
//
// MARK: Functions
//
// Functions are a first-class type, meaning they can be nested
// in functions and can be passed around
// Function with Swift header docs (format as reStructedText)
/**
A greet operation
- A bullet in docs
- Another bullet in the docs
:param: name A name
:param: day A day
:returns: A string containing the name and day value.
*/
func greet(name: String, day: String) -> String {
return "Hello \(name), today is \(day)."
}
greet("Bob", "Tuesday")
// Function that returns multiple items in a tuple
func getGasPrices() -> (Double, Double, Double) {
return (3.59, 3.69, 3.79)
}
// Variadic Args
func setup(numbers: Int...) {}
// Passing and returning functions
func makeIncrementer() -> (Int -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)
//
// MARK: Closures
//
var numbers = [1, 2, 6]
// Functions are special case closures ({})
// Closure example.
// `->` separates the arguments and return type
// `in` separates the closure header from the closure body
numbers.map({
(number: Int) -> Int in
let result = 3 * number
return result
})
// When the type is known, like above, we can do this
numbers = numbers.map({ number in 3 * number })
// Or even this
//numbers = numbers.map({ $0 * 3 })
print(numbers) // [3, 6, 18]
// Trailing closure
numbers = sorted(numbers) { $0 > $1 }
print(numbers) // [18, 6, 3]
// Super shorthand, since the < operator infers the types
numbers = sorted(numbers, < )
print(numbers) // [3, 6, 18]
//
// MARK: Structures
//
// Structures and classes have very similar capabilites
struct NamesTable {
let names: [String]
// Custom subscript
subscript(index: Int) -> String {
return names[index]
}
}
// Structures have an auto-generated (implicit) designated initializer
let namesTable = NamesTable(names: ["Me", "Them"])
//let name = namesTable[2]
//println("Name is \(name)") // Name is Them
//
// MARK: Classes
//
// Classes, structures and its members have three levels of access control
// They are: internal (default), public, private
public class Shape {
public func getArea() -> Int {
return 0;
}
}
// All methods and properties of a class are public.
// If you just need to store data in a
// structured object, you should use a `struct`
internal class Rect: Shape {
var sideLength: Int = 1
// Custom getter and setter property
private var perimeter: Int {
get {
return 4 * sideLength
}
set {
// `newValue` is an implicit variable available to setters
sideLength = newValue / 4
}
}
// Lazily load a property
// subShape remains nil (uninitialized) until getter called
lazy var subShape = Rect(sideLength: 4)
// If you don't need a custom getter and setter,
// but still want to run code before and after getting or setting
// a property, you can use `willSet` and `didSet`
var identifier: String = "defaultID" {
// the `willSet` arg will be the variable name for the new value
willSet(someIdentifier) {
print(someIdentifier)
}
}
init(sideLength: Int) {
super.init()
self.sideLength = sideLength
}
func shrink() {
if sideLength > 0 {
--sideLength
}
}
override func getArea() -> Int {
return sideLength * sideLength
}
}
// A simple class `Square` extends `Rect`
class Square: Rect {
convenience init() {
self.init(sideLength: 5)
}
}
var mySquare = Square()
print(mySquare.getArea()) // 25
mySquare.shrink()
print(mySquare.sideLength) // 4
// compare instances, not the same as == which compares objects (equal to)
if mySquare === mySquare {
println("Yep, it's mySquare")
}
//
// MARK: Enums
//
// Enums can optionally be of a specific type or on their own.
// They can contain methods like classes.
enum Suit {
case Spades, Hearts, Diamonds, Clubs
func getIcon() -> String {
switch self {
case .Spades: return "♤"
case .Hearts: return "♡"
case .Diamonds: return "♢"
case .Clubs: return "♧"
}
}
}
//
// MARK: Protocols
//
// `protocol`s can require that conforming types have specific
// instance properties, instance methods, type methods,
// operators, and subscripts.
protocol ShapeGenerator {
var enabled: Bool { get set }
func buildShape() -> Shape
}
/*
// Protocols declared with @objc allow optional functions,
// which allow you to check for conformance
@objc protocol TransformShape {
optional func reshaped()
optional func canReshape() -> Bool
}
class MyShape: Rect {
var delegate: TransformShape?
func grow() {
sideLength += 2
if let allow = self.delegate?.canReshape?() {
// test for delegate then for method
self.delegate?.reshaped?()
}
}
}
*/
//
// MARK: Other
//
// `extension`s: Add extra functionality to an already existing type
// Square now "conforms" to the `Printable` protocol
extension Square: Printable {
var description: String {
return "Area: \(self.getArea()) - ID: \(self.identifier)"
}
}
println("Square: \(mySquare)")
// You can also extend built-in types
extension Int {
var customProperty: String {
return "This is \(self)"
}
func multiplyBy(num: Int) -> Int {
return num * self
}
}
println(7.customProperty) // "This is 7"
println(14.multiplyBy(2)) // 42
// Generics: Similar to Java. Use the `where` keyword to specify the
// requirements of the generics.
func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
for (index, value) in enumerate(array) {
if value == valueToFind {
return index
}
}
return nil
}
let foundAtIndex = findIndex([1, 2, 3, 4], 3)
println(foundAtIndex == 2) // true
// Operators:
// Custom operators can start with the characters:
// / = - + * % < > ! & | ^ . ~
// or
// Unicode math, symbol, arrow, dingbat, and line/box drawing characters.
prefix operator !!! {}
// A prefix operator that triples the side length when used
prefix func !!! (inout shape: Square) -> Square {
shape.sideLength *= 3
return shape
}
// current value
println(mySquare.sideLength) // 4
// change side length using custom !!! operator, increases size by 3
!!!mySquare
println(mySquare.sideLength) // 12
Swift Advance
Basics
println("Hello, world")
var myVariable = 42 // variable (can't be nil)
let π = 3.1415926 // constant
let (x, y) = (10, 20) // x = 10, y = 20
let explicitDouble: Double = 1_000.000_1 // 1,000.0001
let label = "some text " + String(myVariable) // Casting
let piText = "Pi = \(π)" // String interpolation
var optionalString: String? = "optional" // Can be nil
optionalString = nil
/* Did you know /* you can nest multiline comments */ ? */
Arrays
// Array
var shoppingList = ["catfish", "water", "lemons"]
shoppingList[1] = "bottle of water" // update
shoppingList.count // size of array (3)
shoppingList.append("eggs")
shoppingList += "Milk"
// Array slicing
var fibList = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 5]
fibList[4..6] // [3, 5]. Note: the end range value is exclusive
fibList[0..fibList.endIndex] // all except last item
// Subscripting returns the Slice type, instead of the Array type.
// You may need to cast it to Array in order to satisfy the type checker
Array(fibList[0..4])
// Variants of creating an array. All three are equivalent.
var emptyArray1 = String[]()
var emptyArray2: String[] = []
var emptyArray3: String[] = String[]()
Dictionaries
// Dictionary
var occupations = [
"Malcolm": "Captain",
"kaylee": "Mechanic"
]
occupations["Jayne"] = "Public Relations"
var emptyDictionary = Dictionary<String, Float>()
Control Flow
// for loop (array)
let myArray = [1, 1, 2, 3, 5]
for value in myArray {
if value == 1 {
println("One!")
} else {
println("Not one!")
}
}
// for loop (dictionary)
var dict = [
"name": "Steve Jobs",
"title": "CEO",
"company": "Apple"
]
for (key, value) in dict {
println("\(key): \(value)")
}
// for loop (range)
for i in -1...1 { // [-1, 0, 1]
println(i)
}
// use .. to exclude the last number
// for loop (ignoring the current value of the range on each iteration of the loop)
for _ in 1...3 {
// Do something three times.
}
// while loop
var i = 1
while i < 1000 {
i *= 2
}
// do-while loop
do {
println("hello")
} while 1 == 2
// 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: // required (in order to cover all possible input)
let vegetableComment = "Everything tastes good in soup."
}
// Switch to validate plist content
let city:Dictionary<String, AnyObject> = [
"name" : "Qingdao",
"population" : 2_721_000,
"abbr" : "QD"
]
switch (city["name"], city["population"], city["abbr"]) {
case (.Some(let cityName as NSString),
.Some(let pop as NSNumber),
.Some(let abbr as NSString))
where abbr.length == 2:
println("City Name: \(cityName) | Abbr.:\(abbr) Population: \(pop)")
default:
println("Not a valid city")
}
Functions
Functions are a first-class type, meaning they can be nested in functions and can be passed around
// Function that returns a String
func greet(name: String, day: String) -> String {
return "Hello \(name), today is \(day)."
}
greet("Bob", "Tuesday") // call the greet function
// Function that returns multiple items in a tuple
func getGasPrices() -> (Double, Double, Double) {
return (3.59, 3.69, 3.79)
}
// Function that takes variable number of arguments, collecting them into an array
func setup(numbers: Int...) {
// do something
}
setup(5, 16, 38) // call the setup function with array of inputs
// Nested functions can organize code that is long or complex
func printWelcomeMessage() -> String {
var y = "Hello,"
func add() {
y += " world"
}
add()
return y
}
printWelcomeMessage() // Hello world
// Passing and returning functions
func makeIncrementer() -> (Int -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)
Closures
Functions are special case closures ({})
// Closure example.
// `->` separates the arguments and return type
// `in` separates the closure header from the closure body
var numbers = [1, 2, 3, 4, 5]
numbers.map({
(number: Int) -> Int in
let result = 3 * number
return result
})
// When the type is known, like above, we can do this
numbers = [1, 2, 6]
numbers = numbers.map({ number in 3 * number })
println(numbers) // [3, 6, 18]
// When a closure is the last argument, you can place it after the )
// When a closure is the only argument, you can omit the () entirely
// You can also refer to closure arguments by position ($0, $1, ...) rather than name
numbers = [2, 5, 1]
numbers.map { 3 * $0 } // [6, 15, 3]
Classes
All methods and properties of a class are public. If you just need to store data in a structured object, you should use a struct
```js // A parent class of Square class Shape { init() { }
func getArea() -> Int {
return 0;
}
}
// A simple class Square extends Shape class Square: Shape { var sideLength: Int
// Custom getter and setter property
var perimeter: Int {
get {
return 4 * sideLength
}
set {
sideLength = newValue / 4
}
}
init(sideLength: Int) {
self.sideLength = sideLength
super.init()
}
func shrink() {
if sideLength > 0 {
--sideLength
}
}
override func getArea() -> Int {
return sideLength * sideLength
}
} var mySquare = Square(sideLength: 5) print(mySquare.getArea()) // 25 mySquare.shrink() print(mySquare.sideLength) // 4
// Access the Square class object, // equivalent to [Square class] in Objective-C. Square.self
//example for 'willSet' and 'didSet' class StepCounter { var totalSteps: Int = 0 { willSet(newTotalSteps) { println("About to set totalSteps to (newTotalSteps)") } didSet { if totalSteps > oldValue { println("Added (totalSteps - oldValue) steps to 'totalSteps'") } } } } var stepCounter = StepCounter() stepCounter.totalSteps = 100 // About to set totalSteps to 100 \n Added 100 steps to 'totalSteps' stepCounter.totalSteps = 145 // About to set totalSteps to 145 \n Added 45 steps to 'totalSteps'
// If you don't need a custom getter and setter, but still want to run code // before an after getting or setting a property, you can use willSet and didSet
Enums
Enums can optionally be of a specific type or on their own. They can contain methods like classes.
enum Suit {
case Spades, Hearts, Diamonds, Clubs
func getIcon() -> String {
switch self {
case .Spades: return "♤"
case .Hearts: return "♡"
case .Diamonds: return "♢"
case .Clubs: return "♧"
}
}
}
Protocols
A protocol defines a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality.
protocol SomeProtocol {
// protocol definition goes here
}
Extensions
Add extra functionality to an already created type
// adds the methods first and rest to the array type
extension Array {
func first () -> Any? {
return self[0]
}
func rest () -> Array {
if self.count >= 1 {
return Array(self[1..self.endIndex])
} else {
return []
}
}
}
Operator Overloading
You can overwrite existing operators or define new operators for existing or custom types.
// Overwrite existing types
@infix func + (a: Int, b: Int) -> Int {
return a - b
}
var x = 5 + 4 // x is 1
You can't overwrite the = operator
Add operators for new types
struct Vector2D {
var x = 0.0, y = 0.0
}
@infix func + (left: Vector2D, right: Vector2D) -> Vector2D {
return Vector2D(x: left.x + right.x, y: left.y + right.y)
}
Operators can be prefix, infix, or postfix.
You have to add @assignment if you wish to define compound assignment operators like +=, ++ or -=
@assignment func += (inout left: Vector2D, right: Vector2D) {
left = left + right
}
Operator overloading is limited to the following symbols: / = - + * % < > ! & | ^ . ~
Generics
Generic code enables you to write flexible, reusable functions and types that can work with any type.
// Generic function, which swaps two any values.
func swapTwoValues<T>(inout a: T, inout b: T) {
let temporaryA = a
a = b
b = temporaryA
}
// Generic collection type called `Stack`.
struct Stack<T> {
var elements = T[]()
mutating func push(element: T) {
elements.append(element)
}
mutating func pop() -> T {
return elements.removeLast()
}
}
We can use certain type constraints on the types with generic functions and generic types. Use where after the type name to specify a list of requirements.
// Generic function, which checks that the sequence contains a specified value.
func containsValue<
T where T: Sequence, T.GeneratorType.Element: Equatable>
(sequence: T, valueToFind: T.GeneratorType.Element) -> Bool {
for value in sequence {
if value == valueToFind {
return true
}
}
return false
}
In the simple cases, you can omit where and simply write the protocol or class name after a colon. Writing <T: Sequence> is the same as writing <T where T: Sequence>.
Emoji/Unicode support
You can use any unicode character (including emoji) as variable names or in Strings.
var 😄 = "Smiley"
println(😄) // will print "Smiley"
let 🌍 = "🐶🐺🐱🐭"
var 🚢: String[] = []
for 💕 in 🌍 {
🚢.append(💕+💕)
}
println(🚢) // will print [🐶🐶, 🐺🐺, 🐱🐱, 🐭🐭]
Which, in Xcode looks like
