Swift Academy · Aula

Rótulos de argumentos e nomes de parâmetros

Diferencie nomes externos e internos de parâmetros e veja como a chamada do Swift se parece com inglês.

Rótulos de argumentos e nomes de parâmetros é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Boas-vindas

As funções do Swift têm dois nomes para cada parâmetro: um rótulo de argumento *externo*, usado no local da chamada, e um nome de parâmetro *interno*, usado dentro do corpo da função.

Nomes externos e internos

```swift func greet(person name: String) { print("Hello, \(name)!") } greet(person: "Alice") // call site uses 'person' // body uses 'name' ``` O rótulo externo melhora a legibilidade no local da chamada.

Omitindo o rótulo externo com _

Use `_` para suprimir o rótulo do argumento: ```swift func square(_ n: Int) -> Int { n * n } print(square(5)) // 25 — no label needed ``` É comum em funções matemáticas e utilitárias, nas quais o rótulo seria redundante.

Rótulos que formam frases em inglês

Rótulos bem escolhidos fazem os locais de chamada soarem como frases: ```swift func move(from source: String, to destination: String) {} move(from: "Home", to: "Work") ``` Este é um princípio central de projeto de APIs do Swift.

Mesmo nome externo e interno

Quando apenas um nome é fornecido, ele serve para as duas finalidades: ```swift func add(a: Int, b: Int) -> Int { a + b } add(a: 3, b: 4) // label == parameter name ``` É um estilo comum para funções simples.

Vários parâmetros

```swift func divide(_ numerator: Double, by denominator: Double) -> Double { numerator / denominator } let result = divide(10.0, by: 2.0) // 5.0 ``` O primeiro parâmetro geralmente não tem rótulo; os seguintes têm rótulos descritivos.

Rótulos de parâmetros em APIs

As próprias APIs da Apple demonstram este padrão: ```swift array.insert(42, at: 0) string.replacingOccurrences(of: "a", with: "b") URLSession.shared.dataTask(with: request) ``` Leia cada local de chamada em voz alta — ele deve soar natural.

Sobrecarga com rótulos diferentes

Funções com o mesmo nome, mas rótulos diferentes, são distintas: ```swift func load(url: String) {} func load(file: String) {} load(url: "https://example.com") load(file: "/tmp/data.json") ``` Os rótulos diferenciam as sobrecargas sem alterar o nome-base.

Chamadas de funções aninhadas e rótulos

Os rótulos continuam valendo quando as chamadas são aninhadas: ```swift func stringify(_ n: Int) -> String { "\(n)" } func print(line value: String) { print(value) } print(line: stringify(42)) // "42" ```

Boas práticas

Orientações: • Omita o primeiro rótulo quando o nome da função o indicar: `makeURL(string:)` → `makeURL("…")` • Use preposições gramaticais como rótulos externos: `at`, `with`, `from`, `to` • Evite rótulos que repitam informações de tipo: `func add(intValue v: Int)` é redundante

Verificação rápida

Qual símbolo suprime o rótulo externo do argumento no local da chamada?

Recapitulação

Principais pontos: • `func f(external internal: Type)` — dois nomes, o externo no local da chamada • `_` suprime o rótulo externo • Rótulos bem escolhidos fazem os locais de chamada soarem como frases em inglês • O rótulo e o nome são iguais quando apenas um é fornecido A seguir: parâmetros padrão e variádicos.

Perguntas Frequentes

A aula “Rótulos de argumentos e nomes de parâmetros” é grátis?

Sim — o texto completo de “Rótulos de argumentos e nomes de parâmetros” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Rótulos de argumentos e nomes de parâmetros”?

Diferencie nomes externos e internos de parâmetros e veja como a chamada do Swift se parece com inglês. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Rótulos de argumentos e nomes de parâmetros”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Rótulos de argumentos e nomes de parâmetros
Parâmetros padrão e variádicos
Parâmetros in-out e múltiplos retornos
Funções como valores de primeira classe

← Voltar para Swift Academy