If you’re coming from a language such as Objective-C or C, where the return type is listed first in a function’s declaration, then you may find the order of Swift’s return type a little off putting. However, persevere and I promise you’ll grow to like it.<\/p>\n
Of course, ActionScript and TypeScript developers will already find this syntax familiar as both languages deal with return types in a similar manner to Swift. <\/div>\n
The latest version of our greetJedi<\/code> function now takes two parameters (a forename and surname) and returns a String<\/code> that represents a greeting: previous incarnations of greetJedi<\/code> had simply written the greeting directly to the appropriate output. Let’s see a few examples, where greetJedi<\/code> is called, and the string it returns is output via the println<\/code> function:<\/p>\nprintln(greetJedi("Obi-Wan", "Kenobi"))
\nprintln(greetJedi("Anakin", "Skywalker"))
\nprintln(greetJedi("Qui-Gon", "Jinn"))
\n<\/codeswift><\/p>\nThis would result in the following being displayed in the sidebar of your playground:<\/p>\n
Greetings Master Obi-Wan!
\nGreetings Master Anakin!
\nGreetings Master Qui-Gon<\/codeswift><\/p>\n It’s beneficial to know that
all<\/strong> functions actually return a value, even those that do not explicitly define one. Functions without a defined return type actually return a special value of type Void<\/code>. This is simply an empty tuple, which can also be written as ()<\/code>.<\/p>\nTake this function for example:<\/p>\n
func saySomething() {
\n println("Hullo World!")
\n}<\/codeswift><\/p>\nAlthough there is no need to do so, it could also be written as:<\/p>\n
func saySomething() -> ()<\/codeswiftbold> {
\n println("Hullo World!")
\n}<\/codeswift> <\/div>\nReturning Tuples<\/h3>\n
If you wish to return more than one value from a function then consider returning a tuple. The following example takes an array of names and returns the first and last name from the array:<\/p>\n
func getFirstAndLast(names: [String]) -> (first: String, last: String) {
\n return (names[0], names[names.count – 1])
\n}<\/codeswift>
\n
\nlet names = ["Luke", "Ben", "Anakin", "Yoda"]
\nlet result = getFirstAndLast(names)
\nprintln("\\(result.first) and \\(result.last)")<\/codeswift><\/p>\nThe code snippet above will print the following in your playground’s sidebar:<\/p>\n
Luke and Yoda<\/codeswift><\/p>\nPlayground Experiment<\/span> Our
getFirstAndLast<\/code> function above isn’t particularly robust. If you pass an empty array to it you’ll receive an error.<\/p>\nRe-write the function to safeguard against this by returning nil<\/code> when there are fewer than two names within the array. You’ll need to return an optional tuple to achieve this. <\/div><\/div>\nLocal and External Parameter Names<\/h3>\n
Most of the functions we’ve written so far have defined parameter names. These names are local parameters<\/em><\/strong> however and can only be used within the function’s body.<\/p>\nWith Swift you can also define external parameter names<\/em><\/strong>, which are used when calling the function and help to clarify the purpose of each parameter. When defining a function, the parameter’s external name is placed directly before its local name.<\/p>\nHere’s our greetJedi<\/code> function but with an external name defined for each parameter:<\/p>\nfunc greetJedi(forename<\/codeswiftbold> forename: String, surname<\/codeswiftbold> surname: String) -> String {
\n return "Greetings Master \\(forename)!"
\n}<\/codeswift><\/p>\nAnd here is the function being called:<\/p>\n
greetJedi(forename:<\/codeswiftbold> "Luke", surname:<\/codeswiftbold> "Skywalker")<\/codeswift><\/p>\nAs a comparison, here’s how the call looked before external parameter names were defined:<\/p>\n
greetJedi("Luke", "Skywalker")<\/codeswift><\/p>\nIf an external name is defined for a parameter then it must<\/strong> be used when calling its function.<\/p>\nIn the example above, our external parameter names were identical to the function’s local parameter names, however they can be different. Here’s another example to illustrate this:<\/p>\n
func setPoint(atX<\/codeswiftbold> x: Float, andY<\/codeswiftbold> y: Float) {
\n \/\/ Implementation goes here
\n}<\/codeswift><\/p>\nsetPoint(atX: 10.5 andY: 15.25)<\/codeswift><\/p>\nAs an alternatively we can alter the function’s name and apply an external name to just the second parameter:<\/p>\n
func setPointAtX<\/codeswiftbold>(x: Float, andY<\/codeswiftbold> y: Float) {
\n \/\/ Implementation goes here
\n}<\/codeswift><\/p>\nsetPointAtX(10.5, andY: 15.25)<\/codeswift><\/p>\n If you’re an Objective-C developer then external parameter names should help provide the same level of expressiveness that you’re used to when defining and calling Objective-C methods. <\/div>\n
If you wish to provide an external parameter name that is identical to the function’s local parameter name then there is no need to write the same name twice. Instead you can prefix your local parameter with a hash symbol (#<\/code>). By using this shorthand external parameter name syntax, we can change our greetJedi<\/code> function from:<\/p>\nfunc greetJedi(forename forename: String, surname surname: String) -> String {
\n return "Greetings Master \\(forename)!"
\n}<\/codeswift><\/p>\nto this:<\/p>\n
func greetJedi(#<\/codeswiftbold>forename: String, #<\/codeswiftbold>surname: String) -> String {
\n return "Greetings Master \\(forename)!"
\n}<\/codeswift><\/p>\nDefault Parameter Values<\/h3>\n
A default value can be assigned to a function’s parameter. Any parameters with a default value should be placed at the end of the function’s parameter list. Here’s an example where the energy<\/code> parameter is defaulted to 50<\/code>:<\/p>\nfunc describeJedi(name: String, energy: Int = 50<\/codeswiftbold>) -> String {
\n var description = "\\(name) is "
\n if energy < 40 {\n description += "weak."\n } else if energy < 80 {\n description += "an average Jedi."\n } else {\n description += "a powerful Jedi."\n }<\/codeswift>
\n
\n return description
\n}<\/codeswift><\/p>\nThe following call:<\/p>\n
describeJedi("Luke Skywalker")<\/codeswift><\/p>\nWill return Luke Skywalker is an average Jedi.<\/code> (he’s actually an awesome Jedi: this is just a silly example remember) Because the function call’s second argument was omitted, a default value of 50<\/code> was used.<\/p>\nOf course, you can explicitly specify the second argument:<\/p>\n
describeJedi("Yoda", energy: 100<\/codeswiftbold>)<\/codeswift><\/p>\nNotice the use of the second parameter’s external name in the call above. You may have spotted that we didn’t actually define an external name for this parameter. For parameters with default values, Swift automatically assigns an external name that matches the parameter’s local name. You can of course, explicitly assign an external parameter name of your own choosing. Alternatively you can opt-out of Swift’s default behaviour by placing an underscore (_<\/codeswift>) where the external parameter name would normally be. Here’s an example:<\/p>\nfunc describeJedi(name: String, _<\/codeswiftbold> energy: Int = 50) -> String {
\n \/\/ Implementation goes here
\n}<\/codeswift><\/p>\nYour call to describeJedi<\/code> would now look like this:<\/p>\ndescribeJedi("Yoda", 100)<\/codeswift><\/p>\nVariadic Parameters<\/h3>\n
Swift provides support for variadic parameters. A function can have at most one variadic parameter, which accepts zero or more values of a specified type. Variadic parameters are ideal when writing a function that can be passed a varying number of input values. Place three period characters (…<\/codeswift>) directly after a parameter’s type to indicate that it is a variadic parameter:<\/p>\nfunc averageStarfightersLost(numbers: Int...<\/codeswiftbold>) -> Double {
\n var total: Double = 0
\n for number in numbers {
\n total += Double(number)
\n }
\n return total \/ Double(numbers.count)
\n}<\/codeswift><\/p>\nThe function above is used to determine the average number of starfighters the Rebel Alliance lose during space battles. It accepts a list of integers, where each integer represents the number of fighters lost in a particular battle.<\/p>\n
Each of the values passed to a variadic parameter are made available within the function as an array of the appropriate type. In the example above, the number of starfighters lost in each battle are made available as an array of integers. The array uses the variadic parameter’s name (in this case numbers<\/code>).<\/p>\nWhen calling averageStarfightersLost<\/code>, each of the integers passed should be separated by a comma. Here are a few examples:<\/p>\nvar avg = averageStarfightersLost(10, 5, 0, 4, 1, 0, 0, 6)
\nprintln("The rebel’s are losing \\(avg) X-wings per battle.")<\/codeswift>
\n
\navg = averageStarfightersLost(20, 15, 4, 0, 8)
\nprintln("The rebel’s are losing \\(avg) Y-wings per battle.")<\/codeswift><\/p>\nIf your function has more than one parameter, and one of those parameters is a variadic parameter, then place the variadic parameter last in the parameter list. This is also the case even if some of your other parameters have been assigned default values.<\/p>\n
Playground Experiment<\/span> As stated, a variadic parameter can accept zero or more input values. Our
averageStarfightersLost<\/code> function however seems to have a problem when zero input values are passed to it: it returns (nan)<\/code> instead of the value 0.0<\/code>.<\/p>\nSee if you can identify why this is and make a fix to your function to ensure that 0.0<\/code> is returned when the following call is made:<\/p>\navg = averageStarfightersLost()<\/code> <\/div><\/div>\nConstant and Variable Parameters<\/h3>\n
Unlike many languages, parameters in Swift are constants by default. Take the following example:<\/p>\n
func describeJedi(name: String, energy: Int) -> String {
\n name += " has an energy of \\(energy)"
\n return name
\n}<\/codeswift><\/p>\nIt will return the following compile-time error: Cannot assign to 'let' value 'name'<\/code>.<\/p>\nIf you want to change the value of a parameter within the body of your function then you must explicitly specify that parameter as a variable parameter<\/em><\/strong> by prefixing it with the var<\/code> keyword:<\/p>\nfunc describeJedi(var<\/codeswiftbold> name: String, energy: Int) -> String {
\n name += " has an energy of \\(energy)"
\n return name
\n}<\/codeswift><\/p>\nNow the name<\/code> parameter’s value can be modified within the body of your function.<\/p>\nIn-Out Parameters<\/h3>\n
Variable parameters can only be changed within a function’s body. Changes in value do not persist outside of the function. If you want a change to a parameter’s value to persist after the function call has taken place then define the parameter as an in-out parameter<\/em><\/strong>.<\/p>\nTo specify an in-out parameter, place the inout<\/code> keyword at the beginning of the parameter’s definition:<\/p>\nfunc swapLightsabers(inout<\/codeswiftbold> lightsaber1: String, inout<\/codeswiftbold> lightsaber2: String) {
\n let temp: String = lightsaber1
\n lightsaber1 = lightsaber2
\n lightsaber2 = temp
\n}<\/codeswift><\/p>\nThe function above takes two string parameters that each represent the colour of a Jedi’s lightsaber, and swaps them. After the function has executed, the first lightsaber will have the colour of the second lightsaber and vice versa. Here’s how to call swapLightsabers<\/code>:<\/p>\nvar lukesLightsaber = "blue"
\nvar yodasLightsaber = "green"<\/codeswiftbold>
\nprintln("Luke’s lightsaber is \\(lukesLightsaber)")
\nprintln("Yoda’s lightsaber is \\(yodasLightsaber)")<\/codeswift>
\n
\nswapLightsabers(&lukesLightsaber, &yodasLightsaber)<\/codeswiftbold>
\nprintln("Luke’s lightsaber is now \\(lukesLightsaber)")
\nprintln("Yoda’s lightsaber is now \\(yodasLightsaber)")<\/codeswift><\/p>\nTyping the above into your playground file will result in the following being output:<\/p>\n
Luke’s lightsaber is blue
\nYoda’s lightsaber is green
\nLuke’s lightsaber is now green
\nYoda’s lightsaber is now blue<\/codeswift><\/p>\nNotice in the example above that two variables (lukesLightsaber<\/code> and yodasLightsaber<\/code>) are passed as arguments to the swapLightsabers<\/code> function. You cannot pass a constant or a literal value as an argument since their values cannot be modified. Also notice that an ampersand (&<\/codeswift>) needs to be placed directly before the variable’s name when passing it as an argument to an in-out parameter.<\/p>\nThe point to take from this example is that the function doesn’t return anything. By specifying both parameters as in-out parameters, the changes are made directly to the variables (lukesLightsaber<\/code> and yodasLightsaber<\/code>) that are passed in as arguments to our function.<\/p>\nStructs<\/h2>\n
If you’re from an Objective-C or C background then you’ll be familiar with structures (often referred to as structs). In fact, unlike some languages, structures in Swift share many of the powerful capabilities you’d normally associate with classes.<\/p>\n
If on the other hand, you develop with an ECMAScript-based language such as JavaScript or ActionScript then you may not have come across structures. However, they aren’t difficult to grasp.<\/p>\n
A structure is declared using the struct<\/code> keyword and its definition is placed within a pair of braces. Its general form looks like this:<\/p>\nstruct StructName {
\n \/\/ Implementation goes here
\n}<\/codeswift><\/p>\nHere’s a concrete example of a structure that represents a two-dimensional point:<\/p>\n
struct Point {
\n var x = 0.0, y = 0.0
\n}<\/codeswift><\/p>\nThis struct contains two stored properties<\/em><\/strong> named x<\/code> and y<\/code>. Both are variables of type Double<\/code> and have default values of 0.0<\/code>.<\/p>\nInstantiating a Struct<\/h3>\n
To use a structure you must create an instance of it using initializer syntax. Here’s an example where we instantiate our Point<\/code> structure:<\/p>\nvar target = Point()<\/codeswift><\/p>\nThis creates a variable named target<\/code> that represents a Point<\/code> instance. The instance’s x<\/code> and y<\/code> properties are set to their default value of 0.0<\/code>.<\/p>\nStructures also provide a memberwise initializer<\/em><\/strong>, which can be used to initialise each of the structure’s stored properties:<\/p>\nvar target = Point(x: 64, y: 12.5)<\/codeswift><\/p>\nThe snippet above instantiates an instance that has a default x<\/code> value of 64<\/code> and a default y<\/code> value of 12.5<\/code>. You must provide a value for every one of the structure’s stored properties. Take a look at the following:<\/p>\nvar target = Point(x: 64)<\/codeswift><\/p>\nThis will result in the following compile-time error: Missing argument for parameter 'y' in call<\/code>.<\/p>\nAccessing Properties<\/h3>\n
You can access and modify an instance’s stored properties using