Keluaran bahasa pengaturcaraan Ruby 2.7.0

Selepas setahun pembangunan diterbitkan melepaskan Ruby 2.7.0, bahasa pengaturcaraan dinamik berorientasikan objek yang sangat cekap dalam pembangunan program dan menggabungkan ciri terbaik Perl, Java, Python, Smalltalk, Eiffel, Ada dan Lisp. Kod projek diedarkan di bawah lesen BSD (“2-klausa BSDL”) dan “Ruby”, yang merujuk kepada versi terkini lesen GPL dan serasi sepenuhnya dengan GPLv3. Ruby 2.7 ialah keluaran utama ketujuh berikutan proses pembangunan terancang yang mengambil masa setahun untuk menyediakan penambahbaikan fungsi dan menghasilkan keluaran penyelenggaraan setiap 2-3 bulan.

Utama penambahbaikan:

• percubaan menyokong padanan corak (Padanan corak), yang membolehkan anda mengulangi objek tertentu dan menetapkan nilai jika terdapat padanan dengan corak.

  kes [0, [1, 2, 3]] dalam [a, [b, *c]] pa #=> 0
  pb # => 1
  pc # => [2, 3] tamat

  kes {a: 0, b: 1}
  dalam{a:0,x:1}
  : tidak boleh dicapai
  dalam {a: 0, b: var}
  p var # => 1
  akhir

• Cangkang pengiraan interaktif irb (REPL, Read-Eval-Print-Loop) kini menampilkan pengeditan berbilang baris, dilaksanakan menggunakan perpustakaan serasi baris baca mengalah, ditulis dalam Ruby. Sokongan rdoc telah disepadukan, membolehkan anda melihat maklumat rujukan mengenai kelas, modul dan kaedah tertentu dalam irb. Disediakan penonjolan warna baris kod yang ditunjukkan melalui Binding#irb dan hasil pemeriksaan objek kelas asas.
  

• Menambahkan pemungut sampah padat (Compaction GC) yang boleh menyahfragmentasi kawasan memori, menyelesaikan masalah prestasi dan penggunaan memori yang disebabkan oleh pemecahan memori yang berlaku dalam beberapa aplikasi Ruby berbilang benang. Untuk mengemas objek pada timbunan dicadangkan Kaedah GC.compact, yang membolehkan anda mengurangkan bilangan halaman memori yang digunakan dan mengoptimumkan timbunan untuk operasi
  CoW (salinan-tulisan).

• Dijalankan bersedia untuk memisahkan hujah berdasarkan kedudukan senarai (“def foo(a,b,c)”) dan kata kunci (“def foo(key: val)”). Penukaran hujah automatik berdasarkan kata kunci dan kedudukan telah ditamatkan dan tidak akan disokong dalam cawangan Ruby 3.0. Secara khusus, ia telah ditamatkan penggunaan argumen terakhir sebagai parameter kata kunci, menghantar argumen berasaskan kata kunci sebagai parameter cincang terakhir dan membahagikan argumen terakhir kepada parameter kedudukan dan kata kunci.

  def foo(kunci: 42); akhir; foo({key: 42}) #warning
  def foo(**kw); akhir; foo({key: 42}) #warning
  def foo(kunci: 42); akhir; foo(**{key: 42}) # OK
  def foo(**kw); akhir; foo(**{key: 42}) # OK

  def foo(h, **kw); akhir; foo(kunci: 42) #amaran
  def foo(h, kunci: 42); akhir; foo(kunci: 42) #amaran
  def foo(h, **kw); akhir; foo({key: 42}) # OK
  def foo(h, kunci: 42); akhir; foo({key: 42}) # OK

  def foo(h={}, kunci: 42); akhir; foo("kunci" => 43, kunci: 42) #amaran
  def foo(h={}, kunci: 42); akhir; foo({"kunci" => 43, kunci: 42}) # diberi amaran
  def foo(h={}, kunci: 42); akhir; foo({"key" => 43}, key: 42) # OK

  def foo(opt={}); akhir; foo( kunci: 42 ) # OK

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

  h = {}; def foo(*a) tamat; foo(**h) # [] h = {}; def foo(a) tamat; foo(**h) # {} dan amaran
  h = {}; def foo(*a) tamat; foo(h) # [{}] h = {}; def foo(a) tamat; foo(h) # {}

• Peluang menggunakan nama pembolehubah bernombor secara lalai untuk parameter blok.

  [1, 2, 3].setiap { meletakkan @1 } # sama seperti [1, 2, 3].setiap { |i| meletakkan saya }

• Sokongan percubaan untuk julat tanpa nilai awal.

  ary[..3] # sama seperti ary[0..3] rel.where(jualan: ..100)

• Kaedah Enumerable#tally ditambahkan, yang mengira bilangan kali setiap elemen muncul.

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

• Panggilan kaedah peribadi dibenarkan dengan literal "diri".

  deffoo
  akhir
  peribadi :foo
  diri.foo

• Ditambah Enumerator::Lazy#eager kaedah untuk menjana penghitungan biasa daripada enumerator malas (Enumerator::Lazy).

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

• Pembangunan pengkompil JIT percubaan telah diteruskan, yang boleh meningkatkan prestasi aplikasi dalam bahasa Ruby dengan ketara. Pengkompil JIT Ruby mula-mula menulis kod C ke cakera, dan kemudian memanggil pengkompil C luaran untuk menjana arahan mesin (menyokong panggilan GCC, Clang dan Microsoft VC++). Versi baharu melaksanakan kaedah untuk penempatan sebaris jika perlu, aplikasi terpilih mod pengoptimuman semasa penyusunan dipastikan, nilai lalai "--jit-min-calls" dinaikkan daripada 5 kepada 10000, dan "--jit-max- cache” daripada 1000 hingga 100 .
• Peningkatan prestasi CGI.escapeHTML, Monitor dan MonitorMixin.
• Module#name, true.to_s, false.to_s dan nil.to_s memastikan bahawa rentetan dikembalikan yang tidak berubah untuk objek yang ditentukan.
• Saiz fail binari yang dijana oleh kaedah RubyVM::InstructionSequence#to_binary telah dikurangkan;
• Versi komponen terbina dalam yang dikemas kini, termasuk
  Bundler 2.1.2, RubyGems 3.1.2,
  Racc 1.4.15,
  CSV 3.1.2, REXML 3.2.3,
  RSS 0.2.8,
  Pengimbas Rentetan 1.0.3;

• Perpustakaan telah dipindahkan daripada pakej asas kepada pakej permata luaran
  CMath (permata cmath),
  Scanf (permata scanf),
  Shell (permata cangkang),
  Penyegerak (permata penyegerakan),
  ThreadsWait (permata thwait),
  E2MM (permata e2mmap).

• Modul stdlib lalai diterbitkan di rubygems.org:
  penanda aras,
  cgi,
  perwakilan,
  getoptlong,
  pop bersih,
  net-smtp
  buka3,
  pstore,
  bujang. memantau modul tidak dipindahkan ke rubygems.org
  pemerhati,
  masa tamat,
  pengesan,
  uri,
  yaml, yang hanya dihantar dengan teras delima.

• Membina Ruby kini memerlukan pengkompil C yang menyokong standard C99.

Sumber: opennet.ru