Nach einem Jahr Entwicklung freigeben , eine dynamische objektorientierte Programmiersprache, die bei der Programmentwicklung hocheffizient ist und die besten Funktionen von Perl, Java, Python, Smalltalk, Eiffel, Ada und Lisp vereint. Der Projektcode wird unter den BSD- („2-Klausel-BSDL“) und „Ruby“-Lizenzen vertrieben, die sich auf die neueste Version der GPL-Lizenz beziehen und vollständig mit GPLv3 kompatibel sind. Ruby 2.7 ist die siebte Hauptversion, die im Rahmen eines geplanten Entwicklungsprozesses erstellt wird, der die Bereitstellung eines Jahres für Funktionserweiterungen und eine zwei- bis dreimonatige Patch-Veröffentlichung umfasst.
Haupt- :
- Experimental Mustervergleich (), um das angegebene Objekt zu durchlaufen und einen Wert zuzuweisen, wenn eine Musterübereinstimmung vorliegt.
Fall [0, [1, 2, 3]] in [a, [b, *c]] pa #=> 0
pb #=> 1
pc #=> [2, 3] EndeFall {a: 0, b: 1}
in{a:0,x:1}
:unerreichbar
in {a: 0, b: var}
p var #=> 1
Ende - Die Shell der interaktiven Berechnungen irb (REPL, Read-Eval-Print-Loop) verfügt nun über die Möglichkeit der mehrzeiligen Bearbeitung, implementiert durch eine readline-kompatible Bibliothek geschrieben in Ruby. Unterstützung für rdoc wurde integriert, wodurch Referenzinformationen zu bestimmten Klassen, Modulen und Methoden in irb angezeigt werden können. Es wird eine farbige Hervorhebung von Zeilen mit durch Binding#irb angezeigtem Code und Ergebnissen der Überprüfung von Basisklassenobjekten bereitgestellt.
- Ein kompakter Garbage Collector (Compaction GC) wurde hinzugefügt, der eine Defragmentierung eines Speicherbereichs durchführen kann und so die Probleme der langsamen Leistung und des erhöhten Speicherverbrauchs aufgrund der Speicherfragmentierung löst, die während des Betriebs einiger Multithread-Ruby-Anwendungen auftritt. Um Objekte auf den Heap zu packen GC.compact-Methode, um die Anzahl der verwendeten Speicherseiten zu reduzieren und den Heap für Vorgänge zu optimieren
CoW (Copy-on-Write). - Vorbereitung zur Trennung von Argumenten basierend auf der Position in der Liste („def foo(a,b,c)“) und Schlüsselwörtern („def foo(key: val)“). Die automatische Argumentkonvertierung basierend auf Schlüsselwörtern und Position ist veraltet und wird im Ruby 3.0-Zweig nicht unterstützt. Insbesondere ist es veraltet, das letzte Argument als Schlüsselwortparameter zu verwenden, schlüsselwortbasierte Argumente als letzten Hash-Parameter zu übergeben und das letzte Argument in Positions- und Schlüsselwortparameter aufzuteilen.
def foo(key: 42); Ende; foo({key: 42}) #warned
def foo(**kw); Ende; foo({key: 42}) #warned
def foo(key: 42); Ende; foo(**{key: 42}) # OK
def foo(**kw); Ende; foo(**{key: 42}) # OKdef foo(h, **kw); Ende; foo(key: 42) #warned
def foo(h, Schlüssel: 42); Ende; foo(key: 42) #warned
def foo(h, **kw); Ende; foo({key: 42}) # OK
def foo(h, Schlüssel: 42); Ende; foo({key: 42}) # OKdef foo(h={}, Schlüssel: 42); Ende; foo("key" => 43, key: 42) #warned
def foo(h={}, Schlüssel: 42); Ende; foo({"key" => 43, key: 42}) # gewarnt
def foo(h={}, Schlüssel: 42); Ende; foo({"key" => 43}, key: 42) # OKdef foo(opt={}); Ende; foo( key: 42 ) # OK
def foo(h, **nil); Ende; foo(key: 1) # ArgumentError
def foo(h, **nil); Ende; foo(**{key: 1}) # ArgumentError
def foo(h, **nil); Ende; foo("str" => 1) # ArgumentError
def foo(h, **nil); Ende; foo({key: 1}) # OK
def foo(h, **nil); Ende; foo({"str" => 1}) # OKh = {}; def foo(*a) end; foo(**h) # [] h = {}; def foo(a) end; foo(**h) # {} und Warnung
h = {}; def foo(*a) end; foo(h) # [{}] h = {}; def foo(a) end; foo(h) # {} - Standardmäßig werden nummerierte Variablennamen für Blockparameter verwendet.
[1, 2, 3].each { puts @1 } # wie [1, 2, 3].each { |i| setzt i }
- Experimentelle Unterstützung für Bereiche ohne Anfangswert.
ary[..3] # dasselbe wie ary[0..3] rel.where(sales: ..100)
- Die Enumerable#tally-Methode wurde hinzugefügt, die zählt, wie oft jedes Element vorkommt.
["a", "b", "c", "b"].tally
#=> {"a"=>1, "b"=>2, "c"=>1} - Privater Methodenaufruf mit „self“-Literal zulässig
auf jeden Fall
Ende
privat :foo
self.foo - Enumerator::Lazy#eager-Methode hinzugefügt, um eine reguläre Aufzählung aus einer verzögerten Aufzählung (Enumerator::Lazy) zu generieren.
a = %w(foo bar baz)
e = a.lazy.map {|x| x.upcase }.map {|x| x + "!" }.erpicht
p e.class #=> Enumerator
e.map {|x| x + „?“ } #=> [„FOO!?“, „BAR!?“, „BAZ!?“] - Die Entwicklung eines experimentellen JIT-Compilers wurde fortgesetzt, der die Leistung von Anwendungen in der Ruby-Sprache erheblich verbessern kann. Der in Ruby vorgeschlagene JIT-Compiler schreibt zunächst C-Code auf die Festplatte und ruft anschließend einen externen C-Compiler auf, um Maschinenanweisungen zu generieren (GCC, Clang und Microsoft VC++ werden unterstützt). Die neue Version implementiert eine Methode für die Inline-Bereitstellung bei Bedarf, die selektive Anwendung von Optimierungsmodi während der Kompilierung, der Standardwert von „--jit-min-calls“ wird von 5 auf 10000 erhöht und „--jit-max-cache“ von 1000 bis 100 .
- Verbesserte Leistung von CGI.escapeHTML, Monitor und MonitorMixin.
- Module#name, true.to_s, false.to_s und nil.to_s stellen sicher, dass eine Zeichenfolge zurückgegeben wird, die für das angegebene Objekt unverändert ist.
- Die Größe der von der RubyVM::InstructionSequence#to_binary-Methode generierten Binärdateien wurde reduziert;
- Aktualisierte Versionen integrierter Komponenten, einschließlich
Bundler 2.1.2, RubyGems 3.1.2,
Racc 1.4.15,
CSV 3.1.2, REXML 3.2.3,
RSS 0.2.8,
String-Scanner 1.0.3; - Bibliotheken wurden von der Basisverteilung auf externe Gem-Pakete umgestellt
CMath (cmath gem),
Scanf (Scanf-Edelstein),
Muschel (Muscheledelstein),
Synchronizer (Sync-Gem),
ThreadsWait (thwait gem),
E2MM (e2mmap-Juwel). - Die standardmäßigen stdlib-Module werden auf rubygems.org veröffentlicht:
Benchmark,
cgi,
delegieren,
getoptlong,
Netz-Pop,
Netto-SMTP,
open3,
pstore,
Singleton. Monitormodule wurden nicht nach rubygems.org verschoben
Beobachter,
Auszeit,
Tracer,
Hass,
yaml, die nur mit Ruby-Core ausgeliefert werden. - Für die Erstellung von Ruby ist jetzt ein C-Compiler erforderlich, der den C99-Standard unterstützt.
Source: opennet.ru