URL: https://linuxfr.org/news/ruby-2-0-est-sorti Title: Ruby 2.0 est sorti Authors: reno _jordan_, YLD, Marc Quinton, baud123, Nicolas Blanco, barmic, Nÿco et Katyucha Date: 2013年02月27日T19:44:02+01:00 License: CC By-SA Tags: ruby Score: 33 Pour fêter ses 20 ans, Ruby arrive en version 2.0 ! Malgré ce changement de version majeur, il y a moins de différences entre Ruby 2.0 et 1.9 qu'entre Ruby 1.9 et 1.8. La compatibilité avec les logiciels 1.9 est quasiment assurée. Cerise sur le gâteau : cette nouvelle version est considérée comme stable et on y trouve un certain nombre de nouveautés et d'optimisations. Pour rappel : Ruby est un langage de programmation orienté objets, à typage dynamique et qui s'est inspiré de Lisp, Perl, Smalltalk, Eiffel, etc. Sa principale caractéristique est de mettre en avant les besoins humains avant ceux informatiques, et notamment le fun et la productivité. ### ### ### ### NdM : merci à reno pour son journal et \_jordan\_ pour ses compléments pour approfondir, ainsi qu'à YLD, Marc Quinton, Nicolas Blanco, Barret Michel, Nÿco, Katyucha pour leur participation. ---- [Journal à l'origine de la dépêche](http://linuxfr.org/users/reno/journaux/ruby-2-0-est-sorti) [journal de sortie ruby 1.9.2](http://linuxfr.org/news/sortie-de-ruby-192) [nouveautés de ruby 2 par l'exemple](http://blog.marc-andre.ca/2013/02/23/ruby-2-by-example/) [Annonce officielle](http://www.ruby-lang.org/fr/news/2013/02/25/sortie-de-ruby-2-0-0-p0/) [What's new in ruby 2.0](https://speakerdeck.com/shyouhei/whats-new-in-ruby-2-dot-0) ---- # Changements du langage # ## Paramètres par mot-clé ## Le langage gère maintenant directement le passage de paramètres par mots clefs : c'était déjà possible avant, mais en utilisant un moyen détourné (via un Hash en paramètre). Ci dessous un exemple de définition de méthode avec une valeur par défaut pour un argument "nommé". ```ruby # Ruby 1.9 et précédents def render(source, opts = {}) opts = {fmt: 'html'}.merge(opts) r = Renderer.for(opts[:fmt]) r.render(source) end ``` ```ruby # Ruby 2 def render(source, fmt: 'html') r = Renderer.for(fmt) r.render(source) end ``` A noter que le passage de paramètres par mots clefs utilise la syntaxe de Ruby 1.9 pour définir les Hash. ```ruby # Ruby 1.8 my_hash = { :key1 => 1, :key2 => 3 } ``` ```ruby # Ruby 1.9 my_hash = { key1: 1, key2: 3 } ``` ## UTF8 ## Ruby 1.9 ayant introduit la prise en charge complète de l'UTF-8 au niveau des chaînes, Ruby 2.0 traite désormais les fichiers de code source dans cet encodage (ce qui peut poser des problèmes de compatibilité). ## Débogage ## DTrace et SystemTap sont maintenant pris en charge pour instrumenter l'exécution des scripts. ## Variables non utilisées ## Les variables commençant par `_` peuvent désormais être inutilisées dans vos sources sans causer de warning. C'est l'option `-w` qui permet d'activer cette fonction. ```ruby # Ruby 1.9 def foo _, world = 'hello, world'.split(', ') world end # => pas d'avertissement # Ruby 2.0 def hi _hello, world = 'hello, world'.split(', ') world end # => pas d'avertissement non plus. ``` ## Création de hash ## `to_Hash` permet de convertir une classe en hash. Cette méthode a été implémentée pour `nil`, `Struct` et `OpenStruct` ```ruby # Ruby 2.0: Car = Struct.new(:make, :model, :year) do def build #... end end car = Car.new('Toyota', 'Prius', 2014) car.to_h # => {:make=>"Toyota", :model=>"Prius", :year=>2014} nil.to_h # => {} ``` Attention, cela n'a pas été implémenté pour les classes `Enumerable`/`Array` ```ruby {hello: 'world'}.map{|k, v| [k.to_s, v.upcase]} .to_h # => NoMethodError: # undefined method `to_h' for [["hello", "WORLD"]]:Array ``` ## Chemin du dossier courant ## `__dir__` retourne le chemin absolu du dossier du fichier en cours d'exécution. ## Création de tableaux de symboles ## %i et %I ont été ajoutés pour la création de tableaux de symboles avec une syntaxe minimale. ```ruby # Ruby 1.9: KEYS = [:foo, :bar, :baz] # Ruby 2.0: KEYS = %i[foo bar baz] ``` de la même manière que %w et %W servaient à la création simplifiée de listes de chaîne de caractères : ```ruby KEYS = %w[foo bar baz] KEYS = ["foo", "bar", "baz"] ``` ## Inclusion par précédence ## Lorsqu'un module est inclus dans un autre, il se retrouve automatiquement ajouté après la définition de celui qui l'inclut. Cela oblige à pas mal de gymnastique lorsque l'on veut "wrapper" des méthodes du conteneur. ```ruby class Template def initialize(erb) @erb = erb end def render values ERB.new(@erb).result(binding) end end module RenderProfiler def self.included base base.send :alias_method, :render_without_profiling, :render base.send :alias_method, :render, :render_with_profiling end def render_with_profiling values start = Time.now render_without_profiling(values).tap { $stderr.puts "Rendered in #{Time.now - start}s." } end end class Template include RenderProfiler end Template.ancestors #=> [Template, RenderProfiler, Object, Kernel, BasicObject] ``` Désormais il est possible d'inclure un module avant la défintion de son conteneur: ```ruby module RenderProfiler def render values start = Time.now super(values).tap { $stderr.puts "Rendered in #{Time.now - start}s." } end end class Template prepend RenderProfiler end Template.ancestors #=> [RenderProfiler, Template, Object, Kernel, BasicObject] ``` Exemples ci-dessus issus du [blog de Ben Hoskings](http://benhoskin.gs/2013/02/24/ruby-2-0-by-example?utm_source=rubyweekly&utm_medium=email) ## Onigmo : nouveau moteur d'expression régulière ## [Onigmo](https://github.com/k-takata/Onigmo) remplace Oniguruma comme moteur d'expressions régulières (c'est un fork). Il permet d'utiliser certaines fonctionnalités présentes dans [perl](http://perldoc.perl.org/perlre.html) depuis la version 5.10. Notamment l'expression conditionnelle `(?(condition)yes-pattern|no-pattern)` qui vaut `yes-pattern` si la condition est vérifiée, `no-pattern` sinon. ## Refinements ## Les versions précédentes de Ruby permettent déjà de redéfinir des méthodes ou d'étendre des classes existantes. Le défaut principal de cette fonction très puissante est que les modifications de classes existantes se retrouvent dans tout un projet ainsi que les librairies utilisées. Les refinements, introduits dans Ruby 2.0 en fonctionnalité expérimentale, permettent d'effectuer ces modifications de manière "cloisonnée". Magnus Holm en a donné un bon exemple dans un [article à ce sujet](http://timelessrepo.com/refinements-in-ruby) (en anglais) ```ruby module TimeExtensions refine Fixnum do def minutes; self * 60; end end end class MyApp using TimeExtensions def initialize p 2.minutes end end MyApp.new # => 120 p 2.minutes # => NoMethodError ``` Dans cet exemple, plutôt que d'ajouter la méthode `minutes` dans la classe `Fixnum`, il l'a ajouté en tant que «raffinement» dans le module `TimeExtensions`. L'intérêt est que la méthode minutes n'existe que dans le bloc contenant `using TimeExtensions` ## Lazy Enumerator et Enumerable## Enumerators et Enumerables sont maintenant disponibles en version lazy (optimisation visant à retarder une opération jusqu'au moment où son résultat est nécessaire, ou bien au moment où des ressources sont inoccupées ) : Enumerable#lazy et Enumerator::Lazy permettent de gérer des suites potentiellement infinies (lazy streams) A cela s'ajoutent Enumerator#size et Range#size pour déterminer la taille par évaluation retardée (lazy evaluation) ## API de gestion asynchrone des exceptions ## Une nouvelle API de gestion asynchrone des exceptions fait son apparition dans cette version 2.0. # Optimisations des performances # ## Ramasse-miette ## Le ramasse-miettes a été optimisé par la technique du "bitmap marking". Il devrait radicalement réduire la mémoire occupée par les programmes ruby tournant sur serveur web. [Narihiro Nakamura](www.narihiro.info/index.en.html) (en anglais) y travaillait depuis 2008. L'idée principale est de profiter de la non-duplication de structures égales lors des forks (voir [Copy-On-Write](http://fr.wikipedia.org/wiki/Copy-On-Write "Définition Wikipédia")). En ruby, les valeurs sont divisées en deux parties : les données (RArray, RHash, RFile ...) et un ensemble de flags. On appelle ces valeurs des RValue (Ruby Value). Les ensembles de flags sont souvent identiques d'une RValue à une autre. Le système ne devrait donc pas avoir à les dupliquer. Seulement, l'un des flags `FL_MARK`, est régulièrement modifié par le garbage collector pour indiquer les RValue recyclables. Comme celui-ci change très souvent de valeur, l'ensemble de flags varie, obligeant le système à dupliquer tout l'ensemble. Narihiro Nakamura a donc sorti FL_MARK de la structure en regroupant tous les FL_MARK dans une collection de bit mappés à la RValue (d'où le "bitmap marking"). Ainsi Ruby peut régulièrement modifier FL_MARK sans toucher à l'ensemble de flags de la RValue. Dès lors, le système n'a pas besoin de dupliquer les ensembles de _flags_ lorsqu'ils sont parfaitement égaux pour deux RValue différentes. Vous l'aurez peut-être compris, ceci est valable lors des appels de _fork_ qui, dans les systèmes UNIX, ne dupliquent pas la mémoire tant qu'elle est identique aux deux processus. Pour plus d'informations à ce sujet, je vous invite à lire cet [article](http://patshaughnessy.net/2012/3/23/why-you-should-be-excited-about-garbage-collection-in-ruby-2-0) très intéressant (en anglais). ### ### ### ### ## Autres ## D'autres optimisations ont été faites pour améliorer la vitesse de démarrage notamment sur ``Kernel#require``, les calculs sur des nombres à virgule flottante et sur la machine virtuelle. Cela profite déjà grandement au framework web [Ruby on Rails](http://fr.wikipedia.org/wiki/Ruby on Rails "Définition Wikipédia"). # Documentation # D'après le site [ruby-lang.org](http://www.ruby-lang.org/fr) : « Un effort important à également été produit pour améliorer la documentation, ce qui a été une demande régulière de la part de la communauté. Le volume de documentation rdoc pour les modules et les méthodes a ainsi notablement augmenté : 75% de la 2.0.0 est couvert, tandis que la 1.9.3 plafonnait vers les 60%. Par ailleurs, vous pouvez retrouver une description de la syntaxe ruby en appelant : » ```sh $ ri ruby:syntax ``` L'ouvrage de référence sur Ruby (le ["pickaxe"](http://pragprog.com/book/ruby4/programming-ruby-1-9-2-0?utm_source=rubyweekly&utm_medium=email)) sort, lui, dans une nouvelle édition qui couvre désormais Ruby 2.0. #Autres mises à jour notables# La [version 2.0.0 de RubyGems et la version 1.3 de Bundler](http://rubyweekly.us1.list-manage.com/track/click?u=0618f6a79d6bb9675f313ceb2&id=a8b6aae57a&e=09fa53f0f6) accompagnent la sortie de Ruby 2.0, elles ajoutent la gestion de cette dernière, tout en restant compatible avec les 1.9.x. De même, l'équipe de _Ruby on Rails_ sort une [version 3.2.13-rc1](http://weblog.rubyonrails.org/2013/2/27/Rails-3-2-13-rc1-has-been-released/?utm_source=rubyweekly&utm_medium=email) compatible Ruby 2.0 ainsi qu'une [version 4 en bêta](http://rubyweekly.us1.list-manage.com/track/click?u=0618f6a79d6bb9675f313ceb2&id=7228c96e3d&e=09fa53f0f6) pour qui Ruby 2 sera l'environnement de prédilection.

AltStyle によって変換されたページ (->オリジナル) /