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

Heute werden wir lernen, wie man die Kotlin-Druckfunktionen verwendet und wie man Benutzereingaben von der Konsole erhält und analysiert. Außerdem werden wir uns den Kotlin REPL ansehen.

Kotlin-Druckfunktionen

Um etwas auf dem Bildschirm auszugeben, werden die folgenden zwei Methoden verwendet:

• print()
• println()

Die print-Anweisung gibt alles, was sich darin befindet, auf dem Bildschirm aus. Die println-Anweisung fügt am Ende der Ausgabe eine neue Zeile hinzu. Die Druckanweisungen rufen intern System.out.print auf. Der folgende Code zeigt die Druckanweisungen in Aktion:

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

Um eine Variable innerhalb der Druckanweisung zu drucken, müssen wir das Dollarzeichen ($) gefolgt vom Namen der var/val innerhalb eines doppelten Anführungszeichen-Stringliteral verwenden. Um das Ergebnis eines Ausdrucks zu drucken, verwenden wir ${ //expression goes here }. Die Ausgabe, wenn der obige Code im Kotlin Online Compiler ausgeführt wird, wird unten angezeigt.

Escape-Literale und Ausdrücke

Um das Dollarzeichen zu escapen und sagen wir ${expression} als String nur zu behandeln, anstatt es zu berechnen, können wir es escapen.

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

Beachten Sie, dass ein einfaches $ ohne jeglichen Ausdruck/Variable, die implizit gegen sie gesetzt ist, es nur als Teil des Strings behandelt.

Ausgabe von Funktionswerten

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

Die folgende Ausgabe wird gedruckt: Hinweis: Das Einbetten eines Druckbefehls in einen anderen verhält sich wie Rekursion. Der innerste wird zuerst gedruckt. Der print-Anweisung gibt einen Unit zurück (äquivalent zu void in Java).

Kotlin-Benutzereingabe

Um die Benutzereingabe zu erhalten, können die folgenden beiden Methoden verwendet werden:

• readLine()
• Scanner-Klasse

Hinweis: Die Benutzereingabe erfordert ein Befehlszeilentool. Sie können entweder den REPL oder IntelliJ verwenden. Lassen Sie uns hier IntelliJ verwenden.

Verwendung von readLine()

readLine() gibt den Wert des Typs String? zurück, um mit Nullwerten umzugehen, die auftreten können, wenn Sie das Ende der Datei usw. lesen. Der folgende Code zeigt ein Beispiel für die Verwendung von readLine().

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

Wie Sie sehen können, müssen wir den Nulltyp entpacken, um die Funktionen des String-Typs auf der Eigenschaft zu verwenden. Verwenden Sie !!, um das String? in einen String zu erzwingen, nur wenn Sie absolut sicher sind, dass der Wert nicht null sein wird. Andernfalls stürzt es ab. Umwandeln der Eingabe in eine Ganzzahl Um den Eingabestring in eine Ganzzahl zu konvertieren, tun wir Folgendes:

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

Wieder verwenden wir den ?. Operator, um den Nulltyp zunächst in eine Ganzzahl mit toInt() umzuwandeln. Dann multiplizieren wir es mit 5. Eingabe kontinuierlich lesen Wir können die do while-Schleife verwenden, um die Eingabe kontinuierlich zu lesen, wie unten gezeigt.

    do {
        line = readLine()

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

        println("Echo $line")

    } while (true)
}

Die Ausgabe des obigen Codes in der IntelliJ-Befehlszeile lautet wie folgt.

Mehrere Werte mit dem Split-Operator lesen

Wir können mehrere Werte lesen, die durch Trennzeichen getrennt sind, und sie in einer Tupelform wie unten gezeigt speichern.

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

}

Die Funktion split nimmt das Zeichen als Trennzeichen. Die Funktion readIntegers() verwendet eine Zuordnung auf einem Split, um jeden Wert in eine Ganzzahl umzuwandeln. Wenn Sie Werte eingeben, die kleiner sind als die in dem Tupel angegebenen, erhalten Sie eine IndexOutOfBoundsException. Wir haben sowohl für die Eingabe als auch für die Ausgabe try-catch verwendet. Die Ausgabe sieht wie folgt aus: Alternativ können wir anstelle von Tupeln auch eine Liste verwenden, wie unten gezeigt.

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

Kotlin-Scanner-Klasse

Um Eingaben zu erhalten, können wir Scanner(System.`in`) verwenden, das Eingaben von der Standardtastatur erfasst. Der folgende Code zeigt dasselbe:

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

    // nextInt() liest die nächste Ganzzahl. next() liest den String
    var integer:Int = reader.nextInt()

    println("You entered: $integer")

reader.nextInt() liest die nächste Ganzzahl. reader.next() liest den nächsten String. reader.nextFloat() liest den nächsten Float und so weiter. reader.nextLine() übergibt den Scanner an die nächste Zeile und leert auch den Puffer. Der folgende Code demonstriert das Lesen verschiedener Arten von Eingaben direkt innerhalb einer Druckanweisung.

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)
    // Bewegen Sie den Scanner in die nächste Zeile, sonst würde die gepufferte Eingabe nur hier für die nächste gelesen werden.
    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 wird geworfen, wenn die Eingabe von einem anderen Typ als dem gefragten ist. Die Ausgabe lautet wie folgt.

Kotlin REPL

REPL, auch bekannt als Read-Eval-Print-Loop, wird verwendet, um einen Teil des Codes direkt in einer interaktiven Shell auszuführen. Dies können wir in unserem Terminal/Eingabeaufforderung direkt durch Initiieren des Kotlin-Compilers tun.

Installation des Befehlszeilencompilers

Wir können den Befehlszeilencompiler auf Mac/Windows/Ubuntu installieren, wie hier demonstriert hier. Typischerweise können wir auf einem Mac den Homebrew in unserem Terminal verwenden, um den Kotlin-Compiler zu installieren.

brew update
brew install kotlin

Sobald dies erledigt ist, starten Sie den REPL, indem Sie kotlinc in Ihrem Terminal/cmd eingeben. Im Folgenden finden Sie mein erster Code im REPL. Das ist alles für Kotlin-Druckfunktionen und eine kurze Einführung in Kotlin REPL.