Utgivelse av Ruby programmeringsspråk 2.7.0

Etter et år med utvikling publisert utgivelse Ruby 2.7.0, et dynamisk objektorientert programmeringsspråk som er svært effektivt i programutvikling og inneholder de beste funksjonene til Perl, Java, Python, Smalltalk, Eiffel, Ada og Lisp. Prosjektkoden er distribuert under BSD ("2-klausul BSDL") og "Ruby"-lisenser, som refererer til den nyeste versjonen av GPL-lisensen og er fullt kompatibel med GPLv3. Ruby 2.7 er den syvende store utgivelsen som blir produsert som en del av en planlagt utviklingsprosess som inkluderer å sette av et år til funksjonsforbedringer og en 2-3 måneders patchutgivelse.

Den viktigste forbedringer:

• eksperimentell støtte mønstertilpasning (Mønster matching) for å iterere over det gitte objektet og tilordne en verdi hvis det er en mønstermatch.

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

  sak {a: 0, b: 1}
  i{a:0,x:1}
  :uoppnåelig
  i {a: 0, b: var}
  p var #=> 1
  slutt

• Skallet av interaktive beregninger irb (REPL, Read-Eval-Print-Loop) har nå muligheten for multi-line redigering, implementert ved hjelp av et readline-kompatibelt bibliotek linjeskrevet i Ruby. Støtte for rdoc er integrert, som gjør det mulig å se referanseinformasjon om spesifiserte klasser, moduler og metoder i irb. Farget utheving av linjer med kode vist gjennom Binding#irb og resultater av inspeksjon av basisklasseobjekter er gitt.
  

• Lagt til en kompakt søppelsamler (Compaction GC) som kan utføre defragmentering av et område av minnet, og løse problemene med langsom ytelse og økt minneforbruk på grunn av minnefragmentering som oppstår under driften av noen flertrådede Ruby-applikasjoner. Å pakke gjenstander på haugen foreslått GC.compact-metode for å redusere antall minnesider som brukes og optimalisere haugen for operasjoner
  CoW (kopi-på-skriv).

• Utført forbereder å skille argumenter basert på posisjon i listen ("def foo(a,b,c)") og nøkkelord ("def foo(key: val)"). Automatisk argumentkonvertering basert på søkeord og posisjon er avviklet og vil ikke bli støttet i Ruby 3.0-grenen. Spesielt har det blitt avviklet å bruke det siste argumentet som søkeordparametere, å sende søkeordbaserte argumenter som siste hash-parameter, og å dele det siste argumentet i posisjons- og nøkkelordparametere.

  def foo(nøkkel: 42); slutt; foo({nøkkel: 42}) #advart
  def foo(**kw); slutt; foo({nøkkel: 42}) #advart
  def foo(nøkkel: 42); slutt; foo(**{nøkkel: 42}) # OK
  def foo(**kw); slutt; foo(**{nøkkel: 42}) # OK

  def foo(h, **kw); slutt; foo(tast: 42) #advart
  def foo(h, nøkkel: 42); slutt; foo(tast: 42) #advart
  def foo(h, **kw); slutt; foo({nøkkel: 42}) # OK
  def foo(h, nøkkel: 42); slutt; foo({nøkkel: 42}) # OK

  def foo(h={}, nøkkel: 42); slutt; foo("key" => 43, nøkkel: 42) #advart
  def foo(h={}, nøkkel: 42); slutt; foo({"key" => 43, nøkkel: 42}) # advart
  def foo(h={}, nøkkel: 42); slutt; foo({"key" => 43}, nøkkel: 42) # OK

  def foo(opt={}); slutt; foo( tast: 42 ) # OK

  def foo(h, **null); slutt; foo(nøkkel: 1) # ArgumentFeil
  def foo(h, **null); slutt; foo(**{nøkkel: 1}) # ArgumentFeil
  def foo(h, **null); slutt; foo("str"=> 1) # ArgumentFeil
  def foo(h, **null); slutt; foo({tast: 1}) # OK
  def foo(h, **null); slutt; foo({"str"=> 1}) # OK

  h = {}; def foo(*a) slutt; foo(**h) # [] h = {}; def foo(a) slutt; foo(**h) # {} og advarsel
  h = {}; def foo(*a) slutt; foo(h) # [{}] h = {}; def foo(a) slutt; foo(h) # {}

• Opportunity bruker nummererte variabelnavn som standard for blokkparametere.

  [1, 2, 3].hver { setter @1 } # som [1, 2, 3].hver { |i| setter i }

• Eksperimentell støtte for områder uten startverdi.

  ary[..3] # samme som ary[0..3] rel.where(salg: ..100)

• La til Enumerable#tally-metoden, som teller hvor mange ganger hvert element forekommer.

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

• Privat metodekall tillatt med "selv" bokstavelig

  deffoo
  slutt
  privat :foo
  self.foo

• Lagt til Enumerator::Lazy#eager metode for å generere vanlig opptelling fra lat (Enumerator::Lazy) opptelling.

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

• Utviklingen av en eksperimentell JIT-kompilator har fortsatt, noe som kan forbedre ytelsen til applikasjoner på Ruby-språket betydelig. JIT-kompilatoren foreslått i Ruby skriver først C-kode til disk, hvoretter den kaller en ekstern C-kompilator for å generere maskininstruksjoner (GCC, Clang og Microsoft VC ++ støttes). Den nye versjonen implementerer en metode for inline distribusjon om nødvendig, selektiv bruk av optimaliseringsmoduser under kompilering, standardverdien for "--jit-min-calls" økes fra 5 til 10000, og "--jit-max-cache" fra 1000 til 100.
• Forbedret ytelse av CGI.escapeHTML, Monitor og MonitorMixin.
• Modul#name, true.to_s, false.to_s og nil.to_s sikrer at en streng returneres som er uendret for det angitte objektet.
• Størrelsen på binære filer generert av RubyVM::InstructionSequence#to_binary-metoden har blitt redusert;
• Oppdaterte versjoner av innebygde komponenter, inkludert
  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;

• Biblioteker flyttet fra basisdistribusjon til eksterne edelstenspakker
  CMath (cmath perle),
  Scanf (scanf gem),
  Shell (skall perle),
  Synchronizer (synkroniseringsperle),
  ThreadsWait (thwait perle),
  E2MM (e2mmap perle).

• Standard stdlib-moduler er publisert på rubygems.org:
  benchmark,
  cgi,
  delegat,
  getoptlong,
  nettpop,
  net smtp,
  åpen 3,
  pstore,
  singleton. Monitormoduler er ikke flyttet til rubygems.org
  observatør,
  pause,
  tracer,
  uri,
  yaml, som kun sendes med rubinkjerne.

• Building Ruby krever nå en C-kompilator som støtter C99-standarden.

Kilde: opennet.ru