Valores de Retorno, Optionals y Parámetros de Salida

Hernán Chilabert

student•

Resumen

Una función puede recibir parámetros pero no retornar nada:

func greet2(person: String) {
    print("Hola \(person)")
}

greet2(person: "Hernan")

Otro ejemplo:

func printAndCount(string: String) -> Int {
    print(string)
    return string.count
}

func printWithoutCounting(string: String) {
    let _ = printAndCount(string: string)
}
printAndCount(string: "Hola que tal")
printWithoutCounting(string: "Hola que tal")

Ejemplo de una función que recibe un array y devuelve una tupla:

func minMax(array:[Int]) -> (min: Int, max: Int) {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }

    return (currentMin, currentMax)
}

let bounds = minMax(array: [6, 4, 3, 1, 6, 5, 4, 7, 9])
print("El valor minimo es \(bounds.min) y el valor maximo es \(bounds.max)")

Si le pasamos un array vacío, esta función va a fallar.

minMax(array: [])

Para resolver este problema, lo que se haces es convertir la salida en un tipo de dato Optional agregando el símbolo ? al final para validar si el parametro esta o no vacío:

func minMax(array:[Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    . . .
}

y para imprimir el resultado, tenemos que hacer un force unwrapping (no recomendado) o el optional unwrapping:

Force Unwrapping

Agregamos el simbolo !:

print("El valor minimo es \(bounds!.min) y el valor maximo es \(bounds!.max)")

Optional Unwrapping

Hacemos el uso de if let:

if let bounds = minMax(array: [6, 4, 3, 1, 6, 5, 4, 7, 9]) {
    print("El valor minimo es \(bounds.min) y el valor maximo es \(bounds.max)")
}

David Barreto

student•

Me quedo con tu resumen! Gracias por el aporte! 👍👨🏼‍💻

Eduardo Ramirez Martinez

student•

Comparto mi apuntes:

Grecia Bueno

student•

Pregunta...

Como se ve la función minMax si usamos el optional chaining en vez de force unwrapping?

Ignacio Castillejo Gómez

student•

Hola!!!

Te dejo un código que te he preparado con un par de ejemplos:

De todas formas puedes ver el contenido del archivo en este enlace: https://github.com/icastillejogomez/swift5/blob/master/minmax.playground/Contents.swift

import UIKit

func minMax(_ array: [Int]) -> (min: Int, max: Int)? {
    // Comprobamos si el array es vacio
    if array.isEmpty { return nil }
    
    // Buscamos el min y max
    var min = array[0]
    var max = array[0]
    for n in array[1..<array.count] {
        min = n < min ? n : min
        max = n > max ? n : max
    }
    
    // Devolvemos la tupla con min y max
    return (min, max)
}


//  force unwrapping
let bounds1 = minMax([1,2,3])
print("Min: \(bounds1!.min) Max: \(bounds1!.max)")

// optional Binding
if let bounds2 = minMax([]) {
    // Con un array vacio nunca entramos aqui
    print("Min: \(bounds2.min) Max: \(bounds2.max)")
} else {
    print("No hay máximo y minimo")
}


// Operador Nil Coalescing
let bounds3 = minMax([]) ?? ( min: 0, max: 0 )
print("Min: \(bounds3.min) Max: \(bounds3.max)")

let bounds4 = minMax([1,2,312,31,3,321,-312,-3,-31,-31,-31,-7]) ?? ( min: 0, max: 0 )
print("Min: \(bounds4.min) Max: \(bounds4.max)")

Espero te sirva de ayuda 😇

Paúl Terán

student•

Hola chicos/as! Les comparto mi implementación de este código ya que Swift ha cambiado mucho con respecto al manejo de retorno de datos opcionales, vacíos o los clásicos out of range...

// Return a tuple with optional data output
func minMax(array: [Int]) -> (min: Int, max: Int)? {
    
    var currentMin: Int
    var currentMax: Int
    
    if array.isEmpty {
        return nil
    }else {
        currentMin = array[0]
        currentMax = array[0]
        for value in array[1..<array.count] {
            if value < currentMin {
                currentMin = value
            }else if value > currentMax{
                currentMax = value
            }
        }
    }
    
    return (currentMin, currentMax)
}

// Call function and pass parameters
let bounds = minMax(array: [6,3,-8,3,1,9,5,15,-9])
let defaultArray = (-0,0)
var boundToBeUsed = bounds ?? defaultArray

print("The min value of the array is: \(boundToBeUsed.min) and the max value of the array is: \(boundToBeUsed.max)")

// Empty array case (error) => use nil
if let boundsEmptyArray = minMax(array: []) {
    print("The min value of the array is: \(boundsEmptyArray.min) and the max value of the array is: \(boundsEmptyArray.max)")
}else {
    print("The array to minMax func should have a entry data")
}

Jeferson Arley Salazar Bolaños

student•

Rodrigo Consuelos

student•

func minMax(array : [Int]) -> (min : Int, max : Int)?
{
    if !array.isEmpty
    {
        var currentMin = array[0]
        var currentMax = array[0]
        
        for value in array[1..<array.count]
        {
            if value < currentMin
            {
                currentMin = value
            }
            if value > currentMax
            {
                currentMax = value
            }
        }
        
        return (currentMin,currentMax)
    }
    
    return nil
}


minMax(array: [6,3,-8,9,15,-9])

/*
 Usando constantes para desempacar la tupla
 
 if let (minimum, maximum) = minMax(array: [6,3,-8,9,15,-9])
 {
 print("Los valores se hallan entre \(minimum) y \(maximum)")
 }
 */

// Usando una tupla
if let intervalo = minMax(array: [6,3,-8,9,15,-9])
{
    print("Los valores se hallan entre \(intervalo.min) y \(intervalo.max)")
}

```**func** minMax(array : \[Int]) -> (min : Int, max : Int)?

{

**if** !array.isEmpty

{

**var** currentMin = array\[0]

**var** currentMax = array\[0]



**for** value **in** array\[1..\<array.count]

{

**if** value < currentMin

{

currentMin = value

}

**if** value > currentMax

{

currentMax = value

}

}



**return** (currentMin,currentMax)

}



**return** **nil**

}





minMax(array: \[6,3,-8,9,15,-9])



/\*

Usando constantes para desempacar la tupla



if let (minimum, maximum) = minMax(array: \[6,3,-8,9,15,-9])

{

print("Los valores se hallan entre \\(minimum) y \\(maximum)")

}

\*/



// Usando una tupla

**if** **let** intervalo = minMax(array: \[6,3,-8,9,15,-9])

{

print("Los valores se hallan entre \\(intervalo.min) y \\(intervalo.max)")

}

David Argote

student•

Mi código:

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    
    if array.isEmpty {
        return nil
    }
    
    var currentMin = array[0]
    var currentMax = array[0]

    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

let bounds = minMax(array: [2,3,-2,3,5,6,9])
print("Values max: \(bounds?.max ?? 0), min: \(bounds?.min ?? 0)")

Peter Jonathan Montalvo Garcia

student•

//funcion que no devuelva nada:
func greeting2(person: String){
    print("Hola \(person)!")
}

greeting2(person: "Juan Villalvazo")


func printAndCount(string: String) -> Int{
    print(string)
    return string.count
}

printAndCount(string: "Hola como estás?")

// si no quiero usar el int de la función anterior:
func prinWithoutCounting(string: String){
    let _ = printAndCount(string: string)
}

prinWithoutCounting(string: "Hola como estás?")

José Javier Cueto Mejía

student•

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

Jair Manuel Poveda Frago

student•

func minMax(array:[Int]) -&gt; (min: Int, max: Int)?{
    if array.isEmpty{
        return nil
    }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..&lt;array.count] {
        if value &lt; currentMin {
            currentMin = value
        } else if value &gt; currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}


let bounds = minMax(array: [6,3,-9,10,12,15,17])
print(bounds!.min)
print(bounds!.max)
minMax(array: [])

José Bryan Estrada Bernal

student•

func minMax (array :[Int])-> (min:Int, max: Int ) {
    var arr = Array(array)
    arr=arr.sorted(by : {$0 < $1})
    return (arr[0],arr[arr.endIndex-1])
}
let bounds = minMax(array:
    Array([1,2,1,12,5,345,6,4]))
print("El valos minimo es :\(bounds.min) , el maximo es: \(bounds.max)")

Luis Abdel Rangel Castro

student•

let bounds = minMax(array: array)
print("Los valores se hallan entre \(bounds!.min) y \(bounds!.max)")

let bounds2 = minMax(array: [])
print("Los valores se hallan entre \(bounds2?.min ?? 0 ) y \(bounds2?.max ?? 0)")

Valores de Retorno, Optionals y Parámetros de Salida

Funciones

Qué aprenderás sobre las funciones en Swift

Declarar una función

Parámetros de entrada

Valores de Retorno, Optionals y Parámetros de Salida

Etiquetas de Params y Variadics

Parámetros tipo inout

Function Types

Nested Functions

Tipos de Closures

Closures

Trailing Closures

Capturar Valores

Escaping Closure

Enumeradores

Enumerations, clase vaga

Enumerations, "códigos de barras"

Enumeradores con raw values

Cierre

Conclusión