Ruby 2.7.0-preview3 veröffentlicht

Gepostet von naruse am 23. Nov 2019

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

Eine Vorschauversion wird veröffentlicht, um Feedback für die für Dezember geplante endgültige Veröffentlichung zu sammeln. Diese Vorschau3 wird hauptsächlich veröffentlicht, um die Kompatibilität von Schlüsselwortargumenten zu bestätigen.

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

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

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 Komprimierung des Heaps eingeführt. Diese Funktion komprimiert Live-Objekte im Heap, sodass weniger Seiten verwendet werden können und der Heap besser CoW-freundlich sein kann. [Feature #15626]

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 integrierte interaktive Umgebung (REPL; Read-Eval-Print-Loop), unterstützt jetzt die mehrzeilige Bearbeitung. Sie wird von reline, einer readline-kompatiblen reinen Ruby-Implementierung, angetrieben. 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 bei binding.irb angezeigt werden, und Inspektionsergebnisse für Core-Class-Objekte jetzt farbig.

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 Inkompatibilität von Schlüsselwortargumenten wurden als zu wortreich kritisiert. Derzeit werden zwei mögliche Lösungen diskutiert: Deaktivierung von Deprecation-Warnungen standardmäßig (#16345) oder Unterdrückung duplizierter Warnungen (#16289). Die endgültige Entscheidung ist noch nicht gefallen, wird aber bis zur offiziellen Veröffentlichung getroffen.

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}
  

• Der Aufruf einer privaten Methode auf self 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.

• Symbol#to_s (revertiert), Module#name, true.to_s, false.to_s und nil.to_s geben jetzt immer einen gefrorenen 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, erzeugt einen Fehler.

• 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 erfordern die Unterstützung von C99 [Misc #15347]
  • Details zu unserem Dialekt: https://bugs.ruby-lang.org/projects/ruby-master/wiki/C99
• Regexp#match{?} mit nil löst TypeError aus wie String, Symbol. [Feature #13083] revertiert

3895 Dateien geändert, 213426 Einfügungen (+), 96934 Löschungen (-)

Siehe NEWS oder Commit-Logs für weitere Details.

Mit diesen Änderungen, Statistik 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-preview3.tar.bz2

  SIZE: 14630824
  SHA1: 1fa35d8a26dfc814e92fa259095f4cf70f386f87
  SHA256: df2ddee659873e6fc30a8590ecffa49cf3a4ef81fa922b0d09f821b69ee88bc3
  SHA512: 5d8e99e3fd984c7d05c0bc483e1504e81ccdb920cbb2d78cad3c314e197b30316b692fd0199f836acac41246e3a713cb81dc6dd64c27cba56f807df4c193db1a
  

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

  SIZE: 16723536
  SHA1: 7554926ee29a344da4b53d67fc296d70fdbe60ca
  SHA256: 9baa1f5096ebc2a0923df628d7dc7105da3789c1bf8b873469d9010249736b00
  SHA512: 8fad3e761fd54036fee974a9f33e4db31d9a8a878b1181a08724388f5a1da548ab249136356f675797e9c43b565777bf22e6a419db1364336f134b31f4e75b33
  

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

  SIZE: 11923988
  SHA1: f3c54538915483e5ddc714ac23414e7c47048b12
  SHA256: ad9d61e55ac224e3447a762e001965839846f9658f87a0e792840887cfe61b8c
  SHA512: 2b6844f34d32f1013dc3110043e6ece33a083b20f1343dea9a14311bda0017e8f56fc7d73be1616999b22ce430d7ba59a77bb0892d27c6d1ec243c3860086133
  

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

  SIZE: 20691541
  SHA1: d18b494cda4db751d8b3f5026404e348f3f682e3
  SHA256: 2bc95f67f271b6a41fc3dd40536705b4a7974df8a2fa33ff0758a60822291781
  SHA512: af9f728aebc53693cbd9f78a632c82e851e9f83dfc0c53979fdc37c627b11482c8435ce12dbb1d5a7253e998ea989759be699e6a00aae18384d2d765650cb0d7
  

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.