રૂબી પ્રોગ્રામિંગ ભાષાનું પ્રકાશન 2.7.0

વિકાસના એક વર્ષ પછી પ્રકાશિત પ્રકાશન રૂબી 2.7.0, એક ગતિશીલ, ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગ લેંગ્વેજ કે જે પ્રોગ્રામ ડેવલપમેન્ટમાં અત્યંત કાર્યક્ષમ છે અને પર્લ, જાવા, પાયથોન, સ્મોલટૉક, એફિલ, એડા અને લિસ્પની શ્રેષ્ઠ સુવિધાઓનો સમાવેશ કરે છે. પ્રોજેક્ટ કોડ BSD (“2-ક્લોઝ BSDL”) અને “રુબી” લાઇસન્સ હેઠળ વિતરિત કરવામાં આવે છે, જે GPL લાયસન્સનાં નવીનતમ સંસ્કરણનો સંદર્ભ આપે છે અને GPLv3 સાથે સંપૂર્ણપણે સુસંગત છે. રૂબી 2.7 એ આયોજિત વિકાસ પ્રક્રિયાના ભાગ રૂપે પૂર્ણ થનારી સાતમી મુખ્ય રજૂઆત છે, જેમાં કાર્યાત્મક સુધારાઓ તૈયાર કરવા અને દર 2-3 મહિને જાળવણી પ્રકાશનો બનાવવા માટે એક વર્ષનો સમય લાગે છે.

મુખ્ય સુધારાઓ:

• પ્રાયોગિક આધાર પેટર્ન મેચિંગ (પેટર્ન મેચિંગ) આપેલ ઑબ્જેક્ટ પર પુનરાવર્તિત કરવા અને જો પેટર્ન મેચ હોય તો મૂલ્ય અસાઇન કરવા માટે.

  કેસ [0, [1, 2, 3]] [a, [b, *c]] pa #=> 0 માં
  pb #=> 1
  pc #=> [2, 3] અંત

  કેસ {a: 0, b: 1}
  {a: 0, x: 1} માં
  :અનુપલબ્ધ
  {a: 0, b: var} માં
  p var #=> 1
  અંત

• ઇન્ટરેક્ટિવ કેલ્ક્યુલેશન્સ irb (REPL, Read-Eval-Print-Loop) ના શેલમાં હવે મલ્ટી-લાઇન એડિટિંગની શક્યતા છે, જે રીડલાઇન-સુસંગત લાઇબ્રેરીનો ઉપયોગ કરીને અમલમાં છે. લાઇનરૂબી માં લખાયેલ. rdoc માટે આધાર સંકલિત કરવામાં આવ્યો છે, જે irb માં ઉલ્લેખિત વર્ગો, મોડ્યુલો અને પદ્ધતિઓ પર સંદર્ભ માહિતી જોવા માટે પરવાનગી આપે છે. Binding#irb દ્વારા દર્શાવેલ કોડ સાથે લીટીઓનું રંગીન હાઇલાઇટિંગ અને બેઝ ક્લાસ ઑબ્જેક્ટ્સનું નિરીક્ષણ કરવાના પરિણામો પ્રદાન કરવામાં આવે છે.
  

• એક કોમ્પેક્ટ ગાર્બેજ કલેક્ટર (કોમ્પેક્શન GC) ઉમેર્યું જે મેમરીના વિસ્તારને ડિફ્રેગમેન્ટ કરી શકે છે, ધીમી કામગીરીની સમસ્યાઓ અને મેમરી ફ્રેગમેન્ટેશનને કારણે વધેલી મેમરી વપરાશની સમસ્યાઓ હલ કરી શકે છે જે કેટલીક મલ્ટી-થ્રેડેડ રૂબી એપ્લિકેશનના સંચાલન દરમિયાન થાય છે. ઢગલા પર વસ્તુઓ પેક કરવા માટે સૂચવ્યું GC.compact પદ્ધતિ, જે તમને ઉપયોગમાં લેવાતા મેમરી પૃષ્ઠોની સંખ્યા ઘટાડવા અને કામગીરી માટે ઢગલા ઑપ્ટિમાઇઝ કરવાની પરવાનગી આપે છે.
  CoW (કોપી-ઓન-રાઇટ).

• હાથ ધરવામાં આવી હતી યાદી ("def foo(a,b,c)") અને કીવર્ડ્સ ("def foo(key: val)")માં સ્થાનના આધારે અલગ-અલગ દલીલો કરવાની તૈયારી. કીવર્ડ્સ અને સ્થિતિ પર આધારિત સ્વચાલિત દલીલ રૂપાંતરણને નાપસંદ કરવામાં આવ્યું છે અને રૂબી 3.0 શાખામાં તેને સમર્થન આપવામાં આવશે નહીં. ખાસ કરીને, કીવર્ડ પેરામીટર તરીકે છેલ્લી દલીલનો ઉપયોગ કરવા, છેલ્લા હેશ પેરામીટર તરીકે કીવર્ડ-આધારિત દલીલો પસાર કરવા અને છેલ્લી દલીલને સ્થિતિકીય અને કીવર્ડ પરિમાણોમાં વિભાજિત કરવા માટે તેને નાપસંદ કરવામાં આવ્યું છે.

  def foo (કી: 42); અંત foo({key: 42}) # ચેતવણી આપી
  def foo(**kw); અંત foo({key: 42}) # ચેતવણી આપી
  def foo (કી: 42); અંત foo(**{key: 42}) # બરાબર
  def foo(**kw); અંત foo(**{key: 42}) # બરાબર

  def foo(h, **kw); અંત foo(key: 42) # ચેતવણી આપી
  def foo(h, કી: 42); અંત foo(કી: 42) #ચેતવણી
  def foo(h, **kw); અંત foo({key: 42}) # બરાબર
  def foo(h, કી: 42); અંત foo({key: 42}) # બરાબર

  def foo(h={}, કી: 42); અંત foo("key" => 43, કી: 42) #ચેતવણી
  def foo(h={}, કી: 42); અંત foo({"key" => 43, કી: 42}) # ચેતવણી આપી
  def foo(h={}, કી: 42); અંત foo({"key" => 43}, કી: 42) # બરાબર

  def foo(opt={}); અંત foo (કી: 42) # બરાબર

  def foo(h, **nil); અંત foo(કી: 1) #ArgumentError
  def foo(h, **nil); અંત foo(**{કી: 1}) # દલીલની ભૂલ
  def foo(h, **nil); અંત foo("str" ​​=> 1) # દલીલની ભૂલ
  def foo(h, **nil); અંત foo({key: 1}) # બરાબર
  def foo(h, **nil); અંત foo({"str" ​​=> 1}) # બરાબર

  h = {}; def foo(*a) અંત; foo(**h) # [] h = {}; def foo(a) અંત; foo(**h) # {} અને ચેતવણી
  h = {}; def foo(*a) એક અંત; foo(h) # [{}] h = {}; def foo(a) એ અંત; foo(h) # {}

• તક બ્લોક પરિમાણો માટે ક્રમાંકિત ડિફૉલ્ટ ચલ નામોનો ઉપયોગ કરીને.

  [1, 2, 3].દરેક { @1 મૂકે છે } # જેમ [1, 2, 3].દરેક { |i| મૂકે છે }

• પ્રારંભિક મૂલ્ય વિનાની શ્રેણીઓ માટે પ્રાયોગિક સમર્થન.

  ary[..3] # ary[0..3] rel.where(સેલ્સ: ..100) જેવું જ

• ગણનાપાત્ર #tally પદ્ધતિ ઉમેરવામાં આવી છે, જે દરેક ઘટક કેટલી વખત દેખાય છે તેની ગણતરી કરે છે.

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

• શાબ્દિક "સ્વ" સાથે ખાનગી પદ્ધતિને કૉલ કરવાની મંજૂરી

  ડિફૂ
  અંત
  ખાનગી :foo
  સ્વ.ફૂ

• આળસુ ગણક (ગણક::આળસુ) માંથી નિયમિત ગણતરી જનરેટ કરવા માટે ગણતરીકાર::Lazy#eager પદ્ધતિ ઉમેરવામાં આવી.

  a = %w(foo બાર બાઝ)
  e = a.lazy.map {|x| x.upcase }.નકશો {|x| x + "!" }.આતુર
  p e.class #=> ગણતરીકાર
  e.નકશો {|x| x + "?" } #=> [“FOO!?”, “BAR!?”, “BAZ!?”]

• પ્રાયોગિક JIT કમ્પાઇલરનો વિકાસ ચાલુ રાખ્યો છે, જે રૂબી ભાષામાં એપ્લિકેશનના પ્રદર્શનમાં નોંધપાત્ર સુધારો કરી શકે છે. રૂબીમાં પ્રસ્તાવિત JIT કમ્પાઈલર પહેલા ડિસ્ક પર C કોડ લખે છે, ત્યારબાદ તે મશીન સૂચનાઓ જનરેટ કરવા માટે બાહ્ય C કમ્પાઈલરને કૉલ કરે છે (GCC, Clang અને Microsoft VC ++ સપોર્ટેડ છે). નવું સંસ્કરણ જો જરૂરી હોય તો ઇનલાઇન જમાવટ માટેની પદ્ધતિનો અમલ કરે છે, સંકલન દરમિયાન ઑપ્ટિમાઇઝેશન મોડ્સની પસંદગીયુક્ત એપ્લિકેશન, "--જીત-મીન-કોલ્સ" ની ડિફોલ્ટ મૂલ્ય 5 થી વધારીને 10000 કરવામાં આવે છે, અને "-જીત-મેક્સ-કેશ" 1000 થી 100 સુધી.
• CGI.escapeHTML, Monitor અને MonitorMixin નું બહેતર પ્રદર્શન.
• મોડ્યુલ#નામ, true.to_s, false.to_s અને nil.to_s ખાતરી કરે છે કે સ્ટ્રિંગ પરત કરવામાં આવે છે જે ઉલ્લેખિત ઑબ્જેક્ટ માટે અપરિવર્તિત છે.
• RubyVM::InstructionSequence#to_binary પદ્ધતિ દ્વારા જનરેટ થયેલ બાઈનરી ફાઈલોનું કદ ઘટાડવામાં આવ્યું છે;
• બિલ્ટ-ઇન ઘટકોના અપડેટ કરેલ સંસ્કરણો, સહિત
  બંડલર 2.1.2, રૂબીજેમ્સ 3.1.2,
  Racc 1.4.15,
  CSV 3.1.2, REXML 3.2.3,
  RSS 0.2.8,
  સ્ટ્રિંગસ્કેનર 1.0.3;

• પુસ્તકાલયો બેઝ ડિસ્ટ્રિબ્યુશનમાંથી બહારના રત્ન પેકેજોમાં ખસેડવામાં આવી છે
  CMath (cmath રત્ન),
  સ્કેનફ (સ્કેનફ રત્ન),
  શેલ (શેલ રત્ન)
  સિંક્રોનાઇઝર (સિંક રત્ન),
  થ્રેડ્સ રાહ જુઓ (થ્વેટ રત્ન),
  E2MM (e2mmap રત્ન).

• મૂળભૂત stdlib મોડ્યુલો rubygems.org પર પ્રકાશિત થાય છે:
  બેન્ચમાર્ક
  cgi
  પ્રતિનિધિ,
  લાંબા સમય સુધી,
  નેટ-પોપ,
  નેટ-smtp
  ઓપન3,
  pstore,
  સિંગલટન મોનિટર મોડ્યુલો rubygems.org પર ખસેડાયા નથી
  નિરીક્ષક
  સમયસમાપ્તિ
  ટ્રેસર
  ઉરી,
  yaml, જે માત્ર રુબી-કોરમાં પૂરા પાડવામાં આવે છે.

• રૂબીનું નિર્માણ કરવા માટે હવે C કમ્પાઇલરની જરૂર છે જે C99 સ્ટાન્ડર્ડને સપોર્ટ કરે છે.

સોર્સ: opennet.ru