ProHoster > Blog > nouvèl sou entènèt > Lage langaj pwogram Ruby 2.7.0

Lage langaj pwogram Ruby 2.7.0

Apre yon ane nan devlopman pibliye lage Ruby 2.7.0, yon langaj pwogram dinamik oryante objè ki trè efikas nan devlopman pwogram epi li enkòpore pi bon karakteristik Perl, Java, Python, Smalltalk, Eiffel, Ada ak Lisp. Kòd pwojè a distribye anba lisans BSD ("2-kloz BSDL") ak "Ruby", ki refere a dènye vèsyon lisans GPL la epi li konplètman konpatib ak GPLv3. Ruby 2.7 se setyèm pi gwo lage ki fèt nan kad yon pwosesis devlopman planifye ki gen ladann mete sou kote yon ane pou amelyorasyon karakteristik ak yon lage patch 2-3 mwa.

Prensipal la amelyorasyon:

  • eksperimantal sipòte matche modèl (Modèl matche) pou itere sou objè yo bay la epi bay yon valè si gen yon matche ak modèl.

    ka [0, [1, 2, 3]] nan [a, [b, *c]] pa #=> 0
    pb # => 1
    pc # => [2, 3] fen

    ka {a: 0, b: 1}
    nan{a:0,x:1}
    : inaccessible
    nan {a: 0, b: var}
    p var # => 1
    fen

  • Koki kalkil entèaktif irb (REPL, Read-Eval-Print-Loop) kounye a gen posiblite pou koreksyon milti-liy, aplike lè l sèvi avèk yon bibliyotèk ki konpatib ak readline. liyekri nan Ruby. Sipò pou rdoc te entegre, ki pèmèt gade enfòmasyon referans sou klas espesifye, modil ak metòd nan irb. Mete aksan sou liy koulè ak kòd yo montre nan Binding#irb ak rezilta enspekte objè klas debaz yo bay.

    Lage langaj pwogram Ruby 2.7.0

  • Te ajoute yon pèseptè fatra kontra enfòmèl ant (Compaction GC) ki ka fè defragmantasyon nan yon rejyon nan memwa, rezoud pwoblèm yo nan pèfòmans dousman ak ogmante konsomasyon memwa akòz fwagmantasyon memwa ki fèt pandan operasyon an nan kèk aplikasyon Ruby milti-threaded. Pou pake objè sou pil la pwopoze GC.compact metòd pou redwi kantite paj memwa yo itilize epi optimize pil pou operasyon yo
    CoW (kopi-sou-ekri).

  • Te pote soti prepare pou separe agiman ki baze sou pozisyon nan lis la ("def foo(a,b,c)") ak mo kle ("def foo(kle: val)"). Konvèsyon agiman otomatik ki baze sou mo kle ak pozisyon yo te obsolète epi yo pa pral sipòte nan branch Ruby 3.0 la. An patikilye, li te depreche itilize dènye agiman an kòm paramèt mo kle, pase agiman ki baze sou mo kle kòm dènye paramèt hash la, ak divize dènye agiman an nan paramèt pozisyon ak mo kle.

    def foo(kle: 42); fini; foo({kle: 42}) #avèti
    def foo(**kw); fini; foo({kle: 42}) #avèti
    def foo(kle: 42); fini; foo(**{kle: 42}) # OK
    def foo(**kw); fini; foo(**{kle: 42}) # OK

    def foo(h, **kw); fini; foo(kle: 42) #avètisman
    def foo(h, key: 42); fini; foo(kle: 42) #avèti
    def foo(h, **kw); fini; foo({kle: 42}) # OK
    def foo(h, key: 42); fini; foo({kle: 42}) # OK

    def foo(h={}, kle: 42); fini; foo("key" => 43, kle: 42) #avètisman
    def foo(h={}, kle: 42); fini; foo({"key" => 43, key: 42}) # avèti
    def foo(h={}, kle: 42); fini; foo({"key" => 43}, kle: 42) # OK

    def foo(opt={}); fini; foo(kle: 42) # OK

    def foo(h, **nil); fini; foo (kle: 1) # ArgumentError
    def foo(h, **nil); fini; foo(**{kle: 1}) # ArgumentError
    def foo(h, **nil); fini; foo ("str" ​​​​ => 1) # ArgumentError
    def foo(h, **nil); fini; foo ({kle: 1}) # OK
    def foo(h, **nil); fini; foo({"str" ​​​​ => 1}) # OK

    h = {}; def foo(*a) end; foo(**h) # [] h = {}; def foo(a) end; foo(**h) # {} ak avètisman
    h = {}; def foo(*a) end; foo(h) # [{}] h = {}; def foo(a) end; foo(h) # {}

  • Posibilite itilize non varyab nimewote pa default pou paramèt blòk yo.

    [1, 2, 3].chak { mete @1 } # tankou [1, 2, 3].chak { |i| mete mwen}

  • Sipò eksperimantal pou chenn ki pa gen okenn valè inisyal.

    ary[..3] # menm jan ak ary[0..3] rel.where(sales: ..100)

  • Te ajoute metòd Enumerable#tally, ki konte konbyen fwa chak eleman rive.

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

  • Rele metòd prive pèmèt ak "pwòp tèt ou" literal

    defoo
    fen
    prive :foo
    pwòp tèt ou.foo

  • Te ajoute metòd Enumerator::Lazy#eager pou jenere enimerasyon regilye nan enimerasyon parese (Enumerator::Lazy).

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

  • Devlopman yon konpilateur JIT eksperimantal kontinye, sa ki ka siyifikativman amelyore pèfòmans aplikasyon yo nan lang Ruby. Konpilateur JIT yo te pwopoze nan Ruby premye ekri kòd C nan disk, apre sa li rele yon konpilatè C ekstèn pou jenere enstriksyon machin (GCC, Clang ak Microsoft VC ++ yo sipòte). Nouvo vèsyon an aplike yon metòd pou deplwaman inline si sa nesesè, aplikasyon selektif nan mòd optimize pandan konpilasyon, valè default "--jit-min-calls" ogmante soti nan 5 a 10000, ak "--jit-max-cache" soti nan 1000 a 100.
  • Amelyore pèfòmans CGI.escapeHTML, Monitor ak MonitorMixin.
  • Modil#name, true.to_s, false.to_s, ak nil.to_s asire ke yo retounen yon kòd ki pa chanje pou objè a espesifye.
  • Gwosè fichye binè yo te pwodwi pa metòd RubyVM::InstructionSequence#to_binary te redwi;
  • Mizajou vèsyon nan eleman entegre, ki gen ladan
    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;

  • Bibliyotèk te deplase soti nan distribisyon baz nan pakè gem ekstèn
    CMath (gem Cmath),
    Scanf (scanf gem),
    Shell (koki gem),
    Synchronizer (sync gem),
    ThreadsWait (tann gem),
    E2MM (e2mmap gem).

  • Modil stdlib default yo pibliye sou rubygems.org:
    referans,
    cgi,
    delege,
    getoptlong,
    pòp nèt,
    net smtp,
    louvri3,
    pstore,
    singleton. Siveye modil pa deplase nan rubygems.org
    obsèvatè,
    delè,
    traseur,
    uri,
    yaml, ki fè yo sèlman anbake ak Ruby-core.

  • Building Ruby kounye a mande pou yon du C ki sipòte estanda C99 la.

Sous: opennet.ru

Add nouvo kòmantè