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

Oggi impareremo come usare le funzioni di stampa Kotlin e come ottenere ed interpretare l’input dell’utente dal console. Inoltre, esploreremo Kotlin REPL.

Funzioni di Stampa Kotlin

Per visualizzare qualcosa sullo schermo vengono utilizzati i seguenti due metodi:

• print()
• println()

Il comando print stampa tutto ciò che si trova al suo interno sullo schermo. Il comando println aggiunge una nuova linea alla fine dell’output. I comandi di stampa chiamano internamente System.out.print. Il codice seguente mostra i comandi di stampa in azione:

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")    
}

Per stampare una variabile all’interno del comando di stampa, dobbiamo usare il simbolo del dollaro($) seguito dal nome var/val all’interno di una stringa letterale tra virgolette doppie. Per stampare il risultato di un’espressione usiamo ${ //qui va l'espressione }. L’output quando il codice sopra viene eseguito sul Kotlin Online Compiler è dato di seguito.

Escape letterali ed espressioni

Per escludere il simbolo del dollaro e diciamo trattare ${espressione} come una stringa solo invece di calcolarla, possiamo escluderla.

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")
}

Nota un semplice $ senza alcuna espressione/variabile impostata implicitamente lo esclude e lo tratta solo come parte della stringa.

Stampa dei valori di una funzione

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)}"))    
}

Viene stampato il seguente output: Nota: Passare una stampa all’interno di un’altra funziona come una ricorsione. Viene stampata prima quella più interna. L’istruzione di stampa restituisce un Unit (equivalente di void in Java).

Input utente in Kotlin

Per ottenere l’input dell’utente, possono essere utilizzati i seguenti due metodi:

• readLine()
• Classe Scanner

Nota: L’input dell’utente richiede un’interfaccia a riga di comando. Puoi utilizzare il REPL o IntelliJ. Utilizziamo IntelliJ qui.

Utilizzo di readLine()

readLine() restituisce il valore di tipo String? per gestire i valori nulli che possono verificarsi quando si legge la fine del file ecc. Il codice seguente mostra un esempio di utilizzo di readLine().

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

Come puoi vedere, è necessario estrarre il tipo nullable per utilizzare le funzioni di tipo String sulla proprietà. Utilizza !! per forzare la conversione di String? in String solo quando sei assolutamente sicuro che il valore non sarà nullo. Altrimenti, si verificherà un crash. Conversione dell’input in un intero Per convertire la stringa di input in un intero, esegui quanto segue:

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")
    }
}

Di nuovo, utilizziamo l’operatore ?. per convertire il tipo nullable prima in un intero utilizzando toInt(). Poi moltiplichiamolo per 5. Lettura continua dell’input Possiamo utilizzare il ciclo do while per leggere l’input continuamente come mostrato di seguito.

    do {
        line = readLine()

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

        println("Echo $line")

    } while (true)
}

Di seguito viene riportato l’output del codice sopra nella riga di comando di IntelliJ.

Lettura di valori multipli utilizzando l’operatore split

Possiamo leggere valori multipli separati da delimitatori e salvarli in forma di tuple come mostrato di seguito.

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 funzione split prende il carattere che sarà il delimitatore. La funzione readIntegers() utilizza una mappa su uno split per convertire ogni valore in un Intero. Se si inseriscono valori inferiori a quelli specificati nella tupla, verrà generata un’IndexOutOfBoundsException. Abbiamo utilizzato try-catch sia per gli input. L’output è così: In alternativa, anziché le tuple, possiamo utilizzare anche una lista come mostrato di seguito.

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

Classe Scanner di Kotlin

Per prendere gli input possiamo utilizzare Scanner(System.`in`) che prende gli input dalla tastiera di input standard. Il seguente codice ne dimostra l’utilizzo:

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

    // nextInt() legge il prossimo intero. next() legge la Stringa
    var integer:Int = reader.nextInt()

    println("You entered: $integer")

reader.nextInt() legge il prossimo intero. reader.next() legge la prossima Stringa. reader.nextFloat() legge il prossimo float e così via. reader.nextLine() passa lo Scanner al nextLine e cancella anche il buffer. Il seguente codice dimostra la lettura di diversi tipi di input all’interno di una dichiarazione di stampa diretta.

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)
    //sposta lo scanner alla riga successiva altrimenti l'input in buffer verrebbe letto per il successivo qui. 
    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)")
    }
}

Viene generata un’InputMismatchException quando l’input è di un tipo diverso da quello richiesto. L’output è riportato di seguito.

Kotlin REPL

REPL, noto anche come Read-Eval-Print-Loop, viene utilizzato per eseguire una parte di codice direttamente in una shell interattiva. Possiamo farlo nel nostro terminale / riga di comando avviando il compilatore Kotlin.

Installazione del compilatore a riga di comando

Possiamo installare il compilatore a riga di comando su Mac / Windows / Ubuntu come mostrato qui. Tipicamente, su un Mac, possiamo utilizzare HomeBrew nel nostro terminale per installare il compilatore Kotlin.

brew update
brew install kotlin

Una volta fatto, avvia REPL inserendo kotlinc nel tuo terminale / cmd. Di seguito è riportato il mio primo codice nel REPL. Questo è tutto per le funzioni di stampa Kotlin e una breve introduzione a Kotlin REPL.