Wir freuen uns, die Veröffentlichung von Ruby 2.7.0 bekannt geben zu können. Sie enthält eine Anzahl neuer Funktionalitäten und Performanzverbesserungen, namentlich: * Musterabgleiche * Verbesserungen der interaktiven Kommandozeile _(REPL)_ * Defragmentierung für den GC _(Campaction GC)_ * Trennung der Positions- und der Schlüsselwortargumente ## Musterabgleiche [Experimentell] Musterabgleiche sind eine häufig genutzte Funktion funktionaler Programmiersprachen. Mit 2.7.0 werden sie als experimentell in die Programmiersprache Ruby eingeführt. [#14912](https://bugs.ruby-lang.org/issues/14912) Ein Musterabgleich untersucht das übergebene Objekt und weist seinen Wert dann zu, wenn er auf ein bestimmtes Muster passt. ```ruby require "json" json = < 2 end ``` Weitere Details können Sie der Präsentation [Musterabgleiche - Neue Funktion in Ruby 2.7](https://speakerdeck.com/k_tsj/pattern-matching-new-feature-in-ruby-2-dot-7) entnehmen. ## Verbesserung der interaktiven Kommandozeile Die mitgelieferte interaktive Kommandozeile `irb` _(REPL: Read-Eval-Print-Loop)_ wird mehrzeiliges Editieren unterstützen. Dies wird mithilfe von `reline`, einer `readline`-kompatiblen nur mit Ruby implementierten Bibliothek, umgesetzt. Darüber hinaus wird `irb` besser mit RDoc integriert: es wird möglich, die Referenzdokumentation für eine bestimmte Klasse, ein bestimmtes Modul oder auch eine bestimmte Methode nachzuschlagen. [[Feature #14683]](https://bugs.ruby-lang.org/issues/14683), [[Feature #14787]](https://bugs.ruby-lang.org/issues/14787), [[Feature #14918]](https://bugs.ruby-lang.org/issues/14918) Schließlich werden von `Binding.irb` angezeigte Quellcode-Zeilen und Ergebnisse von `inspect` farblich hevorgehoben werden. ## Defragmentierender GC Die neue Version wird einen defragmentierenden GC _(Compaction GC)_ einführen, der fragmentierten Arbeitsspeicherplatz defragmentieren kann. Einige Ruby-Programme, die mit mehreren Threads arbeiten, leiden derzeit unter Speicherfragmentierung. Dies verursacht einen hohen Speicherverbrauch und eine reduzierte Ausführungsgeschwindigkeit. Zur Behebung des Problems wird die neue Methode `GC.compact` eingeführt. Sie defragmentiert den Freispeicher _(Heap)_, indem sie noch aktive Objekte näher zusammenrückt, sodass weniger Speicherseiten benötigt werden und der Freispeicher insgesamt besser für Copy-on-Write (CoW) geeignet ist. [#15626](https://bugs.ruby-lang.org/issues/15626) ## Trennung von Positions- und Schlüsselwortargumenten Die automatische Konvertierung zwischen Schlüsselwort- und Positionsargumenten gilt nun als veraltet und wird mit Ruby 3 entfernt werden. [[Feature #14183]](https://bugs.ruby-lang.org/issues/14183) Siehe den Artikel "[Trennung von Positions- und Schlüsselwortargumenten in Ruby 3.0](https://www.ruby-lang.org/de/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/)" für Details. Die Änderungen stellen sich wie folgt dar: * Wenn bei einem Methodenaufruf ein Hash als letztes Argument übergeben wird, wenn sonstige Argumente fehlen und wenn die aufgerufene Methode Schlüsselwortargumente annimmt, dann gibt Ruby eine Warnung aus. Um das Hash weiterhin als Schlüsselwortargument zu verwenden, ist es notwendig, den doppelten Auflösungsoperator _(double splat operator)_ zu benutzen. Nur so kann die Warnung vermieden und das korrekte Verhalten in Ruby 3 sichergestellt werden. ```ruby def foo(key: 42); end; foo({key: 42}) # Warnung def foo(**kw); end; foo({key: 42}) # Warnung def foo(key: 42); end; foo(**{key: 42}) # OK def foo(**kw); end; foo(**{key: 42}) # OK ``` * Wenn bei einem Methodenaufruf Schlüsselwortargumente an eine Methode, die auch Schlüsselwortargumente akzeptiert, übergeben werden, jedoch nicht genügend Schlüsselwortargumente bereitgestellt werden, dann werden die übergebenen Schlüsselwortargumente als finales erforderliches Positionsargument gewertet und eine Warnung wird ausgegeben. Übergeben Sie das Argument als Hash statt als Schlüsselwortargumentliste, um die Warnung zu vermeiden und korrektes Verhalten in Ruby 3 sicherzustellen. ```ruby def foo(h, **kw); end; foo(key: 42) # Warnung def foo(h, key: 42); end; foo(key: 42) # Warnung def foo(h, **kw); end; foo({key: 42}) # OK def foo(h, key: 42); end; foo({key: 42}) # OK ``` * Wenn eine Methode bestimmte Schlüsselwortargumente, nicht aber den doppelten Auflösungsoperator verwendet, und ein Hash oder eine Schlüsselwortargumenteliste mit einer Mischung aus Strings und Symbolen übergeben wird, dann wird das Hash weiterhin aufgespalten. Zudem wird eine Warnung ausgegeben. Sie müssen für das korrekte Verhalten in Ruby 3 den aufrufenden Code so ändern, dass zwei einzelne Hashes übergeben werden. ```ruby def foo(h={}, key: 42); end; foo("key" => 43, key: 42) # Warnung def foo(h={}, key: 42); end; foo({"key" => 43, key: 42}) # Warnung def foo(h={}, key: 42); end; foo({"key" => 43}, key: 42) # OK ``` * Wenn eine Methode keine Schlüsselwortargumente akzeptiert, aber mit solchen aufgerufen wird, werden solche Schlüsselwortargumente weiterhin ohne Warnung als Hash für ein Positionsargument interpretiert. Dieses Verhalten wird auch in Ruby 3 weiterhin beibehalten. ```ruby def foo(opt={}); end; foo( key: 42 ) # OK ``` * Schlüsselwortargumente mit anderen Schlüsseln als Symbolen sind zulässig, wenn die Methode beliebige Schlüsselwortargumente akzeptiert. [[Feature #14183]](https://bugs.ruby-lang.org/issues/14183) ```ruby def foo(**kw); p kw; end; foo("str" => 1) #=> {"str"=>1} ``` * `**nil` kann genutzt werden, um in einer Methodendefinition ausdrücklich festzulegen, dass die Methode keine Schlüsselwörter akzeptiert. Der Aufruf einer solchen Methode mit Schlüsselwortargumenten erzeugt einen ArgumentError. [[Feature #14183]](https://bugs.ruby-lang.org/issues/14183) ```ruby def foo(h, **nil); end; foo(key: 1) # ArgumentError def foo(h, **nil); end; foo(**{key: 1}) # ArgumentError def foo(h, **nil); end; foo("str" => 1) # ArgumentError def foo(h, **nil); end; foo({key: 1}) # OK def foo(h, **nil); end; foo({"str" => 1}) # OK ``` * Die Übergabe einess leeren doppelten Auflösungsoperators an eine Methode, die keine Schlüsselwortargumente akzeptiert, führt nicht länger zur impliziten Übergabe eines leeren Hashes, es sei denn, das Hash ist wegen eines erforderlichen Parameters notwendig. In diesem Fall wird eine Warnung ausgegeben. Entfernen Sie den doppelten Auflösungsoperator, um ein Hash als Positionsargument zu übergeben. [[Feature #14183]](https://bugs.ruby-lang.org/issues/14183) ```ruby h = {}; def foo(*a) a end; foo(**h) # [] h = {}; def foo(a) a end; foo(**h) # {} und Warnung h = {}; def foo(*a) a end; foo(h) # [{}] h = {}; def foo(a) a end; foo(h) # {} ``` Wenn Sie die Veraltungswarnungen unterdrücken wollen, verwenden Sie bitte den Kommandozeilenschalter `-W:no-deprecated` oder fügen Ihrem Code den Befehl `Warning[:deprecated] = false` hinzu. ## Sonstige bemerkenswerte neue Funktionen * Blockparameter werden für abgekürzten Zugriff automatisch nummeriert. [#4475](https://bugs.ruby-lang.org/issues/4475) * Es werden anfangslose Range-Objekte eingeführt. Diese sind vielleicht nicht so nützlich wie endlose Range-Objekte, könnten aber für domänenspezifische Sprachen praktisch sein. [#14799](https://bugs.ruby-lang.org/issues/14799) ```ruby ary[..3] # identical to ary[0..3] rel.where(sales: ..100) ``` * `Enumerable#tally` wird hinzugefügt. Die Methode zählt das Vorkommen jedes Elements. ```ruby ["a", "b", "c", "b"].tally #=> {"a"=>1, "b"=>2, "c"=>1} ``` * Es ist jetzt zulässig, eine private Methode auf dem Schlüsselwort `self` aufzurufen. [[Feature #11297]](https://bugs.ruby-lang.org/issues/11297) [[Feature #16123]](https://bugs.ruby-lang.org/issues/16123) ```ruby def foo end private :foo self.foo ``` * `Enumerator::Lazy#eager` wird hinzugefügt. Diese Methode generiert einen nicht verzögertern Enumerator (_non-lazy enumerator_) aus einem verzögerten Enumerator (_lazy enumerator_). [[Feature #15901]](https://bugs.ruby-lang.org/issues/15901) ```ruby a = %w(foo bar baz) e = a.lazy.map {|x| x.upcase }.map {|x| x + "!" }.eager p e.class #=> Enumerator p e.map {|x| x + "?" } #=> ["FOO!?", "BAR!?", "BAZ!?"] ``` ## Performanzverbesserungen * JIT [Experimentell] * JIT-kompilierter Code wird neu zu weniger optimiertem Code kompiliert, wenn eine Optimierungsannahme sich als falsch herausstellt. * Method-Inlining wird durchgeführt, wenn eine Methode als rein _(pure)_ gilt. Diese Optimierung ist noch experimentell und zahlreiche Methoden gelten noch nicht als rein. * Der Standardwert von `--jit-min-calls` wird von 5 auf 10.000 geändert. * Der Standardwert von `--jit-max-cache` wird von 1.000 auf 100 geändert. * Die Cache-Strategie von Fiber wurde verändert und die Erstellung von Fibers beschleunigt. [GH-2224](https://github.com/ruby/ruby/pull/2224) * `Module#name`, `true.to_s`, `false.to_s`, und `nil.to_s` geben jetzt immer einen eingefrorenen String zurück. Der zurückgegebene String ist für das jeweilige Objekt immer derselbe. [Experimenell] [[Feature #16150]](https://bugs.ruby-lang.org/issues/16150) * Die Performanz von `CGI.escapeHTML` wurde verbessert. [GH-2226](https://github.com/ruby/ruby/pull/2226) * Die Performanz von Monitor und MonitorMixin wurde verbessert. [[Feature #16255]](https://bugs.ruby-lang.org/issues/16255) * Der aufruferspezifische Methoden-Cache, den es seit etwa 1.9 gibt, wurde verbessert: die Rückgriffsrate auf den Cache konnte von 89% auf 94% erhöht werden. Siehe [GH-2583](https://github.com/ruby/ruby/pull/2583) * Die Methode RubyVM::InstructionSequence#to_binary generiert kompilierten Binärcode. Die Größe des Binärcodes wurde reduziert. [Feature #16163] ## Sonstige bemerkenswerte Änderungen seit 2.6 * Einige Standardbibliotheken werden aktualisiert. * Bundler 2.1.2 ([Veröffentlichungshinweise](https://github.com/bundler/bundler/releases/tag/v2.1.2)) * RubyGems 3.1.2 * ([Veröffentlichungshinweise für 3.1.0](https://github.com/rubygems/rubygems/releases/tag/v3.1.0)) * ([Veröffentlichungshinweise für 3.1.1](https://github.com/rubygems/rubygems/releases/tag/v3.1.1)) * ([Veröffentlichungshinweise für 3.1.2](https://github.com/rubygems/rubygems/releases/tag/v3.1.2)) * Racc 1.4.15 * CSV 3.1.2 ([Neuigkeiten](https://github.com/ruby/csv/blob/v3.1.2/NEWS.md)) * REXML 3.2.3 ([Neuigkeiten](https://github.com/ruby/rexml/blob/v3.2.3/NEWS.md)) * RSS 0.2.8 ([Neuigkeiten](https://github.com/ruby/rss/blob/v0.2.8/NEWS.md)) * StringScanner 1.0.3 * Es werden auch einige Bibliotheken aktualisiert, die nicht über eine eigenständige Versionsnummer verfügen. * Die folgenden Programmbibliotheken sind nicht länger als mitgelieferte Gems enthalten. Installieren Sie die entsprechenden Gems, um diese Features zu verwenden. * CMath (Gem cmath) * Scanf (Gem scanf) * Shell (Gem shell) * Synchronizer (Gem sync) * ThreadsWait (Gem thwait) * E2MM (Gem e2mmap) * `profile.rb` wurde aus der Standardbibliothek entfernt. * Änderung von stdlib-Bibliotheken in Standard-Gems: * Die folgenden Standard-Gems wurden auf rubygems.org veröffentlicht: * benchmark * cgi * delegate * getoptlong * net-pop * net-smtp * open3 * pstore * singleton * Die folgenden Standard-Gems werden nur mit Rubys Kern, aber noch nicht auf rubygems.org veröffentlicht: * monitor * observer * timeout * tracer * uri * yaml * Die Nutzung von `Proc.new` und `proc` ohne Block in einer Methode, die einen Block erwartet, führt nun zu einer Warnung. * Die Nutzung von `lambda` ohne block in einer Methode, die einen Block erwartet, erzeugt einen Fehler. * Die Unicode- und Emoji-Version werden von 11.0.0 auf 12.0.0 angehoben. [[Feature #15321]](https://bugs.ruby-lang.org/issues/15321) * Die Unicode-Version wird auf 12.1.0 angehoben, um Unterstützung für U+32FF SQUARE ERA NAME REIWA zu erhalten. [[Feature #15195]](https://bugs.ruby-lang.org/issues/15195) * `Date.jisx0301`, `Date#jisx0301`, and `Date.parse` unterstützen die neue japanische Ära. [[Feature #15742]](https://bugs.ruby-lang.org/issues/15742) * Compiler müssen jetzt C99 unterstützen. [[Misc #15347]](https://bugs.ruby-lang.org/issues/15347) * Details zum genutzten Dialekt: Siehe die [NEWS](https://github.com/ruby/ruby/blob/v2_7_0/NEWS) oder die [Commit-Logs](https://github.com/ruby/ruby/compare/v2_6_0...v2_7_0) für weitere Details. Mit diesen Änderungen wurden [4190 Dateien geändert, 227498 Einfügungen(+), 99979 Löschungen(-)](https://github.com/ruby/ruby/compare/v2_6_0...v2_7_0) seit Ruby 2.6.0! Frohe Weihnachten, schöne Ferien, und viel Spaß bei der Programmierung mit Ruby 2.7! ## Download * SIZE: 14703381 SHA1: b54f4633174dbc55db77d9fd6d0ef90cc35503af SHA256: 7aa247a19622a803bdd29fdb28108de9798abe841254fe8ea82c31d125c6ab26 SHA512: 8b8dd0ceba65bdde53b7c59e6a84bc6bf634c676bfeb2ff0b3604c362c663b465397f31ff6c936441b3daabb78fb7a619be5569480c95f113dd0453488761ce7 * SIZE: 16799684 SHA1: 6f4e99b5556010cb27e236873cb8c09eb8317cd5 SHA256: 8c99aa93b5e2f1bc8437d1bbbefd27b13e7694025331f77245d0c068ef1f8cbe SHA512: 973fc29b7c19e96c5299817d00fbdd6176319468abfca61c12b5e177b0fb0d31174a5a5525985122a7a356091a709f41b332454094940362322d1f42b77c9927 * SIZE: 11990900 SHA1: 943c767cec037529b8e2d3cc14fc880cad5bad8d SHA256: 27d350a52a02b53034ca0794efe518667d558f152656c2baaf08f3d0c8b02343 SHA512: dd5690c631bf3a2b76cdc06902bcd76a89713a045e136debab9b8a81ff8c433bbb254aa09e4014ca1cf85a69ff4bcb13de11da5e40c224e7268be43ef2194af7 * SIZE: 20571744 SHA1: fbebdd3a2a641f9a81f7d8db5abd926acea27e80 SHA256: 8bf2050fa1fc76882f878fd526e4184dc54bd402e385efa80ef5fd3b810522e0 SHA512: 5060f2dd3bfd271ef255b17589d6d014260d7ec2d97b48112b717ee01c62fe125c3fe04f813e02d607cea3f0a2a812b14eb3a28d06c2551354dfeff5f4c3dd6b ## Was ist Ruby Die Programmiersprache Ruby wurde 1993 von Yukihiro „Matz“ Matsumoto erfunden und wird heute als quelloffene Software entwickelt. Sie läuft auf verschiedenen Plattformen und wird überall auf der Welt namentlich für die Webentwicklung genutzt.