Capturar Valores

Esto a las 4:33 a.m. es del diablo, hahaha.

{(🧑🏻‍💻) -> () -> 👹}

Resumen

Los closures capturan el ambiente en el que fueron creados, lo que significa que toman una copia de los valores que son usados dentro de ellos.

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

let incrementByTen = makeIncrementer(forIncrement: 10)
incrementByTen()	// 10
incrementByTen()	// 20
incrementByTen()	// 30

Es por eso que cuando se vuelve a invocar a la función makeIncrementer() pero con otro valor (7), el resultado de la anterior se mantiene.

let incrementBySeven = makeIncrementer(forIncrement: 7)
incrementBySeven()	// 7

El valor de incrementBySeven es 7

incrementByTen()

El valor de incrementByTen ahora es 40, ya que mantiene el valor anterior (30)

Realmente este modulo se me ha hecho muy complicado, creo que mas que toda esta carrera de ios (Hasta el momento). Pero con esta clase me quedo todo mas claro.

Recuerden que lo mas importante es practicar y picarle a las cosas

🤯

Por tanto cada vez que yo creo una variable a partir de llamar a una función que me devuelve un clousure, o que me devuelve una función a su vez, cada una de ellas tiene sus variables locales capturadas por el clousure.

Otra forma más simplificada, aunque no tan legible, pero lo dejo como opción:

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    return {
        runningTotal += amount
        return runningTotal
    }
}

Tiene un funcionamiento como el closure de javascript

probe hacer un closure donde guardara el promedio de las clases y pues les comparto mi resultado :

func promedio(_ notaUno: Int, _ notaDos: Int, _ notaTres: Int) -> Int {
    var promedioNota = 0
    func promediar() -> Int{
        promedioNota = (notaUno + notaDos + notaTres) / 3
        return promedioNota
    }
    return promediar()
}


let matematica = promedio(60, 50, 60)
let lenguaje = promedio(45, 60, 70)
let programacion = promedio(100, 90, 80)

print("el promedio de matematica es: \(matematica)")
print("el promedio de lenguaje es: \(lenguaje)")
print("el promedio de programación es: \(programacion)")

desarrollé una función que calcula el IVA por precio y otro que calcula el IVA mediante una lista de precios o productos.

espero feedback 😄

func calculateIvaTotalProducts(_ product: Int) -> () -> Int{
    var totalIva = 0.0
    let IVA = 0.19
    func calculateIvaByProduct() -> Int{
        totalIva = Double(product) * IVA
        return product + Int(totalIva)
    }
    return calculateIvaByProduct
}

let productCaculate =  calculateIvaTotalProducts(2000)
productCaculate()


func calculateIVAListProducts(listProduct products: [Int]) -> () -> Int{
    var totalWithIVA = 0
    let IVA = 0.19
    func calculateIVAProducts() -> Int {
        for product in products {
            let IVAProduct = Double(product) * IVA
            totalWithIVA += product + Int(IVAProduct)
        }
        return totalWithIVA
    }
    return calculateIVAProducts
}

let purchasesOfWeek = calculateIVAListProducts(listProduct: [2000, 3000, 5000, 10000])
print(purchasesOfWeek())

1. El runningTotal está declarado dentro de incrementByTen
   .
2. Cada “variable” ( = func -> closure) tiene variables locales “capturadas” por el closure
   .
3. Llamar a incrementByTen() , es como llamar a incrementer() que por debajo solo hace referencia a la variable local runningTotal , sumarle el amount (que también queda capturada) y retornar la suma.
   |
4. amount no cambia y runningTotal es cambiada por el closure.
   |
   al inicio puede marear un poco 😄

Siguiendo la misma logica se puede hacer un Decreaser. Donde puedes restar e ir reduciendo cada vez mas en los números negativos.

func makeDecreaser(amount:Int) -> () -> Int{
    var runningTotal = 0
    func decreaser () -> Int{
        runningTotal -= amount
        return runningTotal
    }
    return decreaser
}

let decreaseBy10 = makeDecreaser(amount: 10)
decreaseBy10()
decreaseBy10()

Terminado el ejercicio diabolico jaja:
[“C”, “L”, “👹”, “S”, “👹”, “R”, “👹”]

func makeClosurePhrase(phrase collection: [String]) -> () -> [String] {
    
    let filteredLetters = ["a", "e", "i", "o", "u",
                           "A", "E", "I", "O", "U"]
    var finalArray = [String]()
    
    func replaceCharacters() -> [String] {
        for item in collection {
            if filteredLetters.contains(item) {
                finalArray.append("👹")
            }else {
                finalArray.append(item)
            }
        }
        
        return finalArray
    }
    
    return replaceCharacters
}


let originalString = ["C", "L", "O", "S", "U", "R", "E"]
var resultPhrase = makeClosurePhrase(phrase: originalString)
print(resultPhrase())