2

Functions, a pocket show( )!!

#Kotlin
Alberto Rebello
Alberto Rebello

Publico alvo: iniciantes

Objetivo do artigo:

Olá pessoal, fiquei muito animado com este pequeno resumo que fiz ao estudar os diversos tipos de funções disponíveis na linguagem Kotlin. Acredito que muitos iniciantes poderão se beneficiar destes exemplos bem simples. Eles foram encadeados em forma de código executável. Assim quem desejar poderá entender a teoria lendo os comentários, executar o programa para verificar os resultados e alterar o código para fazer suas próprias experimentações.


Pré-requisitos:

Atualmente o Kotlin é a linguagem oficial para desenvolvimento de aplicativos para Android. Para acompanhar este artigo é recomendável:

=> Conhecimentos básicos de alguma linguagem de programação orientada a objeto.


Referencias:

https://developer.android.com/codelabs/kotlin-bootcamp-functions/#0

https://web.digitalinnovation.one/track/everis-kotlin-developer?tab=path


Código:

fun main() {
    /*
    Default Functions vs Compact functions vs lambda functions vs higher-order functions.
    Estes exemplos simulam o processo de limpeza da água de um aquário pelas várias funções chamadas
    de "waterFilter".
    Cada uma das funções  fará o tratamento da água cuja quantidade de sujeira é indicada pela variável
    "dirtylevel".
    */

    //Declaração e inicialização da variável "dirtyLevel" que informará a quantidade de sujeira na água.
    var dirtyLevel = 20
    println("Considerando o nível de sujeira da água $dirtyLevel, " +
            "qual resultado cada função purificadora diz que entregará?")

    /*O exemplo abaixo é uma função nomeada tradicional.
    Para declararmos este tipo de função deve-se:
    - Iniciar a linha com a palavra reservada "fun". 
    - Dar um nome para ela, neste exemplo: "waterfilter".
    - Após o nome o operador de invocação "( )", neste caso: waterfilter( )
    - Se a função for receber parâmetros, devem ser incluídos dentro dos operadores de invocação ,
      neste caso: waterfilter(dirty : Int )
    - A função pode ou não retornar um valor, dependendo da decisão do desenvolvedor.
      O tipo do dado a ser retornado deve ser indicado após os operadores de invocação,
      neste caso a função retornará um valor inteiro: waterfilter(dirty : Int ): Int
    - Incluir o corpo da função, que é o espaço delimitado pelos operadores { },
      neste caso: waterfilter(dirty : Int ): Int {  }
    - O código da função, ou seja, aquilo que será executado pela função quando for chamada (invocada)
      é escrito neste espaço.
     - A palavra reservada "return" é usada ao final do código somente para funções que retornam algum valor.
    */
    fun  waterFilter(dirty : Int): Int {
        return dirty / 2
    }
    println("A função tradicional diz: ${waterFilter(dirtyLevel)}")

    /*O exemplo abaixo é uma função compacta ou função de expressão única.
    Ela pode ser usada quando a função retorna o resultado de uma única expressão.
    Para isso deveremos trocar os operadores "{ }" pelo sinal de "=" e escrever a expressão a ser executada em seguida.
    A palavra reservada "return" NÃO será usada.
    */
    fun  waterFilter_compact(dirty : Int) = dirty / 2
    println("A função compacta diz: ${waterFilter_compact(dirtyLevel)}")

    /*
    O exemplo abaixo é de uma função lambda ou anônima com parâmetros.
    Ela é escrita diretamente dentro ds operadores "{ }", neste exemplo:
    "{ dirty : Int -> dirty / 2}".
    Os parâmetros são escritos antes do operador "->" e o código depois.
    Neste exemplo a função lambda foi atribuida a uma variável chamada "waterFilter_lambda"
    Para invocar a função lambda devemos colocar os operadores "( )" ao lado do nome da variável,
    como foi feito dentro da função "println()" abaixo:
     */
    val waterFilter_lambda = { dirty : Int -> dirty / 2}
    println("A função Lambda (anônima) diz: ${waterFilter_lambda(dirtyLevel)}")

    /*
   O exemplo abaixo é de uma função de ordem superior chamada de "updateDirty".
   Ela é chamada assim porque ela pode receber como parâmetro uma outra função,
   neste caso: "operation: (Int) -> Int): Int {return operation(dirty)"
   o parâmetro chamado de "operation" recebe a função lambda "Int {return operation(dirty)".
   No meio dos dois deve ser colocado o operador ":".
   O que o Parâmetro "operation diz é que a função "updateDirty" quando for invocada receberá uma
   outra função lambda que usa um parâmetro inteiro como entrada e retorna um valor inteiro"
    */
    dirtyLevel = 30
    println("\nConsiderando o nível de sujeira da água $dirtyLevel:")
    fun updateDirty(dirty: Int, operation: (Int) -> Int): Int {
        return operation(dirty)
    }
    /*
    Olha que legal. Podemos criar variações de uma função lambda, todas com alguma diferença entre si,
    e colocá-las dentro de variáveis com nomes diferentes. Nos casos abaixo criamos funções purificadoras
     que se parecem mas cuja diferença é a eficiencia da limpeza.
     */
    val waterFilter_low_: (Int) -> Int = { dirty -> dirty / 2 }
    val waterFilter_normal: (Int) -> Int = { dirty -> dirty / 3 }
    val waterFilter_High: (Int) -> Int = { dirty -> dirty / 4 }
    
    /*
    Note que a função "updateDirty" é a mesma nas três linhas de código abaixo. A diferença está na 
    função lambda que ela recebeu como parâmetro.
     */

    println("A função de ordem superior e a função lambda slow dizem: ${updateDirty(dirtyLevel,    waterFilter_low_)}")
    println("A função de ordem superior e a função lambda normal dizem: ${updateDirty(dirtyLevel, waterFilter_normal)}")
    println("A função de ordem superior e a função lambda fast dizem: ${updateDirty(dirtyLevel, waterFilter_High)}")
}
2
32

Comentários (2)

0
Calil Junior

Calil Junior

26/03/2021 08:13

Excelente explicação ! Muito Obrigado !

0
Francielio Nobrega

Francielio Nobrega

26/03/2021 06:15

Muito bom..

None

Brasil