Ruby programmeerimiskeele 2.7.0 väljalase

Pärast aastast arengut avaldatud vabastama Ruby 2.7.0, dünaamiline objektorienteeritud programmeerimiskeel, mis on programmide arendamisel väga tõhus ja sisaldab Perli, Java, Pythoni, Smalltalki, Eiffeli, Ada ja Lispi parimaid omadusi. Projekti koodi levitatakse litsentside BSD ("2-klausliga BSDL") ja "Ruby" all, mis viitab GPL-i litsentsi uusimale versioonile ja ühildub täielikult GPLv3-ga. Ruby 2.7 on seitsmes suurem väljalase, mis tehakse osana kavandatud arendusprotsessist, mis hõlmab funktsioonide täiustamiseks aasta aega ja 2–3-kuulist plaastri väljalaset.

Kõik täiustused:

• Eksperimentaalne toetama mustri sobitamine (Mustri sobitamine), et korrata antud objekti üle ja määrata väärtus, kui mustri vaste on olemas.

  juhtum [0, [1, 2, 3]] in [a, [b, *c]] pa #=> 0
  pb #=> 1
  pc #=> [2, 3] lõpp

  juhtum {a: 0, b: 1}
  in{a:0,x:1}
  : kättesaamatu
  {a: 0, b: var}
  p var #=> 1
  lõpp

• Interaktiivsete arvutuste kestil irb (REPL, Read-Eval-Print-Loop) on nüüd võimalus mitmerealiseks redigeerimiseks, mis on realiseeritud lugemisliiniga ühilduva teegi abil ridakirjutatud rubiiniga. Integreeritud on rdoc tugi, mis võimaldab vaadata viiteteavet määratud klasside, moodulite ja meetodite kohta irb-s. Esitatakse Binding#irb kaudu näidatud joonte värviline esiletõstmine koodiga ja baasklassi objektide kontrollimise tulemused.
  

• Lisatud on tihendus-GC, mis suudab mälupiirkonda defragmentida, lahendades aeglase jõudluse ja suurenenud mälutarbimise probleemid, mis on tingitud mälu killustatusest, mis tekib mõne mitmelõimelise Ruby rakenduse töötamise ajal. Objektide pakkimiseks hunnikule pakutud GC.compact meetod kasutatavate mälulehtede arvu vähendamiseks ja kuhja optimeerimiseks toimingute jaoks
  CoW (copy-on-write).

• Läbi viidud valmistub argumentide eraldamiseks positsiooni alusel loendis ("def foo(a,b,c)") ja märksõnadel ("def foo(key: val)"). Märksõnadel ja positsioonil põhinev automaatne argumentide teisendamine on aegunud ja seda ei toetata Ruby 3.0 harus. Eelkõige on aegunud kasutada viimast argumenti märksõna parameetritena, märksõnapõhiste argumentide edastamist viimase räsiparameetrina ning viimase argumendi jagamist positsiooni- ja märksõnaparameetriteks.

  def foo(võti: 42); lõpp; foo({võti: 42}) #hoiatatud
  def foo(**kw); lõpp; foo({võti: 42}) #hoiatatud
  def foo(võti: 42); lõpp; foo(**{klahv: 42}) # OK
  def foo(**kw); lõpp; foo(**{klahv: 42}) # OK

  def foo(h, **kw); lõpp; foo(võti: 42) #hoiatatud
  def foo(h, võti: 42); lõpp; foo(võti: 42) #hoiatatud
  def foo(h, **kw); lõpp; foo({klahv: 42}) # OK
  def foo(h, võti: 42); lõpp; foo({klahv: 42}) # OK

  def foo(h={}, võti: 42); lõpp; foo("võti" => 43, võti: 42) #hoiatatud
  def foo(h={}, võti: 42); lõpp; foo({"võti" => 43, võti: 42}) # hoiatatud
  def foo(h={}, võti: 42); lõpp; foo({"klahv" => 43}, klahv: 42) # OK

  def foo(opt={}); lõpp; foo(klahv: 42) # OK

  def foo(h, **null); lõpp; foo(võti: 1) # Argumendi viga
  def foo(h, **null); lõpp; foo(**{key: 1}) # Argumendiviga
  def foo(h, **null); lõpp; foo("str" ​​​​=> 1) # Argumendi viga
  def foo(h, **null); lõpp; foo({klahv: 1}) # OK
  def foo(h, **null); lõpp; foo({"str" ​​​​=> 1}) # OK

  h = {}; def foo(*a) end; foo(**h) # [] h = {}; def foo(a) end; foo(**h) # {} ja hoiatus
  h = {}; def foo(*a) end; foo(h) # [{}] h = {}; def foo(a) end; foo(h) # {}

• Võimalus kasutades ploki parameetrite jaoks nummerdatud vaikemuutujate nimesid.

  [1, 2, 3].each { paneb @1 } # like [1, 2, 3].each { |i| paneb mind }

• Algväärtuseta vahemike eksperimentaalne tugi.

  ary[..3] # sama mis ary[0..3] rel.where(müük: ..100)

• Lisatud on meetod Enumerable#tally, mis loeb, mitu korda iga element esineb.

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

• Privaatmeetodi kutse on lubatud "self" literaaliga

  deffoo
  lõpp
  privaatne :foo
  ise.foo

• Lisatud Loendaja::Lazy#eager meetod regulaarse loenduse genereerimiseks laisk (loendaja::Lazy) loendusest.

  a = %w(foo bar baz)
  e = a.laisk.kaart {|x| x.upcase }.map {|x| x + "!" }.agar
  p e.klass #=> Loendaja
  e.kaart {|x| x + "?" } #=> ["FOO!?", "BAAR!?", "BAZ!?"]

• Jätkus eksperimentaalse JIT-kompilaatori arendamine, mis võib oluliselt parandada Ruby keeles olevate rakenduste jõudlust. Rubys pakutud JIT-kompilaator kirjutab esmalt kettale C-koodi, misjärel kutsub välja välise C-kompilaatori, et genereerida masinakäske (toetatud on GCC, Clang ja Microsoft VC ++). Uus versioon rakendab vajaduse korral sisemise juurutamise meetodit, optimeerimisrežiimide valikulist rakendamist kompileerimise ajal, vaikeväärtust "--jit-min-calls" suurendatakse 5-lt 10000-le ja "--jit-max-cache" 1000 kuni 100.
• Täiustatud CGI.escapeHTML-i, Monitori ja MonitorMixini jõudlus.
• Mooduli #nimi, tõene.to_s, vale.to_s ja null.to_s tagavad, et määratud objekti puhul tagastatakse string, mis on muutumatu.
• RubyVM::InstructionSequence#to_binary meetodil genereeritud binaarfailide suurust on vähendatud;
• Sisseehitatud komponentide värskendatud versioonid, sealhulgas
  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;

• Teegid kolisid baaslevitamiselt välistele kalliskivipakettidele
  CMath (cmath gem),
  Scanf (scanf gem),
  Shell (shelli kalliskivi),
  sünkroniseerija (sünkroonimise pärl),
  ThreadsWait (thwait gem),
  E2MM (e2mmap gem).

• Vaikimisi stdlib-moodulid avaldatakse saidil rubygems.org:
  võrdlusalus,
  cgi,
  delegaat,
  pikutama,
  net pop,
  net smtp,
  avatud 3,
  pstore,
  üksikud. Monitori mooduleid pole rubygems.org-i teisaldatud
  vaatleja,
  aeg maha,
  jälgija,
  uri,
  yaml, mis tarnitakse ainult rubiinsüdamikuga.

• Ruby loomiseks on nüüd vaja C-kompilaatorit, mis toetab C99 standardit.

Allikas: opennet.ru