DEV Community: Renato O da Silva

Tipos Básicos em Kotlin - String Literals

Renato O da Silva — Sat, 14 Sep 2024 03:02:48 +0000

Na última postagem eu comecei falar sobre strings e vamos dar continuidade falando de string literals.
Kotlin possui dois tipos de strings literals, Multiline Strings e Scaped Strings.

Multiline Strings

Diferente das strings convencionais, a multiline permite a adição de mais linhas dentro do texto. Se você tentar criar uma string com várias linhas, utilizando aspas duplas, isso irá gerar um erro.

fun main() {
    val texto = "
    Hoje é domingo
    Pede cachimbo
    O cachimbo é de barro
    Bate no jarro
    "

    println(texto)
}

O código acima irá gerar vários erros conforme abaixo:

Syntax error: Expecting '"'.
Syntax error: Incorrect template entry: .
Unresolved reference 'Hoje'.
Unresolved reference 'domingo'.
Unresolved reference 'Pede'.
Unresolved reference 'O'.
Unresolved reference 'é'.
Unresolved reference 'barro'.
Unresolved reference 'Bate'.
Unresolved reference 'jarro'.
Syntax error: Expecting '"'.
Syntax error: Incorrect template entry: .

Então o que fazemos quando precisamos imprimir um texto com múltiplas linhas? Utilizamos multiline strings:

fun main() {
    val texto = """
    Hoje é domingo
    Pede cachimbo
    O cachimbo é de barro
    Bate no jarro
    """

    println(texto)
    // Hoje é domingo
    //     Pede cachimbo
    //     O cachimbo é de barro
    //     Bate no jarro
}

Repare que o texto mesmo estando formatado, gerou uma saída toda bagunçada. Uma maneira de resolver isso é utilizando o método ** trimMargin()** que pode ser utilizado para remover espaços em brancos quando estamos utilizando multiline strings:

fun main() {
    val texto = """
    |Hoje é domingo
    |Pede cachimbo
    |O cachimbo é de barro
    |Bate no jarro
    """.trimMargin()

    println(texto)
    // Hoje é domingo
    // Pede cachimbo
    // O cachimbo é de barro
    // Bate no jarro
}

O Kotlin por padrão usa o símbolo "|" como prefixo para margem, mas podemos utilizar outro símbolo, apenas devemos indicar isso no método trimMargin():

fun main() {
    val texto = """
    ?Hoje é domingo
    ?Pede cachimbo
    ?O cachimbo é de barro
    ?Bate no jarro
    """.trimMargin("?")

    println(texto)
    // Aqui utilizamos a ? como prefixo, podendo ser outro caractere
    // Hoje é domingo
    // Pede cachimbo
    // O cachimbo é de barro
    // Bate no jarro
}

Escaped Strings

Escaped strings podem conter caracteres escapados. Abaixo temos um exemplo:

fun main() {
    val saudacao = "Ola\nJosé"

    println(saudacao)
    // Ola
    // José
}

Para utilizar escape, usamos o caractere *. Repare que a string está em uma linha só, mas na hora de imprimir na tela, foi impresso em duas linhas. O caractere *\n serve para pular uma linha e o mesmo não é impresso visualmente.
Temos uma lista de caracteres que podem ser escapados, conforme abaixo:

\t – tabulação
\b – backspace (não gostei dessa tradução, por isso deixei sem tradução)
\n – nova linha
\r – enter
\' – aspas simples
\" – aspas duplas
\ – barra inversa
\$ – Sinal de Dólar

fun main() {
    println("\tAqui temos uma tab")
    //  Aqui temos uma tab
    println("\bAqui temos um backspace")
    //Aqui temos um backspace 
    println("Aqui imprime uma nova linha\n")
    // Aqui imprime uma nova linha
    // 
    println("Aqui imprime um enter\r")
    // Aqui imprime um enter 
    println('\'')
    // '
    println("\"")
    // "
    println("Aqui imprime a barra inversa \\")
    // Aqui imprime a barra inversa \
    println("Aqui imprime o sinal de dólar \$")
    // Aqui imprime o sinal de dólar $
}

Vou ficando por aqui, em breve continuaremos com as strings.

Tipos Básicos em Kotlin - Strings

Renato O da Silva — Thu, 12 Sep 2024 16:36:13 +0000

Hoje irei abordar um tipo de dados que é muito utilizado na computação em geral, que são as Strings. Em algumas linguagens de programação antigas é um tanto complicado trabalhar com Strings, mas em linguagens mais recentes como Kotlin é bem fácil de criar e manipular Strings.

Strings são sequências de caracteres, comumente usadas para representar palavras, frases ou textos em um programa. Em Kotlin, strings são representadas pelo tipo String.

Podem ser atribuídas a uma variável da seguinte maneira:

val palavra = "abacate" 
// Uma string sempre irá começar com aspas duplas 
// e terminar com aspas duplas.

É possível acessar caracteres de uma string por meio de indexação, ou seja, através da posição da string no qual você deseja acessar. Podemos iterar sobre os caracteres através de for:

fun main() {
    val item = "um texto qualquer"
    for (i in item) {
        println(i)
    }
    // Ou podemos acessar o item pelo índice
    println(item[0])
    println(item.get(3))
}

Quando vamos acessar uma parte da string pelo índice, temos que tomar cuidado para não tentarmos acessar um índice que não existe.
Caso tente acessar um índice inexistente, será lançada uma exceção do tipo StringIndexOutOfBoundsException. Execute o código abaixo e verá o erro acontecendo:

fun main() {
    val item = "um texto qualquer"
    println(item[20])
}

Strings são imutáveis. Uma vez inicializada, seu valor não pode ser alterado. Qualquer operação que a modifique cria um novo objeto String, preservando o original:

fun main() {
    val item = "Ola mundo"

    // o método abaixa cria e imprime uma nova string escrita ao contrário
    println(item.reversed())
    // odnum alO

    // o valor original continua o mesmo
    println(item) 
    // Ola mundo
}

Existe a possibilidade de se concatenar strings, onde você junta duas strings conforme abaixo:

fun main() {
    val saudacao = "Ola "
    val pessoa = "Renato"    

    println(saudacao + pessoa)
    // Ola Renato

    var novaSaudacao = "Ola "
    novaSaudacao = novaSaudacao + pessoa

    println(novaSaudacao)
    // Ola Renato
}

Vou ficando por aqui, em breve volto com a continuação de strings.

Tipos Básicos em Kotlin - Inteiros sem sinais

Renato O da Silva — Tue, 11 Jun 2024 00:03:11 +0000

No último post eu falei sobre os tipos de dados numéricos mais utilizados.
Hoje vamos falar de outros tipos de dados numéricos,
que não são tão utilizados pela maioria dos desenvolvedores.

Hoje vou dos números inteiros sem sinal, mas o que isso quer dizer? São tipos de dados que só aceitam números positivos, onde o valor inicial começa em 0 e vai até a capacidade máxima permitida para o tipo em questão.

O Kotlin fornece os seguintes tipos de dados para valores inteiros sem sinal:

Tipo	Tamanho (bits)	Valor Máximo
UByte	8	255
UShort	16	65535
UInt	32	4,294,967,295 (232 - 1)
ULong	64	18,446,744,073,709,551,615 (264 - 1)

Números inteiros sem sinal devem ser declarados de forma específica como abaixo:

val b: UByte = 1u
val s: UShort = 1u
val l: ULong = 1u
val x: UInt = 55u

Repare que todos os números são finalizados com a letra u, pode a ser tanto maiúscula ou minúscula. Você pode inicializar uma variável sem especificar o tipo dela, mas nesse caso o Kotlin vai inferir o tipo UInt ou ULong à depender do tamanho do valor.

val b = 1U // Nesse caso será inferido o UInt como tipo
val k = 4294967298U // Como ultrapassa o tamanho reservado ao UInt é inferido o ULong como tipo.

Caso você queira verificar o tipo da variável você pode rodar o código abaixo:

No Exemplo acima você pode ser perguntar o motivo de estar usando Java juntamente com Kotlin, isso é possível por Kotlin tem uma interoperabilidade com Java, onde é possível utilizar código Java com Kotlin e vice-versa.

Com Kotlin é possível você definir o tipo da variável através da inferência de tipos, especificando que a mesma será do tipo Long, adicionando um L ao final:

Um cuidado muito importante ao se trabalhar com números inteiros sem sinal é que não podemos adicionar um valor negativo, pois isso gerará um erro.

Então se você não tiver certeza de que irá trabalhar apenas com números positivos, escolha outro tipo de dados, assim não acontecerá um erro na sua aplicação. Por hoje vou ficando por aqui, até a próxima.

Tipos Básicos em Kotlin - Tipos numéricos

Renato O da Silva — Sat, 08 Jun 2024 01:23:11 +0000

Introdução

Recentemente mudei de equipe na empresa onde estou trabalhando atualmente. Nessa equipe trabalhamos com Android Nativo com Java e Flutter. Como eu não tinha muito conhecimento em desenvolvimento nativo, comecei a estudar e comecei a utilizar Kotlin para ter acesso ao mundo do desenvolvimento de aplicativos Android.

Apesar de eu gostar de desenvolvimento backend, volta e meia estou inserido no desenvolvimento de aplicativos, comecei com React Native, e após algumas escolhas próprias decidi mudar para Flutter e fui seguindo.

Agora com o estudo de Kotlin, pensei e registrar o meu desenvolvimento conforme eu vou estudando. Então hoje vou começar falando sobre tipos de variáveis.

Apesar de ter desenvolvido bastante em JavaScript, pessoalmente eu prefiro linguagens fortemente tipadas e por esse motivo eu migrei para TypeScript e venho desenvolvendo em NestJS com TypeScript desde então.

Para quem está começando no mundo da programação, variável é um nome exclusivo que a identifica dentro do programa. O valor salvo que pode mudar durante a execução do programa. Ebac

No Kotlin variáveis são estaticamente tipadas, o que significa que uma vez que você declarou o seu tipo, isso não pode ser mais alterado. E dentre os tipos básicos podemos ter os seguintes:

Numbers (Números)
Booleans (Booleanos)
Characters (Caracteres)
Strings (Sequência de Caracteres)

Hoje eu falarei apenas do tipo Number, onde podemos ter valores inteiros e de ponto flutuante.

Números Inteiros

De acordo com Rafael C. Asth professor de matemática, os números inteiros são os números positivos e negativos, que não apresentam parte decimal e, o zero. Toda Matéria

Entre os números inteiros, temos os seguintes tipos:

Tipo	Tamanho (bits)	Valor Mínimo	Valor Máximo
Byte	8	-128	127
Short	16	-32768	32767
Int	32	-2,147,483,648 (-231)	2,147,483,647 (231 - 1)
Long	64	-9,223,372,036,854,775,808 (-263)	9,223,372,036,854,775,807 (263 - 1)

Em Kotlin quando você inicializa uma variável sem especificar o tipo, o compilador automaticamente infere o tipo com a menor tamanho à partir do tipo inteiro. Dependendo do tamanho do número o compilador pode inferir como Long.

As variáveis podem começar com as palavras chaves val e var, sendo val para variáveis que não irão mudar seus valores durante a execução do programa e var para aquelas que poderão ter seus valores alterados.

Segue um exemplo de tipagens com números inteiros:

val one = 1 // Int
val threeBillion = 3000000000 // Long
val oneLong = 1L // Long

No exemplo acima, todos os tipos foram inferidos pelo compilador. Agora segue um exemplo onde você pode definir o tipo:

val one: Byte = 1
val valueShort: Short = -25000
val valueInt: Int = 600000
val valueLong: Long = 3000000000

Temos que ter um certo cuidado quando vamos definir o tipo da variável, pois o seu valor pode ultrapassar o seu limite máximo gerando um erro de tipagem.

Números de Ponto Flutuante

De acordo com Rafael C. Asth professor de matemática, os números reais podem ser representados de diversas formas, como: inteiros positivos e negativos, frações, decimais, notação científica, raízes, etc. Toda Matéria

Na computação definimos como números reais números que possuem casas decimais. Ex: 2.50 ou 3.14 ou 300000.85. Note que ao contrário do que estamos acostumados usamos ponto ao invés de vírgula.

Kotlin provê dois tipos de ponto flutuantes, utilizando o padrão IEEE 754:

Tipo	Tamanho (bits)	Bits Significativos	Bits Expoentes	Digitos Decimais
Float	32	24	8	6-7
Double	64	53	11	15-16

Como ocorre com os números inteiros, quando você não específica um tipo para variável, o compilador por padrão infere o tipo Double. Sempre que você quiser definir o tipo Float, você deve colocar um f ao final número. Caso você defina um tipo como Float e não adicione o f ao final do número isso irá gerar um erro de tipagem.

val pi = 3.14 // Double
val oneDouble = 1.0 // Double
val floatValue = 328.25f // Float

Você também pode decidir qual o tipo você quer utilizar:

val e: Double = 2.7182818284 // Double
val eFloat: Float = 2.7182818284f

O tipo Double é o mais utilizado quando se trata de números com pontos flutuantes.

Vou ficando por aqui e espero que tenha dado uma noção sobre os tipos numéricos em Kotlin.