Swift vs Kotlin : comparatif

## Tableau comparatif rapide
| Critère | Swift | Kotlin |
|---|---|---|
| Performance | Forte (joue bien avec Objective-C) | Forte (multiplateformes avec JVM et Native) |
| Courbe d'apprentissage | Plus courte, syntaxe similaire à Objective-C | Longue, mais populaire et facile pour les Java Developers |
| Ecosysteme | Grand ecosysteme iOS/macOS/tvOS/watchOS/CloudKit | Large ecosysteme Android/iOS/macOS/Windows/Linux/Kotlin Multiplatform |
| Communauté | Forte (Apple, Apple Developers) | Généreuse (Google, JetBrains, communautés open source) |
| Cas d'usage | Principalement iOS/macOS/tvOS/watchOS/CloudKit | Multiplateformes (Android/iOS/macOS/Windows/Linux), développement serveur et cloud |
| Typage | Stagnant (structs/classes) | Evolutif (data classes, sealed classes) |
| Bundle size | Plus grand en général | Moins grand grâce à Kotlin Native |
| Asynchronisme | `async` / `await` | `suspend` / coroutines |

## Swift — Points forts
- **Performance** : Optimisé pour les appareils Apple. Exemple :
  ```swift
  func fibonacci(_ n: Int) -> Int {
      var a = 0, b = 1
      for _ in 0..<n {
          (a, b) = (b, a + b)
      }
      return a
  }

• Interopérabilité : Très facile avec Objective-C et autres langages. Exemple :

  let label = UILabel()
  label.text = "Hello, World!"
  

• Sécurité : Utilisation de guard pour les vérifications préalables. Exemple :

  func divide(_ a: Int, by b: Int) -> Int? {
      guard b != 0 else { return nil }
      return a / b
  }
  

• UI/UX : Forte communauté et outils pour développer des interfaces utilisateur. Exemple :

  let button = UIButton(type: .system)
  button.setTitle("Tap me", for: .normal)
  button.addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)
  

• Modularité : Facile à structurer en utilisant extension et les fonctions. Exemple :

  extension String {
      func reversed() -> String {
          return String(self.reversed())
      }
  }
  

Kotlin — Points forts

• Multiplateformes : Permet de développer pour Android, iOS (SwiftUI), desktop, web et serveur. Exemple :

  fun fibonacci(n: Int): Int {
      var a = 0; var b = 1
      repeat(n) {
          val temp = a + b
          a = b
          b = temp
      }
      return a
  }
  

• Sécurité : Utilisation de require pour les vérifications préalables. Exemple :

  fun divide(a: Int, b: Int): Int? {
      require(b != 0) { "Cannot divide by zero" }
      return a / b
  }
  

• Conventions de codage : Forte communauté qui respecte les conventions de codage. Exemple :

  fun greet(name: String) = "Hello, $name!"
  

• Extensions : Facile à structurer en utilisant extension et la fonctionnalité inline. Exemple :

  fun <T> List<T>.swapAt(_ i: Int, _ j: Int) {
      let temp = this[i]
      this[i] = this[j]
      this[j] = temp
  }
  

• Coroutines : Facilité de gestion des threads et des tâches asynchrones. Exemple :

  suspend fun fetchData() {
      val response = withContext(Dispatchers.IO) {
          // Simulate network request
          delay(1000)
          "Data"
      }
      println(response)
  }
  

Syntaxe cote à cote

Initialisation d'une variable

// Swift
var a: Int = 5

// Kotlin
val a: Int = 5

Fonction avec paramètres

// Swift
func add(a: Int, b: Int) -> Int {
    return a + b
}

// Kotlin
fun add(a: Int, b: Int): Int {
    return a + b
}

Boucle for-each

// Swift
for item in array {
    print(item)
}

// Kotlin
array.forEach { item ->
    println(item)
}

If-else condition

// Swift
if number > 0 {
    print("Positive")
} else if number == 0 {
    print("Zero")
} else {
    print("Negative")
}

// Kotlin
if (number > 0) {
    println("Positive")
} else if (number == 0) {
    println("Zero")
} else {
    println("Negative")
}

Asynchronisme avec async/await et suspend/coroutines

// Swift
func fetchData() async throws -> String {
    let url = URL(string: "https://example.com")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return String(data: data, encoding: .utf8)!
}

// Kotlin
suspend fun fetchData(): String {
    val url = URL("https://example.com")
    val response = withContext(Dispatchers.IO) {
        // Simulate network request
        delay(1000)
        "Data"
    }
    return response
}

Quand choisir Swift vs Kotlin

• Swift : Pour les applications iOS/macOS/tvOS/watchOS et nécessitant une intégration profonde avec Objective-C/OC.
• Kotlin : Pour les projets multiplateformes, développement Android/iOS (SwiftUI), ou pour des équipes plus grandes ayant déjà une culture autour de Kotlin.

Verdict

• Swift offre un bon équilibre entre performance et simplicité d'apprentissage, parfait pour les applications mobiles Apple.
• Kotlin est idéal pour les projets multiplateformes, offrant une grande communauté et des outils robustes pour le développement Android/iOS.