Ruby 2.7.0-preview2 veröffentlicht

Gepostet von naruse am 22. Okt 2019

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

Eine Vorschauversion wird veröffentlicht, um Feedback für die endgültige Veröffentlichung zu sammeln, die für Dezember geplant ist. Sie führt 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 in funktionalen Programmiersprachen weit verbreitete Funktion, wird als experimentelle Funktion eingeführt. [Feature #14912] Es kann ein gegebenes Objekt durchlaufen und seinen Wert zuweisen, wenn es einem Muster entspricht.

case JSON.parse('{...}', symbolize_names: true)
in {name: "Alice", children: [{name: "Bob", age: age}]}
  p age
  ...
end

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

REPL-Verbesserung

irb, die mitgelieferte interaktive Umgebung (REPL; Read-Eval-Print-Loop), unterstützt jetzt mehrzeilige Bearbeitung. Sie wird von reline, einer reinen Ruby-Implementierung, die mit readline kompatibel ist, 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] Darüber hinaus sind Quelltextzeilen, die bei binding.irb angezeigt werden, und Inspektionsergebnisse für Kernklassenobjekte 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 eine Hash als letztes Argument übergibt, und wenn keine Schlüssel übergeben werden, und wenn die aufgerufene Methode Schlüssel akzeptiert, wird eine Warnung ausgegeben. Um dies weiterhin als Schlüssel 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 für Keyword-Argumente zulässig, wenn die Methode beliebige Schlüssel 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üssel akzeptiert. Der Aufruf einer solchen Methode mit Schlüsseln 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)    # {}
  

Weitere bemerkenswerte neue Funktionen

• Ein Methodenreferenzoperator, .:, wird als experimentelle Funktion eingeführt. [Feature #12125], [Feature #13581]

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

• Ein beginnloser Bereich wird experimentell eingeführt. Er ist möglicherweise nicht so nützlich wie ein endloser Bereich, 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, 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 für ein gegebenes Objekt immer derselbe. [Experimentell] [Feature #16150]

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

Weitere bemerkenswerte Änderungen seit 2.6

• Einige Standardbibliotheken wurden aktualisiert.
  • Bundler 2.1.0.pre.1
  • RubyGems 3.1.0.pre.1
  • 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.

• 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

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

Mit diesen Änderungen wurden 3670 Dateien geändert, 201242 Einfügungen(+), 88066 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-preview2.tar.bz2

  SIZE:   14555229 bytes
  SHA1:   7d9eed71115acfc8851747517904c1c6809872a9
  SHA256: 417c84346ba84d664a13833c94c6d9f888c89bb9bee9adf469580441eaede30b
  SHA512: 7066ececebbbba4b2933ba1a4f70cdef373169910802259a3e52b4fc144ba298f3cffda4be5fe8a7be8ef769ed43076fa046a9ac2c13bb733475b9852112c6f0
  

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

  SIZE:   16622499 bytes
  SHA1:   5e998eb37ef54e650c0206184d56f506359d5477
  SHA256: bda4b8dc340fad425c8099400fe3ef8e7393837d7e6e1bfae41843d1d938ebc4
  SHA512: dbf05d6ddab59062f507342b25b8c21670b02bdd49e77bda947870607f4bf9049e5e7ddfde6bbce2e1749ca92568da9be3e5f30601b1eb450f10d8add952239a
  

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

  SIZE:   11874200 bytes
  SHA1:   4356e1726027795a5c6b08572bb37bcb5a8c55d6
  SHA256: fa39f088331f6d505154aa9d025aab177fdffedfbbabccd900b8c02e745bc077
  SHA512: a057a186d85fcdf123abd69d584ef3adb20ad4397521e14306395d34102c3d818fe2d34a6476db01effcde479da9a77076cbb6d30bca40f1471ce3f5d3a995a9
  

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

  SIZE:   20576618 bytes
  SHA1:   891b70ec76e9e776774a49b3ce24832a944422b3
  SHA256: 81a240bead4438b064cb4cde562b483b82ec8e414bac057a6df43df5a247545c
  SHA512: 1a8d4503374d31abf43182e2af6902ea6e5295f55d539415c8268b1d6a0fa83a975648c225ae986e687d5283dc2d180cf1e608841485506e4b0ac5efc154949a
  

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.