Ruby-ohjelmointikielen julkaisu 2.7.0

Vuoden kehitystyön jälkeen julkaistu vapauta Ruby 2.7.0, dynaaminen olio-ohjelmointikieli, joka on erittäin tehokas ohjelmakehityksessä ja sisältää Perlin, Javan, Pythonin, Smalltalkin, Eiffelin, Adan ja Lispin parhaat ominaisuudet. Projektikoodia jaetaan BSD- ("2-clause BSDL")- ja "Ruby"-lisenssien alla, mikä viittaa GPL-lisenssin uusimpaan versioon ja on täysin yhteensopiva GPLv3:n kanssa. Ruby 2.7 on seitsemäs suuri julkaisu, joka tuotetaan osana suunniteltua kehitysprosessia, joka sisältää vuoden varaamisen ominaisuuksien parannuksiin ja 2-3 kuukauden korjauspäivityksen.

Pääasiallinen parannuksia:

• kokeellinen tukea kuvion sovitus (Kuvioiden yhteensopivuus) iteroidaksesi tietyn objektin yli ja määrittääksesi arvon, jos kuvio täsmää.

  tapaus [0, [1, 2, 3]] in [a, [b, *c]] pa #=> 0
  pb #=> 1
  PC #=> [2, 3] loppu

  tapaus {a: 0, b: 1}
  in{a:0,x:1}
  :ei saatavilla
  kohdassa {a: 0, b: var}
  p var #=> 1
  loppu

• Interaktiivisten laskutoimitusten kuoressa irb (REPL, Read-Eval-Print-Loop) on nyt mahdollisuus moniriviseen muokkaukseen, joka on toteutettu Readline-yhteensopivalla kirjastolla linjakirjoitettu rubiinilla. Rdoc-tuki on integroitu, mikä mahdollistaa viitetietojen tarkastelun määritetyistä luokista, moduuleista ja menetelmistä irb:ssä. Viivojen värillinen korostus koodilla, joka näkyy Binding#irb:n kautta, ja perusluokan objektien tarkastuksen tulokset tarjotaan.
  

• Lisätty kompakti roskakeräin (Compaction GC), joka voi eheyttää muistialueen, mikä ratkaisee hitaan suorituskyvyn ja lisääntyneen muistin kulutuksen ongelmat, jotka johtuvat joidenkin monisäikeisten Ruby-sovellusten toiminnan aikana tapahtuvasta muistin pirstoutumisesta. Pakkaa esineitä kasaan ehdotettu GC.compact menetelmä vähentää käytettävien muistisivujen määrää ja optimoida kasan toimintoja varten
  CoW (copy-on-write).

• Suoritettu valmistautuu erottelemaan argumentit luettelon sijainnin ("def foo(a,b,c)") ja avainsanojen ("def foo(avain: val)" perusteella). Avainsanoihin ja sijaintiin perustuva automaattinen argumenttien muunnos on poistettu käytöstä, eikä sitä tueta Ruby 3.0 -haarassa. Erityisesti viimeisen argumentin käyttäminen avainsanaparametreina, avainsanapohjaisten argumenttien välittäminen viimeisenä hash-parametrina ja viimeisen argumentin jakaminen sijainti- ja avainsanaparametreiksi on vanhentunut.

  def foo(avain: 42); loppu; foo({avain: 42}) #varoitettu
  def foo(**kw); loppu; foo({avain: 42}) #varoitettu
  def foo(avain: 42); loppu; foo(**{avain: 42}) # OK
  def foo(**kw); loppu; foo(**{avain: 42}) # OK

  def foo(h, **kw); loppu; foo(avain: 42) #varoitettu
  def foo(h, avain: 42); loppu; foo(avain: 42) #varoitettu
  def foo(h, **kw); loppu; foo({avain: 42}) # OK
  def foo(h, avain: 42); loppu; foo({avain: 42}) # OK

  def foo(h={}, avain: 42); loppu; foo("avain" => 43, avain: 42) #varoitettu
  def foo(h={}, avain: 42); loppu; foo({"avain" => 43, avain: 42}) # varoitettu
  def foo(h={}, avain: 42); loppu; foo({"avain" => 43}, avain: 42) # OK

  def foo(opt={}); loppu; foo(avain: 42) # OK

  def foo(h, **nolla); loppu; foo(avain: 1) #Argumenttivirhe
  def foo(h, **nolla); loppu; foo(**{avain: 1}) # Argumenttivirhe
  def foo(h, **nolla); loppu; foo("str" ​​=> 1) # Argumenttivirhe
  def foo(h, **nolla); loppu; foo({avain: 1}) # OK
  def foo(h, **nil); loppu; foo({"str" ​​​​=> 1}) # OK

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

• Tilaisuus käyttämällä numeroituja oletusmuuttujien nimiä lohkoparametreille.

  [1, 2, 3].each { laittaa @1 } # like [1, 2, 3].each { |i| laittaa minä }

• Kokeellinen tuki alueille, joilla ei ole alkuarvoa.

  ary[..3] # sama kuin ary[0..3] rel.where(myynti: ..100)

• Lisätty Enumerable#tally-menetelmä, joka laskee, kuinka monta kertaa kukin elementti esiintyy.

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

• Yksityinen menetelmäkutsu sallittu "itse"-kirjaimella

  deffoo
  loppu
  yksityinen :foo
  self.foo

• Lisätty Enumerator::Lazy#innokas menetelmä säännöllisen luettelon luomiseksi laiskasta (Enumerator::Lazy) luettelosta.

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

• Kokeellisen JIT-kääntäjän kehitystä on jatkettu, mikä voi merkittävästi parantaa Ruby-kielen sovellusten suorituskykyä. Rubyssa ehdotettu JIT-kääntäjä kirjoittaa ensin C-koodin levylle, minkä jälkeen se kutsuu ulkoisen C-kääntäjän luomaan konekäskyt (GCC, Clang ja Microsoft VC ++ ovat tuettuja). Uusi versio toteuttaa menetelmän tarvittaessa inline-käyttöönotolle, optimointitilojen selektiivisen soveltamisen käännöksen aikana, oletusarvo "--jit-min-calls" nostetaan 5:stä 10000:een ja "--jit-max-cache" 1000 - 100.
• CGI.escapeHTML:n, Monitorin ja MonitorMixinin parannettu suorituskyky.
• Moduuli#nimi, tosi.to_s, epätosi.to_s ja nolla.to_s varmistavat, että määritetylle objektille palautetaan merkkijono, joka on muuttumaton.
• RubyVM::InstructionSequence#to_binary-menetelmän luomien binääritiedostojen kokoa on pienennetty;
• Sisäänrakennettujen komponenttien päivitetyt versiot, mukaan lukien
  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;

• Kirjastot siirtyivät perusjakelusta ulkoisiin helmipaketteihin
  CMath (cmath gem),
  Scanf (scanf gem),
  Shell (kuorihelmi),
  Synkronointi (synkronointi helmi),
  ThreadsWait (thwait gem),
  E2MM (e2mmap gem).

• Oletusarvoiset stdlib-moduulit on julkaistu osoitteessa rubygems.org:
  vertailuarvo,
  cgi,
  delegoida,
  pitkittää,
  net pop,
  net smtp,
  avoin3,
  pstore,
  singleton. Näytön moduuleita ei ole siirretty rubygems.org-sivustolle
  tarkkailija,
  Aikalisä
  merkkiaine,
  uri,
  yaml, jotka toimitetaan vain rubiiniytimellä.

• Rubyn rakentaminen vaatii nyt C-kääntäjän, joka tukee C99-standardia.

Lähde: opennet.ru