Kotlin print(), println(), readLine(), Scanner, REPL

Aujourd’hui, nous allons apprendre comment utiliser les fonctions d’impression Kotlin et comment obtenir et analyser les entrées utilisateur à partir de la console. De plus, nous examinerons Kotlin REPL.

Fonctions d’impression Kotlin

Pour afficher quelque chose à l’écran, les deux méthodes suivantes sont utilisées:

• print()
• println()

La commande print imprime tout ce qui se trouve à l’intérieur sur l’écran. La commande println ajoute une nouvelle ligne à la fin de la sortie. Les commandes print appellent en interne System.out.print. Le code suivant montre les commandes print en action:

fun main(args: Array<String>) {
var x = 5
print(x++)
println("Hello World")
print("Do dinasours still exist?\n")
print(false)
print("\nx is $x.")
println(" x Got Updated!!")
print("Is x equal to 6?: ${x == 6}\n")    
}

Pour imprimer une variable à l’intérieur de la commande d’impression, nous devons utiliser le symbole dollar($) suivi du nom var/val à l’intérieur d’une chaîne de caractères entre guillemets doubles. Pour imprimer le résultat d’une expression, nous utilisons ${ //l'expression va ici }. La sortie lorsque le code ci-dessus est exécuté sur le compilateur en ligne Kotlin est donnée ci-dessous.

Littéraux et expressions d’échappement

Pour échapper au symbole dollar et disons traiter ${expression} comme une chaîne de caractères seulement plutôt que de la calculer, nous pouvons l’échapper.

fun main(args: Array<String>) {
val y = "\${2 == 5}"
println("y = ${y}")       
println("Do we use $ to get variables in Python or PHP? Example: ${'$'}x and ${'$'}y")
val z = 5
var str = "$z"
println("z is $str")
str = "\$z"
println("str is $str")
}

Remarquez qu’un simple $ sans aucune expression/variable définie contre lui l’échappe implicitement et le traite comme faisant partie de la chaîne uniquement.

Valeurs de fonction d’impression

fun sumOfTwo(a: Int, b: Int) : Int{
    return a + b
}

fun main(args: Array<String>) {
val a = 2
val b = 3
println("Value of ${'$'}a and ${'$'}b is : ${sumOfTwo(a,b)}") 
println(println("Printing Value of ${'$'}a and ${'$'}b is : ${sumOfTwo(a,b)}"))    
}

La sortie suivante est imprimée: Remarque: L’utilisation d’une instruction print à l’intérieur d’une autre se comporte comme une récursion. La plus interne est imprimée en premier. L’instruction print renvoie une Unité (équivalent de void en Java).

Entrée utilisateur Kotlin

Pour obtenir l’entrée utilisateur, les deux méthodes suivantes peuvent être utilisées:

• readLine()
• Scanner classe

Remarque: L’entrée utilisateur nécessite un outil en ligne de commande. Vous pouvez utiliser soit REPL soit IntelliJ. Utilisons IntelliJ ici.

Utilisation de readLine()

readLine() renvoie la valeur du type String? afin de gérer les valeurs nulles qui peuvent survenir lorsque vous lisez la fin du fichier, etc. Le code suivant montre un exemple utilisant readLine().

fun main(args: Array<String>) {
    println("Enter your name:")
    var name = readLine()
    print("Length is ${name?.length}")
}

Comme vous pouvez le voir, nous devons déballer le type nullable pour utiliser les fonctions de type String sur la propriété. Utilisez !! pour convertir de force String? en String, uniquement lorsque vous êtes absolument sûr que la valeur ne sera pas nulle. Sinon, cela plantera.Conversion de l’entrée en un entier Pour convertir la chaîne d’entrée en un entier, nous faisons ce qui suit :

fun main(args: Array<String>) {
var number = readLine()
try {
        println("Number multiply by 5 is ${number?.toInt()?.times(5)}")
    } catch (ex: NumberFormatException) {
        println("Number not valid")
    }
}

Encore une fois, nous utilisons l’opérateur ?. pour convertir le type nullable d’abord en un entier en utilisant toInt(). Ensuite, nous le multiplions par 5. Lecture de l’entrée en continu Nous pouvons utiliser la boucle do while pour lire l’entrée en continu comme indiqué ci-dessous.

    do {
        line = readLine()

        if (line == "quit") {
            println("Closing Program")
            break
        }

        println("Echo $line")

    } while (true)
}

La sortie ci-dessus dans la ligne de commande IntelliJ est donnée ci-dessous.

Lecture de plusieurs valeurs à l’aide de l’opérateur de séparation

Nous pouvons lire plusieurs valeurs séparées par des délimiteurs et les enregistrer sous forme de tuple comme indiqué ci-dessous.

fun readIntegers(separator: Char = ',')
        = readLine()!!.split(separator).map(String::toInt)

fun main(args: Array<String>) {
    println("Enter your values:")
    try {
        val (a, b, c) = readLine()!!.split(' ')
        println("Values are $a $b and $c")
    } catch (ex: IndexOutOfBoundsException) {
        println("Invalid. Missing values")
    }

    try {
        val (x, y, z) = readIntegers()
        println("x is $x y is $y z is $z")
    } catch (ex: IndexOutOfBoundsException) {
        println("Invalid. Missing values")
    }
    catch (ex: NumberFormatException) {
        println("Number not valid")
    }

}

La fonction split prend en paramètre le caractère qui servira de délimiteur. La fonction readIntegers() utilise une fonction map sur un découpage pour convertir chaque valeur en entier. Si vous saisissez des valeurs inférieures à celles spécifiées dans le tuple, vous obtiendrez une IndexOutOfBoundsException. Nous avons utilisé try-catch pour gérer les deux entrées. La sortie ressemble à ceci : Alternativement, au lieu de tuples, nous pouvons également utiliser une liste comme indiqué ci-dessous.

val ints: List<String>? = readLine()?.split("|".toRegex())
println(ints)

Classe Scanner en Kotlin

Pour saisir des entrées, nous pouvons utiliser Scanner(System.`in`) qui prend des entrées depuis le clavier standard. Le code suivant illustre la même chose :

fun main(args: Array) {
    val reader = Scanner(System.`in`)
    print("Enter a number: ")

    // nextInt() lit le prochain entier. next() lit la chaîne de caractères
    var integer:Int = reader.nextInt()

    println("You entered: $integer")

reader.nextInt() lit le prochain entier. reader.next() lit la prochaine chaîne de caractères. reader.nextFloat() lit le prochain flottant, et ainsi de suite. reader.nextLine() passe le Scanner à la ligne suivante et efface également le tampon. Le code suivant illustre la lecture de différents types d’entrées directement à l’intérieur d’une instruction d’impression.

import java.util.*

fun main(args: Array) {

    val reader = Scanner(System.`in`)
    print("Enter a number: ")

    try {
        var integer: Int = reader.nextInt()
        println("You entered: $integer")
    } catch (ex: InputMismatchException) {
        println("Enter valid number")
    }
    enterValues(reader)
    //déplace le scanner à la ligne suivante sinon l'entrée tamponnée serait lue pour la prochaine ici seulement. 
    reader.nextLine()
    enterValues(reader)
}

fun enterValues(reader: Scanner) {
    println("Enter a float/boolean :")
    try {
        print("Values: ${reader.nextFloat()}, ${reader.nextBoolean()}")
    } catch (ex: InputMismatchException) {
        println("First value should be a float, second should be a boolean. (Separated by enter key)")
    }
}

InputMismatchException est levée lorsque l’entrée est d’un type différent de celui demandé. La sortie est donnée ci-dessous.

Kotlin REPL

REPL, également connu sous le nom de Read-Eval-Print-Loop, est utilisé pour exécuter une partie du code dans un shell interactif directement. Nous pouvons le faire dans notre terminal/ligne de commande en lançant le compilateur Kotlin.

Installation du compilateur en ligne de commande

Nous pouvons installer le compilateur en ligne de commande sur Mac/Windows/Ubuntu comme démontré ici. Typiquement, sur un Mac, nous pouvons utiliser HomeBrew dans notre terminal pour installer le compilateur Kotlin.

brew update
brew install kotlin

Une fois que c’est fait, lancez le REPL en entrant kotlinc dans votre terminal/cmd. Voici mon premier code dans le REPL. C’est tout pour les fonctions d’impression Kotlin et une brève introduction au REPL Kotlin.