Enums Básicos

Clase 27 de 46 • Curso de Swift 4 2018

Oscar Armenta

student•

Hola Andres. Me surge la duda: ¿Qué ocurre si quiero realizar una función que te devuelva absolutamente todos los datos de tipo transaction? ¿De hecho en general como realizas una función que regrese todos los datos de un tipo de valor o todos los datos que tengas? Por ejemplo en tu función los estás filtrando pero que ocurre si no quiero filtrarlos, si quiero regresarlos como cuando en el banco pides un historial de movimientos bancarios. Por favor ayúdame quiero volverme un verdadero experto en iOS development. Traté de realizar dicha función pero no lo logré :( es mas realice un nuevo código diferente al tuyo pero que prácticamente hace lo mismo, todo para practicar y que me quede mas claro.

// Clase para calculadora personal de gastos - Un usuario puede: realizar depositos, realizar gastos, ver su saldo.

struct AmericanExpressClient {
    
    var total:Float {
        willSet (reference) {
            print("Tu saldo era $ \(total) Ahora tu saldo total es $ \(reference) Debido a que:")
        }
        didSet {
            print("Se produjo un \(entryOrExpense) de \(costNumber) por el concepto de \(conceptDescription).")
        }
        
    }
    
    var clientName:String
    var entryOrExpense:String
    var costNumber:Float
    var conceptDescription:String
    
    mutating func entry (concept:String, number:Float) -> Float {
        entryOrExpense = "ingreso"
        costNumber = number
        conceptDescription = concept
        var temporal:Float
        temporal = self.total + number
        self.total += number
        return temporal
    }
    
    mutating func expense (concept:String, number:Float) -> Float {
        var temporal:Float
        if self.total - number < 0 {
            return 0
        } else {
            entryOrExpense = "gasto"
            costNumber = number
            conceptDescription = concept
            temporal = self.total - number
            self.total -= number
        }
    return temporal
    }
    
    mutating func seeBillStatement () -> String {
        var temporal:String = "Hola estimado \(clientName), el saldo total de su cuenta es $ \(total)"
        return temporal
    }
}

var Diego_Armenta = AmericanExpressClient(total: 10_000, clientName: "Diego Armenta Rios", entryOrExpense: "primer pago", costNumber: 0.0, conceptDescription: "nada")

Diego_Armenta.entry(concept: "Salario", number: 15_000)
Diego_Armenta.expense(concept: "Juego de Switch", number: 1_500)
print(Diego_Armenta.seeBillStatement())

Diego_Armenta.expense(concept: "Tenis chulos Nike", number: 6_000)
Diego_Armenta.seeBillStatement()```

Enrique Martinez

student•

Manuel Alejandro Aguilar Téllez Girón

student•

Un enumerador es como una constante que se agrupa dentro de una categoría. Define un tipo común de un grupo de valores relacionados y te permite trabajar con esos valores de una manera segura dentro de tu código.
Aqui

José Francisco Casales Huerta

student•

Comparto mi código del reto

enum DebitCategory{
    case health
    case food
    case services
    case rent
    case transportation
    case entertainment
}

enum GainCategory{
    case pay
    case loan
    case bonus
}

class Transaction{
    var value: Float
    var name: String
    
    init(value: Float, name: String) {
        self.value = value
        self.name = name
    }
}

class Debit: Transaction{
    var assignedCategory: DebitCategory
    init(value: Float, name: String, assignedCategory: DebitCategory){
        self.assignedCategory = assignedCategory
        super.init(value: value, name: name)
    }
}

class Gain: Transaction{
    var assignedCategory: GainCategory
    init(value: Float, name: String, assignedCategory: GainCategory){
        self.assignedCategory = assignedCategory
        super.init(value: value, name: name)
    }
}

Rodrigo Guerra Castilla

student•

enum DebitCategories{
    case health
    case food, rent, tax, transportation
    case entretainment
}
enum GainCategorie{
    case honorarios
    case aguinaldo, utilidades
}

class Transaction {
    var value: Float
    var name: String
    init(value: Float, name:String) {
        self.value = value
        self.name = name
    }
}

class Debit: Transaction{
    var category:DebitCategories
    
    init(value: Float, name: String, category:DebitCategories) {
        self.category = category
        super.init(value: value, name: name)
    }

}

class Gain: Transaction{
    var category: GainCategorie
    
    init(value: Float, name: String, category:GainCategorie) {
        self.category = category
        super.init(value: value, name: name)
    }
    
}

class Account {
    var amount: Float = 0{
        willSet{
            print("Vamos a cambiar el valor", newValue)
        }
        didSet {
            print("Tenemos nuevo valor", amount)
        }
    }
    var name: String = ""
    var transactions:[Transaction] = []
    
    init(amount: Float, name: String) {
        self.amount = amount
        self.name = name
    }
    
    @discardableResult
    func addTransaction(transaction: Transaction) -> Float {
        if transaction is Gain{
            amount += transaction.value
        }
        
        if transaction is Debit{
            if (amount - transaction.value) < 0{
                return 0
            }
            amount -= transaction.value
        }
        
        transactions.append(transaction)
        return amount
    }
    func debits() -> [Transaction] {
        return transactions.filter({$0 is Debit})
    }
    func gains() -> [Transaction] {
        return transactions.filter({$0 is Gain})
    }
    
    func transactionFor(category: DebitCategories) -> [Transaction] {
        return transactions.filter({ (transaction) -> Bool in
            guard let transaction = transaction as? Debit else {
                return false
            }
            
            return transaction.category == category
            })
    }
    
    func  transactionFor(category: GainCategorie) -> [Transaction] {
        return transactions.filter({(transaction) -> Bool in
            guard let transaction = transaction as? Gain else  {
                return false
            }
            return transaction.category == category
        })
    }
}

class Person{
    var name: String = ""
    var lastname: String = ""
    var account: Account?
    
    var fullName: String {
        get{
            return "\(name), \(lastname)"
        }
        set{
            name = String(newValue.split(separator: " ").first ?? "")
            lastname = "\(newValue.split(separator: " ").last ?? "")"
        }
    }
    
    
    init(name: String, lastname: String) {
        self.name = name
        self.lastname = lastname
    }
}

var me =  Person(name: "Rodrigo", lastname: "Guerra")

var account = Account(amount: 100_000, name: "x bank")

me.account = account

print(me.account!)

me.account?.addTransaction(
    transaction: Debit(
        value: 20,
        name: "cafe con amigos",
        category: DebitCategories.food))
me.account?.addTransaction(
    transaction: Debit(
        value: 100,
        name: "juego ps4",
        category: .entretainment))
me.account?.addTransaction(
    transaction: Debit(
        value: 1000,
        name: "juego xbox1",
        category: .entretainment))
me.account?.addTransaction(
    transaction: Gain (
        value: 1000,
        name:  "Salario",
        category: .honorarios

))
me.account?.addTransaction(
    transaction: Gain (
        value: 10000,
        name:  "larguinaldo",
        category: .aguinaldo
        
))


let transactions = me.account?.transactionFor(category: .entretainment) as? [Debit]
for transaction in transactions ?? []{
    print(transaction.name, transaction.value)
}

let transactions2 = me.account?.transactionFor(category: .aguinaldo) as? [Gain]
for transaction in transactions2 ?? []{
    print(transaction.name, transaction.value)
}

Manuel Alejandro Aguilar Téllez Girón

student•

Éste es mi código para el reto:

import Foundation

enum debitCategories {
    case food
    case entertainment
}

enum gainCategories {
    case work
    case webSite
}

class USUARIO {
    var nombreUsuario: String
    var apellidoUsuario: String
    var cuentaUsuario: CUENTA?
    
    init(nombreUsuario: String, apellidoUsuario: String) {
        self.nombreUsuario = nombreUsuario
        self.apellidoUsuario = apellidoUsuario
    }
}

class CUENTA {
    var nombreBanco: String
    var saldoCuenta: Float{
        willSet {
            print("Soy rico, este es mi saldo. :P", saldoCuenta)
        }
        didSet {
            print("Ahora soy más rico, jajaja. :P", saldoCuenta)
        }
    }
    var transactions: [TRANSACTION] = []
    
    init(nombreBanco: String, saldoCuenta: Float) {
        self.nombreBanco = nombreBanco
        self.saldoCuenta = saldoCuenta
    }
    
    @discardableResult
    func addTransaction(transaction: TRANSACTION) -> Float {
        if transaction is DEBIT {
            if (saldoCuenta - transaction.transValue) < 0 {
                return 0
            }else {
                saldoCuenta -= transaction.transValue
            }
        }else if transaction is GAIN {
            saldoCuenta += transaction.transValue
        }
        transactions.append(transaction)
        return saldoCuenta
    }
    
    func debits() -> [TRANSACTION] {
        return transactions.filter({$0 is DEBIT})
    }
    
    func gains() -> [TRANSACTION] {
        return transactions.filter({$0 is GAIN})
    }
    
    func debitTransaction(dCategory: debitCategories) -> [TRANSACTION] {
        return transactions.filter( { (transaction) -> Bool in
            guard let transaction = transaction as? DEBIT else {
                return false
            }
            return transaction.debitCategory == dCategory
        })
    }
    
    func gainTransaction(gCategory: gainCategories) -> [TRANSACTION] {
        return transactions.filter({
            (transaction) -> Bool in
            guard let transaction = transaction as? GAIN else {
                return false
            }
            return transaction.gainCategory == gCategory
        })
    }
}

class TRANSACTION {
    var transValue: Float
    var transDescription: String
    
    init(transValue: Float, transDescription: String) {
        self.transValue = transValue
        self.transDescription = transDescription
    }
}

class DEBIT : TRANSACTION {
    var debitCategory: debitCategories
    
    init(transValue: Float, transDescription: String, debitCategory: debitCategories) {
        self.debitCategory = debitCategory
        super.init(transValue: transValue, transDescription: transDescription)
    }
}

class GAIN : TRANSACTION {
    var gainCategory: gainCategories
    
    init(transValue: Float, transDescription: String, gainCategory: gainCategories) {
        self.gainCategory = gainCategory
        super.init(transValue: transValue, transDescription: transDescription)
    }
}

var me = USUARIO(nombreUsuario: "Manuel", apellidoUsuario: "Aguilar")

me.cuentaUsuario = CUENTA(nombreBanco: "BANCOMER", saldoCuenta: 1_500_000)

me.cuentaUsuario?.addTransaction(
    transaction: DEBIT(
        transValue: 10_000,
        transDescription: "Me compre un xbox",
        debitCategory: .entertainment
    )
)

me.cuentaUsuario?.addTransaction(
    transaction: DEBIT(
        transValue: 10_000,
        transDescription: "compré una vaca",
        debitCategory: .food
    )
)

me.cuentaUsuario?.addTransaction(
    transaction: GAIN(
        transValue: 60_000,
        transDescription: "Me pagó Apple por mi aplicación de finanzas",
        gainCategory: .work
    )
)

me.cuentaUsuario?.addTransaction(
    transaction: GAIN(
        transValue: 175.25,
        transDescription: "Se vendieron cinco pañales en línea",
        gainCategory: .webSite
    )
)

let debitEntertainmentTransaction = me.cuentaUsuario?.debitTransaction(
    dCategory: .entertainment
) as? [DEBIT]

let gainWebsiteTransaction = me.cuentaUsuario?.gainTransaction(
    gCategory: .webSite
) as? [GAIN]

for debit in debitEntertainmentTransaction ?? [] {
    print(
        debit.transValue, "/",
        debit.transDescription, "/",
        debit.debitCategory
    )
}

for gain in gainWebsiteTransaction ?? [] {
    print(
        gain.transValue, "/",
        gain.transDescription, "/",
        gain.gainCategory
    )
}

Manuel Alejandro Aguilar Téllez Girón

student•

Y me imprime esto:

Soy rico, este es mi saldo. :P 1500000.0
Ahora soy más rico, jajaja. :P 1490000.0
Soy rico, este es mi saldo. :P 1490000.0
Ahora soy más rico, jajaja. :P 1480000.0
Soy rico, este es mi saldo. :P 1480000.0
Ahora soy más rico, jajaja. :P 1540000.0
Soy rico, este es mi saldo. :P 1540000.0
Ahora soy más rico, jajaja. :P 1540175.2
10000.0 / Me compre un xbox / entertainment
175.25 / Se vendieron cinco pañales en línea / webSite

Adan Israel García Reséndiz

student•

Comparto el reto

Jonathan Macalupu Reyes

student•

Comparto el reto:

Si alguien me puede ayudar con una duda que tengo, sobre la función TransactionFor. Ya que lo que he realizado es duplicar la función y he colcocado los valores de la categoría que correspondía (Debit, Gain). Pero me imagino que debe de haber una forma para que ambos sean cubiertos en una misma función.

import Foundation
//Enums: Numeradores son casi como constantes pero agrupados en una misma categoría
//reto: Agregar un enum a la categoría de ganancias

enum DebitCategories {
    case health
    case food, rent, tax, transportation
    case entertainment
    
}

enum GainCategories {
    case salary, freelance, tip, smallBusiness, bigBusiness
}


class Transaction {
    var value : Float
    var name : String
    init(value : Float, name : String) {
        self.value = value
        self.name = name
    }
    
}

class Debit : Transaction {
    var category : DebitCategories
    init (value : Float, name : String, category: DebitCategories) {
        self.category = category
        super.init(value: value, name: name)
    }
}


class Gain : Transaction {
    var category : GainCategories
    init (value: Float, name: String, category: GainCategories) {
        self.category = category
        super.init(value: value, name: name)
    }
}

class Account {
    var amount : Float = 0 {
        //Esto es antes de que el valor se cambie. El valoer newValue es un valor implicito, podemos cambiarlo. El newValue es el valor futuro que obtendrá
        willSet {
            print("Vamos a cambiar el valor", amount, newValue)
        }
        
        //Se puede agregar eventos en las propiedades. Se ejecuta cuando la varuable ha sido modificada.
        didSet {
            print("Tenemos nuevo valor:", amount)
        }
    }
    var name : String = ""
    var transactions: [Transaction] = []
    
    init(amount: Float, name : String) {
        self.amount = amount
        self.name = name
    }
    
    @discardableResult
    func addTransaction(transaction: Transaction) -> Float {
        if transaction is Gain {
            amount += transaction.value
        }
        if transaction is Debit {
            if amount - transaction.value < 0 {
                return 0
            }
            amount -= transaction.value
        }
        transactions.append(transaction)
        return amount
    }
    
    func debits() -> [Transaction] {
        return transactions.filter({$0 is Debit})
    }
    func gains() -> [Transaction] {
        return transactions.filter({$0 is Gain})
    }
    func transactionFor(category: DebitCategories) -> [Transaction] {
        return transactions.filter({(transaction) -> Bool in
            guard let transaction = transaction as? Debit else {
                return false
            }
            return transaction.category == category
        })
    }
    func transactionFor(category: GainCategories) -> [Transaction] {
        return transactions.filter({(transaction) -> Bool in
            guard let transaction = transaction as? Gain else {
                return false
            }
            return transaction.category == category
        })
    }
}

class Person {
    var name : String = ""
    var lastName : String = ""
    var account : Account?
    
    var fullName : String {
        //también se puede hacer eso sin colocar el get.
        get {
            return "\(name) \(lastName)"
        }
        //Esta funcion puede hacer que se ejecute la funcion antes de que obtenga el valor
        set {
            name = String(newValue.split(separator: " ").first ?? "")
            lastName = "\(newValue.split(separator: " ").last ?? "")"
        }
    }
    
    //Un inicializador es una funcion que crea la clase como tal.
    init(name : String, lastName : String) {
        self.name = name
        self.lastName = lastName
    }
}
var me = Person(name: "Jonathan", lastName: "Macalupu")
var account = Account(amount: 100_000, name: "X bank")

me.account = account

print(me.account!)





me.account?.addTransaction(transaction: Debit(value: 20, name: "Cafe con amigos", category: DebitCategories.food))
me.account?.addTransaction(transaction: Debit(value: 100, name: "Juego de Nintendo Switch", category: .entertainment))
me.account?.addTransaction(transaction: Debit(value: 1200, name: "Nintendo Switch", category: .entertainment))

me.account?.addTransaction(
    transaction: Gain(
        value: 2000,
        name: "Salario",
        category: .salary))

me.account?.addTransaction(
    transaction: Gain(
        value: 1500,
        name: "Proyecto Diseño de App",
        category: .freelance))

me.account?.addTransaction(
    transaction: Gain(
        value: 100,
        name: "Venta de accesorios de Smartphones",
        category: .smallBusiness))

me.account?.addTransaction(
    transaction: Gain(
        value: 40000,
        name: "Venta de 100 iPhones",
        category: .bigBusiness))

print(me.account!.amount)

let transactions = me.account?.transactionFor(category: .entertainment) as? [Debit]
for transaction in transactions ?? [] {
    print(transaction.name, transaction.value, transaction.category)
}

let transactionsGain = me.account?.transactionFor(category: .bigBusiness) as? [Gain]
for transaction in transactionsGain ?? [] {
    print(transaction.name, transaction.value, transaction.category)
}

Adan Israel García Reséndiz

student•

Hola Andres tengo una pregunta cuando estas creando la inicialización de la clase Debit eliminaste una palabra reservada override esta palabra por que la quitaste y en que casos se deja, es decir cual seria la mejor manera de utilizar override

Andres Silva

teacher•

Hola qué tal todo? Te ha gustado el curso? Claro que si, la palabra reservada override se usa cuando quieres sobre escribir un método de una clase padre, esto es herencia, imagínate que tienes la clase Persona esa tiene una clase que calcula el valor de algo que vendemos, ahora imagínate que creamos una clase llamada PersonaJuridica está extiende las propiedades de la clase padre y sus funciones, pero resulta que una persona jurídica cuando vende un producto paga el iva, así que usamos la palabra reservada override para crear una funcionalidad completamente nueva en esta función , también si usamos super.nombreFuncion podríamos hacer que ejecute el cálculo de la función anterior y debajo de esta crear nuestra nueva regla de incremento del precio.

Te quedó claro? Espero haber sido muy contundente con la respuesta péro si no es así no dudes en escribir de nuevo

Saludos

Vespaciano Forero Sanchez

student•

Reto: Así quedo el enum:

enum GainCategories {
    case work, join
    case business
    case sale
}

Así quedo la clase:

class Gain: Transaction {
    var category: GainCategories
    
    init(value: Float, name: String, category: GainCategories) {
        self.category = category
        super.init(value: value, name: name)
    }
}

Así quedo la función:

func transactionsFor(category: GainCategories) -> [Transaction] {
        return transactions.filter({(transaction) -> Bool in
            guard let transaction = transaction as? Gain else {
                return false
            }
            
            return transaction.category == category
        })
    }

Así quedaron las transacciones:

me.account?.addTransaction(transaction:
    Gain(value: 1000, name: "Salario mensual", category: .work))

me.account?.addTransaction(transaction:
    Gain(value: 100, name: "Venta de Juego PS4r", category: .sale))

me.account?.addTransaction(transaction:
    Gain(value: 250, name: "Invertir en la bolsa de bogota", category: .business))

Así quedo para imprimir:

let transa = me.account?.transactionsFor(category: .sale) as? [Gain]
for tr in transa ?? [] {
    print(tr.name, tr.value, tr.category)
}

Y así quedo el resultado:

Daniel Alcudia

student•

enum DebitCategories{
    case health
    case food, rent, tax, transportation
    case entertainment
}

enum GainCategories{
    case job, trading, becaAMLO, crypto
}

class Transactions{
    var value: Float
    var name: String
    
    init(value: Float, name: String) {
        self.value = value
        self.name = name
    }
}

class Debit: Transactions{
    var category: DebitCategories
    
    init(value: Float, name: String, category: DebitCategories) {
        self.category = category
        super.init(value: value, name: name)
    }
}

class Gain: Transactions{
    var category: GainCategories
    
    init(value: Float, name: String, category: GainCategories) {
        self.category = category
        super.init(value: value, name: name)
    }
}

class Person{
    var name: String
    var lastName: String
    var account: Account?
    
    var fullName: String {
        get{
            return "\(name) \(lastName)"
        }
        set{
            name = String(newValue.split(separator: " ").first ?? "")
            lastName = String(newValue.split(separator: " ").last ?? "")
        }
    }
    
    init(name: String, lastName: String) {
        self.name = name
        self.lastName = lastName
    }
}

class Account{
    var amount: Float = 0.0 {
        //Disparadores de propiedades
        willSet{
            print("Vamos a cambiar el valor",amount)
        }
        didSet{
            print("Tenemos nuevo valor ", amount)
        }
    }
    var name: String = ""
    var transactions: [Transactions] = []
    
    init(amount: Float, name: String) {
        self.amount = amount
        self.name = name
    }
    
    @discardableResult
    func addTransaction(transaction: Transactions) -> Float{
        if transaction is Debit{
            amount -= transaction.value
        }
        if transaction is Gain{
            if(amount - transaction.value) < 0 {
                return 0
            }
            amount += transaction.value
        }
            transactions.append(transaction)
        return amount
    }
    
    func debits() -> [Transactions] {
        return transactions.filter({$0 is Debit})
    }
    
    func gains() -> [Transactions] {
        return transactions.filter({$0 is Gain})
    }
    
    func transactionsFor(category: DebitCategories ) -> [Transactions] {
        return transactions.filter({ (transaction) -> Bool in
            guard let transaction = transaction as? Debit else {
                return false
            }
            return transaction.category == category
        })
    }
    
    func transactionsFor(category: GainCategories ) -> [Transactions] {
        return transactions.filter({ (transaction) -> Bool in
            guard let transaction = transaction as? Gain else {
                return false
            }
            return transaction.category == category
        })
    }
}

var me = Person(name: "Daniel", lastName: "Alcudia")
var account = Account(amount: 100_000, name: "Citibanamex")

me.account = account

//Debit
me.account?.addTransaction(transaction: Debit(value: 80, name: "Sandwich", category: DebitCategories.food))
me.account?.addTransaction(transaction: Debit(value: 100, name: "Pollo Cordon Bleu", category: DebitCategories.food))

//Gain
me.account?.addTransaction(transaction: Gain(value: 500, name: "Trabajo", category: GainCategories.job))
me.account?.addTransaction(transaction: Gain(value: 1000, name: "Bitcoin", category: .crypto))


print(me.account!.amount)

let debitTransactions = me.account?.transactionsFor(category: DebitCategories.food)
for transaction in debitTransactions ?? [] {
print(transaction.name, transaction.value)
}

let gainTransactions = me.account?.transactionsFor(category: GainCategories.job)
for transaction in gainTransactions ?? [] {
    print(transaction.name, transaction.value)
}

Julio Domingo Garcia

student•

Acá esta mi código. Le agregué a la clase Gain la categoría creada de tipo "GainCategories", su inicializador a la clase, y luego a la función "TransactionsFor" la modifiqué agregándole el mismo código que a los debitos. Acto seguido renombre como "TransactionsForGain" / "TransactionsForDebits" respectivamente. Y por último imprimí un ejemplo de ganancias con la categoría nuevas que fueron creadas usando enumeradores. Espero que les sirva.

class Gain: Transaction {
    var category: GainCategories
    
    init(value: Float, name: String, category: GainCategories) {
        self.category = category
        super.init(value: value, name: name)
    }
}
 
func transactionsForGains (category: GainCategories) ->[Transaction]{
        return transactions.filter({ (transaction) -> Bool in
            guard let transaction = transaction as? Gain else {
                return false
            }
            return transaction.category == category
        })
    }
let transactionsGain = me.account?.transactionsForGains(category: .sales) as? [Gain]
for transaction in transactionsGain ?? []{
    print(transaction.name, transaction.value, transaction.category)
}

Luis Capdevila

student•

Retoo

Winston Chavez

student•

El enum de ganancias

enum GainCategories {
    case project
    case salary
}

La inicializacion de categorias

class Gain: Transaction {
    var category : GainCategories
    
    init(value: Float, name: String, category: GainCategories) {
        self.category = category
        super.init(value: value, name: name)
    }
}

El metodo de filtrar ganancias en la clase transaction

func gainsFor ( category: GainCategories ) -> [Transaction] {
        return transactions.filter({ (transaction) -> Bool in
            guard let transaction = transaction as? Gain else {
                return false
            }
            
            return transaction.category == category
        })
    }

Imprimiendo el resultado.

let transactions = me.account?.transactionsFor(category: .entertainment) as? [Debit]
let gainTransactions = me.account?.gainsFor(category: .project) as? [Gain]

for transaction in transactions ?? [] {
    print(transaction.name, transaction.value, transaction.category)
}

for gain in gainTransactions ?? [] {
    print(gain.name, gain.value, gain.category)
}

Salu2!

Enums Básicos

Bienvenida e Introducción

Introducción a Swift

Apple Swift Playgrounds

Conoce el proyecto de este curso

Variables, Constantes y Tipos de Datos

Constantes y Variables

Tipos de datos básicos

Manejo y manipulación de Strings

Manejo y manipulación de Números

Uso de valores boleanos

Tipos de datos Complejos

Arrays en Swift 4

Matrices

Diccionarios

Estructuras de control

If, else, else if, Inline If

Switch

For

Opcionales, Guard, If guard

For Where

Manejo de Arrays

Funciones

Definicion

Parámetros en las funciones

Tuplas

@discardableResult

Objetos

Estructuras vs Clases

Funciones

Propiedades

Manejo de propiedades

Herencia

Enums

Enums Básicos

Enums representativos

Enums con parámetros

Protocolos

Definición

Usando protocolos

Delegados

Advanced Topics

Extensions

Clousures

Typealias

ARC, Retain cycles, Strong, Weak y unowned

Caso práctico de ARC y Retain cycles

Caso práctico de Retain Cycle con Closures

Excepciones

Generics

Completar el proyecto

Organizar nuestro proyecto en clases independientes

Agregar transacciones repetibles

Calcular Lifetime Value

Conclusiones

Finalización del curso

Reto final

Bonus

Primer proyecto en iOS