Merge pull request mouredev#4120 from kontroldev/main

#14, #15 - Swift

Author: Roswell468

Roadmap/14 - FECHAS/swift/kontroldev.swift

@@ -0,0 +1,79 @@
+import Foundation
+
+/*
+ * EJERCICIO:
+ * Crea dos variables utilizando los objetos fecha (date, o semejante) de tu lenguaje:
+ * - Una primera que represente la fecha (día, mes, año, hora, minuto, segundo) actual.
+ * - Una segunda que represente tu fecha de nacimiento (te puedes inventar la hora).
+ * Calcula cuántos años han transcurrido entre ambas fechas.
+ *
+ * DIFICULTAD EXTRA (opcional):
+ * Utilizando la fecha de tu cumpleaños, formatéala y muestra su resultado de
+ * 10 maneras diferentes. Por ejemplo:
+ * - Día, mes y año.
+ * - Hora, minuto y segundo.
+ * - Día de año.
+ * - Día de la semana.
+ * - Nombre del mes.
+ * (lo que se te ocurra...)
+ */
+
+
+// Obtén la fecha actual
+let currentDate = Date()
+
+// Configura el formato de la fecha
+let dateFormatter = DateFormatter()
+dateFormatter.dateFormat = "yyyy/MM/dd HH:mm:ss"
+
+// Define tu fecha de nacimiento (por ejemplo, 1 de enero de 1990 a las 12:00:00)
+let birthDateString = "1990/01/01 12:00:00"
+guard let birthDate = dateFormatter.date(from: birthDateString) else {
+    fatalError("Error al convertir la cadena de fecha a objeto Date")
+}
+
+// Calcula la diferencia de años entre la fecha actual y la fecha de nacimiento
+let calendar = Calendar.current
+let ageComponents = calendar.dateComponents([.year], from: birthDate, to: currentDate)
+let age = ageComponents.year!
+
+print("Han transcurrido \(age) años desde tu fecha de nacimiento.")
+
+
+//MARK: - DIFICULTAD EXTRA (opcional)
+
+// Configura el formato de la fecha
+let dateFormatter2 = DateFormatter()
+dateFormatter.dateFormat = "yyyy/MM/dd HH:mm:ss"
+
+// Define tu fecha de nacimiento (por ejemplo, 1 de enero de 1990 a las 12:00:00)
+let birthDateString2 = "1990/01/01 12:00:00"
+guard let birthDate = dateFormatter.date(from: birthDateString) else {
+    fatalError("Error al convertir la cadena de fecha a objeto Date")
+}
+
+// Función para formatear y mostrar la fecha en diferentes formatos
+func displayFormattedDates(for date: Date) {
+    let formats = [
+        "dd/MM/yyyy",              // Día, mes y año
+        "HH:mm:ss",                // Hora, minuto y segundo
+        "D",                       // Día del año
+        "EEEE",                    // Día de la semana
+        "MMMM",                    // Nombre del mes
+        "MM/dd/yyyy HH:mm",        // Mes/día/año hora:minuto
+        "yyyy/MM/dd",              // Año/mes/día
+        "MMM d, yyyy",             // Mes abreviado día, año
+        "EEEE, MMM d, yyyy",       // Día de la semana, mes abreviado día, año
+        "E, d MMM yyyy HH:mm:ss",  // Día de la semana abreviado, día mes año hora:minuto:segundo
+    ]
+    
+    for format in formats {
+        dateFormatter.dateFormat = format
+        let formattedDate = dateFormatter.string(from: date)
+        print("Formato '\(format)': \(formattedDate)")
+    }
+}
+
+// Muestra las diferentes representaciones de la fecha de nacimiento
+displayFormattedDates(for: birthDate)
+

Roadmap/15 - ASINCRONÍA/swift/kontroldev.swift

@@ -0,0 +1,95 @@
+import Foundation
+
+/*
+ * EJERCICIO:
+ * Utilizando tu lenguaje, crea un programa capaz de ejecutar de manera
+ * asíncrona una función que tardará en finalizar un número concreto de
+ * segundos parametrizables. También debes poder asignarle un nombre.
+ * La función imprime su nombre, cuándo empieza, el tiempo que durará
+ * su ejecución y cuando finaliza.
+ *
+ * DIFICULTAD EXTRA (opcional):
+ * Utilizando el concepto de asincronía y la función anterior, crea
+ * el siguiente programa que ejecuta en este orden:
+ * - Una función C que dura 3 segundos.
+ * - Una función B que dura 2 segundos.
+ * - Una función A que dura 1 segundo.
+ * - Una función D que dura 1 segundo.
+ * - Las funciones C, B y A se ejecutan en paralelo.
+ * - La función D comienza su ejecución cuando las 3 anteriores han
+ *   finalizado.
+ */
+
+import Foundation
+
+// Función asíncrona
+func asyncFunction(name: String, duration: Int) {
+    let startTime = Date()
+    print("La función '\(name)' ha empezado a las \(startTime) y durará \(duration) segundos.")
+
+    // Simula una tarea larga usando sleep
+    sleep(UInt32(duration))
+    
+    let endTime = Date()
+    print("La función '\(name)' ha terminado a las \(endTime).")
+}
+
+// Función que ejecuta la función asíncrona
+func executeAsyncFunction(name: String, duration: Int) {
+    DispatchQueue.global().async {
+        asyncFunction(name: name, duration: duration)
+    }
+}
+
+// Ejemplo de uso
+executeAsyncFunction(name: "Tarea 1", duration: 5)
+executeAsyncFunction(name: "Tarea 2", duration: 3)
+
+// Mantén el programa en ejecución para que puedas ver el resultado de las funciones asíncronas
+RunLoop.current.run(until: Date().addingTimeInterval(10))
+
+//MARK: - DIFICULTAD EXTRA (opcional)
+
+// Función asíncrona 👇
+func asyncFunction(name: String, duration: Int, completion: @escaping () -> Void) {
+    let startTime = Date()
+    print("La función '\(name)' ha empezado a las \(startTime) y durará \(duration) segundos.")
+    
+    // Simula una tarea larga usando el metodo sleep
+    sleep(UInt32(duration))
+    
+    let endTime = Date()
+    print("La función '\(name)' ha terminado a las \(endTime).")
+    
+    // Llama al completion 'handler' al finalizar
+    completion()
+}
+
+// Ejecuta la función asíncrona con un DispatchGroup
+func executeAsyncFunction(name: String, duration: Int, group: DispatchGroup) {
+    group.enter()
+    DispatchQueue.global().async {
+        asyncFunction(name: name, duration: duration) {
+            group.leave()
+        }
+    }
+}
+
+// Crear un DispatchGroup para sincronizar las tareas
+let group = DispatchGroup()
+
+// Ejecutar funciones C, B y A en paralelo
+executeAsyncFunction(name: "C", duration: 3, group: group)
+executeAsyncFunction(name: "B", duration: 2, group: group)
+executeAsyncFunction(name: "A", duration: 1, group: group)
+
+// Ejecutar la función D después de que C, B y A hayan finalizado
+group.notify(queue: DispatchQueue.global()) {
+    asyncFunction(name: "D", duration: 1) {
+        print("Todas las funciones han terminado.")
+    }
+}
+
+// Mantén el programa en ejecución para ver los resultados
+RunLoop.current.run(until: Date().addingTimeInterval(10))
+