Apuntes básicos de swift

// Declaración de variables

// Sin especificar tipo
var nickname = "Violet"
let status = true

// Especificando tipo
var level : String = "Level 7"

/**
 Cambiando variable de tipo string a variable de tipo Int
 */
let amount = "345"
let parseAmount = Int(amount)
print(parseAmount)
// salida: 345

/**
 De Int a Double
 */
var three = 3
var decimal = 0.14159
var piNumber = Double(three) + decimal
print (piNumber)
// salida: 3.14159

// DownCasting
var kms = 5.767
var parteEntera = Int(kms)
print(parteEntera)
// salida: 5

var altura = 5.1
var parteEnteraAltura = Int(altura)
print(parteEnteraAltura)
// salida: 5

// Tuplas
let httpError = (404, "Página no encontrada", 23434)

print(httpError.0)
// salida: 404

let httpSuccess = (code: 200, description: "Is Ok", internalCode: 23434)

print(httpSuccess.code)
// salida: 200

/**
 Declarando una variable que podria no tener valor
 */
var response : String?

/**
Declarando una variable con valor inicial, pero que podria ser nil en algun momento
*/
var errorCode: Int? = 400
errorCode = nil

let defaultAge  = 18
var userAge: Int?

/**
 Si userAge es Nil, se asignara defaultAge
 */
var ageToBeUsed = userAge ?? defaultAge

/**
 Force unwrapping (!)
 */
var age : Int?

if age != nil {
  print("Age is \(age!)")
}

/**
 Optional Binding
 (Optional unwraping)
 */
age=60
if let ageValidate = age {
  // Si se puede crear ageValidate a partir de age, age != nil y se puede usar
  print("Age is \(ageValidate)")
}

// Podemos validar varios optional y condiciones extras

var name : String? = "Jhon"
var payment : Bool = true

if let ageValidate = age,
   let nameValidate = name,
   ageValidate > 40 && payment == true {
  // Si se puede crear ageValidate a partir de age y
  // Si se puede crear nameValidate a partir de name
  print("Age is \(ageValidate)")
}


/**
 Unwraping implicito
 */
// Force unwrapping (!)
let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // requires an exclamation point

// implicitly unwrapped
let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // no need for an exclamation point

// Definir un array
var shoppingList = ["naranjas", "Tomates","Melones"]

// Definir array de strings vacio
var letrasReversas = [String]()

// Saber si esta vacio
shoppingList.isEmpty

// Contar cantidad de elementos
var cantidad = shoppingList.count
print("shopping list tiene \(cantidad) elementos")

// Leer primer elemento
let primerItem = shoppingList[0]

// Agregar un item al final
shoppingList.append("Tunas")

// Remover segundo elemento
let itemEliminado = shoppingList.remove(at: 1)
print("Se elimino \(itemEliminado)")

// Remover ultimo elemento
let ultimoItemEliminado = shoppingList.removeLast()
print("Se elimino el último elemento : \(ultimoItemEliminado)")

// Remover primer elemento
let primerItemEliminado = shoppingList.removeFirst()
print("Se elimino el primer elemento : \(primerItemEliminado)")

// Iterar sobre un array
for item in shoppingList {
  print(item)
}

// Iterar sobre array y obtener el indice
for (index, item) in shoppingList.enumerated(){
  print("index : \(index), valor : \(item)")
}

// !Important: Los conjuntos no permiten dos items iguales

// Declarar un conjunto (Set) de elementos de tipo string
var fruits = Set<String>()

// Agregar items al conjunto
fruits.insert("Naranjas")
fruits.insert("Pomelos")
fruits.insert("Sandias")
fruits.insert("Arandano")


// Contar la cantidad de elementos que tiene el conjunto
fruits.count

// Saber si esta vacio
fruits.isEmpty

// Eliminar un item del conjunto
if let removedFruit = fruits.remove("Pomelos"){
  print("Se ha eliminado \(removedFruit)")
}else{
  print("No se ha podio eliminar el item")
}

// Saber si un elemento existe en el conjunto
if fruits.contains("Sandias"){
  print("Existe el item")
}

// Iterar sobre el conjunto
for fruit in fruits {
  print(fruit)
}

// Iterar sobre el conjunto ordenado
for fruit in fruits.sorted() {
  print(fruit)
}

let conjuntoA: Set = [1,3,5,7,9,11,13]
let conjuntoB: Set = [0,2,4,6,8,10,12]
let conjuntoC: Set = [2,3,5,7]
let conjuntoD: Set = [1,3,5]

// Unir dos conjuntos
let union = conjuntoA.union(conjuntoB)
print(union)

// Interseccion dos conjuntos
let interseccion = conjuntoC.intersection(conjuntoB)
print(interseccion)

// Diferencia de conjunto
let diferencia = conjuntoA.subtracting(conjuntoC)
print(diferencia)

// Diferencia simetrica conjunto
let diferenciaSimetrica = conjuntoA.symmetricDifference(conjuntoC)
print(diferenciaSimetrica)

// Verificar si D es subconjunto de A
conjuntoD.isSubset(of: conjuntoA)

// Verificar A contiene a D
conjuntoA.isSuperset(of: conjuntoD)

// Verificar que B y D no tienen elementos en común
conjuntoB.isDisjoint(with: conjuntoD)

// Diccionarios (no tienen posición)
// [k1:v1, k2:v2, ... ]

// Diccionario con Clave String y valor String
var levels = [String:String]()

// Diccionario con Clave int y valor String
var score = [Int:String]()

// Agregar valor al diccionario
levels["1A"]="Juan Mora"

// Vaciar un diccionario
levels=[:]

// Diccionarios literales
var airports: [String: String] = ["SCL": "Santiago de Chile", "DUB": "Dublin", "PMI":"Palma de mallorca"]

// Saber cuantos registros tiene
airports.count

// Saber si esta vacio
airports.isEmpty

// Actualizar valor, recuperando el valor antiguo
if let oldValue = airports.updateValue("New dublin", forKey: "DUB"){
  print(oldValue)
}

// Leer de forma segura
if let airportName = airports["DUB"]{
  print("El aeropuerto de dublin en \(airportName)")
}

// Eliminar elemento
airports["DUB"] = nil

// Eliminado condicional
if let removedAirport = airports.removeValue(forKey: "DUB"){
  print("Se ha eliminado \(removedAirport)")
}

// Iterar un diccionario
for (key, value) in airports{
  print("clave es \(key) y su valor es \(value)")
}


// Iterar sobre las claves de un diccionario
for key in airports.keys{
  print("clave es \(key)")
}

// Iterar sobre las claves de un diccionario
for value in airports.values{
  print("el valor es \(value)")
}

// Obtener las keys de un diccionario
let airportsKeys = [String](airports.keys)

// obtener solo los valores de un diccionario
let airportsValues = [String](airports.values)

// Iterar sobre un Array
let students = ["Alex Mora", "Rose Hirch", "Math Zurich"]

for student in students{
  print("Estudiante \(student)")
}

// iterar sobre un diccionario
let enrollments = ["1A":45,"1B":60,"1C":100]

for (index, value) in enrollments{
  print("Enrollments in \(index) is \(value)")
}

// Iterar en un rango
for index in 1...5{
  print("index is \(index)")
}


// Iterar de 0 a 20, de 5 en 5
for value in stride(from: 0, to: 20, by: 5){
  print(value) // 0,5,10,15,20
}

var i = 0

// Evalua condicion y ejecuta
while i<=10 {
  i += 1
  print(i)
}
print(i)

// Ejecuta al menos una vez y evalua condicion luego
repeat {
  i += 1
} while i <= 10

print(i)

var temp = 16

if temp <= 15 {
  print("Turn on heating ")
}else if temp >= 25 {
  print("Turn of heating ")
  print("Turn on air ")
}else{
  print("Turn of heating ")
  print("Turn of air ")
}

var platform = "ios"

switch platform {
  case "ios":
    print("use APNs")
  case "android":
    print("use FCM")
  default:
    print("not use Push")
}

// switch con interval matching
let speed = 0

switch speed {
  case 0:
    print("Vehiculo detenido")
  case 1..<10:
    print("Se mueve despacion")
  case 10..<100:
    print("Velocidad normal")
  default:
    print("infracción")
}

// switch con tuplas
let coordenadas = (555,555)
switch coordenadas {
  case (0,0):
    print("La posición esta en el origen")
  case (_,0):
    print("El punto esta sobre el eje x")
  case (0,_):
    print("El punto esta sobre el eje y")
  case (0...100,-100...0):
    print("El punto esta sobre el cuadrante 4")
  
  // Evaluando condición
  case (let x,let y) where x == y:
    print("x === y, \(x),\(y)")
  
  // Capturando los valores
  case (let x,let y):
    print("El punto esta en \(x),\(y)")
    
}

// Casos compuestos ( más de un valor en cada case )
let level = "1 Básico"

switch level {
case "1 Básico","2 Básico","3 Básico","4 Básico","5 Básico":
  print("\(level) is primary education")
case "1 Medio","2 Medio","3 Medio","4 Medio":
  print("\(level) is secondary education")
default:
  print("\(level) is unknown")

let numbers = [1,2,3,4,5,6,7,8,9,10]
let numberSearched = 5

// Break
// Detiene el ciclo
for number in numbers {
  print(number)
  if number == numberSearched {
    print("Encontramos el número buscado")
    break
  }
}

// continue
// Detiene el script interno del for, pero continua con el item siguiente
for number in numbers {
  
  if number % 2 != 0 {
    print("El \(number) es impar, rompe y coninua al siguiente valor")
    continue
  }
  
  // Ejecutas mas instrucciones para los PARES
  print("El \(number) es par")
}

let number = 2

switch number {
case 2,4,6,8,10:
  print("El número \(number) es par")
  // Permite continuar evaluando casos
  fallthrough
case 0..<10:
  print("El número \(number) es menor a 10")
default:
  break
}

if #available(iOS 12, macOS 10.12, *){
  // Ejecuta este bloque para iOS 12 o superior y macOS 10.12 o superior
  
}else{
  // Ejecuta para versiones anteriores
  
}