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

Hoje vamos aprender como usar as funções de impressão do Kotlin e como obter e analisar a entrada do usuário no console. Além disso, vamos explorar o Kotlin REPL.

Funções de Impressão do Kotlin

Para exibir algo na tela, são usados os seguintes dois métodos:

• print()
• println()

A instrução print imprime tudo que está dentro dela na tela. A instrução println anexa uma nova linha ao final da saída. As instruções de impressão chamam internamente System.out.print. O código a seguir mostra as instruções de impressão em ação:

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

Para imprimir uma variável dentro da instrução de impressão, precisamos usar o símbolo de dólar($) seguido pelo nome da var/val dentro de uma string literal entre aspas duplas. Para imprimir o resultado de uma expressão, usamos ${ //expressão aqui }. A saída ao executar o código acima no Kotlin Online Compiler é mostrada abaixo.

Escanear literais e expressões

Para escapar do símbolo de dólar e, digamos, tratar ${expressão} apenas como uma string, em vez de calculá-la, podemos escapá-lo.

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

Observe que um simples $ sem nenhuma expressão/variável definida implicitamente o escapa e o trata apenas como parte da string.

Valores da função de impressão

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

A seguinte saída é impressa: Nota: Passar um print dentro de outro se comporta como recursão. O mais interno é impresso primeiro. A instrução de impressão retorna uma Unit (equivalente a void em Java).

Entrada do Usuário em Kotlin

Para obter a entrada do usuário, os seguintes dois métodos podem ser usados:

• readLine()
• Classe Scanner

Nota: A entrada do usuário requer uma ferramenta de linha de comando. Você pode usar o REPL ou o IntelliJ. Vamos usar o IntelliJ aqui.

Usando readLine()

readLine() retorna o valor do tipo String? para lidar com valores nulos que podem ocorrer ao ler o final do arquivo, etc. O código a seguir mostra um exemplo usando readLine()

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

Como você pode ver, precisamos desembrulhar o tipo anulável para usar as funções do tipo String na propriedade. Use !! para converter forçadamente o String? em String, apenas quando tiver certeza absoluta de que o valor não será nulo. Caso contrário, ocorrerá uma falha. Convertendo a entrada para um Integer Para converter a String de entrada em um Int, fazemos o seguinte:

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

Novamente, usamos o operador ?. para converter o tipo anulável primeiro para um Int usando toInt(). Em seguida, multiplicamos por 5. Lendo a entrada continuamente Podemos usar o loop do while para ler a entrada continuamente, como mostrado abaixo.

    do {
        line = readLine()

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

        println("Echo $line")

    } while (true)
}

A saída do código acima no IntelliJ Command Line é mostrada abaixo.

Lendo Múltiplos Valores usando o operador de divisão

Podemos ler múltiplos valores separados por delimitadores e salvá-los em forma de tupla, como mostrado abaixo.

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

}

A função `split` recebe o caractere que será o delimitador. A função `readIntegers()` utiliza um mapeamento em um split para converter cada valor em um Inteiro. Se você inserir valores menores do que o especificado na tupla, você receberá uma IndexOutOfBoundsException. Nós utilizamos try-catch em ambas as entradas. A saída se parece com isso: Alternativamente, ao invés de tuplas, também podemos utilizar uma lista como mostrado abaixo.

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

Classe Scanner Kotlin

Para receber entradas, podemos utilizar `Scanner(System.`in`)`, que recebe entradas do teclado de entrada padrão. O código a seguir demonstra o mesmo:

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

    // nextInt() lê o próximo inteiro. next() lê a String
    var integer:Int = reader.nextInt()

    println("You entered: $integer")

reader.nextInt() lê o próximo inteiro. reader.next() lê a próxima String. reader.nextFloat() lê o próximo float e assim por diante. reader.nextLine() passa o Scanner para a próxima linha e também limpa o buffer. O código a seguir demonstra a leitura de diferentes tipos de entradas dentro de um comando de impressão diretamente.

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)
    //move scanner to next line else the buffered input would be read for the next here only.
    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 é lançada quando a entrada é de um tipo diferente do solicitado. A saída é apresentada abaixo.

REPL Kotlin

REPL, também conhecido como Read-Eval-Print-Loop, é usado para executar uma parte do código em um shell interativo diretamente. Podemos fazer isso em nosso terminal/linha de comando iniciando o compilador Kotlin.

Instalando o Compilador de Linha de Comando

Podemos instalar o compilador de linha de comando no Mac/Windows/Ubuntu conforme demonstrado aqui. Tipicamente, em um Mac, podemos usar o HomeBrew em nosso terminal para instalar o compilador Kotlin.

brew update
brew install kotlin

Assim que estiver pronto, inicie o REPL digitando kotlinc em seu terminal/cmd. A seguir está o meu primeiro código no REPL. Isso é tudo para as funções de impressão do Kotlin e uma rápida introdução ao REPL Kotlin.