Uso de try y catch

// Reto
var cleanDishes = 0
var ingredientes = 10
var haveHungry: Bool = true

enum sandwichError: Error{
    case noCleanDishes
    case noIngredients
    case noHungry
}

func makeASandwich() throws{
    if cleanDishes < 1 {
        throw sandwichError.noCleanDishes
    }
    if ingredientes < 4 {
        throw sandwichError.noIngredients
    }
    if haveHungry == false {
        throw sandwichError.noHungry
    }
    print("Me hago un sandwich")
}


do{
    try makeASandwich()
    //Me como el sandwich
    print("Me como el sandwich")
}catch(sandwichError.noCleanDishes){
    //tengo platos limpios ...-> Lavar los platos
        print("lava 1 plato")
}catch (sandwichError.noIngredients){
    //tengo ingredientes -> Ir a hacer la compra
        print("compra ingredientes")
}catch (sandwichError.noHungry){
    //tengo hambre -> Esperar a tener hambre
        print("Esperar a tener hambre")
}
    

No es buena practica de software manejar business logic con try and catch . Hace la curva de aprendizaje y el software mas complejo . For instance se puede usar cuando se conneta a un webservice y se cae la conexion de datos , hay es una buena practica para el try{}catch

try{
webservice.login(){
catch(Exception e){
throw new ConnectionDown();
}

No usen para manejar busienss logic . Les va ser la vida mas dificil 😃

let pokemon = (name:"eevee", lv:29)
let level: Int! = pokemon.1
enum lvUp: Error{
   case getMoreLvel
}
func jolteon() throws{
    if  level > 30{
        print("Jolteon!!!!!")
    }
    if level < 30 {
        throw lvUp.getMoreLvel
    }
}
do{
    try jolteon()
} catch (lvUp.getMoreLvel){
    print("Debes conseguir mas experiencia")
}```

este profesor es lo máximo, he visto muy pocos que sean tan practicos e incluso te enseñan sin tanto tecnicismo y con muchos ejemplos

func makeASandwich() throws
{

}


func eatSandwich()
{
    print("ñam ñam ñam ¡Estuvo delicioso el sandwich!")
}

func washDishes()
{
    print("lavando los platos")
}
func buyIngredients()
{
    print("Compre los ingredientes faltantes")
}
func waitForHungry()
{
    print("Espera a que tengas hambre")
}



//enumeramos los errores que pueden suceder
enum ErrorSandwich: Error
{
    case outOfCleanDishes
    case missingIngredients
    case dontHungry
}


do
{
    try makeASandwich()
    //Si tengo éxito: Me como el sandwich
    eatSandwich()
}
    //Si no tengo éxito:
    //hacer una verificación de la información y ejecutar un método
    //verificar si tengo platos limpios -> lava los platos
    
    //verificar si tengo hambre -> esperar a tener hambre
    //verificar si tengo ingredientes -> comprar ingredientes
catch ErrorSandwich.outOfCleanDishes
{
    washDishes()
}
catch ErrorSandwich.missingIngredients
{
    buyIngredients()
}
catch ErrorSandwich.dontHungry
{
    waitForHungry()
}

let haveHungry: Bool = false
let haveIngredients: Bool = false
let haveCleanDishes: Bool = false
let haveSoap: Bool = false
let isStoreOpen: Bool = false
let haveTime: Bool = false

func makeASandwich() throws {
    
}

func washDishes() throws {
    
}

func doShopping() throws {
    
}

func waitAnHour() throws {
    
}

func buySoap() {
    
}

func waitUntilStoreOpens() {
    
}

func eatSomethingElse() {
    
}

do {
    try makeASandwich()
    //Me como el sandwich
} catch {
    //tengo platos limpios... -> lavar los platos
    if !haveCleanDishes {
        do {
            try washDishes()
        } catch {
            if !haveSoap {
                buySoap()
            }
        }
    }
    //tengo ingredientes... -> Ir a hacer la compra
    if !haveIngredients {
        do {
            try doShopping()
        } catch {
            if !isStoreOpen {
                waitUntilStoreOpens()
            }
        }
    }
    //tengo hambre... -> esperar dentro de una hora
    if !haveHungry {
        do {
            try waitAnHour()
        } catch {
            if !haveTime {
                eatSomethingElse()
            }
        }
    }
}

let cuentaBancaria = 1_000
let precioBicicleta = 5_00
let disponible = true
func comprarBicileta() throws {
if cuentaBancaria < precioBicicleta {
throw ErroresDeCompraDeBicicleta.faltaDinero
}
if !disponible {
throw ErroresDeCompraDeBicicleta.noEstaDisponible
}
print(“Se realizo su compra con exito”)
}

do {
try comprarBicileta()
// Comprar bicicleta
} catch (let error) {
print(error)
}

//Reto Make a Sandwich
var hayIngredientes: Bool = false
var hayPlatos: Bool = true

//Se crean los errores
enum ErrorSandwich: Error
{
    case noHayIngredientes
    case noHayPlatosLimpios
}
//Función
func makeASandwich() throws
{
    if hayIngredientes && hayPlatos
    {
        print("Aquí está tu sandwich :p")
    }else if hayPlatos{
        throw ErrorSandwich.noHayIngredientes
    }else{
        throw ErrorSandwich.noHayPlatosLimpios
    }
}
//Manejo de errores
do{
    try makeASandwich()
    //Me como el sandwich
}catch ErrorSandwich.noHayIngredientes{
    print("Comprar ingredientes")
}catch ErrorSandwich.noHayPlatosLimpios{
    print("Lavar los platos")
}

//OUTPUT: Comprar ingredientes

La gestion de errores con el try catch es importante saberlo manejar para evitar que la aplicación truene sin saber la causa de porque se detuvo

super diferente el try de swift

Estan enseñando mucha cosa sin enseñar cosas tan basicas como un for o while cuando tienen mucha importancia y es basico

// Manage error handler enum
enum ErrorHandler : Error {
    case noCleanDishes
    case withoutIngredients
    case withoutHungry
}

// function to prepare a sandwich
func makeASandwich() throws {
    // Code here and launch a posible error
}

do {
    try makeASandwich()
    // Code here, not error found.
} catch ErrorHandler.noCleanDishes {
    // Manage no clean dishes error
} catch ErrorHandler.withoutIngredients {
    // Manage ingredients error
} catch ErrorHandler.withoutHungry {
    // Manage hungry error
} catch {
    // Manage unexpected error
}

Vaya que este ejercicio si me costo ya que aún no menejamos ciertos conceptos, pero que bueno tener retos así:

import UIKit

/* Error handling
 We use error handling to respond to error conditions your program
 may encounter during the execution.
 
 Structure:
 
 mainFuncionWithPossibleErrors() throws {}
 
 do {
    try mainFuncionWithPossibleErrors()
    //No errors here
 }catch {
    //Errors here
 }
 
 do: Starts the block of code that contains the method
 that can potencially throw an error
 
 try: Use this in front of the methos that throws errors.
 Think of it like you're trying to execute the method.
 
 catch: if the throwing method fails and raises an error,
 the execution will fall into this catch block.
 As many as you have or need in the main method
 
 throws: Use this pattern in a method than have errors
 
*/

//Example: makeASandwich function

enum SandwichError: Error {
    case outOfCleandDishes
    case missingIngredients(ingredients: [String])
}

do {
    //I'm gonna make a sandwich
    try makeASandwich()
    eatASandwich()
}catch SandwichError.outOfCleandDishes {
    washDishes()
} catch SandwichError.missingIngredients(let ingredients) {
    buyGroceries(ingredients : ingredients)
    
}

func makeASandwich() throws {
    let missingIngredients: [String] = []
    let cleanDishesCount = 5
    
    if missingIngredients.count > 0 {
        print("Oh no, we need ingredients...")
        throw SandwichError.missingIngredients(ingredients: missingIngredients)
    }else if cleanDishesCount == 0 {
        print("Out of clean dishes")
        throw SandwichError.outOfCleandDishes
    }
    //print("I need a Sandwich...")
}

func eatASandwich() {
    print("Eating my Sandwich 🥪")
}

func washDishes() {
    print("Washing the dishes 🍽")
}

func buyGroceries (ingredients: [String]) {
    print("Going shopping for: \(ingredients.joined(separator: ",")) 🛍 ")
}

enum MakingASandwichError: Error{
    case insufficientBread(breadsNeeded: Int)
    case noHam
    case noCleanDishes
}

func makeASandwich(quantityBreads: Int, hamQuantity: Int, areThereCleanDishes: Bool) throws{
    if quantityBreads >= 2 {
        print("Tomo los panes");
    }else{
        throw MakingASandwichError.insufficientBread(breadsNeeded: 2);
    }
    if hamQuantity >= 1{
        print("Le pongo jamon a los panes");
    }else{
        throw MakingASandwichError.noHam;
    }
    if areThereCleanDishes {
        print("sirvo mi sandwich en un plato");
    }else{
        throw MakingASandwichError.noCleanDishes;
    }
    print("me hice otro sandwich");
}

do{
    try makeASandwich(quantityBreads: 2, hamQuantity: 1, areThereCleanDishes: true);
}catch MakingASandwichError.insufficientBread(let breadsNeeded){
    print("No habia suficientes panes, son necesarios \(breadsNeeded)")
}catch MakingASandwichError.noHam{
    print("No hay jamon");
}catch MakingASandwichError.noCleanDishes{
    print("No hay platos limpios");
}

//Ejercicio Sandwich
func makeMySandwich() throws {
    
}

func eatSandwich(){
    print("Me lo comi todo")
}

func washDishes(){
    print("lavando los platos")
}

func buyIngredientes(){
    print("comprando pan,mortadela,queso")
}

func waitForHungry(){
    print("ya comi demasiado mejor despues")
}

enum ErrorSandwich: Error {
    case clean
    case buy
    case wait
}

do {
    try makeMySandwich()
    
    eatSandwich()
}catch ErrorSandwich.clean {
    washDishes()
}catch ErrorSandwich.buy {
    buyIngredientes()
}catch ErrorSandwich.wait {
    waitForHungry()
}

hola a todos, ¿como puedo hacer que identifique mas de 1 error?

Pare el ejemplo de abajo se pueden usar variables para el estado del programa o una enumeración .

Mi solución

let thereAreCleanDishes = false
let ImHungry = false
let IHaveIngredients = false

enum makeASandwichError: Error {
    case ImNotHungry
    case thereAreNoCleanDishes
    case noIngredients
}

func dishWashing() throws {
    print("Lavando los platos")
}

func waitToBeHungry() throws {
    print("Esperando a tener hambre !!")
}

func getIngredients() throws {
    print("Debo obtener mas ingredientes")
}

func makeASandwich() throws {
    guard ImHungry else {
        throw makeASandwichError.ImNotHungry
    }
    
    guard thereAreCleanDishes else {
        throw makeASandwichError.thereAreNoCleanDishes
    }
    
    guard IHaveIngredients else {
        throw makeASandwichError.noIngredients
    }
    print("Comiendo el sandwich")
}

do {
    try makeASandwich()
}
catch makeASandwichError.ImNotHungry {
    try waitToBeHungry()
}
catch makeASandwichError.thereAreNoCleanDishes {
    try dishWashing()
}
catch makeASandwichError.noIngredients {
    try getIngredients()
}
catch {
    print("Error inesperado: \(error).")
}

Mi prueba 😃

let minIngredientsNeeded: Int8 = 3

func makeASandwich(ingredientsNeeded: Int8, iAmHungry: Bool = true) throws {
    if ingredientsNeeded < minIngredientsNeeded {
        throw makeASandwichError.insufficientIngredients(ingredientsNeeded: ingredientsNeeded)
    }
    if iAmHungry == false {
        throw makeASandwichError.noHungry
    }
}

enum makeASandwichError: Error {
    case noHungry
    case insufficientIngredients(ingredientsNeeded: Int8)
}

do {
    try makeASandwich(ingredientsNeeded: 2, iAmHungry: false)
    print("Me como el Sandwich!")
} catch makeASandwichError.noHungry {
    print("No tengo hambre!")
} catch makeASandwichError.insufficientIngredients(let ingredientsNeeded) {
    print("Tienes \(ingredientsNeeded) ingredientes, necesitas \(minIngredientsNeeded) como mínimo.")
}

como puedo decir a mi función que retorne algo y a la ves pueda manejar errores, es decir

func asd () -> Int throws {
  ...
}