Swift Academy · Aula

Parâmetros in-out e múltiplos retornos

Modifique argumentos com inout e retorne vários valores por meio de tuplas.

Parâmetros in-out e múltiplos retornos é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 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 normalmente trabalham com cópias de valores. Parâmetros `inout` permitem que uma função modifique diretamente a variável de quem a chama. Tuplas permitem que as funções retornem vários valores de uma só vez.

A palavra-chave inout

Marque um parâmetro como `inout` para modificar o original: ```swift func doubleInPlace(_ value: inout Int) { value *= 2 } var x = 5 doubleInPlace(&x) print(x) // 10 ``` O prefixo `&` no local da chamada indica que a variável pode ser modificada.

inout com estruturas

```swift struct Point { var x: Double; var y: Double } func translate(_ p: inout Point, dx: Double, dy: Double) { p.x += dx p.y += dy } var origin = Point(x: 0, y: 0) translate(&origin, dx: 3.0, dy: 4.0) // origin is now (3.0, 4.0) ```

Restrições de inout

• Constantes (`let`) não podem ser passadas como `inout` • Literais não podem ser passados como `inout` • Subscritos e propriedades computadas podem ser `inout` se tiverem configuradores ```swift let c = 5 doubleInPlace(&c) // ❌ cannot pass let as inout ```

Retornando vários valores com tuplas

Retorne vários valores agrupando-os em uma tupla: ```swift func minMax(of array: [Int]) -> (min: Int, max: Int) { (array.min()!, array.max()!) } let result = minMax(of: [3, 1, 7, 2]) print(result.min, result.max) // 1 7 ```

Elementos de tupla nomeados e sem nome

Elementos nomeados tornam as tuplas autoexplicativas: ```swift let named: (width: Int, height: Int) = (1920, 1080) print(named.width) // 1920 let unnamed = (1920, 1080) print(unnamed.0) // 1920 ``` Prefira nomes para tuplas retornadas por funções.

Desestruturação de retornos de tuplas

Desempacote um retorno de tupla em várias variáveis: ```swift let (minimum, maximum) = minMax(of: [5, 3, 8]) print(minimum) // 3 print(maximum) // 8 ``` Use `_` para descartar elementos desnecessários: `let (minimum, _) = minMax(of: arr)`.

Retornos de tuplas opcionais

Retorne nil nos casos de falha: ```swift func parse(_ s: String) -> (Int, Int)? { let parts = s.split(separator: ",") guard parts.count == 2, let a = Int(parts[0]), let b = Int(parts[1]) else { return nil } return (a, b) } ```

swap com inout

A troca clássica usando inout: ```swift func swap(_ a: inout T, _ b: inout T) { let temp = a a = b b = temp } var m = 1, n = 2 swap(&m, &n) print(m, n) // 2 1 ``` A biblioteca padrão do Swift já fornece `swap(_:_:)` — não é necessário escrever a sua própria versão.

Quando usar inout em vez de retornar

Prefira retornar um novo valor em vez de alterar algo com inout: ```swift // Prefer: func normalised(_ v: SIMD3) -> SIMD3 { v / v.magnitude } // Use inout only when mutation is expected API contract, e.g. algorithms on large arrays func sort(_ arr: inout [Int]) { arr.sort() } ```

Verificação rápida

Qual prefixo é necessário no local da chamada ao passar uma variável para um parâmetro `inout`?

Recapitulação

Principais conclusões: • `inout` permite que as funções alterem as variáveis do chamador; passe-as com `&` • Não é possível passar constantes `let` nem literais como `inout` • As tuplas retornam vários valores de forma organizada; dê nomes aos elementos para maior clareza • Desestruture tuplas: `let (a, b) = f()` • Prefira retornar novos valores; use `inout` somente quando a alteração fizer parte do contrato da interface de programação A seguir: funções como valores de primeira classe.

Perguntas Frequentes

A aula “Parâmetros in-out e múltiplos retornos” é grátis?

Sim — o texto completo de “Parâmetros in-out e múltiplos retornos” é 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 in-out e múltiplos retornos”?

Modifique argumentos com inout e retorne vários valores por meio de tuplas. 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 3 de 4.

Quanto tempo leva a aula “Parâmetros in-out e múltiplos retornos”?

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