objective c not Qual é o representante de sublinhado em Swift References?




using swift in objective c project (6)

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

Neste caso específico, isso significa que a função será invocada como runAction(argument) vez de runAction(action:argument)

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

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

Isso significa que nós simplesmente queremos 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 segundo elemento da tupla, apenas o primeiro.

Na seção de referência dos documentos da Apple, há muitos exemplos desse tipo de coisa:

func runAction(_ action : SKAction!)

O Objective-C 'equivalente' disto é:

- (void)runAction:(SKAction *)

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

Mas não consigo descobrir o que isso está tentando transmitir. Então talvez a questão 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 em como nomes de parâmetros de função / método e rótulos de argumentos são usados ​​e nomeados. Isso tem ramificações sobre essa questão e sua resposta. @Rickster faz um ótimo trabalho respondendo a uma pergunta diferente sobre os recursos em funções que limpam muito disso, aqui: Por que preciso de sublinhados em swift?


Eu acho que isso força uma convenção no Swift que faz com que ela seja mais próxima do objetivo-c, o que combina melhor com as convenções do 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, da seguinte forma:

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

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

Para tornar as chamadas da API do Swift consistentes com o objc, você desejará 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 pegar o método UIControl - addTarget: action: forControlEvents: por exemplo, o código real é:

Mas em docs, aparece assim (note _ antes do alvo):

Em código real, _ é usado para fazer o nome externo do segundo parâmetro ou subseqüente não aparecer quando um método é chamado, enquanto em docs, _ antes do nome local de um parâmetro indicar que quando você chama um método ou uma função, você 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) o nome local de um parâmetro, por exemplo, é assim que usamos dispatch_after :

E em docs, aparece assim (note três _):

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


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:

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

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

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

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

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

Mas , você pode sobrescrever esse comportamento usando _ na frente de s2 onde ele é declarado.

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

Então, quando você chama foo , ele pode ser simplesmente chamado de 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. Portanto, colocar uma action antes do parâmetro permite que você chame runAction sem um nome externo.

Atualização para o Swift 2.0

A função e o 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 aplica-se apenas ao código Swift puro.

Portanto, ao fornecer um _ na frente de uma função , o chamador não precisará especificar o nome do parâmetro externo, exatamente como faria em um método .


Como 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 com _ .

func foo(a: String) {
}

func foo2(_ a: String) {
}

chamado foo(a: "abc") e foo2("abc")

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

Por que a Apple está usando isso?

Você pode ver que a Apple está usando a API. As bibliotecas da Apple ainda estão escritas em Objective-C (se não, elas compartilham os mesmos nomes de funções, que foram projetadas para a sintaxe do Objective-C)

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

Seu exemplo

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


Apenas mais visualmente.

Como você pode ver o _ apenas omita um nome de parâmetro local ou não.







declaration