devkuma – Swift

Introduction to Swift | Preparing to Use Swift

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Swift is used with Apple’s official development environment, Xcode. This section explains how to prepare the environment and run a simple program.

Swift Introduction | Preparing to Use Swift | What Is Swift?

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Swift is a completely new programming language that Apple announced at its developer conference in June 2014.

Previously, developers used a programming language called Objective-C to create macOS and iOS apps for devices such as the iPhone and iPad. This was rooted in the origins of macOS.

macOS is based on an earlier operating system called NeXTSTEP. NeXTSTEP was originally created as a platform for writing and running programs in the powerful object-oriented language Objective-C. Objective-C and NeXTSTEP were closely connected. NeXT, the company that developed NeXTSTEP, was led by Steve Jobs.

When Steve Jobs returned to Apple, NeXTSTEP also moved to Apple and became the foundation of macOS. Its appearance became more Mac-like, but its internals were based on NeXTSTEP. As a result, macOS was designed around Objective-C programs.

That underlying assumption has not disappeared. macOS and iOS include frameworks originally prepared for Objective-C, and applications run by using those frameworks. This explains why Mac and iPhone development historically required Objective-C: the operating systems were designed with Objective-C in mind.

Objective-C is not an easy language to understand. It combines C with ideas from Smalltalk, an early object-oriented language, so its syntax can feel like two languages living side by side. As C++, Java, C#, and other languages with more familiar syntax became mainstream, Objective-C increasingly came to be regarded as unusual and difficult to learn.

As Macs and iPhones became popular, many developers wanted to build applications for them. Many of those developers found Objective-C difficult to approach and wanted a more understandable language.

That situation was not ideal for Apple either. Apple therefore introduced a new language designed to be easier to learn, understand, and use: Swift.

Swift Introduction | Preparing to Use Swift | Swift Features

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

What kind of language is Swift? This article summarizes its features.

A Modern Language

Objective-C did not support many convenient features adopted by modern languages. Swift provides language features that were not available in Objective-C, including closures, which let you handle a process like a value, and generics, which let you work with different kinds of values.

A Safer Language

Swift has syntax designed to remove common sources of bugs from code. For example, variables must be initialized, optional values explicitly represent the absence of an object, variables have types from the beginning, and control-flow bodies must be enclosed in braces. These features help prevent accidental mistakes.

An Interactive Language

Swift is a compiled language. You can compile a program in advance into binary code that a computer executes directly. Swift can also run interactively. Xcode provides a playground where you can write and run statements immediately. We will use this approach to learn the basics of Swift.

Fast Execution

Because Swift includes many convenient features, you might assume that Objective-C applications run faster. However, Apple stated that programs written in Swift could run faster than Objective-C programs.

Other programmers identified bottlenecks in early versions of Swift, so it was not always possible to state that Swift was faster than Objective-C. Its performance was expected to improve as the language matured.

The Same Objective-C Backbone

Objective-C was used on macOS and iOS because the operating systems were optimized for it. The appearance of a new language such as Swift does not change that foundation. Frameworks built into macOS and iOS were created for Objective-C, and Swift uses them directly. Although the language is new, Swift developers use many of the same operating-system features that Objective-C developers used. You do not need to learn every platform feature again from the beginning. Much of your Objective-C knowledge remains useful.

Swift Introduction | Preparing to Use Swift | Setting Up Swift

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Let us set up an environment for using Swift. Swift is supported by Apple’s Xcode development environment starting with Xcode 6. Xcode 6 was released in the fall of 2014, and Xcode 7 was available when this article was written in September 2017.

You can install Xcode from the App Store or download it from Apple’s developer website. Download availability from the developer website may depend on your Apple Developer Program membership.

https://developer.apple.com/xcode/downloads/

If you download Xcode from Apple’s developer website, mount the disk image (.dmg) and copy Xcode to install it.

The first launch may take some time because Xcode sets up required components. If a dialog asks you to install components, complete the installation. Once Xcode starts correctly, installation is complete.

Using a Playground

After launching Xcode, create a playground. A playground is a special file that lets you run Swift programs immediately.

In the Welcome window that appears when Xcode starts, click “Get started with a playground.” In the dialog, enter a program or file name in Name and select “OS X” for Platform. Choose a folder and save the file. A playground window appears, ready for use.

Swift Introduction | Preparing to Use Swift | Running a Playground

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

A newly created playground contains a few simple statements by default. Let us understand what they mean.

// Playground - noun: a place where people can play
 
import Cocoa
 
var str = "Hello, playground"

Importing a Library

import Cocoa

This imports the Cocoa framework. macOS and iOS include Cocoa, a framework for working with operating-system features. The import statement loads a specified library so that your program can use it.

Using a Variable

var str = "Hello, playground"

This statement contains several elements. First, var str creates a variable named str. The text value is written inside double quotation marks.

The text "Hello, playground" displayed to the right of the editor is the result of executing the var str statement.

A playground immediately displays the result of each statement. For example, when you create a variable and assign a value, the stored value appears on the right. This is a convenient feature.

Using a playground, you can write a program incrementally and inspect the result immediately. You now have an environment for trying Swift.

The following articles use a playground to explain basic Swift syntax.

Introduction to Swift | Values, Variables, and Operations

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

The basics of programming are values, variables, and operations. This section starts with these fundamental concepts.

Introduction to Swift | Control Statements

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Control statements are essential for writing complex programs. This section explains the four basic statements: if, switch, for, and while.

Introduction to Swift | Control Statements | Repetition with while

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

A for statement includes a mechanism that changes on each iteration. There is also a simpler loop statement that only checks a condition to decide whether to repeat a process. This is the while statement.

There are two ways to write a while loop, depending on where the condition appears. The latter is also called a do while statement.

Basic form of while

while condition {
    ... repeated processing ...
}

Basic form of do while

do {
    ... repeated processing ...
} while condition

Write the condition after while. If the condition is true, the loop runs. When it becomes false, execution exits the loop.

Why are there two forms for such a simple operation? The difference is when the condition is checked. The first form, with while at the beginning, checks the condition before executing the block inside {}.

The second form, with while at the end, executes the block first and checks the condition afterward. As a result, the block runs at least once even if the condition is initially false.

Compare the following simple loops.

var n:Int = 0
 
while 10 > n++ {
    "index:" + String(n)
}
 
var m:Int = 0
do {
    "index:" + String(m)
} while 10 > m++

The first loop produces values in the form index:1 through index:10. The second loop produces index:0 through index:9. Because the variable is incremented with ++ in the condition, the values differ depending on whether the condition appears before or after the block.

As this example shows, the two forms behave slightly differently in subtle cases. As a general rule, use while by default and reserve do while for situations that require it.

Introduction to Swift | Functions

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Functions group processing so it can be called when needed. They are an important feature for structuring programs. Swift functions are designed to be convenient even in their details and include distinctive features.

Swift Introduction | Functions | Defining and Using Functions

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

The examples so far have executed statements sequentially, but real programs are more complex.

Group reusable processes so that they can be called whenever needed. A function provides this capability.

In Swift, define and call a function as follows.

func functionName(arguments) -> ReturnType {
    ...... process to perform ......
    return value
}

Specify arguments inside parentheses after the function name. Write each argument as a name and type pair, such as variableName:Type. Separate multiple arguments with commas.

After ->, specify the return type. If the function does not return a value, specify Void or omit the return type. Swift then treats it as Void.

Use return to return a value. A function returning Void does not need return.

The following is a simple example.

func calc(num:Int) -> Int {
    var total:Int = 0
    for i in 1...num {
        total += i
    }
    return total
}
 
calc(100)

This code declares and calls calc, a function that receives an integer and returns the sum from 1 through that value. The declaration calc(num:Int) shows that the function receives one Int argument. The -> Int declaration shows that it returns an Int.

Swift

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Swift is a programming language developed for creating macOS and iOS applications for devices such as the iPhone and iPad. Learn the basics of Swift and start developing apps.

Swift Introduction | Functions | Default Argument Values

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

There are additional features to learn about function arguments. This article explains default values.

You can specify a default value for a function argument in advance. Assign a value to the argument variable with an equals sign (=), as shown below.

func functionName(argumentName:Type = defaultValue)

When you specify a default value, the argument name automatically becomes an external name that can be provided by the caller. There is no need to add a hash sign (#) as a shorthand declaration.

Specifying a default value means that the argument can be omitted. When calling the function, the argument may or may not be present. To make it clear which argument is being passed, an argument with a default value uses an external name.

The following example uses a default value.

func tax(#price:Int, rate:Double = 0.08) -> Int {
    return Int(Double(price) * (1.0 + rate))
}
 
var res:Int = tax(price:10000, rate:0.08)
var res3:Int = tax(price:12300)

If you omit the rate argument, Swift automatically uses 0.08.

Swift Introduction | Functions | Variadic Parameters

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Use a variadic parameter when you do not know how many values will be passed to a function.

(argumentName:Type...)

Callers can provide multiple comma-separated values for this parameter. The function receives those values as an array. You can think of a variadic parameter as an array parameter.

func calc(nums:Int...) -> Int {
    var total:Int = 0
    for num in nums {
        total += num
    }
    return total
}
calc(1,2,3,4,5)

The declaration is:

calc(nums:Int...)

The call is:

calc(1,2,3,4,5)

Multiple values are passed through nums. Inside the function, iterate over them with for.

for num in nums {...

The number of elements in a variadic parameter is not fixed. Processing it with a for statement is the usual approach.

Swift Introduction | Functions | inout Arguments

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Another Swift function feature to learn is the inout argument. This special argument lets a function modify the argument itself. Add inout before the argument.

(inout argumentName:Type)

When passing a variable to an inout argument, add & before the variable name. You cannot pass a literal because a literal cannot be modified.

The following is an example of an inout argument.

func tax(inout price:Int, rate:Double = 0.08) -> Void {
    price = Int(Double(price) * (1.0 + rate))
}

var num = 12300
tax(&num)

The function is declared as follows.

tax(inout price:Int, rate:Double = 0.08)

The first argument, price, is an inout argument. The return type is Void. The function call is as follows.

tax(&num)

This directly changes the value of num. Functions usually return values, but an inout argument lets a function modify the value stored in a variable directly.

Introduction to Swift | Class Basics

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

In object-oriented languages, you define classes to create and use objects. This section explains the basic usage of classes, as well as inheritance, overrides, computed properties, type properties, and type methods.

Swift Introduction | Class Basics | Initializers

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Until now, instances have been created without arguments, as in Helo(). It is convenient to pass required values when creating an instance.

Use an initializer for this purpose. An initializer is a special method that runs automatically when an instance is created. Define it as follows.

init(arguments) {
    ...... initialization process ......
}

Do not write func init. Write only init. An initializer is a special method and does not require func.

Declare arguments inside the parentheses to pass values when creating an instance. The following is a simple example.

import Cocoa

class Helo {
    var name:String;
    
    init(name:String){
        self.name = name;
    }
    
    func say(){
        print("Hello, " + name + "!");
    }
}

var obj:Helo = Helo(name:"Taro");
obj.say();

The Helo class defines an initializer in the form init(name:String). Create an instance by passing an argument, as in Helo(name:"Taro").

Inside the initializer, self.name assigns the argument name to the name property of the Helo class. The special value self represents the instance itself. This syntax refers to the name property of the current instance and is frequently used in class definitions.

Swift Introduction | Class Basics | Type Properties and Type Methods

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Ordinary properties and methods require an instance. A class can also provide properties and methods that you use directly through the class. These are called type properties and type methods.

To declare type properties and type methods, add the class modifier. You can then call them directly through the class.

Keep the following points in mind when using type properties and type methods.

A type property can be a computed property. An ordinary stored property is not available. Because there is no class-level stored variable, a setter for a computed property also has limited use.
A type method can use only type methods and type properties. It cannot use ordinary properties and methods that belong to instances.

The following is an example.

class Exchange {
    class var rate:Double {
        return 1005.0
    }
    
    class func DollarToWon(d:Double)->Int {
        return Int(d * rate)
    }
    
    class func WonToDollar(y:Int)->Double {
        return Double((y * 100) / Int(rate)) / 100
    }
}

print(Exchange.DollarToWon(1.5))
print(Exchange.WonToDollar(1500))

This example defines an Exchange class that converts won to dollars and dollars to won. It provides the rate type property and two type methods for the calculations. A class centered on calculations can be used efficiently through type methods because there is no need to create an instance each time.

Introduction to Swift | Arrays and Dictionaries

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Arrays and dictionaries manage multiple values together. This section explains their basic usage.

Swift Introduction | Arrays and Dictionaries | Array Basics

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

An array manages multiple values together. It stores values of the same type and assigns each storage location an index starting at 0. Use an index to retrieve or replace a value.

An array is created with a specified number of storage locations. An array with ten elements has indexes from 0 through 9, not 1 through 10. Reading or writing an index outside the allocated range causes an error.

Creating Arrays

var variable:Type = [Type]()
var variable:Type = [Type](count: number, repeatedValue: value)
var variable:Type = [value1, value2, ...]

Reading and Writing Values

variable = array[index]
array[index] = value

Write the element type inside square brackets. For example, an array of strings has the type [String].

Create an empty array with [Type](). To create storage locations with an initial value, write:

[Type](count: numberOfLocations, repeatedValue: initialValue)

You can also use an array literal such as [value1, value2, ...].

var arr1 : [Int] = [Int] (count : 10, repeatedValue : 0)
var arr2 : [Int] = [0,0,0,0,0,0,0,0,0,0]

An array literal is convenient for a small number of elements. For ten thousand zero values, (count: 10000, repeatedValue: 0) is more practical.

Swift can infer the type when the assigned value makes it clear.

var arr1 = [Int] (count : 10, repeatedValue : 0)
var arr2 = [0,0,0,0,0,0,0,0,0,0]

Swift Introduction | Arrays and Dictionaries | Arrays and for-in Statements

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

You can retrieve and process array elements one at a time by specifying index numbers. When using an array to manage data, however, you often need to process every element in the same way.

For this purpose, use a for-in statement.

for variable in array {
    ...... process to perform ......
}

A for-in statement retrieves values from an array in order, assigns each value to a variable, and repeatedly executes the code inside the braces. By using that variable in the body, you can perform the same operation on every array element.

The following is a simple example.

let data:[Int] = [10, 20, 30]
var total:Int = 0
for num in data {
    total += num
}
println("total: \(total)")

This code retrieves every value from the data array, calculates the sum, and displays it. The statement for num in data retrieves each value from data in order and assigns it to num.

Introduction to Swift | Structures, Enumerations, and Tuples

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Swift frequently uses values with complex structures. This section explains structures, enumerations, and tuples.

Swift Introduction | Structures, Enumerations, and Tuples | Tuples

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Tuples have already appeared several times. A tuple groups multiple values, including values of different types, in one place. Write a tuple as follows.

(value1, value2, ...)

Create a tuple by writing comma-separated values inside parentheses. Retrieve its values by adding a dot and an index to the variable that stores the tuple, such as tuple.1.

Using indexes can cause mistakes if you do not clearly understand the order of the values. Like a dictionary, a tuple can also assign names to its values.

(key1 : value1, key2 : value2, ...)

For a tuple written in this form, retrieve a value with a key instead of a number, such as tuple.key. You can think of it as similar to the difference between an array and a dictionary.

The following example uses tuples.

func MakeTuple(name:String, age:Int)->(name:String, age:Int) {
    return (name:name, age:age)
}

var me = MakeTuple("Yamada", age: 99)
var you = MakeTuple("Hanako", age: 36)

print(me.name)
print(you.age)

This example provides a function that creates tuples in a fixed format, then creates tuples and displays their values.

Tuples let you freely choose their value structure. That freedom can make their contents inconsistent, but a function such as this one lets you create tuples with the same format.

Introduction to Swift | Function Literals and Closures

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Swift provides closures, which allow functions to be handled as values. This section explains closures and how to use functions as values.

Swift Introduction | Function Literals and Closures | Functions Are Values

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Swift functions have an important characteristic: they can be treated as values. A function groups together a process, but in Swift the function itself is also a value.

Run the following simple example.

func calc(num:Int)->Int {
    var res = 0
    for n in 0...num {
        res += n
    }
    return res
}
 
var f1 = calc
 
print(f1(10))

This example defines a function named calc. It assigns calc to the variable f1, then calls f1 with an argument.

The calc process runs correctly and returns a result. In other words, the calc function assigned to f1 works as expected.

Because functions are values, Swift can handle functions in a variety of ways. Remember this key point: a function is a value.

Swift Introduction | Function Literals and Closures | Closures

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Now that you understand the basics of functions as values, let us use closures, a central Swift feature.

A closure lets you pass a function as an argument to another function. Because functions are values, a function can accept another function as an argument.

This may sound unfamiliar until you see an example.

func calc(num:Int)->Int {
    var res = 0
    for n in 0...num {
        res += n
    }
    return res
}

func printResult(function:(num:Int)->Int, n:Int) {
    print(function(num: n))
}

printResult(calc, n: 123)

This code defines two functions: calc and printResult. As in the previous example, calc returns the sum of the values from 0 through its argument. The printResult function uses a closure.

printResult receives a function and an Int value. The function type is (num:Int)->Int. When you pass calc, printResult runs it internally and prints the result.

printResult is not limited to printing the result of calc. You can pass any function that receives an Int value and returns an Int value.

Closures let you separate a process and provide it from outside a function. This is one of their main benefits.

Swift Introduction | Function Literals and Closures | Function Literals

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Closures require passing a function as a value. You can define a function in advance and pass it as an argument, as in the previous example.

For a simple process used in only one place, defining a separate function can be unnecessary. Instead, write the function directly as an argument with a function literal.

{ ... process ... }

In practice, arguments are commonly included.

{ arguments in ... process ... }

Separate multiple arguments with commas. A function literal lets you provide the required function without defining it beforehand.

func printResult(function:(num:Int)->Int, n:Int) {
    print(function(num: n))
}

printResult({n in n * 2}, n: 10)

printResult({n in
    var re:Int = 0
    for num in 0...n {
        re += num
    }
    return re
}, n: 100)

This example calls the previously defined printResult function. It no longer uses a separate calc function. Instead, each call provides a function literal directly.

When the result comes from a single expression, write the literal on one line. Multiline processing is more complex but follows the same principle.

Closures and function literals may initially seem difficult. Remember that they treat functions as values, and experiment by modifying the examples.

Introduction to Swift | Protocols and Extensions

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Swift includes features that help extend classes. Protocols require method implementations, and extensions add methods later. This section explains how to combine these two features.

Swift Introduction | Protocols and Extensions | Extensions

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

A protocol requires a class to implement methods. An extension adds methods directly to an existing class. Its syntax is simple.

extension ClassName {
    ...... additions ......
}

Specify the class to extend as ClassName.

You can add properties as well as methods. However, an extension can add only computed properties, which define get and set behavior.

Extensions work with your own classes, classes provided by the Swift standard library, and classes from iOS frameworks.

For example, extend Int with a getTotal method that calculates the sum from 1 through a given number.

extension Int {
    func getTotal()->Int {
        var total:Int = 0
        for i in 1...self {
            total += i
        }
        return total
    }
}

var num = 1234
print(num.getTotal())

The declaration extension Int extends the Int type. Every Int value can then use the getTotal method. Even an ordinary variable such as var num = 1234 can call it. To calculate the sum through 100, call 100.getTotal().

Extensions make it easy to add functionality even to fundamental Swift types such as Int and String.

Swift Introduction | Protocols and Extensions | Combining Protocols and Extensions

kc@example.com (kc kim) — Sun, 24 Sep 2017 21:56:54 +0900

Combining protocols and extensions enables useful designs.

An extension can add a protocol as well as methods and properties. This lets multiple existing types implement common behavior and be processed together.

protocol MyDataPrintable {
    func printData ()
}

extension String: MyDataPrintable {
    func printData() {
        print("문자열 : \(self).")
    }
}

extension Int: MyDataPrintable {
    func printData() {
        print("숫자 : \(self).")
    }
}

var str = "Hello"
var num = 12345
str.printData()
num.printData()

This example declares the MyDataPrintable protocol with a printData method. Extensions then add protocol conformance to String and Int.

extension String: MyDataPrintable {...}
extension Int: MyDataPrintable {...}

Every String and Int value can now be treated as MyDataPrintable. You can process both types uniformly through the same protocol.

Protocols and extensions do more than improve your own classes. They also let you customize types included with Swift.