Enumerations, clase vaga

Un pequeño truco para que Swift escriba todos los cases por nosotros.

enum myMusic {
    case Jazz
    case Clasic
    case Bachata
    case Salsa
    case RYB
    case Regueton
    case Rock
    case Rap
}

var music = myMusic.Jazz

switch music {
}

Forzamos el error al solamente escribir que haremos un switch en el enumerado de music
Esperamos un poco para que aparezca el error.

Oprimimos fix y automaticamente creara todos los cases que tengamos en nuestro enumerado.

switch music {

case .Jazz:
    <#code#>
case .Clasic:
    <#code#>
case .Bachata:
    <#code#>
case .Salsa:
    <#code#>
case .RYB:
    <#code#>
case .Regueton:
    <#code#>
case .Rock:
    <#code#>
case .Rap:
    <#code#>
}

Esto funciona con las 2 formas de hacer enumerados, en un solo caso y con casos individuales.

Tener cuidado que en este ejemplo si usamos él allCase con la inicializada en mayúscula el código no va a funcionar, porque va requerir un valor que represente a todos los valores de ese tipo

enum DailyRoutine: CaseIterable {
    case wakeUp
    case breackfast
    case study
    case lunch
    case code
    case snack
    case moreCode
    case dinner
    case moreMoreCode
    case moreMoreMoreCode
    case goToBed
}
for routine in DailyRoutine.allCases {
    print(routine)
}```

Resumen

Definición de la sintaxis:

enum SomeEnumeration {
    // Definicion de un enumeration
}

Podemos definir cada uno en un case por separado o en una sola línea.

Luego puedo acceder a cada case con .north, por ejemplo, porque Swift sabe que la variable directionToGo es del tipo CompassPoint.

enum CompassPoint {
    case north
    case south
    case east
    case west
}

enum Planet {
    case mercury, venus, earth, mars, jupiter, uranus, neptune
}

var directionToGo = CompassPoint.east
directionToGo = .south

Ejemplos:

switch directionToGo {
case .north:
    print("Hay que ir al norte")
case .south:
    print("Hay pinguinos en el sur")
case .east:
    print("Mordor se extiende hacia las tierras del este")
case .west:
    print("Cuidado con los vaqueros")
}

let somePlanet = Planet.earth
switch somePlanet {
case .earth:
    print("La tierra es segura")
default:
    print("No es segur ir a ese planeta")
}

Si queremos recorrer lo elementos de un enumeration, tenemos que usar un protocolo llamado CaseIterable.

Los protocolos nos permiten delegar funcionalidades.

enum Beverage: CaseIterable {
    case coffee, tea, juice, redbull
}
let numberOfChoices = Beverage.allCases.count

for beverage in Beverage.allCases {
    print(beverage)
}

dejo mi código de las Tortugas Ninja hehe 🐢🥷

enum TeenageMutantNinjaTurtles: CaseIterable {
    case Abril, Donatello, Leonardo, Rafael, MiguelAngel, Splinter, Jonny
}

let ninjaCharacter = TeenageMutantNinjaTurtles.allCases.count
print("Puedes elejir entre estos \(ninjaCharacter) personajes")

for selectCharacter in TeenageMutantNinjaTurtles.allCases {
    switch selectCharacter{
    case .Abril:
        print("\(selectCharacter) es rapida, inteligente, astuta y viste de amarillo")
    case .Donatello:
        print("\(selectCharacter) es muy inteligente, tecnologico y su cinta es morada")
    case .Leonardo:
        print("\(selectCharacter) es el Lider del grupo, honorable, fuerte y justo, cita azul")
    case .Rafael:
        print("\(selectCharacter) es impulsivo, el mas fuerte del grupo, cinta roja")
    case .MiguelAngel:
        print("\(selectCharacter) es el mas divertido del equipo, es muy agil y su cinta es el naranja")
    case .Splinter:
        print("\(selectCharacter) es el mas sabio y viejo del equipo, el maestro y papa de las torgutas, le encanta el queso")
    case .Jonny:
        print("\(selectCharacter) es fuerte, tenaz y un aliado fiel del equipo, usas una mascara de Hokey")
    }
}

Hice un enumerador para asignarle cinturones en una academia de artes marciales 😄

enum BeltRanks: CaseIterable {
    case white
    case blue
    case purple
    case brown
    case black
}

var students = [String : BeltRanks]()

func registerStudent(studentName: String, belt: BeltRanks) {
    students.updateValue(belt, forKey: studentName)
    print("\(studentName) is a new \(belt) belt in the academy")
}

registerStudent(studentName: "Jonathan", belt: .white)
registerStudent(studentName: "Jonathan", belt: .blue)

enum RoutineMorning: CaseIterable {
    case wakeup,makebed,makeBreakFast,meditation,exercise
}


for routineMornings in RoutineMorning.allCases {
    print("Mi rutina es:\(routineMornings)")
}

para poder extraer el numero de casos de un enum, poder utilizar allCases e igual poder realizar un switch hay que hacerlo por separado, una constante para la el conteo de casos y una variable para los casos en el switch; esto debido a que podrían ser de distintos tipos, en este caso al pasar por el switch se vuelve String y al realizar el conteo de tipo numérico

enum GeneroMusical: CaseIterable {
case banda, rock, reggaeton, clasica, reggae, salsa, bachata
}
var genMusical = GeneroMusical.banda
genMusical = .bachata
switch genMusical {
case .banda:
print(“El papel cambió - El komander”)
case .clasica:
print(“Nocturne in C minor - Chopin”)
case .reggae:
print(“Jammin - Bob Marley”)
case .reggaeton:
print(“Y nos fuimos hasta abajo - Daddy Yankey”)
case .rock:
print(“Bohemian Rhapsody -Queen”)
case .salsa:
print(“Te va a Doler - Gilberto Santa Rosa”)
case.bachata:
print(“La mejor version de mi - Natti Natasha feat Romeo Santos”)
}

let numGenMus = GeneroMusical.allCases.count

enum PublicTransport : CaseIterable{
    case bus, metro, trolleyCar, train, taxi, uber
}

for publicTransport in PublicTransport.allCases{
    print(publicTransport)
}

//reto
enum aplicationsIUse: CaseIterable {
    case Bank, Whatsapp, Brave, mail
}

enum Footwear: CaseIterable {
    case sneakers, shoes, sandals, slippers
}

let numberOfFootwear = Footwear.allCases.count

for footwear in Footwear.allCases {
    print(footwear)
}

enum MusicalGenre: CaseIterable {
    case Rock, Pop, Metal, Cumbia, Reggaeton, Salsa, Electronica
}

for musicGen in MusicalGenre.allCases{
    print(musicGen)
}```

import UIKit

enum Week {
    case sunday, monday, tuesday, wednesday, thursday, friday, saturday
}

let today = Week.saturday

//Reto
enum NotasMusicales: CaseIterable
{
    case A, B, C, D, E, F, G
}

for notas in NotasMusicales.allCases
{
    print(notas)
}
print("Número de notas: \(NotasMusicales.allCases.count)")
//OUTPUT: A B C D E F G
//Número de notas: 7

Sobre lo de ser inclusivo al pedir al usuario su género, os quiero recordar que ahora mismo la convención más adoptada es “Hombre, Mujer, No Binario, Prefiero no especificarlo”. “Indefinido” no sería correcto ya que su género sí está definido, solo que no es hombre ni mujer. Poco a poco todos tenemos que trabajar y aprender para hacer de esta industria un lugar cada vez más inclusivo y acogedor con todo el mundo 😃

¡Un saludo a todos!

enum MartialArts: CaseIterable {
    case muayThai, Karate, Judo, kickBoxing, Box, JuJitsu
}

//let martialArts = MartialArts.allCases.count

for martialAert in MartialArts.allCases {
    print(martialAert)
}