Treinamento do Kotlin para programadores 3: funções

Este codelab faz parte do curso de treinamento do Kotlin para programadores. Você vai aproveitar mais este curso se fizer os codelabs em sequência. Dependendo do seu conhecimento, talvez você possa passar mais rápido por algumas seções. Este curso é destinado a programadores que conhecem uma linguagem orientada a objetos e querem aprender Kotlin.

Introdução

Neste codelab, você vai criar um programa em Kotlin e aprender sobre funções nessa linguagem, incluindo valores padrão para parâmetros, filtros, lambdas e funções compactas.

Em vez de criar um único app de exemplo, as lições deste curso foram criadas para aumentar seu conhecimento, mas são semi-independentes umas das outras para que você possa ler as seções com que já está familiarizado. Para unificar os exemplos, muitos deles usam um tema de aquário. Se quiser conferir a história completa do aquário, acesse o curso da Udacity Treinamento do Kotlin para programadores (link em inglês).

O que você já precisa saber

• Os conceitos básicos de uma linguagem de programação moderna, orientada a objetos e com tipagem estática
• Como programar com classes, métodos e tratamento de exceções em pelo menos uma linguagem
• Como trabalhar com o REPL (Read-Eval-Print Loop) do Kotlin no IntelliJ IDEA
• Os conceitos básicos do Kotlin, incluindo tipos, operadores e loops

Este codelab é destinado a programadores que conhecem uma linguagem orientada a objetos e querem aprender mais sobre Kotlin.

O que você vai aprender

• Como criar um programa com uma função main() e argumentos no IntelliJ IDEA
• Como usar valores padrão e funções compactas
• Como aplicar filtros a listas
• Como criar lambdas básicos e funções de ordem superior

Atividades deste laboratório

• Trabalhe com o REPL para testar alguns códigos.
• Trabalhar com o IntelliJ IDEA para criar programas básicos em Kotlin.

Nesta tarefa, você vai criar um programa em Kotlin e aprender sobre a função main(), além de como transmitir argumentos para um programa na linha de comando.

Você deve se lembrar da função printHello() que inseriu no REPL em um codelab anterior:

fun printHello() {
    println ("Hello World")
}

printHello()

⇒ Hello World

Você define funções usando a palavra-chave fun, seguida pelo nome da função. Assim como em outras linguagens de programação, os parênteses () são para argumentos de função, se houver. As chaves {} enquadram o código da função. Não há tipo de retorno para essa função, porque ela não retorna nada.

Etapa 1: criar um arquivo Kotlin

1. Abra o IntelliJ IDEA.
2. O painel Project à esquerda no IntelliJ IDEA mostra uma lista dos arquivos e pastas do projeto. Encontre e clique com o botão direito do mouse na pasta src em Hello Kotlin. (Você já deve ter o projeto Hello Kotlin do codelab anterior.)
3. Selecione New > Kotlin File / Class.
4. Mantenha Tipo como Arquivo e nomeie o arquivo como Hello.
5. Clique em OK.

Agora há um arquivo na pasta src chamado Hello.kt.

Etapa 2: adicionar código e executar o programa

1. Assim como em outras linguagens, a função main() do Kotlin especifica o ponto de entrada para execução. Todos os argumentos de linha de comando são transmitidos como uma matriz de strings.
   
   Digite ou cole o seguinte código no arquivo Hello.kt :

fun main(args: Array<String>) {
    println("Hello, world!")
}

Dica:a partir do Kotlin 1.3, se a função main() não usar parâmetros, não será necessário definir args.

Assim como a função printHello() anterior, essa função não tem uma instrução return. Toda função em Kotlin retorna algo, mesmo quando nada é especificado explicitamente. Portanto, uma função como esta main() retorna um tipo kotlin.Unit, que é a maneira do Kotlin de dizer que não há valor.

Observação:quando uma função retorna kotlin.Unit, não é necessário especificar isso explicitamente. Isso é diferente de algumas outras linguagens, em que é preciso dizer explicitamente que você não está retornando nada.

3. Para executar o programa, clique no triângulo verde à esquerda da função main(). Selecione Executar "HelloKt" no menu.
4. O IntelliJ IDEA compila e executa o programa. Os resultados aparecem em um painel de registro na parte de baixo, como mostrado abaixo.

Programadores Java:se você estiver usando uma versão instalada anteriormente do IntelliJ IDEA em vez de instalar uma cópia nova, talvez tenha problemas para acessar o compilador Kotlin. Verifique se o projeto está se referindo à versão correta do JDK. Consulte esta discussão no Stack Overflow e a documentação sobre como mudar o SDK do projeto para o IntelliJ IDEA.

Etapa 3: transmitir argumentos para main()

Como você está executando o programa no IntelliJ IDEA e não na linha de comando, é necessário especificar os argumentos de maneira um pouco diferente.

1. Selecione Run > Edit Configurations. A janela Executar/depurar configurações é aberta.
2. Digite Kotlin! no campo Argumentos do programa.
3. Clique em OK.

Etapa 4: mudar o código para usar um modelo de string

Um modelo de string insere uma variável ou expressão em uma string, e $ especifica que parte da string será uma variável ou expressão. As chaves {} enquadram a expressão, se houver.

1. Em Hello.kt, mude a mensagem de boas-vindas para usar o primeiro argumento transmitido ao programa, args[0], em vez de "world".

fun main(args: Array<String>) {
    println("Hello, ${args[0]}")
}

2. Execute o programa. A saída vai incluir o argumento especificado.

⇒ Hello, Kotlin!

Nesta tarefa, você vai aprender por que quase tudo em Kotlin tem um valor e por que isso é útil.

Algumas outras linguagens têm instruções, que são linhas de código sem um valor. Em Kotlin, quase tudo é uma expressão e tem um valor, mesmo que esse valor seja kotlin.Unit.

1. Em Hello.kt, escreva um código em main() para atribuir um println() a uma variável chamada isUnit e imprima-o. (println() não retorna um valor, então retorna kotlin.Unit.)

// Will assign kotlin.Unit
val isUnit = println("This is an expression")
println(isUnit)

2. Execute o programa. O primeiro println() imprime a string "This is an expression". O segundo println() imprime o valor da primeira instrução println(), ou seja, kotlin.Unit.

⇒ This is an expression
kotlin.Unit

3. Declare um val chamado temperature e inicialize-o como 10.
4. Declare outro val chamado isHot e atribua o valor de retorno de uma instrução if/else a isHot, conforme mostrado no código a seguir. Como é uma expressão, você pode usar o valor da expressão if imediatamente.

val temperature = 10
val isHot = if (temperature > 50) true else false
println(isHot)

⇒ false

4. Use o valor de uma expressão em um modelo de string. Adicione um código para verificar a temperatura e determinar se um peixe está seguro ou muito quente. Em seguida, execute o programa.

val temperature = 10
val message = "The water temperature is ${ if (temperature > 50) "too warm" else "OK" }."
println(message)

⇒ The water temperature is OK.

Observação:os loops são exceções à regra "tudo tem um valor". Não há um valor sensato para loops for ou while, então eles não têm valores. Se você tentar atribuir o valor de um loop a algo, o compilador vai gerar um erro.

Nesta tarefa, você vai aprender mais sobre funções no Kotlin e sobre a expressão condicional when, que é muito útil.

Etapa 1: criar algumas funções

Nesta etapa, você vai juntar parte do que aprendeu e criar funções com diferentes tipos. Substitua o conteúdo de Hello.kt por esse novo código.

1. Escreva uma função chamada feedTheFish() que chama randomDay() para receber um dia aleatório da semana. Use um modelo de string para imprimir um food para o peixe comer naquele dia. Por enquanto, os peixes comem a mesma coisa todos os dias.

fun feedTheFish() {
    val day = randomDay()
    val food = "pellets"
    println ("Today is $day and the fish eat $food")
}

fun main(args: Array<String>) {
    feedTheFish()
}

2. Escreva a função randomDay() para escolher um dia aleatório de uma matriz e retorná-lo.

A função nextInt() usa um limite inteiro, que limita o número de Random() a 0 por 6 para corresponder à matriz week.

fun randomDay() : String {
    val week = arrayOf ("Monday", "Tuesday", "Wednesday", "Thursday",
            "Friday", "Saturday", "Sunday")
    return week[Random().nextInt(week.size)]
}

3. As funções Random() e nextInt() são definidas em java.util.*. Na parte de cima do arquivo, adicione a importação necessária:

import java.util.*    // required import

Dica:antes de adicionar a importação, Random() mostra um erro de referência não resolvida no IntelliJ IDEA. Para adicionar a importação automaticamente, clique em Random() e pressione Alt+Enter (Option+Enter no Mac). Selecione Importar > java.util.Random.

4. Execute o programa e verifique a saída.

⇒ Today is Tuesday and the fish eat pellets

Etapa 2: usar uma expressão when

Para ir além, mude o código para escolher alimentos diferentes para dias diferentes usando uma expressão when. A instrução when é semelhante a switch em outras linguagens de programação, mas when é interrompida automaticamente no final de cada ramificação. Ele também garante que seu código cubra todas as ramificações se você estiver verificando uma enumeração.

1. Em Hello.kt, adicione uma função chamada fishFood() que usa um dia como String e retorna a comida do peixe para o dia como String. Use when() para que cada dia o peixe receba um alimento específico. Execute o programa algumas vezes para ver saídas diferentes.

fun fishFood (day : String) : String {
    var food = ""
    when (day) {
        "Monday" -> food = "flakes"
        "Tuesday" -> food = "pellets"
        "Wednesday" -> food = "redworms"
        "Thursday" -> food = "granules"
        "Friday" -> food = "mosquitoes"
        "Saturday" -> food = "lettuce"
        "Sunday" -> food = "plankton"
    }
    return food
}

fun feedTheFish() {
    val day = randomDay()
    val food = fishFood(day)

    println ("Today is $day and the fish eat $food")
}

⇒ Today is Thursday and the fish eat granules

2. Adicione uma ramificação padrão à expressão when usando else. Para testar e garantir que o padrão seja usado às vezes no seu programa, remova as ramificações Tuesday e Saturday.
   
   Ter uma ramificação padrão garante que food receba um valor antes de ser retornado, então não é mais necessário inicializá-lo. Como o código agora atribui uma string a food apenas uma vez, é possível declarar food com val em vez de var.

fun fishFood (day : String) : String {
    val food : String
    when (day) {
        "Monday" -> food = "flakes"
        "Wednesday" -> food = "redworms"
        "Thursday" -> food = "granules"
        "Friday" -> food = "mosquitoes"
        "Sunday" -> food = "plankton"
        else -> food = "nothing"
    }
    return food
}

3. Como toda expressão tem um valor, é possível deixar esse código um pouco mais conciso. Retorne o valor da expressão when diretamente e elimine a variável food. O valor da expressão when é o valor da última expressão da ramificação que atendeu à condição.

fun fishFood (day : String) : String {
    return when (day) {
        "Monday" -> "flakes"
        "Wednesday" -> "redworms"
        "Thursday" -> "granules"
        "Friday" -> "mosquitoes"
        "Sunday" -> "plankton"
        else -> "nothing"
    }
}

A versão final do programa vai ficar parecida com o código abaixo.

import java.util.*    // required import

fun randomDay() : String {
    val week = arrayOf ("Monday", "Tuesday", "Wednesday", "Thursday",
        "Friday", "Saturday", "Sunday")
    return week[Random().nextInt(week.size)]
}

fun fishFood (day : String) : String {
    return when (day) {
        "Monday" -> "flakes"
        "Wednesday" -> "redworms"
        "Thursday" -> "granules"
        "Friday" -> "mosquitoes"
        "Sunday" -> "plankton"
        else -> "nothing"
    }
}

fun feedTheFish() {
    val day = randomDay()
    val food = fishFood(day)
    println ("Today is $day and the fish eat $food")
}

fun main(args: Array<String>) {
    feedTheFish()
}

Nesta tarefa, você vai aprender sobre os valores padrão de funções e métodos. Você também vai aprender sobre funções compactas, que podem tornar seu código mais conciso e legível, além de reduzir o número de caminhos de código para teste. As funções compactas também são chamadas de funções de expressão única.

Etapa 1: criar um valor padrão para um parâmetro

Em Kotlin, é possível transmitir argumentos pelo nome do parâmetro. Também é possível especificar valores padrão para parâmetros: se um argumento não for fornecido pelo autor da chamada, o valor padrão será usado. Mais tarde, ao escrever métodos (funções de membro), você evita escrever muitas versões de sobrecarga do mesmo método.

1. Em Hello.kt, escreva uma função swim() com um parâmetro String chamado speed que imprime a velocidade do peixe. O parâmetro speed tem um valor padrão de "fast".

fun swim(speed: String = "fast") {
   println("swimming $speed")
}

2. Na função main(), chame a função swim() de três maneiras. Primeiro, chame a função usando o padrão. Em seguida, chame a função e transmita o parâmetro speed sem um nome. Depois, chame a função nomeando o parâmetro speed.

swim()   // uses default speed
swim("slow")   // positional argument
swim(speed="turtle-like")   // named parameter

⇒ swimming fast
swimming slow
swimming turtle-like

Observação:os argumentos não precisam usar os nomes dos parâmetros. Basta transmitir os argumentos na ordem definida. Mas com valores padrão, isso pode ficar um pouco confuso. Por isso, a prática recomendada é colocar primeiro os parâmetros sem valores padrão e depois os que têm.

Etapa 2: adicionar parâmetros obrigatórios

Se nenhum padrão for especificado para um parâmetro, o argumento correspondente sempre precisará ser transmitido.

1. Em Hello.kt, escreva uma função shouldChangeWater() que receba três parâmetros: day, temperature e um nível dirty. A função retorna true se a água precisa ser trocada, o que acontece se for domingo, se a temperatura estiver muito alta ou se a água estiver muito suja. O dia da semana é obrigatório, mas a temperatura padrão é 22, e o nível de sujeira padrão é 20.
   
   Use uma expressão when sem um argumento, que em Kotlin funciona como uma série de verificações if/else if.

fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = 20): Boolean {
    return when {
        temperature > 30 -> true
        dirty > 30 -> true
        day == "Sunday" ->  true
        else -> false
    }
}

2. Chame shouldChangeWater() de feedTheFish() e forneça o dia. O parâmetro day não tem um valor padrão. Portanto, é necessário especificar um argumento. Os outros dois parâmetros de shouldChangeWater() têm valores padrão, então não é necessário transmitir argumentos para eles.
   

fun feedTheFish() {
    val day = randomDay()
    val food = fishFood(day)
    println ("Today is $day and the fish eat $food")
    println("Change water: ${shouldChangeWater(day)}")
}

=> Today is Thursday and the fish eat granules
Change water: false

Etapa 3: criar funções compactas

A expressão when que você escreveu na etapa anterior reúne muita lógica em uma pequena quantidade de código. Se você quiser detalhar um pouco mais ou se as condições a serem verificadas forem mais complicadas, use algumas variáveis locais com nomes adequados. Mas a maneira do Kotlin de fazer isso é com funções compactas.

Funções compactas, ou funções de expressão única, são um padrão comum em Kotlin. Quando uma função retorna os resultados de uma única expressão, é possível especificar o corpo da função após um símbolo =, omitir as chaves {} e omitir o return.

1. Em Hello.kt, adicione funções compactas para testar as condições.

fun isTooHot(temperature: Int) = temperature > 30

fun isDirty(dirty: Int) = dirty > 30

fun isSunday(day: String) = day == "Sunday"

2. Mude shouldChangeWater() para chamar as novas funções.

fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = 20): Boolean {
    return when {
        isTooHot(temperature) -> true
        isDirty(dirty) -> true
        isSunday(day) -> true
        else  -> false
    }
}

3. Execute o programa. A saída do println() com shouldChangeWater() precisa ser a mesma de antes da mudança para funções compactas.

Valores padrão

O valor padrão de um parâmetro não precisa ser um valor. Pode ser outra função, conforme mostrado no exemplo parcial a seguir:

fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = getDirtySensorReading()): Boolean {
    ...

Observação:uma função usada como valor padrão é avaliada no tempo de execução. Portanto, não coloque uma operação cara, como uma leitura de arquivo ou uma grande alocação de memória, na função. A operação é executada sempre que a função é chamada, o que pode deixar o programa mais lento.

Nesta tarefa, você vai aprender um pouco sobre filtros em Kotlin. Os filtros são uma maneira prática de receber parte de uma lista com base em alguma condição.

Etapa 1: criar um filtro

1. Em Hello.kt, defina uma lista de decorações de aquário no nível superior com listOf(). Você pode substituir o conteúdo de Hello.kt.

val decorations = listOf ("rock", "pagoda", "plastic plant", "alligator", "flowerpot")

2. Crie uma função main() com uma linha para imprimir apenas as decorações que começam com a letra "p". O código da condição de filtro está entre chaves {}, e it se refere a cada item à medida que o filtro passa por eles. Se a expressão retornar true, o item será incluído.

fun main() {
    println( decorations.filter {it[0] == 'p'})
}

3. Execute o programa. Você vai encontrar a seguinte saída na janela Executar:

⇒ [pagoda, plastic plant]

Etapa 2: comparar filtros imediatos e lentos

Se você conhece filtros em outras linguagens, talvez se pergunte se os filtros em Kotlin são rápidos ou lentos. A lista de resultados é criada imediatamente ou quando ela é acessada? No Kotlin, isso acontece da maneira que você precisa. Por padrão, filter é ansioso, e uma lista é criada sempre que você usa o filtro.

Para tornar o filtro lento, use um Sequence, que é uma coleção que só pode analisar um item por vez, começando do início e indo até o fim. Convenientemente, essa é exatamente a API de que um filtro lento precisa.

1. Em Hello.kt, mude o código para atribuir a lista filtrada a uma variável chamada eager e imprima-a.

fun main() {
    val decorations = listOf ("rock", "pagoda", "plastic plant", "alligator", "flowerpot")

    // eager, creates a new list
    val eager = decorations.filter { it [0] == 'p' }
    println("eager: " + eager)

2. Abaixo desse código, avalie o filtro usando um Sequence com asSequence(). Atribua a sequência a uma variável chamada filtered e imprima-a.

   // lazy, will wait until asked to evaluate
    val filtered = decorations.asSequence().filter { it[0] == 'p' }
    println("filtered: " + filtered)

Quando você retorna os resultados do filtro como um Sequence, a variável filtered não contém uma nova lista. Ela contém um Sequence dos elementos da lista e o conhecimento do filtro a ser aplicado a esses elementos. Sempre que você acessa elementos do Sequence, o filtro é aplicado e o resultado é retornado.

3. Forçar a avaliação da sequência convertendo-a em um List com toList(). Imprima o resultado.

    // force evaluation of the lazy list
    val newList = filtered.toList()
    println("new list: " + newList)

4. Execute o programa e observe a saída.

⇒ eager: [pagoda, plastic plant]
filtered: kotlin.sequences.FilteringSequence@386cc1c4
new list: [pagoda, plastic plant]

Para visualizar o que está acontecendo com a Sequence e a avaliação lenta, use a função map(). A função map() realiza uma transformação simples em cada elemento da sequência.

5. Com a mesma lista decorations acima, faça uma transformação com map() que não faz nada e simplesmente retorna o elemento transmitido. Adicione um println() para mostrar cada vez que um elemento é acessado e atribua a sequência a uma variável chamada lazyMap.

    val lazyMap = decorations.asSequence().map {
        println("access: $it")
        it
    }

6. Imprima lazyMap, o primeiro elemento de lazyMap usando first() e lazyMap convertido em um List.

    println("lazy: $lazyMap")
    println("-----")
    println("first: ${lazyMap.first()}")
    println("-----")
    println("all: ${lazyMap.toList()}")

7. Execute o programa e observe a saída. A impressão de lazyMap apenas mostra uma referência ao Sequence. O println() interno não é chamado. A impressão do primeiro elemento acessa apenas o primeiro elemento. Converter o Sequence em um List acessa todos os elementos.

⇒ lazy: kotlin.sequences.TransformingSequence@5ba23b66
-----
access: rock
first: rock
-----
access: rock
access: pagoda
access: plastic plant
access: alligator
access: flowerpot
all: [rock, pagoda, plastic plant, alligator, flowerpot]

8. Crie um novo Sequence usando o filtro original antes de aplicar map. Imprima esse resultado.

    val lazyMap2 = decorations.asSequence().filter {it[0] == 'p'}.map {
        println("access: $it")
        it
    }
    println("-----")
    println("filtered: ${ lazyMap2.toList() }")

9. Execute o programa e observe a saída adicional. Assim como ao receber o primeiro elemento, o println() interno só é chamado para os elementos acessados.

⇒
-----
access: pagoda
access: plastic plant
filtered: [pagoda, plastic plant]

Nesta tarefa, você vai conhecer lambdas e funções de ordem superior no Kotlin.

Lambdas

Além das funções nomeadas tradicionais, o Kotlin é compatível com lambdas. Um lambda é uma expressão que cria uma função. Mas, em vez de declarar uma função nomeada, você declara uma função que não tem nome. Parte do que torna isso útil é que a expressão lambda agora pode ser transmitida como dados. Em outras linguagens, os lambdas são chamados de funções anônimas, literais de função ou nomes semelhantes.

Funções de ordem superior

É possível criar uma função de ordem superior transmitindo uma lambda para outra função. Na tarefa anterior, você criou uma função de ordem superior chamada filter. Você transmitiu a seguinte expressão lambda para filter como a condição a ser verificada:
{it[0] == 'p'}

Da mesma forma, map é uma função de ordem superior, e o lambda transmitido a ela foi a transformação a ser aplicada.

Etapa 1: saiba mais sobre lambdas

1. Assim como as funções nomeadas, as lambdas podem ter parâmetros. Para lambdas, os parâmetros (e os tipos deles, se necessário) ficam à esquerda do que é chamado de seta de função ->. O código a ser executado fica à direita da seta da função. Depois que a lambda é atribuída a uma variável, é possível chamá-la como uma função.
   
   Usando o REPL (Ferramentas > Kotlin > Kotlin REPL), teste este código:

var dirtyLevel = 20
val waterFilter = { dirty : Int -> dirty / 2}
println(waterFilter(dirtyLevel))

⇒ 10

Neste exemplo, a lambda usa um Int chamado dirty e retorna dirty / 2. (Porque a filtragem remove a sujeira.)

2. A sintaxe do Kotlin para tipos de função está intimamente relacionada à sintaxe para lambdas. Use esta sintaxe para declarar uma variável que contém uma função:

val waterFilter: (Int) -> Int = { dirty -> dirty / 2 }

Veja o que o código diz:

• Crie uma variável chamada waterFilter.
• waterFilter pode ser qualquer função que use um Int e retorne um Int.
• Atribua um lambda a waterFilter.
• A lambda retorna o valor do argumento dirty dividido por 2.

Não é mais necessário especificar o tipo do argumento lambda. O tipo é calculado por inferência de tipo.

Etapa 2: criar uma função de ordem superior

Até agora, os exemplos de lambdas parecem funções. O verdadeiro poder dos lambdas está em usá-los para criar funções de ordem superior, em que o argumento de uma função é outra função.

1. Escreva uma função de ordem superior. Confira um exemplo básico, uma função que usa dois argumentos. O primeiro argumento é um número inteiro. O segundo argumento é uma função que usa um número inteiro e retorna um número inteiro. Teste no REPL.

fun updateDirty(dirty: Int, operation: (Int) -> Int): Int {
   return operation(dirty)
}

O corpo do código chama a função transmitida como o segundo argumento e transmite o primeiro argumento para ela.

2. Para chamar essa função, transmita um número inteiro e uma função.

val waterFilter: (Int) -> Int = { dirty -> dirty / 2 }
println(updateDirty(30, waterFilter))

⇒ 15

A função transmitida não precisa ser uma lambda. Ela pode ser uma função nomeada regular. Para especificar o argumento como uma função regular, use o operador ::. Assim, o Kotlin sabe que você está transmitindo a referência da função como um argumento, e não tentando chamar a função.

3. Tente transmitir uma função nomeada regular para updateDirty().

fun increaseDirty( start: Int ) = start + 1

println(updateDirty(15, ::increaseDirty))

⇒ 16

Observação:o Kotlin prefere que qualquer parâmetro que receba uma função seja o último. Ao trabalhar com funções de ordem superior, o Kotlin tem uma sintaxe especial, chamada de sintaxe de chamada do último parâmetro, que permite deixar o código ainda mais conciso. Nesse caso, você pode transmitir um lambda para o parâmetro de função, mas não precisa colocar o lambda entre parênteses.

var dirtyLevel = 19;
dirtyLevel = updateDirty(dirtyLevel) { dirtyLevel -> dirtyLevel + 23}
println(dirtyLevel)

⇒ 42

• Para criar um arquivo de origem Kotlin no IntelliJ IDEA, comece com um projeto Kotlin.
• Para compilar e executar um programa no IntelliJ IDEA, clique no triângulo verde ao lado da função main(). A saída aparece em uma janela de registro abaixo.
• No IntelliJ IDEA, especifique argumentos de linha de comando para transmitir à função main() em Run > Edit Configurations.
• Quase tudo em Kotlin tem um valor. É possível usar esse fato para deixar seu código mais conciso usando o valor de um if ou when como uma expressão ou um valor de retorno.
• Os argumentos padrão eliminam a necessidade de várias versões de uma função ou método. Exemplo:
  fun swim(speed: String = "fast") { ... }
• Funções compactas, ou de expressão única, podem tornar seu código mais legível. Exemplo:
  fun isTooHot(temperature: Int) = temperature > 30
• Você aprendeu algumas noções básicas sobre filtros, que usam expressões lambda. Exemplo:
  val beginsWithP = decorations.filter { it [0] == 'p' }
• Uma expressão lambda é uma expressão que cria uma função sem nome. As expressões lambda são definidas entre chaves {}.
• Em uma função de ordem superior, você transmite uma função, como uma expressão lambda, para outra função como dados. Por exemplo:
  dirtyLevel = updateDirty(dirtyLevel) { dirtyLevel -> dirtyLevel + 23}

Há muito conteúdo nesta lição, especialmente se você não conhece lambdas. Uma lição posterior revisita lambdas e funções de ordem superior.

Observação : você deve ter notado que, em Kotlin, assim como em algumas outras linguagens, há mais de uma maneira correta de fazer as coisas. Tornar o código mais compacto às vezes ajuda na legibilidade e até no desempenho, mas nem sempre. À medida que você aprende mais sobre o Kotlin, pode encontrar maneiras mais fáceis e concisas de fazer as coisas.

Documentação do Kotlin

Se você quiser mais informações sobre algum tópico deste curso ou se tiver dúvidas, https://kotlinlang.org é o melhor ponto de partida.

• Convenções de programação em Kotlin
• Idiomas do Kotlin

• Modelos de string (link em inglês)
• Expressão when
• Funções de expressão única
• Funções de ordem superior e lambdas
• Filtros
• sequências
• Sintaxe da última chamada de parâmetro

Tutoriais do Kotlin

O site https://try.kotlinlang.org inclui tutoriais avançados chamados Kotlin Koans, um interpretador baseado na Web e um conjunto completo de documentação de referência com exemplos.

Curso Udacity

Para conferir o curso da Udacity sobre esse tema, consulte Treinamento do Kotlin para programadores (link em inglês).

IntelliJ IDEA

A documentação do IntelliJ IDEA está disponível no site da JetBrains.

Esta seção lista as possíveis atividades de dever de casa para os alunos que estão fazendo este codelab como parte de um curso ministrado por um professor. Cabe ao professor fazer o seguinte:

• Atribuir o dever de casa, se necessário.
• Informar aos alunos como enviar deveres de casa.
• Atribuir nota aos deveres de casa.

Os professores podem usar essas sugestões o quanto quiserem, podendo passar os exercícios que acharem mais apropriados como dever de casa.

Se você estiver seguindo este codelab por conta própria, sinta-se à vontade para usar esses deveres de casa para testar seu conhecimento.

Responda estas perguntas

Pergunta 1

A função contains(element: String) retorna true se a string element estiver contida na string em que ela é chamada. Qual será a saída do código a seguir?

val decorations = listOf ("rock", "pagoda", "plastic plant", "alligator", "flowerpot")

println(decorations.filter {it.contains('p')})

▢ [pagoda, plastic, plant]

▢ [pagoda, plastic plant]

▢ [pagoda, plastic plant, flowerpot]

▢ [rock, alligator]

Pergunta 2

Na definição de função a seguir, qual dos parâmetros é obrigatório?
fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = 20, numDecorations: Int = 0): Boolean {...}

▢ numDecorations

▢ dirty

▢ day

▢ temperature

Pergunta 3

É possível transmitir uma função nomeada regular (não o resultado da chamada dela) para outra função. Como você transmitiria increaseDirty( start: Int ) = start + 1 para updateDirty(dirty: Int, operation: (Int) -> Int)?

▢ updateDirty(15, &increaseDirty())

▢ updateDirty(15, increaseDirty())

▢ updateDirty(15, ("increaseDirty()"))

▢ updateDirty(15, ::increaseDirty)

Siga para a próxima lição: 4. Classes e objetos

Para ter uma visão geral do curso, incluindo links para outros codelabs, consulte "Treinamento do Kotlin para programadores: seja bem-vindo ao curso".