Voir la source de Tester un script Kotlin

PROVISOIRE

Kotlin est un langage utilisé notamment dans les applications Android. On peut l'utiliser dans l'environnement de développement Android 
Studio. Et il est aussi possible de l'utiliser dans une fenêtre terminal dans une première étape de familiarisation, un peu comme pour Python.

Il y a plusieurs étapes à suivre,

https://otfried.org/courses/cs109/project-install.html

1) installer ou vérifier la présence de Java sur la machine, et l'installer si besoin


2) installer le compilateur Kotlin


3) tester des scripts

Taper la commande kotlinc-jvm pour démarrer le REPL Kotlin.

Puis charger le script en tapant :load NomDuFichier.kt

Et si script contient une classe, on la lance en tapant la commande main()

<pre>
fun main() {
    print("Entrez votre nom : ")
    val nom = readLine()
    println("Bienvenue, $nom !")
}
</pre>

Puis tester d'autres scripts, 

<pre>
fun main() {
    var somme = 0

    repeat(2) {
        print("Entrez un chiffre : ")
        val chiffre = readLine()?.toIntOrNull() ?: 0
        somme += chiffre
    }

    println("La somme des deux chiffres est : $somme")
}
</pre>
<pre>
class Utilisateur(val nom: String, val age: Int)

fun main() {
    print("Entrez votre nom : ")
    val nom = readLine() ?: ""

    print("Entrez votre âge : ")
    val age = readLine()?.toIntOrNull() ?: 0

    val utilisateur = Utilisateur(nom, age)

    println("Bonjour, ${utilisateur.nom} ! Vous avez ${utilisateur.age} ans.")
}
</pre>

<pre>
class Calculatrice {
    fun additionner(nombre1: Int, nombre2: Int): Int {
        return nombre1 + nombre2
    }
}

fun main() {
    val calculatrice = Calculatrice()

    print("Entrez le premier nombre : ")
    val num1 = readLine()?.toIntOrNull() ?: 0

    print("Entrez le deuxième nombre : ")
    val num2 = readLine()?.toIntOrNull() ?: 0

    val resultat = calculatrice.additionner(num1, num2)

    println("La somme de $num1 et $num2 est : $resultat")
}
</pre>

liste et boucles
<pre>
fun main() {
    val nombres = mutableListOf<Int>()

    for (i in 1..3) {
        print("Entrez le nombre $i : ")
        val num = readLine()?.toIntOrNull() ?: 0
        nombres.add(num)
    }

    val somme = nombres.sum()
    println("La somme des nombres est : $somme")
}
</pre>
Condition If
<pre>
fun main() {
    print("Entrez votre âge : ")
    val age = readLine()?.toIntOrNull() ?: 0

    val message = if (age >= 18) {
        "Vous êtes majeur."
    } else {
        "Vous êtes mineur."
    }

    println(message)
}
</pre>
extension de fonctions
<pre>
fun String.saluer() {
    println("Bonjour, $this!")
}

fun main() {
    print("Entrez votre prénom : ")
    val prenom = readLine() ?: ""
    prenom.saluer()
}
</pre>
manipulation de fichiers
<pre>
import java.io.File

fun main() {
    print("Entrez le chemin du fichier : ")
    val chemin = readLine() ?: ""
    val fichier = File(chemin)

    if (fichier.exists()) {
        println("Le fichier existe.")
    } else {
        println("Le fichier n'existe pas.")
    }
}

</pre>
travail sur exception
<pre>
fun main() {
    try {
        print("Entrez un nombre : ")
        val num = readLine()?.toInt() ?: throw NumberFormatException("Entrée invalide")
        println("Le double de $num est : ${num * 2}")
    } catch (e: NumberFormatException) {
        println("Erreur : ${e.message}")
    }
}

</pre>
liste et tableaux
<pre>
fun main() {
    // Exemple avec une liste de noms
    val listeNoms = mutableListOf("Alice", "Bob", "Charlie")

    // Afficher la liste initiale
    println("Liste initiale : $listeNoms")

    // Ajouter un nouveau nom à la liste
    listeNoms.add("David")

    // Afficher la liste mise à jour
    println("Liste mise à jour : $listeNoms")

    // Exemple avec un tableau de scores
    val scores = intArrayOf(90, 85, 95, 88, 92)

    // Afficher le tableau de scores
    println("Scores initiaux : ${scores.joinToString(", ")}")

    // Calculer la moyenne des scores
    val moyenne = scores.average()

    // Afficher la moyenne
    println("Moyenne des scores : $moyenne")
}

</pre>
travailler avec des fichiers
<pre>
import java.io.File

fun lireFichier(nomFichier: String): String {
    val fichier = File(nomFichier)
    return if (fichier.exists()) {
        fichier.readText()
    } else {
        "Le fichier n'existe pas."
    }
}

fun ecrireFichier(nomFichier: String, contenu: String) {
    val fichier = File(nomFichier)
    fichier.writeText(contenu)
}

fun main() {
    val nomFichier = "exemple.txt"
    
    ecrireFichier(nomFichier, "Contenu du fichier.")
    
    val contenuLu = lireFichier(nomFichier)
    println("Contenu lu : $contenuLu")
}
</pre>
Expression Lambda et Fonctions Anonymes
<pre>
fun operation(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

fun main() {
    val addition = operation(10, 5) { x, y -> x + y }
    val multiplication = operation(3, 4) { x, y -> x * y }

    println("Addition : $addition")
    println("Multiplication : $multiplication")
}
</pre>
Exploration des fonctions de la bibliothèque standard de Kotlin
<pre>
fun main() {
    val liste = listOf(1, 2, 3, 4, 5)

    // Filtrer les éléments pairs
    val pairs = liste.filter { it % 2 == 0 }

    // Doubler chaque élément
    val doubles = liste.map { it * 2 }

    // Somme des éléments
    val somme = liste.sum()

    // Affichage des résultats
    println("Liste originale : $liste")
    println("Éléments pairs : $pairs")
    println("Éléments doublés : $doubles")
    println("Somme des éléments : $somme")
}
</pre>
les types Nullable
<pre>
fun longueurChaine(chaine: String?): Int {
    return chaine?.length ?: 0
}

fun main() {
    val chaineNonNull: String = "Hello"
    val chaineNullable: String? = null

    val longueurNonNull = longueurChaine(chaineNonNull)
    val longueurNullable = longueurChaine(chaineNullable)

    println("Longueur de la chaine non null : $longueurNonNull")
    println("Longueur de la chaine nullable : $longueurNullable")
}
</pre>
Et un exemple qui combine un peu tout ça, 
<pre>
import java.io.File

fun division(a: Int, b: Int): Int {
    return try {
        a / b
    } catch (e: ArithmeticException) {
        println("Erreur de division : ${e.message}")
        0
    } finally {
        println("Opération de division terminée")
    }
}

fun lireFichier(nomFichier: String): String {
    val fichier = File(nomFichier)
    return if (fichier.exists()) {
        fichier.readText()
    } else {
        "Le fichier n'existe pas."
    }
}

fun ecrireFichier(nomFichier: String, contenu: String) {
    val fichier = File(nomFichier)
    fichier.writeText(contenu)
}

fun operation(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

fun longueurChaine(chaine: String?): Int {
    return chaine?.length ?: 0
}

fun main() {
    // Gestion d'erreurs
    val resultatDivision = division(10, 0)
    println("Résultat de la division : $resultatDivision")

    // Manipulation de fichiers
    val nomFichier = "exemple.txt"
    ecrireFichier(nomFichier, "Contenu du fichier.")

    val contenuLu = lireFichier(nomFichier)
    println("Contenu lu du fichier : $contenuLu")

    // Expression Lambda
    val addition = operation(10, 5) { x, y -> x + y }
    println("Addition : $addition")

    // Bibliothèque standard
    val liste = listOf(1, 2, 3, 4, 5)
    val pairs = liste.filter { it % 2 == 0 }
    println("Éléments pairs : $pairs")

    // Nullabilité
    val chaineNonNull: String = "Hello"
    val chaineNullable: String? = null

    val longueurNonNull = longueurChaine(chaineNonNull)
    val longueurNullable = longueurChaine(chaineNullable)

    println("Longueur de la chaine non null : $longueurNonNull")
    println("Longueur de la chaine nullable : $longueurNullable")
}
</pre>

Pour aller plus loin, créer une première appli avec Android Studio,
https://developer.android.com/codelabs/basic-android-kotlin-compose-first-app?hl=fr#0