Kotlin (linguagem de programação) - Kotlin (programming language)

Kotlin
Logotipo da Kotlin 2021.svg
Paradigma Multi-paradigma : orientado a objetos , funcional , imperativo , estruturado em blocos , declarativo , genérico , reflexivo , concorrente
Projetado por JetBrains
Desenvolvedor JetBrains
Apareceu pela primeira vez 22 de julho de 2011 ; 10 anos atrás ( 22/07/2011 )
Versão estável
1.5.31  Edite isso no Wikidata / 20 de setembro de 2021 ; 28 dias atrás ( 20 de setembro de 2021 )
Versão de visualização
build-1.6.20-dev-107/26 de agosto de 2021 ; 53 dias atrás ( 2021-08-26 )
Disciplina de digitação Inferido , estático , forte
Plataforma
SO Plataforma cruzada
Licença Licença Apache 2.0
Extensões de nome de arquivo .kt, .kts, .ktm
Local na rede Internet kotlinlang .org Edite isso no Wikidata
Influenciado por

Kotlin ( / k ɒ t l ɪ n / ) é uma plataforma cruzada , tipagem estática , para fins gerais linguagem de programação com o tipo de inferência . Kotlin é projetado para interoperar totalmente com Java e a versão JVM da biblioteca padrão de Kotlin depende da Biblioteca de classes Java , mas a inferência de tipo permite que sua sintaxe seja mais concisa. O Kotlin visa principalmente a JVM, mas também compila para JavaScript (por exemplo, para aplicativos da web front-end usando React ) ou código nativo (via LLVM ); por exemplo, para aplicativos iOS nativos que compartilham lógica de negócios com aplicativos Android . Os custos de desenvolvimento da linguagem são suportados pela JetBrains , enquanto a Fundação Kotlin protege a marca comercial Kotlin.

Em 7 de maio de 2019, o Google anunciou que a linguagem de programação Kotlin agora é sua linguagem preferida para desenvolvedores de aplicativos Android . Desde o lançamento do Android Studio 3.0 em outubro de 2017, o Kotlin foi incluído como uma alternativa ao compilador Java padrão. O compilador Android Kotlin produz bytecode Java 8 por padrão (que é executado em qualquer JVM posterior), mas permite que o programador escolha direcionar o Java 9 até 16, para otimização, ou permite mais recursos; tem suporte de interoperabilidade de classe de registro bidirecional para JVM, introduzido em Java 16, considerado estável a partir do Kotlin 1.5.

O suporte do Kotlin para compilação diretamente para JavaScript (ou seja, o back-end clássico) é considerado estável desde o Kotlin 1.3 por seus desenvolvedores, enquanto o novo Kotlin / JS (IR) está em beta a partir da versão 1.5.30. As novas implementações otimizadas de Kotlin / JVM (IR) e Kotlin / JS ( baseado em IR ) foram introduzidas na versão 1.4. Kotlin / JVM (IR) é considerado estável a partir do lançamento da versão 1.5. Kotlin / Native (por exemplo, suporte de silício da Apple) foi considerado beta desde a versão 1.3.

História

Em julho de 2011, a JetBrains revelou o Projeto Kotlin, uma nova linguagem para o JVM, que estava em desenvolvimento há um ano. O líder da JetBrains, Dmitry Jemerov, disse que a maioria dos idiomas não tem os recursos que procuram, com exceção do Scala . No entanto, ele citou o tempo de compilação lento de Scala como uma deficiência. Um dos objetivos declarados do Kotlin é compilar tão rapidamente quanto o Java. Em fevereiro de 2012, a JetBrains abriu o código do projeto sob a licença Apache 2 .

O nome vem da Ilha Kotlin , perto de São Petersburgo . Andrey Breslav mencionou que a equipe decidiu batizá- la com o nome de uma ilha, assim como Java recebeu o nome da ilha indonésia de Java (embora a linguagem de programação Java talvez tenha o nome do café).

A JetBrains espera que a nova linguagem impulsione as vendas do IntelliJ IDEA .

O Kotlin v1.0 foi lançado em 15 de fevereiro de 2016. Este é considerado o primeiro lançamento oficialmente estável e a JetBrains se comprometeu com a compatibilidade retroativa de longo prazo a partir desta versão.

No Google I / O 2017, o Google anunciou o suporte de primeira classe para Kotlin no Android .

O Kotlin v1.2 foi lançado em 28 de novembro de 2017. O recurso de compartilhamento de código entre as plataformas JVM e JavaScript foi adicionado recentemente a este lançamento (a partir da versão 1.4, a programação multiplataforma é um recurso alfa atualizado de "experimental"). Uma demonstração completa foi feita com o novo plug-in Kotlin / JS Gradle.

O Kotlin v1.3 foi lançado em 29 de outubro de 2018, trazendo corrotinas para programação assíncrona.

Em 7 de maio de 2019, o Google anunciou que a linguagem de programação Kotlin agora é sua linguagem preferida para desenvolvedores de aplicativos Android.

O Kotlin v1.4 foi lançado em agosto de 2020, com algumas pequenas alterações, por exemplo, no suporte para plataformas da Apple, ou seja, na interoperabilidade Objective-C / Swift .

O Kotlin v1.5 foi lançado em maio de 2021.

Projeto

O líder de desenvolvimento, Andrey Breslav, disse que o Kotlin foi projetado para ser uma linguagem orientada a objetos de força industrial e uma "linguagem melhor" do que Java , mas ainda assim ser totalmente interoperável com o código Java, permitindo que as empresas façam uma migração gradual de Java para Kotlin .

Os pontos-e-vírgulas são opcionais como terminadores de instrução ; na maioria dos casos, uma nova linha é suficiente para o compilador deduzir que a instrução terminou.

As declarações de variáveis e listas de parâmetros do Kotlin têm o tipo de dados depois do nome da variável (e com um separador de dois pontos ), semelhante a BASIC , Pascal , TypeScript e Rust .

As variáveis ​​no Kotlin podem ser somente leitura, declaradas com a palavra-chave val , ou mutáveis , declaradas com a palavra-chave var .

Os membros da classe são públicos por padrão e as próprias classes são finais por padrão, o que significa que a criação de uma classe derivada é desabilitada, a menos que a classe base seja declarada com a palavra-chave open .

Além das classes e funções-membro (equivalentes aos métodos) da programação orientada a objetos, o Kotlin também oferece suporte à programação procedural com o uso de funções . As funções Kotlin (e construtores) suportam argumentos padrão , listas de argumentos de comprimento variável , argumentos nomeados e sobrecarga por assinatura única. As funções de membro de classe são virtuais, ou seja, despachadas com base no tipo de tempo de execução do objeto no qual são chamadas.

Kotlin 1.3 adiciona (estável em stdlib; contratos definidos pelo usuário experimental) suporte para contratos (inspirado no paradigma de programação de design por contrato de Eiffel )

De acordo com os desenvolvedores do Kotlin, você pode chamar o código JavaScript do Kotlin, por exemplo, escrever aplicativos React completos e com segurança de tipo , ou escrever e manter aplicativos da web full-stack compartilhando lógica de validação com o front-end, ou você pode "gerar bibliotecas a partir do seu código Kotlin que podem ser consumidos como módulos de qualquer base de código escrita em JavaScript ou TypeScript ".

Sintaxe

Estilo de programação procedimental

Kotlin relaxa a restrição do Java de permitir que métodos e variáveis estáticos existam apenas dentro do corpo de uma classe. Objetos e funções estáticos podem ser definidos no nível superior do pacote sem a necessidade de um nível de classe redundante. Para compatibilidade com Java, Kotlin fornece uma JvmNameanotação que especifica um nome de classe usado quando o pacote é visualizado em um projeto Java. Por exemplo @file:JvmName("JavaClassName"),.

Ponto de entrada principal

Como em C , C ++ , C # , Java e Go , o ponto de entrada para um programa Kotlin é uma função chamada "main", que pode receber uma matriz contendo quaisquer argumentos de linha de comando. Isso é opcional desde o Kotlin 1.3. A interpolação de strings em estilo shell Perl , PHP e Unix é suportada. A inferência de tipo também é suportada. 

// Hello, World! example
fun main() {
    val scope = "World"
    println("Hello, $scope!")
}

fun main(args: Array<String>) {
    for (arg in args)
        println(arg)
}

Funções de extensão

Semelhante ao C #, o Kotlin permite adicionar uma função de extensão a qualquer classe sem as formalidades de criar uma classe derivada com novas funções. Uma função de extensão tem acesso a toda a interface pública de uma classe, que pode ser usada para criar uma nova interface de função para uma classe de destino. Uma função de extensão aparecerá exatamente como uma função da classe e será mostrada na inspeção de conclusão do código das funções da classe. Por exemplo: 

package MyStringExtensions

fun String.lastChar(): Char = get(length - 1)

>>> println("Kotlin".lastChar())

Ao colocar o código anterior no nível superior de um pacote, a classe String é estendida para incluir uma lastCharfunção que não foi incluída na definição original da classe String. 

// Overloading '+' operator using an extension function
operator fun Point.plus(other: Point): Point {
    return Point(x + other.x, y + other.y)
}

>>> val p1 = Point(10, 20)
>>> val p2 = Point(30, 40)
>>> println(p1 + p2)
Point(x=40, y=60)

Descompacte os argumentos com o operador de propagação

Semelhante ao Python, o asterisco do operador spread (*) descompacta o conteúdo de uma matriz como argumentos separados por vírgulas para uma função: 

fun main(args: Array<String>) { 
    val list = listOf("args: ", *args)
    println(list)
}

Declarações de desestruturação

Não deve ser confundido com o método destruidor comum em linguagens orientadas a objetos.

Declarações de desestruturação decompõem um objeto em múltiplas variáveis ​​ao mesmo tempo, por exemplo, um objeto de coordenada 2D pode ser desestruturado em dois inteiros, x e y.

Por exemplo, o Map.Entryobjeto oferece suporte à desestruturação para simplificar o acesso aos seus campos de chave e valor: 

for ((key, value) in map)
    println("$key: $value")

Funções aninhadas

O Kotlin permite que funções locais sejam declaradas dentro de outras funções ou métodos. 

class User(val id: Int, val name: String, val address: String)
    
fun saveUserToDb(user: User) {
    fun validate(user: User, value: String, fieldName: String) {
        require(value.isNotEmpty()) { "Can't save user ${user.id}: empty $fieldName" }
    }
    
    validate(user, user.name, "Name") 
    validate(user, user.address, "Address")
    // Save user to the database 
    ...
}

As aulas são finais por padrão

No Kotlin, para derivar uma nova classe de um tipo de classe base, a classe base precisa ser explicitamente marcada como "aberta". Isso contrasta com a maioria das linguagens orientadas a objetos, como Java, onde as classes são abertas por padrão.

Exemplo de uma classe base que está aberta para derivar uma nova subclasse dela. 

// open on the class means this class will allow derived classes
open class MegaButton  {

    // no-open on a function means that 
    //    polymorphic behavior disabled if function overridden in derived class
    fun disable() { ... }

    // open on a function means that
    //    polymorphic behavior allowed if function is overridden in derived class
    open fun animate() { ... }
}

class GigaButton: MegaButton {

    // Explicit use of override keyword required to override a function in derived class
    override fun animate() { println("Giga Click!") } 
}

As classes abstratas são abertas por padrão

As classes abstratas definem funções de placeholder abstratas ou "virtuais puras" que serão definidas em uma classe derivada. As classes abstratas são abertas por padrão. 

// No need for the open keyword here, it’s already open by default
abstract class Animated {

    // This virtual function is already open by default as well
    abstract fun animate()
  
    open fun stopAnimating() { }

    fun animateTwice() { }
}

As aulas são públicas por padrão

Kotlin proporciona as seguintes palavras-chave para restringir a visibilidade para a declaração de nível superior, tais como aulas, e por membros da classe: public, internal, protected, e private.

Quando aplicado a um membro da classe:

Palavra-chave Visibilidade
public (predefinição) Em todos os lugares
internal Dentro de um módulo
protected Dentro das subclasses
private Dentro de uma classe

Quando aplicado a uma declaração de nível superior:

Palavra-chave Visibilidade
public (predefinição) Em todos os lugares
internal Dentro de um módulo
private Dentro de um arquivo

Exemplo: 

// Class is visible only to current module
internal open class TalkativeButton : Focusable {
    // method is only visible to current class 
    private fun yell() = println("Hey!")

    // method is visible to current class and derived classes
    protected fun whisper() = println("Let's talk!")
}

Construtor primário vs. construtores secundários

Kotlin suporta a especificação de um "construtor primário" como parte da própria definição da classe, consistindo em uma lista de argumentos após o nome da classe. Esta lista de argumentos suporta uma sintaxe expandida nas listas de argumentos de função padrão do Kotlin, que permite a declaração de propriedades de classe no construtor primário, incluindo atributos de visibilidade, extensibilidade e mutabilidade. Além disso, ao definir uma subclasse, as propriedades em superinterfaces e superclasses podem ser substituídas no construtor primário. 

// Example of class using primary constructor syntax
// (Only one constructor required for this class)
open class PowerUser(
    protected val nickname: String, 
    final override var isSubscribed: Boolean = true) 
  : User(...) {
    ...
}

No entanto, nos casos em que mais de um construtor é necessário para uma classe, um construtor mais geral pode ser usado, chamado sintaxe de construtor secundário, que se assemelha muito à sintaxe do construtor usada na maioria das linguagens orientadas a objetos como C ++, C # e Java. 

// Example of class using secondary constructor syntax
// (more than one constructor required for this class)
class MyButton : View {

    // Constructor #1 
    constructor(ctx: Context) : super(ctx) { 
        // ... 
    } 
  
    // Constructor #2
    constructor(ctx: Context, attr: AttributeSet) : super(ctx, attr) { 
        // ... 
    }
}

Classes de dados

A data classconstrução de Kotlin define classes cujo objetivo principal é armazenar dados. Esta construção é semelhante às classes normais, excepto que as funções principais equals, toStringe hashCodesão gerados automaticamente a partir das propriedades de classe. Em Java, espera-se que essas classes forneçam uma variedade padrão de funções como essas. As classes de dados não precisam declarar nenhum método, embora cada uma deva ter pelo menos uma propriedade. Uma classe de dados geralmente é escrita sem um corpo, embora seja possível fornecer a uma classe de dados quaisquer métodos ou construtores secundários válidos para qualquer outra classe. A datapalavra-chave é usada antes da classpalavra-chave para definir uma classe de dados. 

fun main(args: Array) {
    // create a data class object like any other class object
    var book1 = Book("Kotlin Programming", 250)
    println(book1)
    // output: Book(name=Kotlin Programming, price=250)
}
     
// data class with parameters and their optional default values
data class Book(val name: String = "", val price: Int = 0)

Shell interativo do Kotlin

$ kotlinc-jvm
type :help for help; :quit for quit
>>> 2 + 2
4
>>> println("Hello, World!")
Hello, World!
>>>

Kotlin como linguagem de script

Kotlin também pode ser usado como uma linguagem de script. Um script é um arquivo-fonte Kotlin (.kts) com código executável de nível superior. 

// list_folders.kts
import java.io.File
val folders = File(args[0]).listFiles { file -> file.isDirectory() }
folders?.forEach { folder -> println(folder) }

Os scripts podem ser executados passando a -scriptopção e o arquivo de script correspondente para o compilador. 

$ kotlinc -script list_folders.kts "path_to_folder_to_inspect"

Segurança nula

Kotlin faz uma distinção entre tipos de dados anuláveis ​​e não anuláveis. Todos os objetos anuláveis ​​devem ser declarados com um "?" postfix após o nome do tipo. Operações em objetos anuláveis ​​precisam de cuidado especial dos desenvolvedores: a verificação de nulos deve ser realizada antes de usar o valor. O Kotlin fornece operadores seguros para nulos para ajudar os desenvolvedores: 

fun sayHello(maybe: String?, neverNull: Int) {
    // use of elvis operator
    val name: String = maybe ?: "stranger"
    println("Hello $name")
}

Um exemplo do uso do operador de navegação segura: 

// returns null if...
// - foo() returns null,
// - or if foo() is non-null, but bar() returns null,
// - or if foo() and bar() are non-null, but baz() returns null.
// vice versa, return value is non-null if and only if foo(), bar() and baz() are non-null
foo()?.bar()?.baz()

Lambdas

O Kotlin oferece suporte para funções de ordem superior e funções anônimas ou lambdas. 

// the following function takes a lambda, f, and executes f passing it the string, "lambda"
// note that (s: String) -> Unit indicates a lambda with a String parameter and Unit return type
fun executeLambda(f: (s: String) -> Unit) {
    f("lambda")
}

Lambdas são declarados usando chaves, {} . Se um lambda aceita parâmetros, eles são declarados entre colchetes e seguidos pelo operador -> . 

// the following statement defines a lambda that takes a single parameter and passes it to the println function
val l = { c : Any? -> println(c) }
// lambdas with no parameters may simply be defined using { }
val l2 = { print("no parameters") }

Exemplo complexo de "olá, mundo" 

fun main(args: Array<String>) {
    greet {
        to.place
    }.print()
}

// Inline higher-order functions
inline fun greet(s: () -> String) : String = greeting andAnother s()

// Infix functions, extensions, type inference, nullable types, 
// lambda expressions, labeled this, Elvis operator (?:)
infix fun String.andAnother(other : Any?) = buildString() 
{ 
    append(this@andAnother); append(" "); append(other ?: "") 
}

// Immutable types, delegated properties, lazy initialization, string templates
val greeting by lazy { val doubleEl: String = "ll"; "he${doubleEl}o" }

// Sealed classes, companion objects
sealed class to { companion object { val place = "world"} }

// Extensions, Unit
fun String.print() = println(this)

Ferramentas

  • IntelliJ IDEA tem suporte de plug-in para Kotlin. IntelliJ IDEA 15 foi a primeira versão a agrupar o plug-in Kotlin no instalador IntelliJ e fornecer suporte Kotlin pronto para uso.
  • JetBrains também fornece um plugin para Eclipse .
  • A integração com ferramentas de construção Java comuns é suportada, incluindo Apache Maven , Apache Ant e Gradle .
  • O Android Studio (baseado no IntelliJ IDEA) tem suporte oficial para Kotlin, a partir do Android Studio 3.
  • Emacs tem um modo Kotlin em seu repositório de pacotes Melpa.
  • O Vim tem um plugin mantido no GitHub.
  • Json2Kotlin gera código Kotlin nativo de estilo POJO para mapeamento de resposta de serviço da web.

Formulários

Quando Kotlin foi anunciado como uma linguagem de desenvolvimento Android oficial no Google I / O em maio de 2017, tornou-se a terceira linguagem totalmente compatível com Android, além de Java e C ++. Em 2020, o Kotlin ainda era mais amplamente usado no Android, com o Google estimando que 70% dos 1000 principais aplicativos da Play Store eram escritos em Kotlin. O próprio Google tem 60 aplicativos escritos em Kotlin, incluindo Maps e Drive. Muitos aplicativos Android, como o Google Home, estão em processo de migração para o Kotlin e, portanto, usam Kotlin e Java. O Kotlin no Android é visto como benéfico por sua segurança de ponteiro nulo, bem como por seus recursos que tornam o código mais curto e legível.

Além de seu uso proeminente no Android, Kotlin está ganhando força no desenvolvimento do lado do servidor. O Spring Framework adicionou oficialmente o suporte ao Kotlin com a versão 5 em 4 de janeiro de 2017. Para dar mais suporte ao Kotlin, o Spring traduziu toda a sua documentação para o Kotlin e adicionou suporte integrado para muitos recursos específicos do Kotlin, como corrotinas. Além do Spring, a JetBrains produziu uma estrutura Kotlin-first chamada Ktor para a construção de aplicativos da web.

Em 2020, a JetBrains descobriu em uma pesquisa com desenvolvedores que usam Kotlin que 56% usavam Kotlin para aplicativos móveis, enquanto 47% o usavam para back-end da web. Pouco mais de um terço de todos os desenvolvedores do Kotlin disseram que estavam migrando de outro idioma para o Kotlin. A maioria dos usuários do Kotlin tinha como alvo o Android (ou outro tipo de JVM), com apenas 6% usando o Kotlin Native.

Adoção

Em 2018, Kotlin era a linguagem de crescimento mais rápido no GitHub com 2,6 vezes mais desenvolvedores em comparação com 2017. É a quarta linguagem de programação mais amada de acordo com a Pesquisa de Desenvolvedor Stack Overflow de 2020.

Kotlin também recebeu o prêmio O'Reilly Open Source Software Conference Breakout de 2019.

Muitas empresas / organizações têm usado o Kotlin para o desenvolvimento de back-end:

  • Google
  • Administração Tributária Norueguesa
  • Gradle
  • Amazonas
  • Quadrado
  • JetBrains
  • Fluxo
  • Allegro
  • OLX
  • Shazam
  • Pivotal
  • Viagem de foguete
  • Meshcloud
  • Zalando

Algumas empresas / organizações têm usado o Kotlin para desenvolvimento web:

  • JetBrains
  • Data2viz
  • Fritz2
  • Banco Barclays

Várias empresas declararam publicamente que estavam usando o Kotlin:

Veja também

Referências

  • Este artigo contém citações de tutoriais de Kotlin lançados sob uma licença Apache 2.0.

links externos