Qual é o representante _ sublinhado no Swift References?

Na seção de referência dos documentos da Apple, existem muitas instâncias desse tipo de coisa:

func runAction(_action: SKAction!)

O 'Objetivo-C' equivalente 'disso é:

- (void)runAction:(SKAction *)action

Parece-me que provavelmente é importante que (na referência Swift) exista um espaço após o sublinhado e a "ação" serem escritas em itálico.

Mas não consigo descobrir o que isso está tentando transmitir. Então talvez a pergunta seja ... existe uma referência para as convenções usadas nas referências?

- aqui está a página que estou referenciando nesta referência ao uso de sublinhado: https://developer.apple.com/documentation/spritekit/sknode#//apple_ref/occ/instm/SKNode/runAction

Atualizar

O Swift 3 fez algumas alterações na maneira como os nomes de parâmetros de função / método e os rótulos de argumentos são usados ​​e nomeados. Isso tem implicações sobre esta questão e sua resposta. O @Rickster faz um trabalho incrível ao responder a uma pergunta diferente sobre _underscores em funções que esclarece muito isso aqui: Por que preciso de sublinhados rapidamente?

Ambas as respostas estavam corretas, mas quero esclarecer um pouco mais.

_é usado para modificar o comportamento do nome do parâmetro externo para métodos .

Na seção Nomes de Parâmetros Locais e Externos para Métodos da documentação, ele diz:

Swift fornece ao primeiro nome de parâmetro em um método um nome de parâmetro local por padrão e fornece o segundo e os nomes de parâmetro subseqüentes, tanto nomes de parâmetros locais quanto externos por padrão.

Por outro lado, funções por padrão não possuem nomes de parâmetros externos.

Por exemplo, temos este foo()método definido na classe Bar:

class Bar{
    func foo(s1: String, s2: String) -> String {
        return s1 + s2;
    }
}

Quando você liga foo(), é chamado como bar.foo("Hello", s2: "World").

Mas , você pode substituir esse comportamento usando _na frente de s2onde ele foi declarado.

func foo(s1: String, _ s2: String) -> String{
    return s1 + s2;
}

Então, quando você chama foo, pode ser chamado simplesmente como bar.foo("Hello", "World")sem o nome do segundo parâmetro.

De volta ao seu caso, runActioné um método porque está associado ao tipo SKNode, obviamente. Assim, colocar um _parâmetro before actionpermite que você chame runActionsem um nome externo.

Atualização para Swift 2.0

Função e método agora funcionam da mesma maneira em termos de declaração de nome de argumento local e externo.

As funções agora são chamadas usando o nome do parâmetro externo por padrão, iniciando no segundo parâmetro. Esta regra se aplica apenas ao código Swift puro.

Portanto, fornecendo um _na frente de uma função , o chamador não precisará especificar o nome do parâmetro externo, exatamente como o que você faria para um método .

O sublinhado é um token geral usado para indicar um valor descartado.

Nesse caso específico, significa que a função será chamada como em runAction(argument)vez derunAction(action:argument)

Em outros contextos, tem outro significado semelhante, por exemplo:

for _ in 0..<5 { ... }

Isso significa que queremos apenas executar o bloco 5 vezes e não nos importamos com o índice dentro do bloco.

Neste contexto:

let (result, _) = someFunctionThatReturnsATuple()

Isso significa que não nos importamos com o que é o segundo elemento da tupla, apenas o primeiro.

Desde o Swift 3, todos os rótulos de argumentos são obrigatórios por padrão .

Você pode forçar um IDE a ocultar um rótulo de argumento _.

func foo(a: String) {
}

func foo2(_ a: String) {
}

chamado foo(a: "abc")efoo2("abc")

Nota: Isso pode ser usado apenas quando aé o rótulo do argumento (externo) e o nome da variável (interna) ao mesmo tempo. É equivalente - func foo(a a: String)não aceita o _.

Por que a Apple está usando?

Você pode ver que a Apple está usando-o na API. As bibliotecas da Apple ainda são escritas em Objective-C (caso contrário, elas compartilham os mesmos nomes de função, que foram projetados para a sintaxe Objective-C)

Funções como applicationWillResignActive(_ application: UIApplication)teriam um nome de parâmetro redundanteapplication , pois já existe o aplicativo em seu nome de função.

Seu exemplo

func runAction(_ action: SKAction!)seria chamado sem sua _marca como runAction(action:). O nome do parâmetro actionseria redundante, pois já existe um no nome da função. Esse é o propósito e por que está lá.

Um identificador na frente da declaração de parâmetro define um nome de parâmetro externo . Este é o nome que deve ser fornecido pelo chamador ao chamar a função:

func someFunction(externalParameterName localParameterName: Int)

Swift fornece um nome externo automático para qualquer parâmetro padrão definido, se você não fornecer um nome externo. O uso de um sublinhado para o nome do parâmetro externo opta por esse comportamento:

Você pode desativar esse comportamento escrevendo um sublinhado ( _) em vez de um nome externo explícito ao definir o parâmetro.

Você pode ler mais sobre esse comportamento na seção Nomes externos para parâmetros com valores padrão aqui .

Eu acho que isso força uma convenção em Swift que a torna mais próxima do objetivo-c, que combina melhor com as convenções de cacau. Em objc, você não (externamente) nomeia seu primeiro parâmetro. Em vez disso, por convenção, você geralmente inclui o nome externo na última parte do nome do método, assim:

- (void)myFancyMethodWithFirstName:(NSString *)aFirstName lastName:(NSString *)aLastName;

[someInstance myFancyMethodWithFirstName:@"John" lastName:@"Doe"];

Para tornar as chamadas api do Swift consistentes com objc, você deseja suprimir o nome do parâmetro externo do primeiro parâmetro.

func myFancyMethodWithFirstName(_ firstName:String, lastName:String);

someInstance.myFancyMethodWithFirstName("John", lastName:"Doe")

Na verdade, há uma diferença entre o código real usado para definir um método e a declaração do método nos documentos da Apple. Vamos dar UIControl 's - addTarget: ação: forControlEvents: método, por exemplo, o código real é:

Mas, nos documentos, ele aparece assim (observe _ antes do destino):

No código real, _ é usado para fazer com que o nome externo do segundo parâmetro ou subseqüente não apareça quando um método é chamado, enquanto nos documentos, _ antes do nome local de um parâmetro indica que, quando você chama um método ou uma função, não deve fornecer um nome externo.

Não há nome externo quando uma função é chamada por padrão, a menos que você forneça seu próprio nome ou adicione # antes (sem espaço em branco) do nome local de um parâmetro, por exemplo, é assim que usamos o dispatch_after :

E nos documentos, aparece assim (observe três _):

A convenção da declaração da função é exatamente a mesma que descrevi para o método.

Apenas mais visualmente.

Como você pode ver, _basta fazer omitir um nome de parâmetro local ou não.