81

What does the lone underscore mean in function definitions?

e.g. map(_:)

I understand that when defining functions I can do:

func myFunc(_ string: String) { ... }

Would I then refer to that as myFunc(_:) instead of myFunc(_string:), i.e. purposefully hiding the parameter name?

  • 2
    Worth Reading: Swift 3 has made some changes to how function/method parameter names and argument labels are used and named. Here is _underscores in functions with much clarity: http://stackoverflow.com/questions/24437388/whats-the-underscore-representative-of-in-swift-references – Niraj Jan 03 '17 at 09:55

3 Answers3

108

The _ is used to define that the parameter is not named

If you have multiple _ it states that you do not need to name the parameters in your function call

func myFunc(name:String, _ age:String){
}

myFunc(“Milo", "I'm a really old wizard")

If you do not use the underscore you would use

myFunc(“Milo”, age: "I'm a really old wizard")

The _ is not necessary for function calls. It is just used to indicate that something does not need to have a name.

In regards to how you would refer to your function, You would not have to pass any name for the function call.
But since you also don’t define a parameter type this seems to me like an invalid example (it at least doesn’t work in Xcode 7 with Swift 2.0)

Edit:
Since Swift 3.0

myFunc(name: “Milo”, age: "I'm a really old wizard")

Should be used

Iain Smith
  • 9,230
  • 4
  • 50
  • 61
milo526
  • 5,012
  • 5
  • 41
  • 60
  • 3
    I'm new to swift 2.0. I see that you did not use underscore for the first parameter in both cases. So should you also declare name in the function call like so: myFunc(name: "Milo", age: "I'm a really old wizard") ? – user234159 Sep 24 '16 at 16:12
45

Swift needs a convention for saying what the name of a function is, including not only the function name itself (before the parentheses) but also the external names of the parameters. The convention is that the names are followed by colons. So here's a function declaration (in Swift 2.0):

func myFunc(param1 param1:String, param2:String, param3:String) {}

And here is that function's name:

myFunc(param1:param2:param3:)

In real life, however, it is possible (indeed likely) that one or more parameters will not externalize any name. Thus we need a placeholder for that name. The underscore is that placeholder - just as the underscore is the symbol in the declaration suppressing externalization of the name. So, here's another function declaration (in Swift 2.0):

func myFunc2(param1:String, _ param2:String, _ param3:String) {}

And here is that function's name:

myFunc2(_:_:_:)

[The Swift 2.0 spec is important here. In Swift 2.0, the first param name is always not externalized by default, and the other param names are externalized by default. In Swift 1.2 and before, the externalization rules depended on where the declaration appeared, which was unnecessarily inconsistent and confusing.]

matt
  • 515,959
  • 87
  • 875
  • 1,141
  • In the first declaration, you haven't given external names for the second and third parameters, nor have you used #. So should it really by referred to as you have, or is it correct because it is externalised by default? -- if so, is the # no longer needed? –  Jun 16 '15 at 19:49
  • 1
    @Alex Did you read the note at the bottom of my answer? I am describing the situation for Swift 2.0. And `#` is gone in Swift 2.0. – matt Jun 16 '15 at 19:50
  • I did read it, but was confusing myself trying to relate 2.0 with 1.2, when I shouldn't be. What you've said makes sense, I'll have to re-read the guide with 2.0 this time. @matt –  Jun 16 '15 at 19:56
  • You can't give a function in isolation a consistent name in Swift 1.2, because you don't know how its parameters will be externalized. – matt Jun 16 '15 at 20:00
  • 1
    Worth Reading: Swift 3 has made some changes to how function/method parameter names and argument labels are used and named. Here is _underscores in functions with much clarity: http://stackoverflow.com/questions/24437388/whats-the-underscore-representative-of-in-swift-references – Niraj Jan 03 '17 at 09:56
25

When referring to a function, in order to disambiguate it is necessary to provide the function name along with the external names of any parameters that it expects.

For example,

func myFunc(myString string: String) { ... }

and

func myFunc(_ string: String) { ... }

represent two different functions, one where an external label is provided for the first String parameter when the function is called and the other where no label is used, as in:

myFunc(myString: "hi")

and

myFunc("hi")

So, in order to identify a function we include the external label for each parameter where ':' indicates that a parameter is to be provided - e.g. yourFunc(arg1:arg2:) will take 2 arguments.

When no external label is used, we place an underscore ('_').

For the 2 functions given above, we would uniquely identify them using:

myFunc(myString:) and myFunc(_:)

fqdn
  • 2,823
  • 1
  • 13
  • 16