Langue officielle pour le développement de Android.
Pourquoi Kotlin a-t-il nommé Kotlin en l'honneur de l'île de la baie finlandaise, comme et lorsque la langue est devenue populaire parmi les développeurs d'applications mobiles, pourquoi peut-il être pratique pour une utilisation et pourquoi ils sont-ils originaires? Directeur marketing Kotlin Roman Belov a dit "Papier"Comme à Saint-Pétersbourg, ils ont créé une langue reconnue par Google.
Photo de l'archive de la Belova romaine
Comment et quand le langage de programmation de la kotlin a-t-il apparu?
Nous avons commencé à développer Kotlin en 2010. À ce moment-là, Jetbrains avait déjà eu dix ans et le principal produit de la société - Jetbrains Intellij Idea, entièrement écrit en Java, était déjà très grand. Il est devenu évident que, à bien des égards, Java ne nous convient pas. Il y avait plusieurs langages de programmation alternatifs, mais il s'est avéré qu'aucun d'entre eux ne correspond aux exigences que nous avons présentées à la langue qui souhaiterait aller.
Il y avait une deuxième raison. Lorsque beaucoup de gens vont à un endroit avec une grande expérience d'experts dans le domaine des langages de programmation, il s'avère souvent qu'une nouvelle langue est née. Donc, il s'est avéré. Premièrement, il y avait un besoin conscient et sérieux, et deuxièmement, nous pourrions le satisfaire.
Comme beaucoup de nos produits, nous avons créé Kotlin en fonction de leur besoin. Ceci, en général, le principe du développement de la société: nous constatons qu'il n'y a pas d'outil sur le marché, ce qui résoudrait un problème, puis la créerait. Nos premiers utilisateurs sont toujours nous-mêmes. Par conséquent, nous obtenons généralement des outils très pratiques et pragmatiques.
Pourquoi Kotlin est-il appelé de cette façon?
À ce moment-là, lorsque le nom a été inventé, sur JVM (machine virtuelle Java - env. "Papier") Il y avait encore des langues appelées en l'honneur des îles: Java, Ceylan. Et nous avons pensé: Quelle est l'île près de nous? Kotlin. Et ce nom a eu lieu. Il n'y a pas de tradition ni de règle ici, mais c'est arrivé, il n'y a pas de pensées plus profondes pour cela.
Quelles sont les caractéristiques de la langue?
Le mot le plus réussi qui vient à la langue de Kotlin est probablement pragmatique. Les langues sont différentes: certains sortent de l'environnement académique, d'autres sont conçus pour des plateformes spécifiques. Nous étions initialement destinés à une langue pratique pour le public le plus large possible. Il devait être démocratique, c'est-à-dire sans choses ennuyeuses. Il existe des situations où le programmateur connaît toutes les subtilités de la langue et, grâce à cela, il écrit un code délicat, et dans ce code, aucun des programmeurs juniors ne peut grimper. Nous avons besoin d'une langue également bonne pour les programmeurs novices et avancé.
À l'intérieur de la société, nous avons également la pleine démocratie: chaque programmeur lui-même décide, dans quelle langue écrire, sur Java ou à Kotlin, et tout ne se passe pas à Kotlin. Pour moi, quant au responsable du marketing, la langue de Jetbrains est un petit monde. Quand tout ira à Kotlin dans notre grande entreprise, alors, probablement, dans le monde entier, les programmeurs vont y passer. Mais, en effet, le pourcentage de l'utilisation de Kotlin dans la société augmente systématiquement.
Qu'est-ce que Kotlin est si bon? Tout d'abord, les développeurs adorent Kotlin pour sa brièveté et sa expressivité. C'est caractéristique de toutes les nouvelles langues. Auparavant, les gens n'étaient pas très gênés, puis la taille des programmes devenait plus - les gens ont compris qu'ils écrivent beaucoup d'éléments de code complètement sans signification, car il nécessite la syntaxe du langage de programmation.
La deuxième raison est qu'elle est entièrement compatible avec Java et vous permet de migrer progressivement à partir d'applications Java à l'application Kotlin. Par exemple, l'application BASECAMP a complètement migré avec Java sur Kotlin.
Le troisième élément - Kotlin est sécurisé: la sémantique de la langue a posé les principes qui empêchent un certain nombre d'erreurs très courantes qui se produisent généralement au moment de l'exécution du programme. Cela vous permet d'écrire un code plus sûr qui aide finalement à économiser de l'argent et à réduire les coûts de test.
Comment Kotlin a-t-il remarqué les développeurs d'applications?
À Jetbrains, nous ne nous engageons pas à l'android et à l'origine, personne ne pensait que Kotlin serait une langue qui conviendrait avec succès aux fins des développeurs Android. Mais à un moment donné, il s'est avéré que Android était coincé sur Java 6 et de nombreuses nouvelles fonctionnalités Java sur Android ne sont pas disponibles. Les développeurs progressifs ont ensuite porté une attention particulière à Kotlin.
Nous avons réalisé que Kotlin pourrait être très utile pour Android et commençait à affiner les fonctionnalités qui aident les développeurs Android, ont pris en compte leurs besoins lors de la mise au point d'une conception linguistique.
Il y a un an, nous avons eu un événement assez important: le système d'assemblage de grade, avec lequel toutes les applications sont collectées pour Android, ont annoncé la transition vers Kotlin.
En un sens, l'histoire avec Kotlin sur Android est complètement fabuleuse et logement: nous venons de faire le langage de programmation, et il a vraiment aimé les développeurs. Ceci est une histoire de mouvement de bas en haut, et pas le contraire. Les développeurs ont longtemps demandé à Google de soutenir Kotlin. Et Google les a écoutés.
Avec l'annonce de Google officiellement, rien ne change pour nous: nous continuons à développer une langue et visons à différentes plates-formes. Naturellement, nous prévoyons une attention particulière à la langue des développeurs Android: il sera notamment exprimé dans des messages d'erreur, dans les requêtes pour soutenir une ou une autre fonctionnalité, et bien sûr, nous allons tous traiter tout cela. Mais en général, bien sûr, nous continuerons à bouger le long du chemin prévu.
Qui et pourquoi utiliser la langue de Kotlin?
Dans la société, nous avons commencé à appliquer Kotlin Years depuis la publication de 2012, mais la libération officielle de la langue était le 17 février 2016. Avant cette période, la conception de la langue changeait activement et soutenue sur Kotlin était assez problématique. Il faut comprendre que le développement des langages de programmation nécessite une grande attention à la compatibilité rédaction. Et lorsque nous avons déclaré une libération, renvoyé la compatibilité en arrière: car le nouveau code sera compatible au niveau binaire avec l'ancien. Et nous effectuons ces obligations.
Maintenant, Kotlin Language dans ses applications utilise de telles entreprises russes comme avito et Rocket Bank. Au cours de la dernière année, Kotlin a essayé 160 000 programmeurs. Jusqu'à aujourd'hui, Kotlin a montré une croissance exponentielle du nombre de programmeurs, et je pense que l'annonce de Google nous aidera à poursuivre cette croissance.
Fun Main (Args: Array
Les fonctions d'ordre supérieur sont des fonctions qui prennent d'autres fonctions comme des arguments et des fonctions de retour. Considérez l'exemple suivant:
Fun Alphanum (Func: () -\u003e Unité) ()
En informatique, Func est le nom de l'argument, a () -\u003e unité est le type de fonction. Nous disons que Func sera une fonction qui n'accepte pas les arguments et ne renvoyant rien.
Les expressions Lambda ou les fonctions anonymes sont des fonctions qui ne sont pas déclarées, mais sont transmises comme des expressions. Voici un exemple:
Val sum: (int, int) -\u003e int \u003d (x, y -\u003e x + y)
Nous déclarons la variable de somme, qui prend deux chiffres, les plie et prend la valeur du montant donné à l'ensemble. Appeler une somme simple (2.2).
Comparaison de la vitesse Java et Kotlin
La première assemblée du code Kotlin prend environ 15 à 20% de plus de temps qu'un processus similaire sur Java. Cependant, l'assemblage incrémentiel de Kotlin est même un peu plus rapide que Java. Ainsi, les langues sont à peu près égales dans le taux de compilation.
Future Kotlin.
Kotlin est la prochaine étape de développement Java avec laquelle elle est entièrement compatible. Cela en fait un excellent outil pour les applications mobiles et d'entreprise. Et puisque Kotlin est maintenant la langue officielle Android, vous ne pouvez pas avoir peur de l'avoir étudié, vous resterez sans travail.
Dans l'étude de cette langue, une série d'articles vous aidera à décrire le processus de création d'une simple application mobile KEDDIT - un client pour une ressource populaire RedDit. Toutes ses pièces pour votre commodité que nous avons répertoriées dans la liste ci-dessous.
Vous aurez besoin des bibliothèques suivantes:
- Modernisation 2.0;
- Rxjava;
- Picasso;
- Recyclerview;
- Extensions Kotlin pour Android;
- Dagge 2.
Toutes les sources sont disponibles sur GitHub. La série se compose des parties suivantes.
Cet article parle du langage de programmation de Kotlin. Vous en apprendrez sur les raisons de l'émergence du projet, des capacités linguistiques et de voir quelques exemples. L'article est principalement écrit dans le calcul que le panneau de lecture avec le langage de programmation Java, cependant, sache une autre langue sera également en mesure d'obtenir une idée du sujet. L'article est superficiel et n'affecte pas les problèmes de compilation dans JavaScript. Sur le site officiel du projet, vous pouvez trouver une documentation complète, je vais essayer de parler de la langue en bref.
à propos du projet
Pas si longtemps, Jetbrains, qui est engagé dans la création d'environnements de développement, a annoncé son nouveau produit - Langage de programmation de Kotlin. Une vague de critique collectée sur la société: critiquer les entreprises offertes de faire glisser et terminer le plugin pour Scala, au lieu de développer leur langue. Les développeurs sur Scala n'ont vraiment pas un bon environnement de développement, mais les problèmes des développeurs plug-in peuvent être compris: Scala, qui est né grâce à des chercheurs de Suisse, a absorbé de nombreux concepts scientifiques et approches innovants qui ont créé la création d'un Bon outil pour développer une tâche extrêmement difficile. Pour le moment, le segment des langues modernes avec la typographie statique pour JVM est faible, la décision de créer votre propre langue avec l'environnement de développement en l'air très loin. Même si cette langue n'a pas lieu du tout dans la Communauté - Jetbrains le rend principalement pour ses besoins. Ces besoins peuvent comprendre n'importe quel programmeur Java: Java, en tant que langue, se développe très lentement, de nouvelles opportunités dans la langue n'apparaissent pas (les fonctions de premier ordre que nous n'attendons aucune première année), la compatibilité avec les anciennes versions de langue rend impossible Apparaître de nombreuses choses utiles dans un proche avenir (par exemple, paramétrisation décente des types). Pour une entreprise qui se développe sur le langage de programmation est l'outil de travail principal, de sorte que l'efficacité et la simplicité de la langue sont des indicateurs sur lesquels non seulement la simplicité du développement des outils dépend, mais également des coûts d'un programmeur pour le codage, c'est-à-dire Quelle est la facilité ce code pour accompagner et se réveiller.À propos de la langue
La langue est statiquement typée. Mais par rapport à Java, le compilateur Kotlin ajoute au type d'informations sur les caractéristiques du lien pour contenir NULL, qui resserre les types de types et rend l'exécution plus sécurisée:Amusement foo (texte: string) (texte.tolowercase ()) // NPE? Non!) Val Str: String? \u003d Null // chaîne? - Type permettant à NULL-S FOO (STR) //<- компилятор не пропустит такой вызов -- // тип str должен быть String, чтобы // передать его в foo
Malgré le fait que cette approche puisse enregistrer un programmeur à partir d'un certain nombre de problèmes liés à la NPE, pour un programmeur Java au début, il semble d'abord inutile - vous devez faire une vérification supplémentaire ou une transformation supplémentaire. Mais après une programmation de temps sur Kotlin, de retour à Java, vous estimez que vous n'avez pas eu ces informations sur le type, vous pensez à utiliser des annotes nullables / NotNull. Avec cela, il n'y a pas de problèmes de compatibilité en arrière avec Java - il n'y a pas de Java dans le code, mais aussi loin que je sache, cette question est toujours dans le processus de solution, mais pour l'instant, tous les types provenant de Java sont nullables.
Au fait, à propos de la compatibilité en retard: Kotlin est compilée dans le bytecode JVM (créateurs de la langue consacre beaucoup de force pour soutenir la compatibilité), ce qui vous permet de l'utiliser dans un projet avec Java et la capacité d'utiliser mutuellement le Java. Les classes et les classes de kotlin constituent un seuil d'imitation de kotlin complètement minimal dans un grand projet Java déjà existant. À cet égard, il est important d'utiliser plusieurs développements Java, créant ainsi un projet entièrement sur Kotlin. Par exemple, je n'ai presque pas travaillé pour créer un petit projet basé sur Spring-WebMVC.
Voyons le fragment du contrôleur:
Chemin (tableau ("/ Notes /")) Classe de contrôleur NotesController (Val Notesservice privé: Notesservice? \u003d NULL PATH (tableau ("Tous") Fun () \u003d Render ("Notes / Notes") Notes ", notservice !!. tout)) // ...)
Les caractéristiques de l'utilisation d'annotations à Kotlin sont visibles: il ne semble pas aussi dans la situation que dans Java (cela concerne les cas particuliers, par exemple un tableau d'un élément), mais des annotations peuvent être utilisées comme des mots-clés "auto-fabriqués" comme Autonome ou contrôleur (si vous définissez un type d'alyas lorsqu'il est importé) et en fonction des possibilités d'approche d'annotation de ces classes.
Il convient de noter que le printemps ne pouvait pas envelopper les classes de kotlin pour la gestion des transactions - j'espère à l'avenir, ce sera possible.
Dans la langue, il y a un soutien aux fonctions de première classe. Cela signifie que la fonction est le type de type intégré pour lequel il existe une syntaxe spéciale. Les fonctions peuvent être créées sur place, transférer à d'autres fonctions sur les paramètres, stocker des liens sur eux:
Dosomething amusant (chose: () -\u003e unité) (// déclarer une fonction de type fonction // () -\u003e unité n'accepte rien et // rien d'importance ne renvoie rien () // Appelez) Dosomething () (// et Ici, à la volée, nous créons une fonction de type // () -\u003e unité et transmettez-la à la fonction Doshomething // si la fonction est le dernier paramètre, vous pouvez // le sortez pour les crochets d'appel d'impression ("Bonjour World "))
Si vous ajoutez une extension à cela, vous permettez de développer la classe déjà existante par la méthode qui ne viole pas l'encapsulation de la classe, mais que vous pouvez contacter en tant que méthodes de cette classe, nous recevrons une expansion assez puissante. Mécanisme des puits bien pauvres en termes de bibliothèques java standard. Par tradition, ajoutez la liste du filtrage de la liste déjà existant dans la bibliothèque standard:
Amusant.
Notez que les variables ne spécifient pas les types - le compilateur Kotlin les affiche si cela est possible et n'interfère pas avec l'absorption de l'interface. En général, la langue est faite de manière à maximiser la personne derrière le clavier à partir des gains de signes inutiles: une syntaxe courte mais claire avec un minimum de mots-clés, pas besoin de points avec une virgule pour séparer les expressions, type Sortie, où il convient, l'absence d'un nouveau mot clé pour créer une classe - juste nécessaire.
Pour illustrer le sujet des cours et des shorts, consultez le code suivant:
// Créer des classes de haricots devient // Peu, des champs peuvent être annoncés // DROITE dans la classe Timelord Designer Déclaration // La classe peut ne pas avoir le corps de la classe TARDIS (VAL Owner: Timelord) Fun Main (Args: Array
Dans plusieurs lignes, nous avons pu déclarer deux classes, créer deux objets et retirer le nom du propriétaire de TARDIS! On peut noter que la classe est déclarée avec les paramètres de son seul concepteur possible, qui sont simultanément la déclaration de ses propriétés. Bref brièvement, mais en même temps informatif. Il y aura sûrement ceux qui condamnent l'incapacité à déclarer plus d'un constructeur, mais il me semble que cela a son propre pragmatisme - après tout, plusieurs designers de Java ou vous permettent de déclarer les paramètres par défaut que Kotlin prend en charge le niveau de langue, Ou convertir un type à un autre, avec lequel il fonctionnera cette classe, ce qui peut déjà être tranquillement pour dégager la méthode d'usine. Payez votre attention sur l'annonce des «variables» et des champs. Kotlin nous fait faire un choix: Val ou Var. Lorsque le VAL - déclare une liaison finale non modifiable et variable var - une variable permettant d'éviter l'utilisation omniprésente de liaisons changeantes.
Exemple
Nous sommes donc arrivés à l'endroit où quelque chose de plus intéressant peut être fait. Dans les interviews, je donne souvent une tâche à mettre en œuvre un arbre, ce qui le permet de contourner et de déterminer une certaine action avec un élément. Voyons comment il est mis en œuvre à Kotlin.Donc, j'aimerais ressembler à:
Fun Main (Args: Array
Essayons maintenant de la mettre en œuvre. Créer une classe de nœuds d'arbre:
/ ** * @param Valeur Node Data * / Nœud de classe
Ajoutez maintenant une fonction pour créer un sommet de bois:
/ ** * crée un sommet de bois avec la valeur de la valeur et initialise ses enfants par l'init. * / Amusant.
Dans deux endroits du code, la conception du type de nœud a été utilisée. () -\u003e Unité, sa signification est que la fonction de type devrait être exécutée en tant que méthode d'objet de type nœud. Du corps de cette caractéristique, il y a accès à d'autres méthodes de cet objet, telles que la méthode Node.Node (), qui permet l'initialisation de l'arbre similaire à celle décrite dans l'exemple.
Au lieu de l'emprisonnement
Au détriment de la bonne compatibilité avec Java et la capacité de remplacer l'ancien code progressivement, Kotlin pourrait être un bon remplacement de Java dans de grands projets et un outil pratique pour créer de petits projets avec la perspective de leur développement. La simplicité de la langue et sa flexibilité confèrent au développeur plus de possibilités d'écrire un code rapide mais de haute qualité.
Si vous êtes intéressé par la langue, toutes les informations sur la langue sont disponibles sur le site officiel du projet, les silicones sur le GITUB-E et les erreurs trouvées en émission Tracker trouvée. Il y a encore beaucoup de problèmes, mais les développeurs de la langue luttent activement avec eux. Maintenant, l'équipe travaille sur la version mais pas très stable de Milestone 3, après la stabilisation, autant que je sache, il est prévu d'utiliser une langue au sein de la société Jetbrains, après quoi la première version est déjà prévue.
Mots clés:
- kotlin.
- java.
- jetBrains.
05/18/2017, Thu, 14:39, Msk Texte: Alexander Kornev
Google Developers a créé Kotlin la première langue de la première classe pour le système d'exploitation Android, notant qu'elle ne sera pas encore remplacée par la principale langue «première classe» Java.
Kotlin comme langue de première classe pour Android
Jeudi à la conférence annuelle de Google E / S, les développeurs ont déclaré que la langue de Kotlin créée par les programmeurs russes deviendra la "langue de première classe" pour écrire des applications pour Android. Comme TechCrunch écrit, Google a également raconté l'organisation avec les créateurs de la langue - Jetbrains - Fonds spécial pour le développement de Kotlin.
Google a souligné que Kotlin sera une langue supplémentaire et en aucun cas ne remplacera pas Java et C ++ (aujourd'hui la langue de la première classe pour Android est Java). Il est prévu que les outils de Kotlin basés sur Jetbrains IDE seront inclus dans Android Studio 3.0 - l'outil de développement officiel pour Android OS.
"Depuis que Kotlin est entièrement soutenu par Java, vous aviez l'habitude de rédiger des applications, mais il sera maintenant soutenu par l'autorité et la réputation de Google", disons aux journalistes.
Google traduit Android à la langue de Kotlin créée en Russie
Dans le même temps, Google ne devient pas propriétaire de Kotlin. Les droits appartiendront toujours à Jetbrains. La langue continuera de travailler avec d'autres plates-formes, par exemple, en tant que code natif pour iOS et Mac ou pour compiler le code JavaScript pour les applications Web.
Dans un combat concurrentiel avec Swift
Kotlin est une langue de programmation typée de manière statique sur JVM Compilation JavaScript. La langue est développée depuis 2010, son code source a été ouvert en 2012 son nom Kotlin a reçu en l'honneur de l'île de Kotlin dans la baie de Finnois, sur laquelle se trouve Krystadt.
Rappelez-vous au printemps 2016 dans Google sur la perspective de développer des applications pour Android Swift - Langage de programmation pour iPhone et iPad. Et en même temps, Kotlin a été nommé langue variante possible. Au début, Swift était un projet interne d'Apple, mais le code source a ensuite été ouvert par les développeurs.
Il a été signalé que la raison éventuelle de la recherche d'un remplaçant pour Java pourrait être le problème d'un plan juridique avec Oracle Corporation, qui insiste sur le fait que Google a violé son droit d'auteur et ses brevets. Les experts ont noté que pour adapter Swift to Android nécessiterait le développement d'un nouvel environnement d'exécution pour le système d'exploitation mobile, l'adaptation de la bibliothèque standard, fournissant une prise en charge de la langue dans les interfaces de programmation (API) et les outils de développement, etc.
De Kotlin, Swift est différent, selon des experts, une productivité plus élevée. Parmi les avantages de Kotlin a déjà mentionné une compatibilité totale avec JavaScript.
Ces dernières années, une nouvelle langue doit être compilée dans un code d'octet portable pour la machine virtuelle Java. Il existe plusieurs projets pour créer des langues et l'une d'elles - Kotlin, une langue d'objet typée de manière statique.
11/07/2011 Andrey Breslav
Ces dernières années, une nouvelle langue doit être compilée dans un code d'octet portable pour la machine virtuelle Java. Il existe plusieurs projets pour créer de telles langues, dont l'un est Kotlin, une langue d'objet typée statiquement axée sur des objets compatibles avec Java et destiné au développement des applications industrielles.
L'histoire du développement des langues "alternatives" sur la plate-forme Java a plus de plusieurs décennies, mais la diffusion de telles langues reçues uniquement relativement récemment. Sur la vague de popularité des langues dactylographiées dynamiquement, Jruby, Groovy et Clojure Rose, et parmi les langues typées statiquement, Scaal, Fantom et GOSU doivent être mentionnées. La langue Java elle-même n'est pas non plus en place, mais son développement est compliqué comme la nécessité de maintenir la compatibilité rédaction et du sort difficile des microsystèmes Sun Sun, absorbés par Oracle.
Dans ce contexte, un nouveau projet JetBrains sous le nom de code Kotlin (l'accent sur «O»), d'une part, semble presque hommage à la mode, et de l'autre, il est entouré d'un nombre notable de concurrents. Cependant, nous nous sentons assez confiants dans cette situation et il y a plusieurs raisons à cela. Premièrement, Jetbrains a été engagé dans les médias de développement intégrés pour différentes langages de programmation (dont beaucoup travaillent sur la plate-forme Java) et, pendant cette période, une forte équipe de spécialistes a été collectée et une expérience significative des langages de programmation et des technologies connexes a été accumulé. Deuxièmement, nous ne pouvons pas dire que l'une des langues existantes sur la plate-forme Java satisfait pleinement nos besoins et nous croyons, fondé sur des examens préliminaires des programmeurs du monde entier, que nos collègues d'autres sociétés connaissent des difficultés similaires.
Le développement du projet de Kotlin a débuté à l'été 2010, en juillet 2011, le projet a été officiellement annoncé et une description de la langue a été publiée sur le site. La version de la version bêta publique du compilateur est prévue au début de 2012.
Créer une langue, nous avons été guidés par un certain nombre d'exigences qui semblent être plus importantes pour un tel projet.
Compatibilité avec Java.La plate-forme Java est principalement écosystème: Outre les produits "officiels" d'Oracle, il comprend de nombreux projets open source: bibliothèques et cadres d'un profil différent, sur la base desquels un grand nombre d'applications sont construits. Par conséquent, la compatibilité avec le code existant, écrite en Java est très importante pour la langue compilée pour cette plate-forme. Il est nécessaire que les projets existants puissent aller dans une nouvelle langue progressivement, c'est-à-dire non seulement le code sur Kotlin devrait facilement appeler le code sur Java, mais au contraire.
Garanties statiques de l'exactitude.Au cours de la compilation du code sur une langue statistique dactylographiée, de nombreux contrôles conçus pour garantir que certaines erreurs ne se produiront pas lors de l'exécution. Par exemple, le compilateur Java garantit que des objets sur lesquels certaines méthodes sont "capables" de les exécuter, c'est-à-dire que dans les classes appropriées, ces méthodes sont mises en œuvre. Malheureusement, outre cette propriété très importante, Java ne garantit rien. Cela signifie que les programmes compilés avec succès sont complétés avec des erreurs de temps d'exécution (causant des situations exclusives). Un exemple brillant consiste à faire référence à zéro, dans lequel l'exception du type NullPointerException est causée lors de l'exécution. Une exigence importante pour une nouvelle langue est le renforcement des garanties statiques. Cela vous permettra de détecter davantage d'erreurs au stade de la compilation et de réduire ainsi les coûts de test.
Taux de compilation.Les contrôles statiques simplifient la programmation, mais ralentissent la compilation et il est nécessaire d'atteindre un certain équilibre. L'expérience de créer des langues avec un système de type puissant (l'exemple le plus frappant est Scala) montre qu'un tel équilibre n'est pas facile à trouver: la compilation devient souvent inacceptable longtemps. En général, une telle caractéristique de la langue, comme le temps de compilation du projet, peut sembler secondaire, dans les conditions de la conception industrielle, lorsque le volume du code compilé est très élevé, il s'avère que ce facteur est très important - Après tout, le code est compilé, le programmeur ne peut souvent pas continuer à fonctionner. En particulier, une compilation rapide est l'un des avantages importants de Java par rapport à C ++ et Kotlin doit sauvegarder cet avantage.
Laconique.On sait que les programmeurs dépensent souvent plus de temps de lecture de temps que lors de son écriture, il est donc important que les conceptions disponibles dans la langue de programmation vous permettent d'écrire brièvement des programmes brièvement et compréhensibles. Java est considéré comme une langue verbeuse (langue de cérémonie - la langue cérémonielle) et la tâche de Kotlin est d'améliorer la situation en ce sens. Malheureusement, des méthodes strictes d'évaluation des langues en termes de concistance sont assez faibles, mais il existe des critères indirects; L'un d'entre eux est la capacité de créer des bibliothèques travaillant avec qui est proche de l'utilisation langues orientées vers le sujet (Langue spécifique au domaine, DSL). Pour créer de telles bibliothèques, une certaine flexibilité de la syntaxe est nécessaire pour combiner conceptions de commandes supérieures; Les fonctions les plus courantes des ordres plus élevés, c'est-à-dire des caractéristiques qui prennent d'autres fonctions en tant que paramètres.
Disponibilité à explorer.Des contrôles statiques sophistiqués, une syntaxe flexible et des conceptions d'ordre supérieur compliquent la langue et rendent difficile l'étude, il est donc nécessaire de limiter l'ensemble des capacités appuyées dans une certaine mesure dans une certaine mesure que la langue est disponible à l'étude. Lorsque vous développez Kotlin, l'expérience de Scala et d'autres langues modernes ont été prises en compte et des concepts trop complexes n'étaient pas inclus dans la langue.
Soutien instrumental.Les programmeurs modernes utilisent activement divers outils automatisés, l'endroit central parmi lequel occupe environnements de développement intégrés Environnement de développement intégré, IDE). L'expérience de dix ans accumulée à Jetbrains montre que certaines propriétés de la langue peuvent entraver de manière significative le soutien instrumental. Lorsque nous développons Kotlin, nous considérons ce fait et crée IDE en même temps avec compilateur.
Éléments de base de la langue
Les fonctions. Kotlin est une langue orientée objet, mais contrairement à Java, il vous permet de déclarer des fonctions en dehors des classes. En Java, des méthodes statiques sont utilisées à ces fins, ce qui conduit à des cours, réels pas comme ceux: leurs instances ne sont jamais créées, mais seules des méthodes statiques sont causées.
Les annonces à Kotlin sont combinées noms d'espace (Espace de noms), et la fonction peut être annoncée directement à l'intérieur de l'espace de noms:
espace de noms.exemple ( amusant.max (A: INT, B: INT): INT ( si(Un retour. revenir.b))Une fonction d'annonce est précédée d'un mot clé amusant., Les types de paramètres sont indiqués après la suite du nom du paramètre suivant le nom du paramètre. De même dénote le type de valeur de retour de la fonction. Une telle syntaxe suit les traditions du «monde fonctionnel», telles que ML et Scala. Il est facile de réduire les annotations typiques si le type peut être supprimé Compacteur du contexte automatiquement.
Variables À Kotlin, comme à Scala, est annoncé à l'aide de mots-clés val.(variables immuables) et var.(changeable):
var.sinsum: Double \u003d 0.0 pour(x en xs.) { Val.y \u003d sin (x) sinsum + \u003d y)Dans cet exemple, le type de variable inchangée Y est omis, car le compilateur peut l'afficher automatiquement par la valeur de la partie droite de la définition variable. Le type de variable variable Sinsum n'est clairement indiqué que pour démontrer la syntaxe correspondante; Le compilateur est suffisant pour afficher le type et dans ce cas.
Des classes.L'outil principal de la décomposition à Kotlin, comme dans d'autres langues orientées objet, sont des cours. Lorsque la déclaration de classe, la conception des paramètres du constructeur est indiquée directement dans le titre:
classerIntPair (x: int, y: int) (...)Les instances de classe sont créées par appel de constructeur direct; Mots clés nouveauÀ Kotlin no:
val.xy \u003d intpair (x, y)L'en-tête de classe indique également la liste paramètres typiques (Générique) en supports angulaires et liste des Suppels, c'est-à-dire les types d'hérités de cette classe séparées par un côlon:
classerMyList (longueur: int): liste, sérialisable (...)TRETES.La classe peut être héritée d'une classe ou de plusieurs traire (Trait est une caractéristique littérale «caractéristique», caractéristique). Les trètes sont similaires aux classes en ce sens qu'ils définissent également des types, peuvent également avoir des membres et hérité des autres traits. La principale différence est que les traits n'ont pas de constructeurs et, par conséquent, ne peuvent pas avoir État (des champs). On peut dire que les traits sont familiers à toutes les interfaces de la langue Java, seules les fonctions ne peuvent avoir des implémentations. Les restrictions imposées aux traits permettent d'éviter les difficultés associées à une héritage de classe multiple.
Fonctions externes.Un autre mécanisme de «expansion» des types de kotlin est des fonctions externes (fonction d'extension - «Fonction d'extension»). De telles fonctions peuvent être annoncées en dehors de toute classe et d'être appelées comme si elles étaient déclarées à l'intérieur. Voici un exemple d'une annonce de fonction externe pour le type INT:
amusant.Int.abs (): int ( si(cETTEretour-ce aUTRE. renvoyer ceci }Le type expansible par cette fonction est indiqué avant qu'elle ne soit nommé et séparé par un point. Cela correspond à l'annonce du paramètre "implicite", qui est indiqué à l'intérieur de la fonction par mot clé cETTE. Par exemple, dans notre exemple, la fonction ABS () étend le type INT et un paramètre implicite cETTEest un entier. Cette fonctionnalité peut être appelée à l'aide de l'opération "Point", ainsi que des fonctions - membres de la classe:
val.x \u003d (-1) .abs ()Une telle syntaxe vous permet de mettre en œuvre des classes uniquement la fonctionnalité minimale nécessaire sans nuire à la lisibilité du programme.
Les fonctions externes sont associées statiquementc'est-à-dire pas virtuel (virtuel).
Structures de contrôle. Lorsque.
Kotlin soutient les conceptions administratives traditionnelles pour les langues impératives si, pouret pendant quesur lequel nous ne nous arrêterons pas en détail, ainsi que le design lorsque.- Fonctionnement de la ramification, qui peut être considéré comme une version étendue de l'opérateur traditionnel changer:
lorsque.(x) (1 \u003d\u003e Imprimer ("Un") 2, 3 \u003d\u003e Imprimer ("Deux ou trois") aUTRE.\u003d\u003e Imprimer ("Numéro inconnu"))À gauche du signe "\u003d\u003e" indique l'expression ou la liste des expressions séparées par des virgules, appelées État. Si un argument Conceptions lorsque.(Dans notre exemple, la variable X) est égale à au moins une de ces expressions, le corps de cette condition est effectué, c'est-à-dire l'expression ou le bloc spécifié à la droite du signe "\u003d\u003e". Les conditions sont vérifiées séquentiellement, vers le bas. Si aucune des conditions n'est exécutée, le code spécifié après le mot aUTRE.. contrairement à changer, utilisant lorsque.les conditions ne sont pas des étiquettes, il n'est donc pas nécessaire de terminer la condition corporelle dans un mot se rompre.
En plus de la simple comparaison sur l'égalité, lorsque.vous permet de vérifier l'argument pour appartenir à une collection à l'aide de l'opération dANS.:
lorsque.(X) ( dANS.ensemble \u003d\u003e Imprimer ("En jeu") dANS.1..10 \u003d\u003e Imprimer ("1..10") aUTRE.\u003d\u003e Imprimer ("Branche par défaut"))Après le mot-clé dANS.l'expression qui a tout type prenant en charge la méthode contient () est indiquée. En particulier, une collection peut être indiquée (comme dans la première condition de cet exemple) ou écart (comme dans la seconde). Les lacunes peuvent être formées à la fois en tant qu'oquet et de nombres fractionnaires, et les valeurs extrêmes (dans cet exemple 1 et 10) sont incluses.
Un autre type de conditions est marqué par un mot clé est et vous permet de vérifier le type d'argument. Par exemple, la vérification de laquelle des multiples types comprend la valeur x, comme suit:
lorsque.(X) ( eST.String \u003d\u003e println ("string") eST.Int \u003d\u003e println ("int") eST.Array \u003d\u003e println ("tableau double"))Type de type
Zéro liens.Le système de type de langue KOTLIN vous permet de garantir l'absence de certaines erreurs dans les programmes, telles que la référence nulle. Les types de kotlin sont divisés en contenant nULet ne contenant pas nUL. Types contenant nUL, annotant un point d'interrogation:
amusant.isempty (S: String?): Boolean (...)Signe de la question après le nom de type (String) signifie que le lien S indique la classe de la chaîne de classe ou des choses nUL . Le résultat de la fonction ISPTY, à son tour, doit être une valeur booléenne et ne peut pas importer nULPuisque le type approprié n'est pas projeté par le point d'interrogation.
revenir.s.Length () \u003d\u003d 0 // Erreur: Plage Zero LinkIl est nécessaire de vérifier clairement s'il fait référence à l'objet existant:
JE. f (s! \u003d nUL) { revenir.s.Length () \u003d\u003d 0 // S Références exactement à un objet existant) aUTRE.{ retourne vrai.} revenir.(S \u003d\u003d nUL) | S.Length () \u003d\u003d 0 // Opérateur || Fournit une vérification
Souvent, il y a de longues chaînes d'appels, chacun peut retourner nUL. En conséquence, nous obtenons plusieurs conditions imbriquées qui sont vérifiées, qui ont renvoyé chacun des appels de la chaîne. Pour éviter le code de colmatage, l'opérateur est pris en charge à Kotlin. défi en toute sécuritéindiquant "?":
A? .Getb ()? Getc ()? Getd ()
Si A n'est pas égal nUL, expression a? .getb () renvoie a.getb () et autrement - nUL.
Type de type automatique.Nous avons donné un exemple de la manière dont le compilateur prend en compte les informations contenues dans les conditions et vous permet de conserver des liens déjà éprouvés. Un mécanisme similaire insère automatiquement l'opération. apporter de typeSi plus tôt la condition correspondante a été vérifiée dans le programme. Type Operateur de vérification (analogique exemple de.en Java) à Kotlin appelé eST.:
val.x: objet \u003d ... si(X est la chaîne) (Imprimer (X.Length Longueur ()))Dans cet exemple, la référence X est vérifiée pour appartenir au type de chaîne et si la vérification est passée avec succès, la longueur de la chaîne est affichée. Lorsque vous appelez la fonction de longueur (), le compilateur insère automatiquement le dépôt X au type de chaîne, car il est sûr dans ce lieu du programme.
Type automatique Fixation fonctionne pour toutes les structures conditionnelles: si, lorsque., pendant que, ||, &&, etc.
Fonctions des ordres supérieurs
Les utilisateurs de langages de programmation fonctionnelle sont familiers avec fonctions des ordres supérieurs: Un mécanisme qui vous permet de transmettre des fonctions comme un argument à d'autres fonctions, enregistrez des fonctions dans des variables, etc. Comme déjà mentionné, ce mécanisme facilite la création de bibliothèques. Dans les langues orientées objet, les fonctions d'ordre supérieur sont généralement Émulé En utilisant le modèle de stratégie. Par exemple, afin de mettre en œuvre un filtrage pour des collections d'un type arbitraire, il est nécessaire de paramétrer l'objet filtre de fonction (), qui "sait" pour répondre à la question de savoir s'il faut inclure cet élément à la collection résultante. Cet objet est stratégie de filtration. Dans la langue fonctionnelle, vous n'avez pas besoin de créer une stratégie - vous pouvez simplement transmettre la fonction.
En tant que langue orientée objet, Kotlin soutient néanmoins des fonctions supérieures. Cela signifie principalement que la fonction de Kotlin peut être sensavoir le type approprié:
val.prédicat: amusant.(X: int): booléen \u003d ...Dans cet exemple, la variable de prédicat a type fonctionnel « amusant.(X: INT): Boolean, "c'est-à-dire que la valeur stockée par elle est une fonction qui accepte un paramètre entier et renvoyant une valeur booléenne. En particulier, nous pouvons causer cette fonctionnalité:
val.yesNoro \u003d prédicat (1)Cette fonction peut être utilisée, par exemple, lors du filtrage d'un ensemble d'entiers:
amusant.Collection .intFilter (prédicat: amusant.(X: int): booléen): collection (...)Et pour les collections arbitraires, vous pouvez le généraliser en utilisant des paramètres typiques (génériques):
amusant. Collection .Filter (prédicat: amusant.(X: t): booléen): collection ( val.résultat \u003d ArrayList () pour(X. dans ce) Si (prédicat (x)) résultat.Ajouter (x) revenir.rÉSULTAT)(Voici seulement la mise en œuvre naïve de la fonction filtrante (). Une mise en œuvre plus réaliste nécessite des calculs paresseux, mais ce sujet dépasse cet article.)
La chose la plus intéressante est de savoir comment définir la valeur d'un argument ayant un type fonctionnel. Pour cela, les déjà mentionnés littéraux fonctionnels:
INTS.FILTER ((x \u003d\u003e x% 2 \u003d\u003d 0))
Dans cet exemple, l'argument du filtre de fonction externe () est un littéral fonctionnel, c'est-à-dire une courte fonction de la publicité. Il est définitivement dans des supports bouclés, au caractère "\u003d\u003e" Suivez les déclarations de paramètres et, après le corps de la fonction, et la déclaration de retour n'est pas requise, car le résultat est considéré. dernière expression Dans le corps littéral. Ainsi, la collection INS sera sélectionnée seulement des nombres voireÉtant donné que notre littéral revient vrai, seulement si le résidu de diviser x par 2 est égal à zéro.
Dans l'exemple ci-dessus, le type de paramètre littéral fonctionnel n'est pas spécifié, car le compilateur le conduit automatiquement à partir du contexte. Si nécessaire, les types peuvent être spécifiés, mais dans la plupart des cas, un tel enregistrement court est possible et vous permet de rendre le code beaucoup plus lisible.
Pour une facilité d'utilisation des littéraux littéraux fonctionnels, les conventions de syntaxe suivantes sont adoptées à Kotlin. Premièrement, si le littéral fonctionnel comporte exactement un paramètre, ce paramètre ne peut pas être annoncé, ce qui reçoit automatiquement le nom (et son type est dérivé du contexte):
INTS.FILTER (((IT% 2 \u003d\u003d 0)) // L'appel est similaire à l'exemple précédent
Deuxièmement, si le dernier argument lorsque vous appelez une fonction est un littéral fonctionnel, il peut être transmis en dehors des supports ronds et s'il n'y a pas d'autres arguments, les parenthèses elles-mêmes peuvent être omises:
INTS.FILTER (IT% 2 \u003d\u003d 0) // L'appel est similaire à deux exemples précédents
Une telle syntaxe vous permet d'enregistrer la conversion de collections dans un style ressemblant à LINQ:
INTS.Sélectionnez (IT * IT). Où (c'est% 2 \u003d\u003d 0) // parmi les carrés des éléments de la collection // sélectionne même
(Ici la fonction où () fait la même chose que la fonction filtrante ().)
En outre, cette convention fait des difficultés plus similaires à des conceptions de contrôle familières. Nous donnons un autre exemple. La fonction synchronisée () reçoit deux paramètres: objet de synchronisation (moniteur) et fonction. Au cours de l'exécution, le moniteur est d'abord capturé, puis dans le bloc essayer..finalement.une fonction est effectuée, puis le moniteur est libéré:
amusant.synchronisé (L: verrouillage, corps: amusant.(): T): t (l.lock () essayer.{ revenir.corps ()) pour terminer.(l.unlock ()))Afin de déclencher un fragment d'un code avec la synchronisation à l'aide de cette fonction, il suffit d'écrire:
Synchronisé (myLock) (// code que vous devez effectuer)
Cet exemple montre comment dans Kotlin, vous pouvez exprimer la langue à la langue, ce qui, à Java, est intégré.
Langues orientées objet
Dans les bibliothèques mentionnées sur l'introduction, travaillent avec qui rappelle à l'utilisation de langues orientées sur le sujet, c'est-à-dire des langues "petites", comme si elle est intégrée à Kotlin. Un exemple est la bibliothèque pour décrire modules, c'est-à-dire les unités de compilation utilisées dans notre langue. Le module est décrit scénario de montage - programme sur Kotlin, provoquant la fonction de la bibliothèque standard; Ce script est effectué pendant la compilation. Considérons un exemple du scénario d'assemblage:
val.homeDir \u003d "..." Module ("Org.jetbrains.test") (// Annonce du module dépend (Mavenrepo (" [Email protégé]")) // Dépendance de ImportaNamespace (" Java.lang ") // Importation par défaut ImportsNamespace (" Org.junit ") // Importation par défaut Sourceroot (" $ HomeDir / src ") // voie suivante des fichiers source Testsourceroot (" $ HomeDir / tests ") // voie de tests)Malgré le fait que nous ayons un programme ordinaire sur Kotlin, cela ressemble à un programme sur une langue spécialisée destinée à une description déclarative des modules. Une telle approche de la description des structures de données est très populaire dans Groovy et d'autres langues dynamiques, car elle évite les descripteurs lisibles volumineux et difficiles écrits sur XML. À Groovy, cette approche est connue comme des constructeurs. L'exemple brillant de son utilisation est la bibliothèque des grades.
Comparé aux langages dynamiques groovy et autres, une distinction importante de la DSL interne de Kotlin est qu'avec la même crime de syntaxe, système de type garantie statiquement des garanties Cidence du programme.
Considérez le principe de la mise en œuvre des constructeurs typés de manière statique à Kotlin. À ces fins, un petit fragment de la langue des scénarios d'assemblage est suffisant: des descriptions de dépendances entre modules dans le cas le plus simple. Donc, les modules eux-mêmes sont décrits par les classes suivantes:
// module abstrait classe abstraite. Module (Nom: String) ( val.dépendances: Liste \u003d ArrayList ()) // Module composé de classes écrites sur Kotlin classerKotlinModule (Nom: String): Module (Nom) ( amusant.dépendance (module: module) (dépendances.add (module)) // Module basé sur le référentiel Maven classerMavenrepo (Nom: String): Module (nom) (...)
Nous définissons la fonction Module () Création d'un nouveau module:
amusant.module (Nom: String, Init: amusant.KotlinModule. (): Unité): Kotlinmodule ( val.résultat \u003d kotlinmodule (nom) Résultat.Init () revenir.rÉSULTAT)Cette fonction est une fonction d'ordre supérieur, car le paramètre init lui-même est une fonction, et extérieur Fonction: Ceci est dit par le type de kotlinmodule, spécifié devant la liste (vide) des paramètres du type fonctionnel. Cela signifie que la fonction Module () peut être appelée comme suit:
Module ("org.jetbrains.test") (// la fonction corporelle init)
Cela ressemble à un exemple de script que nous avons déjà vu. Notez qu'un paramètre implicite est disponible à l'intérieur du littéral fonctionnel cETTEtapez KotlinModule (puisque ce littéral est la "fonction externe" de type), et nous pouvons l'utiliser:
Module ("org.jetbrains.test") ( cETTE.Dépendance (Mavenrepo (" [Email protégé]")) cETTE.Dépendance (autreModule) // ...)
Il reste à noter que cETTEComme d'habitude, vous pouvez omettre et nous obtenons exactement la même syntaxe que dans l'exemple du script affiché dans le début de cette section:
Module ("Org.JetBrains.test") (dépendance (Mavenrepo (" [Email protégé]")) Dépendance (autreModule) // ...)
De même, de nombreuses langues déclaratives peuvent être mises en œuvre, y compris les langages de balisage, tels que HTML. Dans le même temps, au lieu de balises, des appels à des fonctions supérieures d'ordre seront utilisés et l'exactitude de l'utilisation de telles balises, ainsi que leurs attributs, seront garanties par le système de type:
HTML (tête (Titre (+ "codage XML avec kotlin")) Corps (H1 (+ "xml coding avec kotlin") P (+ "Ceci est témoin. Pour plus, voir le" A (href \u003d "http: // jetbrains .com / kotlin ") (+" page d'accueil de kotlin ")))
Nous avons examiné plusieurs des caractéristiques les plus intéressantes de la langue de Kotlin, mais les cadres de la langue en tant que types généralisés sont laissés au-delà des cadres (fonction intégrée), le type de types lors de l'exécution (type de réifié), le support de la délégation, les opérateurs redéfinis, etc. Ces opportunités, ainsi que la progression du projet, peuvent être trouvées sur la page du projet.
La langue est en cours de développement et, bien que la spécification ne soit pas enregistrée, nous nous efforçons de prendre en compte les opinions de nos futurs utilisateurs.
Littérature
- Bloch J. efficace Java. DEUXIÈME ÉDITION. - Prentice Hall, 2008.
- Gamma E., Helm R., Johnson R., Wlissides J. Prendre la conception orientée objet. Modèles de conception. - SPB.: Peter, 2007.
- Troelsen E. Langue de programmation C # 2008 et plate-forme. NET 3.5. - M.: Williams, 2010.
Sauf en cas de compilation distincte incohérente. - Environ. auteur.
Vous permet également de mener comparaison avec échantillon (Correspondance de motif) - env. auteur.
Andrey Breslav. ([Email protégé]) - Développeur de Kotlin, Jetbrains.
