Frigivelse af Ruby-programmeringssproget 2.7.0

Efter et års udvikling offentliggjort релиз Ruby 2.7.0, et dynamisk, objektorienteret programmeringssprog, der er yderst effektivt i programudvikling og inkorporerer de bedste funktioner fra Perl, Java, Python, Smalltalk, Eiffel, Ada og Lisp. Projektkoden distribueres under BSD ("2-klausul BSDL") og "Ruby"-licenser, som refererer til den seneste version af GPL-licensen og er fuldt ud kompatibel med GPLv3. Ruby 2.7 er den syvende store udgivelse efter en planlagt udviklingsproces, der tager et år at forberede funktionsforbedringer og producerer vedligeholdelsesudgivelser hver 2.-3. måned.

The main forbedring:

• Eksperimentel støtte mønstermatchning (Mønster matchende), som giver dig mulighed for at iterere over et givent objekt og tildele en værdi, hvis der er et match til mønsteret.

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

  case {a: 0, b: 1}
  i {a: 0, x: 1}
  : ikke tilgængelig
  i {a: 0, b: var}
  p var #=> 1
  ende

• Skallen af ​​interaktive beregninger irb (REPL, Read-Eval-Print-Loop) har nu multi-line redigering, implementeret ved hjælp af et readline-kompatibelt bibliotek reline, skrevet i Ruby. rdoc-understøttelse er blevet integreret, så du kan se referenceoplysninger om specificerede klasser, moduler og metoder i irb. Forudsat farvefremhævning af kodelinjer vist gennem Binding#irb og resultaterne af inspektion af basisklasseobjekter.
  

• Tilføjet en kompakt skraldeopsamler (Compaction GC), der kan defragmentere et område af hukommelsen, og løse problemerne med ydeevne og hukommelsesforbrug forårsaget af hukommelsesfragmentering, der forekommer i nogle flertrådede Ruby-applikationer. At pakke genstande på dyngen foreslog GC.compact metode, som giver dig mulighed for at reducere antallet af brugte hukommelsessider og optimere heapen til operationer
  CoW (copy-on-write).

• Udført forbereder at adskille argumenter baseret på listeposition ("def foo(a,b,c)") og nøgleord ("def foo(key: val)"). Automatisk argumentkonvertering baseret på søgeord og position er blevet forældet og vil ikke blive understøttet i Ruby 3.0-grenen. Specifikt har den udfaset brugen af ​​det sidste argument som søgeordsparametre, videregivelse af søgeordsbaserede argumenter som den sidste hash-parameter og opdeling af det sidste argument i positions- og søgeordsparametre.

  def foo(nøgle: 42); ende; foo({nøgle: 42}) # advaret
  def foo(**kw); ende; foo({nøgle: 42}) # advaret
  def foo(nøgle: 42); ende; foo(**{nøgle: 42}) # OK
  def foo(**kw); ende; foo(**{nøgle: 42}) # OK

  def foo(h, **kw); ende; foo(tast: 42) # advaret
  def foo(h, nøgle: 42); ende; foo(tast: 42) # advaret
  def foo(h, **kw); ende; foo({nøgle: 42}) # OK
  def foo(h, nøgle: 42); ende; foo({nøgle: 42}) # OK

  def foo(h={}, nøgle: 42); ende; foo("key" => 43, nøgle: 42) # advaret
  def foo(h={}, nøgle: 42); ende; foo({"key" => 43, nøgle: 42}) # advaret
  def foo(h={}, nøgle: 42); ende; foo({"key" => 43}, tast: 42) # OK

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

  def foo(h, **nul); ende; foo(nøgle: 1) #ArgumentError
  def foo(h, **nul); ende; foo(**{nøgle: 1}) # ArgumentError
  def foo(h, **nul); ende; foo("str"=> 1) # ArgumentError
  def foo(h, **nul); ende; foo({tast: 1}) # OK
  def foo(h, **nul); ende; foo({"str"=> 1}) # OK

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

• Opportunity bruger nummererede variabelnavne som standard for blokparametre.

  [1, 2, 3].hver { sætter @1 } # samme som [1, 2, 3].hver { |i| sætter i}

• Eksperimentel støtte til områder uden startværdi.

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

• Tilføjet Enumerable#tally-metode, som tæller antallet af gange, hvert element forekommer.

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

• Tilladt at kalde en privat metode med det bogstavelige "selv"

  def foo
  ende
  privat :foo
  self.foo

• Tilføjet Enumerator::Lazy#eager metode til at generere en regulær optælling fra en doven enumerator (Enumerator::Lazy).

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

• Udviklingen af ​​en eksperimentel JIT-kompiler er fortsat, som kan forbedre ydeevnen af ​​applikationer på Ruby-sproget markant. Rubys JIT-kompiler skriver først C-kode til disken og kalder derefter en ekstern C-kompiler for at generere maskininstruktioner (understøtter kald af GCC, Clang og Microsoft VC++). Den nye version implementerer en metode til inline-implementering om nødvendigt, selektiv anvendelse af optimeringstilstande under kompilering er sikret, standardværdien for "--jit-min-calls" øges fra 5 til 10000, og "--jit-max- cache” fra 1000 til 100 .
• Forbedret ydeevne af CGI.escapeHTML, Monitor og MonitorMixin.
• Modul#name, true.to_s, false.to_s og nil.to_s sikrer, at der returneres en streng, der er uændret for det angivne objekt.
• Størrelsen af ​​binære filer genereret af RubyVM::InstructionSequence#to_binary; metoden er blevet reduceret.
• Opdaterede versioner af indbyggede komponenter, herunder
  Bundler 2.1.2, RubyGems 3.1.2,
  Racc 1.4.15,
  CSV 3.1.2, REXML 3.2.3,
  RSS 0.2.8,
  StringScanner 1.0.3;

• Biblioteker er blevet flyttet fra basispakken til eksterne ædelstenspakker
  CMath (cmath perle),
  Scanf (scanf gem),
  Skal (skalperle)
  Synchronizer (sync perle),
  ThreadsWait (thwait perle),
  E2MM (e2mmap perle).

• Standard stdlib-modulerne er udgivet på rubygems.org:
  benchmark,
  cgi,
  delegeret,
  getoptlong,
  net-pop,
  net-smtp
  åben 3,
  pstore,
  singleton. monitormoduler er ikke flyttet til rubygems.org
  observatør
  tiden er gået
  sporstof,
  uri,
  yaml, som kun leveres i rubinkerne.

• Building Ruby kræver nu en C-compiler, der understøtter C99-standarden.

Kilde: opennet.ru