Enumerações (ou enums para abreviar) em Swift definem um tipo comum para um grupo de valores relacionados. De acordo com a documentação do Swift , enums permitem que você trabalhe com esses valores de forma segura em seu código. Enums são particularmente úteis quando você tem muitas opções diferentes que deseja codificar.
Usar enum em Swift é semelhante a escrever código que retorna um booleano-por exemplo, true ou false -quando uma condição é atendida. No caso de enums, no entanto, você pode ter mais de dois valores possíveis.
Pense em um enum como um termostato. Existe uma gama de valores que podem corresponder ao resultado-por exemplo, baixo, médio, alto, extremo. Dependendo do caso que corresponde, queremos executar algum código especificado.
Um enum é um tipo especial de variável que é usado especificamente com switch e condicionais. Os casos de enumeração Swift não têm valores inteiros padrão exclusivos (como uma matriz), ao contrário de linguagens como TypeScript e Objective C, onde o primeiro elemento tem um valor de 0 , o segundo um valor de 1 e assim por diante.
Neste tutorial, cobriremos todos os conceitos básicos de enums do Swift, incluindo:
- Sintaxe de enum Swift
-
CaseIterableem casos de enumeração - Enum valores brutos
- Valores associados Enum
- Métodos Enum
- Propriedades computadas em enums Swift
Sintaxe de enum Swift
Para definir um enum em Swift, use a palavra-chave enum seguida do nome do enum. O nome de um enum em Swift deve seguir a convenção de nomenclatura PascalCase em que a primeira letra de cada palavra em uma palavra composta é maiúscula.
//começa com a palavra-chave'enum'e segue a convenção de nomenclatura PascalCase
enum EnumerationNmae { //nossos valores enum (case) vão aqui }
Aqui está uma visão mais detalhada de como declarar valores em um enum:
enum Direction { caso acima caso para baixo caso restante caso certo
}
Os valores declarados em um enum- up , down , left e right -são referidos como caso de enumeração. Usamos a palavra-chave case para apresentar um novo caso de enumeração.
Enums são particularmente úteis dentro das instruções switch , ao contrário de uma instrução if-else . Isso ocorre porque, em uma instrução switch, o Swift conhece todos os valores que o enum contém, portanto, garantirá que você cubra todos os casos em seu enum ou adicione um caso padrão.
CaseIterable em casos de enumeração
CaseIterable é um tipo que fornece uma coleção de todos os valores de uma enumeração. É usado para iterar todos os casos em um enum.
Para fazer isso, adicione CaseIterable após o nome do enum. Com isso em vigor, o Swift nos dará acesso a uma coleção de todos os casos por meio de uma propriedade no tipo de enumeração chamada allCases .
enum CarBrand: String, CaseIterable { case Mercedes="Conhecida por luxo e design icônico. Definitivamente meu favorito!" case Toyota="Conhecido por carros de alta qualidade e alto valor" case Volkswagen="Este é o carro do povo" case Ford="Conhecido por seu manuseio nítido, direção absorvente e toque sólido" case Honda="Conhecidos por seus carros confiáveis e bem construídos"
}
Para acessar a coleção de todos os casos em nossa enum CarBrand , podemos fazer isso:
imprimir (CarBrand.allCases.count) //saída esperada: 5
No exemplo acima, escrevemos CarBrand.allCases para acessar uma coleção que contém todos os casos da enumeração CarBrand . O método count fornece o número de elementos em nossa coleção.
Podemos ir mais longe usando um loop for em todos os casos em nosso enum.
Vamos imprimir o valor bruto em nossos casos de enumeração usando o método allCases :
//cria um enum com um tipo CaseIterable enum CarBrand: String, CaseIterable { case Mercedes="Conhecida por luxo e design icônico. Definitivamente meu favorito!" case Toyota="Conhecido por carros de alta qualidade e alto valor" case Volkswagen="Este é o carro do povo" case Ford="Conhecido por seu manuseio nítido, direção absorvente e toque sólido" case Honda="Conhecidos por seus carros confiáveis e bem construídos"
} //estamos percorrendo nosso enum e acessando todos os seus valores brutos
para a marca em CarBrand.allCases { imprimir (brand.rawValue)
}
//saída esperada:
//Conhecida pelo luxo e design icônico. Definitivamente, meu favorito!
//Conhecido por carros de alta qualidade e alto valor
//Este é o carro do povo
//Conhecido por seu manuseio nítido, passeio absorvente e toque sólido
//Conhecidos por seus carros confiáveis e bem construídos
Valores brutos enum
Em nosso enum, podemos declarar um tipo de valor bruto. Basicamente, isso significa anexar um valor ao caso enum.
Para entender melhor os valores brutos em enums, vamos criar um enum do tipo string (pode ser qualquer tipo) para conter diferentes marcas de carros junto com atributos pelos quais cada marca é conhecida (esses serão os valores brutos):
//Enum com valores brutos enum CarBrand: String { case Mercedes="Conhecida por luxo e design icônico. Definitivamente meu favorito!" case Toyota="Conhecido por carros de alta qualidade e alto valor" case Volkswagen="Este é o carro do povo" case Ford="Conhecido por seu manuseio nítido, direção absorvente e toque sólido" case Honda="Conhecidos por seus carros confiáveis e bem construídos"
}
Para definir um valor para seu enum, você precisa atribuir um tipo de dados a ele. Em nosso caso acima, estamos usando um tipo de String .
Cada valor bruto para o nosso caso enum deve ser uma string, caractere ou valor exclusivo de qualquer tipo inteiro ou de ponto flutuante. Isso significa que o valor para as duas declarações de caso não pode ser o mesmo. Veja o código abaixo:
enum CarBrand: String { case Toyota="Carros de alto valor." case Volkswagen="Carros de alto valor."
}
O código acima gera um erro de “ O valor bruto para o caso enum não é exclusivo ” porque os dois valores do caso são exatamente iguais.
Agora que criamos nosso enum com cada caso de enumeração tendo um valor bruto, vamos criar uma função que retornará o rawValue das várias marcas de automóveis. Os valores brutos aqui representam os atributos pelos quais cada marca é conhecida:
func carKnownFor (marca: CarBrand)-> String { return brand.rawValue
} carKnownFor (marca:.Ford)
carKnownFor (marca:.Mercedes) //saída esperada:
//"Conhecido pelo luxo e design icônico. Definitivamente meu favorito!"
//"Conhecido por seu manuseio nítido, passeio absorvente e toque sólido"
Valores associados Enum
Uma das melhores características das enumerações em Swift é que você pode ter valores que você define anexados a enums em cada caso . Isso permite que você anexe informações adicionais às suas enums para que possam representar dados mais significativos.
Por exemplo, digamos que temos um enum que define os preços dos carros Mercedes. Com base no preço, queremos determinar se um usuário pode pagar pelo modelo do carro ou não. Podemos associar um preço à marca do carro em nosso enum como temos no exemplo abaixo:
//enum com valores associados
enum MercedesModelPrice { case MayBach (preço: Int) case AMG_GT (preço: Int) Case Metris (preço: Int) estojo SprinterWagon (preço: Int) case GClass
}
//enum sem valores associados
enum MercedesModelPrice { case MayBach case AMG_GT case Metris estojo SprinterWagon case GClass
}
Agora, vamos criar uma função para verificar se um usuário pode comprar um Mercedes:
func getMercedesPrice (para mercedesModel: MercedesModelPrice) { switch mercedesModel { case.MayBach (preço: preço de venda) onde preço>=100_000: imprimir ("Você acabou de comprar um carro novo") case.Metris (preço: preço de aluguel) onde preço>=86_000: imprimir ("Você acabou de comprar um carro novo") case.AMG_GT (preço: preço let) onde preço>=74_000: imprimir ("Você acabou de comprar um carro novo") case.SprinterWagon (preço: preço de venda) onde preço>=45_000: imprimir ("Você acabou de comprar um carro novo") case.GClass,.SprinterWagon,.Metris,.AMG_GT,.MayBach: imprimir ("Fundos insuficientes. Você não pode comprar este carro no momento") }
} //Chamando nossa função
getMercedesPrice (para:.SprinterWagon (preço: 200_000))
//saída esperada: você acabou de comprar um carro novo
Observe como estamos usando a palavra-chave where para filtrar o case por um preço específico.
É importante notar que a ordem da instrução case é importante. Colocar a última instrução case ( case.GClass,.SprinterWagon,.Metris,.AMG_GT,.MayBach: ) primeiro significa que sempre obteremos o resultado anexado a este caso como uma correspondência.
Métodos Enum
Além de definir casos de enumeração em nosso enum, também podemos definir métodos em nosso enum , como este:
enum Weekday { caso segunda-feira caso terça-feira caso quarta-feira caso quinta-feira caso sexta-feira caso sábado caso domingo função dayType ()-> String { switch self { caso. Domingo,. Sábado: voltar"Fim de semana" padrão: retornar"Dia da semana" } }
} Weekday.Monday.dayType ()
//isso retornará"Dia da semana"
Weekday.Sunday.dayType ()
//isso retornará"Fim de semana"
No trecho de código acima, estamos usando a instrução switch dentro do método dayType para retornar Weekend ou Weekday como a saída, dependendo no dia da semana.
Propriedades computadas em enums Swift
Você também pode usar propriedades computadas em enums no lugar de funções.
Vamos substituir a função dayType que temos em nosso código acima por uma propriedade computada:
enum Weekday { caso segunda-feira caso terça-feira caso quarta-feira caso quinta-feira caso sexta-feira caso sábado caso domingo var dayType: String { self==. Sábado || self==. Domingo?"Fim de semana":"Dia da semana" } } Weekday.Monday.dayType
//isso retornará"Dia da semana"
Weekday.Sunday.dayType
//isso retornará"Fim de semana"
>
Conclusão
Os enums do Swift podem ser uma maneira poderosa de simplificar seu código. Neste tutorial, cobrimos a sintaxe de enums e como defini-los, como criar casos de enumeração e como usá-los em instruções switch . Também definimos CaseIterable como um tipo que fornece uma coleção de todos os valores da enumeração. Abordamos os valores enum (valores brutos e associados) e como usá-los em nossa base de código. Por fim, demonstramos como usar propriedades computadas em enums do Swift no lugar de funções.
A postagem Enums Swift: uma visão geral com exemplos apareceu primeiro no LogRocket Blog .
