Swift Academy · Aula

Alternativas sem Mutação

Retorne novos valores em vez de modificar o valor no local.

Aula 4 de 413 etapas

Alternativas sem Mutação é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 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.

Retornar em vez de alterar

Em vez de alterar uma instância no próprio lugar, um método sem mutação pode retornar um valor totalmente novo com a alteração aplicada.

struct Counter {
    var value: Int
    func incremented() -> Counter {
        return Counter(value: value + 1)
    }
}
let c = Counter(value: 0)
let next = c.incremented()
print(c.value, next.value)

O original permanece inalterado

Como nada é alterado, o valor original é preservado e um novo valor é produzido.

struct Vector {
    var x: Int
    var y: Int
    func scaled(by factor: Int) -> Vector {
        return Vector(x: x * factor, y: y * factor)
    }
}
let v = Vector(x: 2, y: 3)
let big = v.scaled(by: 10)
print(v.x, v.y, big.x, big.y)

Funciona em instâncias let

Métodos sem mutação podem ser chamados em constantes let, pois não alteram o receptor.

struct Money {
    var cents: Int
    func plus(_ other: Int) -> Money {
        return Money(cents: cents + other)
    }
}
let m = Money(cents: 100)
print(m.plus(50).cents)

Convenção de nomenclatura

Convenção do Swift: métodos mutating usam verbos no imperativo (sort), enquanto os métodos sem mutação usam formas de particípio passado ou terminações -ed/-ing (sorted).

var nums = [3, 1, 2]
let ordered = nums.sorted()
nums.sort()
print(ordered, nums)

sorted e sort

A biblioteca padrão segue esta convenção: sorted() retorna uma nova matriz, enquanto sort() altera a matriz no próprio lugar.

let a = [5, 2, 8, 1]
let b = a.sorted()
print(a)
print(b)

reversed e reverse

Da mesma forma, reversed() não altera o valor. Aqui, materializamos o resultado com Array.

let a = [1, 2, 3]
let b = Array(a.reversed())
print(a, b)

Encadeando chamadas sem mutação

Métodos sem mutação retornam valores, portanto você pode encadeá-los de maneira fluida.

let result = [4, 2, 9, 1].sorted().map { $0 * 2 }
print(result)

Estilo funcional

Retornar novos valores em vez de alterar os existentes favorece um estilo funcional que é fácil de testar e compreender.

struct Account {
    var balance: Int
    func deposited(_ n: Int) -> Account {
        return Account(balance: balance + n)
    }
}
let a0 = Account(balance: 0)
let a1 = a0.deposited(100).deposited(50)
print(a0.balance, a1.balance)

Evitando erros de estado compartilhado

Produzir novos valores evita alterações compartilhadas acidentais, o que é especialmente útil entre linhas de execução.

struct Settings {
    var volume: Int
    func with(volume newVolume: Int) -> Settings {
        return Settings(volume: newVolume)
    }
}
let base = Settings(volume: 5)
let loud = base.with(volume: 11)
print(base.volume, loud.volume)

Quando alterar em vez disso

Se você estiver atualizando repetidamente uma instância em um laço, a mutação no próprio lugar pode ser mais eficiente do que criar muitas cópias.

var total = 0
for n in 1...5 {
    total += n
}
print(total)

Ofereça as duas formas

Tipos bem projetados às vezes oferecem as duas formas, como a biblioteca padrão, para que os chamadores escolham entre alterar a instância ou obter um valor novo.

struct Text {
    var value: String
    func uppercased() -> Text {
        return Text(value: value.uppercased())
    }
    mutating func uppercase() {
        value = value.uppercased()
    }
}
var t = Text(value: "hi")
let u = t.uppercased()
t.uppercase()
print(u.value, t.value)

Verificação rápida

Teste o design sem mutação.

Responda na aula interativa

Recapitulação

Como alternativa à mutação, um método sem mutação retorna um novo valor com a alteração aplicada, deixando o original intacto e funcionando em instâncias let. A convenção do Swift associa nomes no imperativo (sort) a nomes com terminações -ed/-ing (sorted).

let a = [3, 1, 2]
let b = a.sorted()
print(a, b)

Grátis para começar

Aprenda Swift com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 122
Aulas: 409

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Alternativas sem Mutação” é grátis?

Sim — o texto completo de “Alternativas sem Mutação” é 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 “Alternativas sem Mutação”?

Retorne novos valores em vez de modificar o valor no local. 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 4 de 4.

Quanto tempo leva a aula “Alternativas sem Mutação”?

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

← Voltar para Swift Academy