Ruby 2.7.0-rc2 veröffentlicht

Gepostet von naruse am 21. Dez 2019

Wir freuen uns, die Veröffentlichung von Ruby 2.7.0-rc2 bekannt zu geben.

Ein Release Candidate wird veröffentlicht, um Feedback für die für den 25. Dezember geplante endgültige Veröffentlichung zu sammeln.

Sie führt auch eine Reihe neuer Funktionen und Leistungsverbesserungen ein, insbesondere

• Pattern Matching
• REPL-Verbesserung
• Kompaktierende GC
• Trennung von positionsbezogenen und Schlüsselwortargumenten

Pattern Matching [Experimentell]

Pattern Matching, eine weit verbreitete Funktion in funktionalen Programmiersprachen, wird als experimentelle Funktion eingeführt. [Feature #14912]

Es kann ein gegebenes Objekt durchlaufen und seinen Wert zuweisen, wenn es einem Muster entspricht.

require "json"

json = <<END
{
  "name": "Alice",
  "age": 30,
  "children": [{ "name": "Bob", "age": 2 }]
}
END

case JSON.parse(json, symbolize_names: true)
in {name: "Alice", children: [{name: "Bob", age: age}]}
  p age #=> 2
end

Weitere Details finden Sie unter Pattern Matching - Neue Funktion in Ruby 2.7.

REPL-Verbesserung

irb, die gebundene interaktive Umgebung (REPL; Read-Eval-Print-Loop), unterstützt jetzt die mehrzeilige Bearbeitung. Sie wird von reline, einer readline-kompatiblen Bibliothek, die in reinem Ruby implementiert ist, unterstützt. Sie bietet auch RDoc-Integration. In irb können Sie die Referenz für eine gegebene Klasse, ein Modul oder eine Methode anzeigen. [Feature #14683], [Feature #14787], [Feature #14918]

Außerdem sind Quellzeilen, die von Binding#irb angezeigt werden, und Inspektionsergebnisse für Kernobjekte farblich hervorgehoben.

Kompaktierende GC

Diese Version führt die komprimierende GC ein, die einen fragmentierten Speicherplatz defragmentieren kann.

Einige Multi-Thread-Ruby-Programme können Speicherfragmentierung verursachen, was zu hohem Speicherverbrauch und Leistungseinbußen führt.

Die Methode GC.compact wird zur Verdichtung des Heaps eingeführt. Diese Funktion verdichtet aktive Objekte im Heap, sodass weniger Seiten verwendet werden können und der Heap Copy-on-Write (CoW) freundlicher wird. [Feature #15626]

Trennung von positionsbezogenen und Schlüsselwortargumenten

Die automatische Konvertierung von Schlüsselwortargumenten und positionsbezogenen Argumenten wird veraltet sein und in Ruby 3 entfernt. [Feature #14183]

• Wenn ein Methodenaufruf einen Hash als letztes Argument übergibt, wenn keine Schlüsselwörter übergeben werden und die aufgerufene Methode Schlüsselwörter akzeptiert, wird eine Warnung ausgegeben. Um den Hash weiterhin als Schlüsselwörter zu behandeln, fügen Sie einen doppelten Sternchenoperator hinzu, um die Warnung zu vermeiden und das korrekte Verhalten in Ruby 3 sicherzustellen.

  def foo(key: 42); end; foo({key: 42})   # warned
  def foo(**kw);    end; foo({key: 42})   # warned
  def foo(key: 42); end; foo(**{key: 42}) # OK
  def foo(**kw);    end; foo(**{key: 42}) # OK
  

• Wenn ein Methodenaufruf Schlüsselwörter an eine Methode übergibt, die Schlüsselwörter akzeptiert, aber nicht genügend erforderliche positionsbezogene Argumente übergibt, werden die Schlüsselwörter als letztes erforderliches positionsbezogenes Argument behandelt und eine Warnung ausgegeben. Übergeben Sie das Argument als Hash anstelle von Schlüsselwörtern, um die Warnung zu vermeiden und das korrekte Verhalten in Ruby 3 sicherzustellen.

  def foo(h, **kw); end; foo(key: 42)      # warned
  def foo(h, key: 42); end; foo(key: 42)   # warned
  def foo(h, **kw); end; foo({key: 42})    # OK
  def foo(h, key: 42); end; foo({key: 42}) # OK
  

• Wenn eine Methode bestimmte Schlüsselwörter akzeptiert, aber keinen Schlüsselwort-Splat, und ein Hash oder Schlüsselwort-Splat an die Methode übergeben wird, der sowohl Symbol- als auch Nicht-Symbol-Schlüssel enthält, wird der Hash weiterhin aufgeteilt und eine Warnung ausgegeben. Sie müssen den aufrufenden Code aktualisieren, um separate Hashes zu übergeben, um das korrekte Verhalten in Ruby 3 sicherzustellen.

  def foo(h={}, key: 42); end; foo("key" => 43, key: 42)   # warned
  def foo(h={}, key: 42); end; foo({"key" => 43, key: 42}) # warned
  def foo(h={}, key: 42); end; foo({"key" => 43}, key: 42) # OK
  

• Wenn eine Methode keine Schlüsselwörter akzeptiert und mit Schlüsselwörtern aufgerufen wird, werden die Schlüsselwörter weiterhin als positionsbezogener Hash behandelt, ohne Warnung. Dieses Verhalten wird auch in Ruby 3 weiterhin funktionieren.

  def foo(opt={});  end; foo( key: 42 )   # OK
  

• Nicht-Symbole sind als Schlüssel von Schlüsselwortargumenten zulässig, wenn die Methode beliebige Schlüsselwörter akzeptiert. [Feature #14183]

  def foo(**kw); p kw; end; foo("str" => 1) #=> {"str"=>1}
  

• **nil ist in Methodendefinitionen zulässig, um explizit zu kennzeichnen, dass die Methode keine Schlüsselwörter akzeptiert. Der Aufruf einer solchen Methode mit Schlüsselwörtern führt zu einem ArgumentError. [Feature #14183]

  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 eines leeren Schlüsselwort-Splats an eine Methode, die keine Schlüsselwörter akzeptiert, übergibt keinen leeren Hash mehr, es sei denn, der leere Hash ist für einen erforderlichen Parameter notwendig. In diesem Fall wird eine Warnung ausgegeben. Entfernen Sie den doppelten Sternchenoperator, um weiterhin einen positionsbezogenen Hash zu übergeben. [Feature #14183]

  h = {}; def foo(*a) a end; foo(**h) # []
  h = {}; def foo(a) a end; foo(**h)  # {} and warning
  h = {}; def foo(*a) a end; foo(h)   # [{}]
  h = {}; def foo(a) a end; foo(h)    # {}
  

HINWEIS: Zu viele Deprecation-Warnungen bezüglich der Inkompatibilität von Schlüsselwortargumenten wurden als zu wortreich empfunden. Derzeit werden zwei mögliche Lösungen diskutiert: Deaktivierung von Deprecation-Warnungen per Standard (#16345) oder Unterdrückung duplizierter Warnungen (#16289). Die endgültige Entscheidung ist noch nicht getroffen, wird aber vor der offiziellen Veröffentlichung behoben.

Weitere bemerkenswerte neue Funktionen

• Ein Methodenreferenzoperator, .:, wurde in früheren Vorschauen als experimentelle Funktion eingeführt, aber wieder verworfen. [Feature #12125], [Feature #13581], [Feature #16275]

• Nummerierte Parameter als Standard-Blockparameter werden als experimentelle Funktion eingeführt. [Feature #4475]

• Ein beginnloses Intervall wird experimentell eingeführt. Es ist vielleicht nicht so nützlich wie ein endloses Intervall, aber gut für DSL-Zwecke. [Feature #14799]

  ary[..3]  # identical to ary[0..3]
  rel.where(sales: ..100)
  

• Enumerable#tally wird hinzugefügt. Es zählt die Häufigkeit jedes Elements.

  ["a", "b", "c", "b"].tally
  #=> {"a"=>1, "b"=>2, "c"=>1}
  

• Das Aufrufen einer privaten Methode mit einem literalen self als Empfänger ist jetzt erlaubt. [Feature #11297], [Feature #16123]

  def foo
  end
  private :foo
  self.foo
  

• Enumerator::Lazy#eager wird hinzugefügt. Es generiert einen nicht-faulen Enumerator aus einem faulen Enumerator. [Feature #15901]

  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!?"]
  

Leistungsverbesserungen

• JIT [Experimentell]

  • JIT-kompilierter Code wird zu weniger optimiertem Code neu kompiliert, wenn eine Optimierungsannahme ungültig wird.

  • Methodeninlining wird durchgeführt, wenn eine Methode als rein betrachtet wird. Diese Optimierung ist noch experimentell und viele Methoden werden noch NICHT als rein betrachtet.

  • Der Standardwert von --jit-min-calls wurde von 5 auf 10.000 geändert.

  • Der Standardwert von --jit-max-cache wurde von 1.000 auf 100 geändert.

• 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 immer derselbe für ein gegebenes Objekt. [Experimentell] [Feature #16150]

• Die Leistung von CGI.escapeHTML wurde verbessert. GH-2226

• Die Leistung von Monitor und MonitorMixin wurde verbessert. [Feature #16255]

Weitere bemerkenswerte Änderungen seit 2.6

• Einige Standardbibliotheken wurden aktualisiert.
  • Bundler 2.1.0.pre.3 (Verlauf)
  • RubyGems 3.1.0.pre.3 (Verlauf)
  • CSV 3.1.2 (NEWS)
  • Racc 1.4.15
  • REXML 3.2.3 (NEWS)
  • RSS 0.2.8 (NEWS)
  • StringScanner 1.0.3
  • Einige andere Bibliotheken, die keine Originalversion haben, wurden ebenfalls aktualisiert.
• Standardbibliotheken als Standard-Gems fördern
  • 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 wurden nur für ruby-core gefördert, aber noch nicht auf rubygems.org veröffentlicht.
    • monitor
    • observer
    • timeout
    • tracer
    • uri
    • yaml

• Proc.new und proc ohne Block in einer Methode, die mit einem Block aufgerufen wird, geben jetzt eine Warnung aus.

• lambda ohne Block in einer Methode, die mit einem Block aufgerufen wird, löst eine Ausnahme aus.

• Unicode-Version und Emoji-Version von 11.0.0 auf 12.0.0 aktualisiert. [Feature #15321]

• Unicode-Version auf 12.1.0 aktualisiert, Hinzufügen der Unterstützung für U+32FF SQUARE ERA NAME REIWA. [Feature #15195]

• Date.jisx0301, Date#jisx0301 und Date.parse unterstützen die neue japanische Ära. [Feature #15742]

• Compiler werden aufgefordert, C99 zu unterstützen. [Misc #15347]
  • Details zu unserem Dialekt: https://bugs.ruby-lang.org/projects/ruby-master/wiki/C99

Weitere Details finden Sie in NEWS oder den Commit-Logs.

Mit diesen Änderungen wurden 4184 Dateien geändert, 226864 Einfügungen(+), 99937 Löschungen(-) seit Ruby 2.6.0! Viel Spaß beim Programmieren mit Ruby 2.7!

Herunterladen

• https://cache.ruby-lang.org/pub/ruby/2.7/ruby-2.7.0-rc2.tar.bz2

  SIZE: 14686646
  SHA1: e04680f57d8b7576637eb75b8b56aceeb1806992
  SHA256: 8f94ea7ba79b6e95225fb4a7870e882081182c3d12d58c4cad2a7d2e7865cf8e
  SHA512: 9010f72bb3f33b6cd3f515531e6e05198f295bb2a8a788e3a46cdfd776a9f6176b6ba8612f07f0236a11359302d2b77fdecca1dc6be33581edbb028069397a0a
  

• https://cache.ruby-lang.org/pub/ruby/2.7/ruby-2.7.0-rc2.tar.gz

  SIZE: 16775053
  SHA1: 787a86023f0abe6ca9c0b31e95328725e8bb7814
  SHA256: b16cd92479e5648cc53425602e9dc6d76b18dd2cc180add2fd4c9f254646779d
  SHA512: d59910a140ea1b7ca7a64073dbbe4cbe8f11cd6fc68ea7874ca160e1a23549bd159f49f4d199002f9806e77d4426bff3aa81b62707d539e0710ece7b7ff83438
  

• https://cache.ruby-lang.org/pub/ruby/2.7/ruby-2.7.0-rc2.tar.xz

  SIZE: 11965624
  SHA1: 1f9f30eaf1829250931c4c465ee1c15e07452e7d
  SHA256: c90d29fba655b2dd577ff755f084e4d1fe0673cfcd888af7ff5d0b2d2f449bb7
  SHA512: dba23aada4921c98eb90d216db656833d1759c4f611d5087e2a0123d932ab1c6704dfedc0d671d2d51b4b3949ff95b6aec012481141c6fce3988a3d0bc5d18b8
  

• https://cache.ruby-lang.org/pub/ruby/2.7/ruby-2.7.0-rc2.zip

  SIZE: 20642713
  SHA1: e0b6f91398d55436b776d7a5eae0faaf810b1578
  SHA256: ac87c1666cc840cad26083a067bae1975d1fdb41ca1f1569903c05bca1b61174
  SHA512: 4e84b1f59b574a59b5346d30a0770e06ad81a4838813cc8789157f4e1a3fcbe7ca75bf83663c20736024760f1b0675ca288f1cee7f8a28f8918c4e43b0d09982
  

Was ist Ruby

Ruby wurde erstmals 1993 von Matz (Yukihiro Matsumoto) entwickelt und wird nun als Open Source entwickelt. Es läuft auf mehreren Plattformen und wird weltweit, insbesondere für die Webentwicklung, eingesetzt.