Swift Academy · Aula

Parâmetros padrão e variádicos

Defina valores padrão e aceite quantidades variáveis de argumentos.

Parâmetros padrão e variádicos é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 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

Valores padrão de parâmetros permitem que quem chama omita argumentos que não precisa personalizar. Parâmetros variádicos aceitam qualquer número de argumentos. Ambos reduzem código repetitivo e melhoram as APIs.

Valores padrão de parâmetros

```swift func log(_ message: String, level: String = "INFO") { print("[\(level)] \(message)") } log("Server started") // [INFO] Server started log("Disk full", level: "ERROR") // [ERROR] Disk full ``` Os valores padrão devem ser colocados depois dos parâmetros obrigatórios.

Vários valores padrão

```swift func connect(host: String, port: Int = 443, useTLS: Bool = true) {} connect(host: "api.example.com") connect(host: "api.example.com", port: 8080) connect(host: "api.example.com", port: 80, useTLS: false) ``` Quem chama pode substituir qualquer subconjunto dos parâmetros com valores padrão.

Parâmetros variádicos

Um parâmetro variádico aceita zero ou mais valores do mesmo tipo: ```swift func sum(_ numbers: Int...) -> Int { numbers.reduce(0, +) } print(sum(1, 2, 3)) // 6 print(sum(10, 20, 30, 40)) // 100 ``` Dentro da função, `numbers` é uma matriz `[Int]`.

Apenas um parâmetro variádico por função

O Swift permite apenas um parâmetro variádico por função (ele não precisa ser o último desde o Swift 5.4): ```swift func format(_ template: String, args: String...) -> String { var result = template for arg in args { result = result.replacingOccurrences(of: "%s", with: arg) } return result } ```

Combinando valores padrão e parâmetros variádicos

```swift func build(separator: String = ", ", _ items: String...) -> String { items.joined(separator: separator) } build("apple", "banana", "cherry") // "apple, banana, cherry" build(separator: " | ", "one", "two", "three") // "one | two | three" ```

Passando uma matriz para um parâmetro variádico

Não é possível passar uma matriz diretamente para um parâmetro variádico: ```swift let nums = [1, 2, 3] // sum(nums) ❌ — won't compile ``` Descompacte com `...` (a expansão de sequências no Swift 5.4+ não é integrada; use redução/expansão por conta própria): ```swift let total = nums.reduce(0, +) ```

Fechamentos padrão

Os valores padrão também funcionam para parâmetros de fechamento: ```swift func retry(count: Int = 3, action: () -> Bool) {} retry { fetchData() } // count defaults to 3 retry(count: 5) { fetchData() } ``` A sintaxe de fechamento à direita ainda se aplica ao usar valores padrão.

Documentando valores padrão

Comente ou nomeie os valores padrão claramente para que quem chama saiba o que esperar: ```swift /// Sends a request. Timeout defaults to 30 seconds. func send(request: URLRequest, timeout: TimeInterval = 30.0) {} ``` Uma boa documentação evita que quem chama forneça explicitamente o valor padrão.

Padrão do mundo real: APIs semelhantes a print

O `print` padrão do Swift também é variádico e tem valores padrão: ```swift // Simplified signature: func print(_ items: Any..., separator: String = " ", terminator: String = "\n") print("a", "b", "c") // a b c print("x", "y", separator: "-") // x-y print("no newline", terminator: "") ```

Verificação rápida

Dentro de uma função, que tipo tem um parâmetro variádico `Int...`?

Recapitulação

Principais pontos: • Valores padrão tornam os parâmetros opcionais no local da chamada • Os valores padrão devem vir depois dos parâmetros obrigatórios • Parâmetros variádicos (`Type...`) aceitam zero ou mais valores e tornam-se uma matriz dentro da função • Apenas um parâmetro variádico por função • Combine os dois para criar APIs flexíveis e claras A seguir: parâmetros in-out e retorno de vários valores.

Perguntas Frequentes

A aula “Parâmetros padrão e variádicos” é grátis?

Sim — o texto completo de “Parâmetros padrão e variádicos” é 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 “Parâmetros padrão e variádicos”?

Defina valores padrão e aceite quantidades variáveis de argumentos. 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 2 de 4.

Quanto tempo leva a aula “Parâmetros padrão e variádicos”?

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