Utgivning av programmeringsspråket Ruby 2.7.0

Efter ett år av utveckling publicerad släpp Ruby 2.7.0, ett dynamiskt objektorienterat programmeringsspråk som är mycket effektivt i programutveckling och som innehåller de bästa funktionerna i Perl, Java, Python, Smalltalk, Eiffel, Ada och Lisp. Projektkoden distribueras under licenserna BSD ("2-klausul BSDL") och "Ruby", som hänvisar till den senaste versionen av GPL-licensen och är helt kompatibel med GPLv3. Ruby 2.7 är den sjunde stora utgåvan som produceras som en del av en planerad utvecklingsprocess som inkluderar att avsätta ett år för funktionsförbättringar och en 2-3 månaders patch-release.

Den huvudsakliga förbättringar:

• experimentell stöd mönstermatchning (Mönstermatchning) för att iterera över det givna objektet och tilldela ett värde om det finns en mönstermatchning.

  fall [0, [1, 2, 3]] i [a, [b, *c]] pa #=> 0
  pb #=> 1
  pc #=> [2, 3] slut

  fall {a: 0, b: 1}
  i{a:0,x:1}
  :onåbar
  i {a: 0, b: var}
  p var #=> 1
  änden

• Skalet av interaktiva beräkningar irb (REPL, Read-Eval-Print-Loop) har nu möjligheten att redigera flera rader, implementerad med ett läslinjekompatibelt bibliotek linjeskrivet i Ruby. Stöd för rdoc har integrerats, vilket gör det möjligt att se referensinformation om specificerade klasser, moduler och metoder i irb. Färgad markering av linjer med kod som visas genom Binding#irb och resultat av inspektion av basklassobjekt tillhandahålls.
  

• Lade till en kompakt sopsamlare (Compaction GC) som kan defragmentera en minnesregion, vilket löser problemen med långsam prestanda och ökad minnesförbrukning på grund av minnesfragmentering som uppstår under driften av vissa flertrådiga Ruby-applikationer. Att packa föremål på högen föreslagen GC.compact-metod för att minska antalet minnessidor som används och optimera högen för operationer
  CoW (copy-on-write).

• Utförd förbereder sig på att separera argument baserat på position i listan ("def foo(a,b,c)") och nyckelord ("def foo(nyckel: val)"). Automatisk argumentkonvertering baserad på nyckelord och position har fasats ut och kommer inte att stödjas i Ruby 3.0-grenen. I synnerhet har det föråldrats att använda det sista argumentet som nyckelordsparametrar, att skicka nyckelordsbaserade argument som den sista hashparametern och att dela upp det sista argumentet i positions- och nyckelordsparametrar.

  def foo(nyckel: 42); slutet; foo({nyckel: 42}) #varnad
  def foo(**kw); slutet; foo({nyckel: 42}) #varnad
  def foo(nyckel: 42); slutet; foo(**{nyckel: 42}) # OK
  def foo(**kw); slutet; foo(**{nyckel: 42}) # OK

  def foo(h, **kw); slutet; foo(nyckel: 42) #varnad
  def foo(h, nyckel: 42); slutet; foo(nyckel: 42) #varnad
  def foo(h, **kw); slutet; foo({nyckel: 42}) # OK
  def foo(h, nyckel: 42); slutet; foo({nyckel: 42}) # OK

  def foo(h={}, nyckel: 42); slutet; foo("key" => 43, nyckel: 42) #varnad
  def foo(h={}, nyckel: 42); slutet; foo({"key" => 43, nyckel: 42}) # varnad
  def foo(h={}, nyckel: 42); slutet; foo({"key" => 43}, nyckel: 42) # OK

  def foo(opt={}); slutet; foo( tangent: 42 ) # OK

  def foo(h, **noll); slutet; foo(nyckel: 1) # ArgumentError
  def foo(h, **noll); slutet; foo(**{nyckel: 1}) # ArgumentError
  def foo(h, **noll); slutet; foo("str"=> 1) # ArgumentError
  def foo(h, **noll); slutet; foo({nyckel: 1}) # OK
  def foo(h, **noll); slutet; foo({"str"=> 1}) # OK

  h = {}; def foo(*a) slut; foo(**h) # [] h = {}; def foo(a) slut; foo(**h) # {} och varning
  h = {}; def foo(*a) slut; foo(h) # [{}] h = {}; def foo(a) slut; foo(h) # {}

• Möjlighet med numrerade standardvariabelnamn för blockparametrar.

  [1, 2, 3]. varje { sätter @1 } # som [1, 2, 3]. varje { |i| sätter jag }

• Experimentellt stöd för intervall utan startvärde.

  ary[..3] # samma som ary[0..3] rel.where(försäljning: ..100)

• Lade till metoden Enumerable#tally, som räknar hur många gånger varje element förekommer.

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

• Privat metodanrop tillåts med "self" bokstavlig

  deffoo
  änden
  privat :foo
  self.foo

• Lade till Enumerator::Lazy#eager metod för att generera regelbunden uppräkning från lat (Enumerator::Lazy) uppräkning.

  a = %w(foo bar baz)
  e = a.lazy.map {|x| x.upcase }.map {|x| x + "!" }.ivrig
  p e.klass #=> Enumerator
  e.map {|x| x + "?" } #=> ["FOO!?", "BAR!?", "BAZ!?"]

• Utvecklingen av en experimentell JIT-kompilator har fortsatt, vilket avsevärt kan förbättra prestandan för applikationer på Ruby-språket. JIT-kompilatorn som föreslås i Ruby skriver först C-kod till disk, varefter den anropar en extern C-kompilator för att generera maskininstruktioner (GCC, Clang och Microsoft VC ++ stöds). Den nya versionen implementerar en metod för inline-distribution vid behov, selektiv tillämpning av optimeringslägen under kompilering, standardvärdet för "--jit-min-calls" ökas från 5 till 10000, och "--jit-max-cache" från 1000 till 100 .
• Förbättrad prestanda för CGI.escapeHTML, Monitor och MonitorMixin.
• Modul#name, true.to_s, false.to_s och nil.to_s säkerställer att en sträng returneras som är oförändrad för det angivna objektet.
• Storleken på binära filer som genereras av RubyVM::InstructionSequence#to_binary-metoden har reducerats;
• Uppdaterade versioner av inbyggda komponenter, inklusive
  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;

• Bibliotek flyttade från basdistribution till externa ädelstenspaket
  CMath (cmath pärla),
  Scanf (scanf gem),
  Skal (skal pärla),
  Synchronizer (sync gem),
  ThreadsWait (thwait pärla),
  E2MM (e2mmap pärla).

• Standard stdlib-modulerna publiceras på rubygems.org:
  riktmärke,
  cgi,
  delegera,
  getoptlong,
  nätpop,
  net smtp,
  öppen 3,
  pstore,
  singel. Övervakningsmoduler har inte flyttats till rubygems.org
  observatör,
  Paus,
  spårämne,
  uri,
  yaml, som endast levereras med ruby-core.

• Att bygga Ruby kräver nu en C-kompilator som stöder C99-standarden.

Källa: opennet.ru