![\"Figure](\"http:\/\/www.yeahbutisitswift.com\/wp-content\/uploads\/2014\/08\/playground-window-1024x767.png\")
<\/a>Figure 3. Your playground window.<\/p><\/div>\n
On the left-hand side is where you’ll enter your Swift code. In fact, you should see some default code already sitting there. On the right is a sidebar where the results of your evaluated code will be shown.<\/p>\n
Your playground window also provides a timeline assistant, which comes in handy when working with code that runs over time. For example, if you write a loop, you can watch its progress in graph form, with the value of each of the loop’s variables clearly charted over time. However, focusing on the sidebar for the time being will be more than enough to get us up and running.<\/p>\n
Feel free to delete the code that’s already within your playground. Now let’s get the ball rolling.<\/p>\n
Your First Program<\/h2>\n
Take a look at the following line:<\/p>\n
println(“Hullo World!”)<\/codeswift><\/p>\nIf you were to save the above within a text file and give it the .swift<\/code> extension, you’d have written the simplest program you can write with the Swift programming language.<\/p>\nThat’s right, just a single line of text and you have a working program. Any code written at the global scope is used as your program’s main entry point, and there’s no need to import a library to handle output of your string either.<\/p>\n
You may also notice one curious omission. There’s no semicolon at the end of the line. Semicolons aren’t required at the end of every statement. Adding semicolons to the end of a statement is a hard habit to break. Hang on in there though and you’ll soon learn to live without them.<\/p>\n
Try the above example out by typing it into your playground window. Hitting the Enter<\/em> key will result in Hullo World!<\/code> being displayed within the sidebar.<\/p>\n If we were running our code from an Xcode project rather than a playground, then
Hullo World!<\/code> would have been displayed within Xcode’s console panel rather than your playground’s sidebar.<\/p>\nThere are various destinations that text can be written to depending on the context in which you are running Swift. It’s therefore better to refer to those destinations collectively as the appropriate output<\/strong><\/em>. We’ll use that term throughout. <\/div>\nComments<\/h2>\n
Comments in Swift are similar to comments in most languages. Here’s an example of a single-line comment:<\/p>\n
\/\/ Player has been killed.<\/codeswift><\/p>\nComments can also span several lines:<\/p>\n
\/* The player has collided with a projectile. Reduce their energy and
\n check to see if the collision killed them. *\/<\/codeswift><\/p>\nUnlike most languages, multiline comments can also be nested inside other multiline comments. This is particularly useful if you need to quickly comment out large blocks of code that already contain multiline comments.<\/p>\n
Variables and Constants<\/h2>\n
Variables are declared with the var<\/code> keyword. Here’s an example of a variable that stores the number of lives a player has:<\/p>\nvar remainingLives = 2<\/codeswift><\/p>\nConstants can also be declared. Use the let<\/code> keyword:<\/p>\nlet maximumLives = 5<\/codeswift><\/p>\nYou can also declare multiple variables or multiple constants on a single line:<\/p>\n
var remainingLives = 3, score = 0, level = 0<\/codeswift> <\/p>\nUse constants for any values that will not change during the lifetime of your program.<\/p>\n
When you declare a constant you must also provide it with an initial value. Unlike a constant, a variable does not require an initial value when being declared. However, a value must be assigned before the variable is actually used.<\/p>\n
Playground Experiment<\/span> In your playground, declare and initialise a constant named
maximumLevel<\/code> on one line then attempt to change its value on the next:<\/p>\nlet maximumLevel = 20
\nmaximumLevel = 25<\/codeswift><\/p>\nYou’ll receive the following error:<\/p>\n
Cannot assign to ‘let’ value ‘maximumLevel’<\/codeswift>
\n <\/div><\/div>\nTypes and Type Inference<\/h2>\n
You probably noticed that a type was not specified for any of the variables or constants. Swift can infer the type you intend to use from the initial value you provide. The following declares a constant that stores a string:<\/p>\n
let name = “Luke Skywalker”<\/codeswift><\/p>\nWhen you need to be clear about the type being used you can specify it by placing a colon after the constant or variable name:<\/p>\n
let name: String = “Luke Skywalker”<\/codeswift> <\/p>\nIn most situations however, you shouldn’t need to explicitly state the type you intend to use.<\/p>\n
Swift provides types for integers, floating-point numbers, strings, characters and boolean values.<\/p>\n
Integers<\/h3>\n
Integers are represented by signed and unsigned types in 8 (Int8<\/code>, UInt8<\/code>), 16 (Int16<\/code>, UInt16<\/code>), 32 (Int32<\/code>, UInt32<\/code>), and 64 (Int64<\/code>, UInt64<\/code>) bit forms. However, you really don’t need to worry about the specific size of an integer. Instead, use the Int<\/code> integer type, which is represented by Int32<\/code> on a 32-bit platform, and Int64<\/code> on a 64-bit platform. Here is an example:<\/p>\nvar age: Int = 16<\/codeswift><\/p>\nAlternatively, as discussed earlier, the type can be inferred:<\/p>\n
var age = 16<\/codeswift><\/p>\nAn unsigned integer type, UInt<\/code>, is also available:<\/p>\nvar age: UInt = 16<\/codeswift><\/p>\nHowever, it’s recommended that you use Int<\/code> even for values that are known only to be non-negative. This avoids the need to convert between different number types.<\/p>\nFloating-Point Numbers<\/h3>\n
If you need to store a number with a fractional component or a much larger number than can be stored with an integer type, then use either the Float<\/code> or Double<\/code> type. A Double<\/code> has a precision of at least 15 digits whereas a Float<\/code> can have a precision of at least 6 decimal digits:<\/p>\nlet value1: Float = 1 \/ 3
\nlet value2: Double = 1 \/ 3<\/codeswift><\/p>\nOf course, you can stop worrying about the exact type and let Swift make that decision for you:<\/p>\n
let value3 = 1.0 \/ 3<\/codeswift><\/p>\nUse Double<\/code> only when you require the additional precision or to store a number that’s too large to be represented by Float<\/code>.<\/p>\nPlayground Experiment<\/span>In the example directly above, notice that the value 1 is written as a floating-point value (
1.0<\/code>). This is to ensure that the value3<\/code> constant is implicitly declared of type Double<\/code>. If two integers had been divided instead, Swift would have incorrectly inferred that an integer type was to be used for your value3<\/code> constant, which would have resulted in it being initialised with a value of 0<\/code>.<\/p>\nYou can test this directly within your playground. Go ahead and enter the following:<\/p>\n
let value1: Float = 1 \/ 3
\nlet value2 = 1.0 \/ 3
\nlet value3 = 1 \/ 3<\/codeswift><\/p>\nIf you examine the sidebar you’ll notice that value3<\/code> contains a value of 0<\/i>, which is probably not what you expected.<\/p>\nThis is a common mistake made by those coming from languages such as JavaScript.<\/div><\/div>\n
Boolean<\/h3>\n
Swift has a Bool<\/code> type and provides two constant values, true<\/code> and false<\/code> for you to work with. Here are some examples:<\/p>\nvar shieldActivated = false
\nvar isAlive = true
\nlet catsHateDogs = true<\/codeswift><\/p>\nOf course, with all three variables above, you could have declared each as being of type Bool<\/code>. However the use of the Bool<\/code> type is inferred by assigning either true<\/code> or false<\/code> to each.<\/p>\nStrings<\/h3>\n
Swift represents strings with the String<\/code> type, which is essentially a collection of characters:<\/p>\nlet jedi = “Luke Skywalker”
\nlet sith = “Darth Vader”<\/codeswift><\/p>\nAs expected, in the example above, the String<\/code> type is inferred by the fact that a string literal is used to initialise each constant.<\/p>\nIt’s worth noting that a Swift string is a value type. In other words, the value of the string is copied when passed to a function or method. The same is also true when a string is assigned to another constant or variable. This is different to the behaviour of Objective-C where a reference to a string is used instead.<\/p>\n
Strings can be concatenated to create a new string:<\/p>\n
var forename = “Christopher”
\nvar surname = “Caleb”
\nlet fullName = forename + ” ” + surname<\/codeswift><\/p>\nStrings that are represented by constants cannot be modified once they are initialised.<\/p>\n
Printing Values<\/h3>\n
As you have already seen, you can print a string to the appropriate output (Xcode’s console pane for example) using the global println<\/code> function:<\/p>\nprintln(“May the force be with you.”)<\/codeswift><\/p>\nYou can also print the current value of any variable or constant:<\/p>\n
var name = “Obi-Wan Kenobi”
\nprintln(name)<\/codeswift><\/p>\nIt’s also possible to insert variables or constants as placeholders directly within a string. This is done by wrapping the name in parentheses and escaping it with a backslash before the opening parenthesis:<\/p>\n
var player1 = “Vader”
\nvar player2 = “Yoda”
\nprintln(“\\(player1) vs. \\(player2)”)<\/codeswift><\/p>\nThe example above will print Vader vs. Yoda<\/code> to the appropriate output.<\/p>\nType Conversion<\/h3>\n
Each number type has a different range. For example, the Int8<\/code> type can store any value ranging from -128<\/code> to 127<\/code>. The UInt8<\/code> type has a range from 0<\/code> to 255<\/code>. A variable or constant whose value is too small or too large for its specified type will result in a compile-time error. For example, this will result in an error:<\/p>\nlet tooBig: Int8 = Int8.max + 1<\/codeswift><\/p>\nIn other words, Swift does not attempt to automatically handle numeric overflow. By refusing to do so it prevents hidden conversion errors. Instead, if you are dealing with different numeric types then you must explicitly convert all your values to the same type. Take a look at the following:<\/p>\n
let numberOfKills: UInt16 = 2400
\nlet remainingTime: UInt8 = 12
\nlet finalScore = numberOfKills * UInt16(remainingTime)<\/codeswift><\/p>\nIn the example above, the value of the finalScore<\/code> constant is calculated by multiplying the value of numberOfKills<\/code> with remainingTime<\/code>. However, since numberOfKills<\/code> and remainingTime<\/code> are both of different types, one of the types must first be converted to match that of the other. In our example, this is done by calling UInt16(remainingTime)<\/code> to convert the remainingTime<\/code> constant to the same type as numberOfKills<\/code>.<\/p>\nUInt16(remainingTime)<\/code> is an example of a type’s initializer being called and passed an initial value. This is known as initializer syntax and can be used to initialise a variable or constant of any numeric type. Here’s a similar example, but this time, both constants are converted to Int8<\/code> types before the final score is calculated:<\/p>\nlet numberOfKills: UInt8 = 10
\nlet bonusPoints: Int8 = -2
\nlet finalScore = Int8(numberOfKills) + bonusPoints<\/codeswift><\/p>\nConversion between floating point and integer number types must also be handled explicitly. Here’s an example, where the numberOfKills<\/code> variable is converted from an Int<\/code> to a Double<\/code>:<\/p>\nvar numberOfKills = 21
\nvar remainingSeconds = 2.45
\nlet finalScore = Double(numberOfKills) * remainingSeconds<\/codeswift> <\/p>\nIt’s also possible to convert a floating-point value to an integer, although there will be a loss of precision:<\/p>\n
let remainingSeconds = 2.45
\nlet pi = 3.14
\nlet height = 5.9
\nlet temperature = -3.9
\nprintln(“remaining seconds: \\(Int(remainingSeconds))”)
\nprintln(“pi: \\(Int(pi))”)
\nprintln(“height: \\(Int(height))”)
\nprintln(“temperature: \\(Int(temperature))”)<\/codeswift><\/p>\nWhen run, the following will be appear in the appropriate output:<\/p>\n
remaining seconds: 2
\npi: 3
\nheight: 5
\ntemperature: -3<\/codeswift><\/p>\nA conversion from floating-point to integer is always truncated. For example, 5.9<\/code> will become 5<\/code>, whereas -3.9<\/code> will be converted to -3<\/code>.<\/p>\nTuples<\/h3>\n
You can group multiple values into a single compound value through the use of a tuple. The values stored within a tuple do not have to be of the same type. The following example groups information about the non-Retina iPad’s screen resolution:<\/p>\n
let iPadStandard = (768, 1024, “standard”)<\/codeswift><\/p>\nRemember, Swift infers the type of each value. However if you did want to be explicit:<\/p>\n
let iPadStandard: (Int, Int, String) = (768, 1024, “standard”)<\/codeswift><\/p>\nYou can access an individual value within a tuple by specifying that value’s position. The following example obtains the screen resolution’s width and height:<\/p>\n
var width = iPadStandard.0
\nvar height = iPadStandard.1
\nprintln(“The screen is \\(width) pixels wide and \\(height) pixels high.”)<\/codeswift><\/p>\nRather than working with index positions you can also decompose a tuple like this:<\/p>\n
var (width, height, screenType) = iPadStandard
\nprintln(“The screen is \\(width) pixels wide and \\(height) pixels high.”)<\/codeswift><\/p>\nThe example above creates three variables (width<\/code>, height<\/code>, and screenType<\/code>) and assigns each of them to a value within the tuple.<\/p>\nNotice that we had no need for the screenType<\/code> variable in our example. You can use an underscore to ignore values you don’t require when decomposing a tuple:<\/p>\nvar (width, height, _) = iPadStandard
\nprintln(“The screen is \\(width) pixels wide and \\(height) pixels high.”)<\/codeswift><\/p>\nYou can also assign a name to individual elements within a tuple. Here’s our non-Retina iPad example again but with a name associated with each element:<\/p>\n
let iPadStandard = (width: 768, height: 1024, screenType: “standard”)
\nvar width = iPadStandard.width
\nvar height = iPadStandard.height
\nprintln(“The screen is \\(width) pixels wide and \\(height) pixels high.”)<\/codeswift><\/p>\nTuples are ideal for temporarily storing groups of related data. They are also an extremely powerful means of returning multiple values from a function or method. They aren’t however, suitable for representing complex data structures. <\/p>\n
Playground Experiment<\/span>We’ve already created a tuple to store details regarding a non-Retina iPad. Try adding three new constants that represent the Retina iPad, non-Retina iPhone, and the Retina iPhone 4.<\/p>\n
Now create a variable named currentScreen<\/code> and arbitrarily assign it to the various constants. Using that variable, extract values from each and print them using the printlin()<\/code> function.<\/div><\/div>\nOptionals<\/h3>\n
It was stated earlier that a variable or constant must be assigned a value before it can be used. How do we handle variables that, for one reason or another, may not hold a value at various points during your program’s execution? Swift provides nil<\/code>, which is a special value that represents a valueless state.<\/p>\nYou therefore might reasonably expect to see code like this in Swift:<\/p>\n
var middleName: String = nil<\/codeswift><\/p>\nAfter all, not everyone has a middle name. Unfortunately Swift variables cannot be nil<\/code>. They must always have a value associated with them.<\/p>\nIn such situations you would use an optional<\/i><\/strong> variable instead. By using an optional you are saying that the variable will either have a value, or no value at all. An optional type has a question mark placed after it. Here’s our middle name example again, but this time using an optional:<\/p>\nvar middleName: String?<\/codeswift><\/p>\nNotice that, in this case, the optional string type has to be explicitly stated. It’s also defaulted to nil<\/code>.<\/p>\nLet’s set our middleName<\/code> variable to something:<\/p>\nmiddleName = “Tiberius”<\/codeswift><\/p>\nForced Unwrapping<\/h4>\n
Now that we have a value stored within our optional, we can consider using it. To retrieve a value from an optional you have to unwrap<\/i><\/strong> it by placing an exclamation mark at the end of the optional’s name:<\/p>\nprintln(“James \\(middleName!) Kirk”)<\/codeswift><\/p>\nBefore you can unwrap an optional though, you must first check that it contains a value. In other words, you must check that your optional is not nil<\/code>.<\/p>\nif middleName != nil {
\n println(“James \\(middleName!) Kirk”)
\n}<\/codeswift><\/p>\n We used an
if<\/code> statement in the example above but haven’t yet covered control flow yet. It should be fairly obvious how it works though. <\/div>\nBy using the exclamation mark to obtain the optional’s value, you are stating that you are absolutely sure that the optional does actually contain a non-nil<\/code> value. This is known as forced unwrapping<\/i><\/strong>, and doing so on a variable that contains nil<\/code> will result in a runtime error.<\/p>\nPlayground Experiment<\/span>You’ll be using optionals a lot in Swift so try to get comfortable using them.<\/p>\n
Create a few optional constants. Each optional should be initialised to a string literal that contains the name of a friend. Print each of your friend names (one println()<\/code> for each friend) and check the result in the sidebar. Verify that you’ve actually unwrapped your optional by checking that the keyword Optional<\/code> doesn’t appear in the sidebar next to each of your println()<\/code> statements.<\/p>\nNow go back and initialise each of your constants to nil<\/code>. Ensure that nothing is now being printed to the sidebar and confirm that you aren’t receiving any runtime errors.
\n <\/div><\/div>\nOptional Binding<\/h4>\n
As an alternative to using an if<\/code> statement before obtaining an optional’s value, you can also use a technique known as optional binding<\/i><\/strong>. It works by checking that an optional contains a value and then storing that value in a temporary variable or constant for you to work with. Here’s our middle name example again, but this time taking advantage of optional binding:<\/p>\nvar middleName: String?
\nmiddleName = “Tiberius”
\nif let name = middleName {
\n println(“James \\(name) Kirk”)
\n}<\/codeswift><\/p>\nThe example above checks to see if the middleName<\/code> optional contains a value. If it does then it sets a new constant called name<\/code> to the value contained within middleName<\/code>. That constant is then made available within the first branch of the if<\/code> statement.<\/p>\n
![\"Figure](\"http:\/\/www.yeahbutisitswift.com\/wp-content\/uploads\/2014\/09\/welcome-to-xcode-1024x600.png\")
<\/a>![\"Figure](\"http:\/\/www.yeahbutisitswift.com\/wp-content\/uploads\/2014\/08\/choose-options-for-your-new-file-1024x767.png\")
<\/a>