ఒక సంవత్సరం అభివృద్ధి తర్వాత విడుదల , ప్రోగ్రామ్ డెవలప్‌మెంట్‌లో అత్యంత ప్రభావవంతమైన మరియు పెర్ల్, జావా, పైథాన్, స్మాల్‌టాక్, ఈఫిల్, అడా మరియు లిస్ప్ యొక్క ఉత్తమ ఫీచర్‌లను కలిగి ఉన్న డైనమిక్ ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ లాంగ్వేజ్. ప్రాజెక్ట్ కోడ్ 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
ముగింపు - ఇంటరాక్టివ్ లెక్కల షెల్ (REPL, రీడ్-ఎవల్-ప్రింట్-లూప్) ఇప్పుడు రీడ్‌లైన్-అనుకూల లైబ్రరీని ఉపయోగించి అమలు చేయబడిన బహుళ-లైన్ సవరణకు అవకాశం ఉంది. రూబీలో వ్రాయబడింది. rdoc మద్దతు ఏకీకృతం చేయబడింది, ఇది irbలో పేర్కొన్న తరగతులు, మాడ్యూల్స్ మరియు పద్ధతులపై సూచన సమాచారాన్ని వీక్షించడానికి మిమ్మల్ని అనుమతిస్తుంది. బైండింగ్#irb మరియు బేస్ క్లాస్ ఆబ్జెక్ట్‌ల తనిఖీ ఫలితాల ద్వారా చూపబడిన కోడ్ పంక్తుల యొక్క రంగు హైలైటింగ్ అందించబడింది.
- కొన్ని బహుళ-థ్రెడ్ రూబీ అప్లికేషన్‌లలో సంభవించే మెమరీ ఫ్రాగ్మెంటేషన్ వల్ల ఏర్పడే పనితీరు మరియు మెమరీ వినియోగ సమస్యలను పరిష్కరించడం, మెమరీ ప్రాంతాన్ని డీఫ్రాగ్మెంట్ చేయగల కాంపాక్ట్ గార్బేజ్ కలెక్టర్ (కంపాక్షన్ GC) జోడించబడింది. కుప్పపై వస్తువులను ప్యాక్ చేయడానికి GC.compact పద్ధతి, ఇది ఉపయోగించిన మెమరీ పేజీల సంఖ్యను తగ్గించడానికి మరియు ఆపరేషన్ల కోసం హీప్‌ను ఆప్టిమైజ్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది
CW (కాపీ-ఆన్-రైట్). - జాబితాలోని స్థానం ("def foo(a,b,c)") మరియు కీలకపదాలు ("def foo(key: val)") ఆధారంగా వాదనలను వేరు చేయడానికి సిద్ధమౌతోంది. కీలకపదాలు మరియు స్థానం ఆధారంగా ఆటోమేటిక్ ఆర్గ్యుమెంట్ మార్పిడి నిలిపివేయబడింది మరియు రూబీ 3.0 బ్రాంచ్‌లో మద్దతు ఇవ్వబడదు. ప్రత్యేకించి, చివరి ఆర్గ్యుమెంట్‌ని కీవర్డ్ పారామీటర్‌లుగా ఉపయోగించడం, కీవర్డ్-ఆధారిత ఆర్గ్యుమెంట్‌లను చివరి హాష్ పారామీటర్‌గా పాస్ చేయడం మరియు చివరి ఆర్గ్యుమెంట్‌ను పొజిషనల్ మరియు కీవర్డ్ పారామీటర్‌లుగా విభజించడం విస్మరించబడింది.
డెఫ్ ఫూ(కీ: 42); ముగింపు; foo({కీ: 42}) #హెచ్చరించబడింది
def foo (**kw); ముగింపు; foo({కీ: 42}) #హెచ్చరించబడింది
డెఫ్ ఫూ(కీ: 42); ముగింపు; foo(**{కీ: 42}) # సరే
డెఫ్ ఫూ (**kw); ముగింపు; foo(**{కీ: 42}) # సరేడెఫ్ ఫూ(h, **kw); ముగింపు; foo(కీ: 42) #హెచ్చరించింది
డెఫ్ ఫూ(h, కీ: 42); ముగింపు; foo(కీ: 42) # హెచ్చరించింది
డెఫ్ ఫూ(h, **kw); ముగింపు; foo({కీ: 42}) # సరే
డెఫ్ ఫూ(h, కీ: 42); ముగింపు; foo({కీ: 42}) # సరేడెఫ్ ఫూ(h={}, కీ: 42); ముగింపు; foo("కీ" => 43, కీ: 42) #హెచ్చరించబడింది
డెఫ్ ఫూ(h={}, కీ: 42); ముగింపు; foo({"కీ" => 43, కీ: 42}) # హెచ్చరించింది
డెఫ్ ఫూ(h={}, కీ: 42); ముగింపు; foo({"కీ" => 43}, కీ: 42) # సరేడెఫ్ ఫూ(opt={}); ముగింపు; foo(కీ: 42) # సరే
def foo(h, **nil); ముగింపు; foo(కీ: 1) # వాదన లోపం
def foo(h, **nil); ముగింపు; foo(**{కీ: 1}) # వాదన లోపం
def foo(h, **nil); ముగింపు; foo("str" => 1) # వాదన లోపం
def foo(h, **nil); ముగింపు; foo({కీ: 1}) # సరే
def foo(h, **nil); ముగింపు; foo({"str" => 1}) # సరేh = {}; def foo(*a) ముగింపు; foo(**h) # [] h = {}; def foo(a) end; foo(**h) # {} మరియు హెచ్చరిక
h = {}; def foo(*a) ముగింపు; foo(h) # [{}] h = {}; def foo(a) end; foo(h) # {} - బ్లాక్ పారామీటర్ల కోసం నంబర్డ్ డిఫాల్ట్ వేరియబుల్ పేర్లను ఉపయోగించడం.
[1, 2, 3].ప్రతి {1ని ఉంచుతుంది } # వంటి [1, 2, 3].ప్రతి { |i| నేను ఉంచుతుంది }
- ప్రారంభ విలువ లేని పరిధుల కోసం ప్రయోగాత్మక మద్దతు.
ary[..3] # అదే ary[0..3] rel. ఎక్కడ(అమ్మకాలు: ..100)
- ఎన్యూమరబుల్#టాలీ పద్ధతి జోడించబడింది, ఇది ప్రతి మూలకం ఎన్నిసార్లు సంభవిస్తుందో లెక్కించబడుతుంది.
["a", "b", "c", "b"].tally
#=> {"a"=>1, "b"=>2, "c"=>1} - "సెల్ఫ్" లిటరల్‌తో ప్రైవేట్ పద్ధతి కాల్ అనుమతించబడుతుంది
defoo
ముగింపు
ప్రైవేట్: foo
self.foo - సోమరి గణనదారు (ఎన్యూమరేటర్:: లేజీ) నుండి సాధారణ గణనను రూపొందించడానికి ఎన్యూమరేటర్::లేజీ#ఆత్రుత పద్ధతిని జోడించారు.
a = %w(foo bar baz)
e = a.lazy.map {|x| x.upcase }.మ్యాప్ {|x| x + "!" }.ఆత్రుత
p e.class #=> ఎన్యుమరేటర్
ఇ.మ్యాప్ {|x| x + "?" } #=> [“FOO!?”, “BAR!?”, “BAZ!?”] - ప్రయోగాత్మక JIT కంపైలర్ అభివృద్ధి కొనసాగింది, ఇది రూబీ భాషలో అప్లికేషన్‌ల పనితీరును గణనీయంగా మెరుగుపరుస్తుంది. రూబీ యొక్క JIT కంపైలర్ మొదట C కోడ్‌ను డిస్క్‌కి వ్రాస్తాడు, ఆపై మెషీన్ సూచనలను రూపొందించడానికి బాహ్య C కంపైలర్‌ని పిలుస్తుంది (GCC, క్లాంగ్ మరియు Microsoft VC++కి కాల్ చేయడానికి మద్దతు ఇస్తుంది). కొత్త వెర్షన్ అవసరమైతే ఇన్‌లైన్ డిప్లాయ్‌మెంట్ కోసం ఒక పద్ధతిని అమలు చేస్తుంది, సంకలనం సమయంలో ఆప్టిమైజేషన్ మోడ్‌ల ఎంపిక చేసిన అప్లికేషన్ నిర్ధారించబడుతుంది, “--jit-min-calls” డిఫాల్ట్ విలువ 5 నుండి 10000కి పెరిగింది మరియు “--jit-max- కాష్” 1000 నుండి 100 వరకు.
- CGI.escapeHTML, మానిటర్ మరియు 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,
స్టోర్,
సింగిల్టన్. మానిటర్ మాడ్యూల్స్ rubygems.orgకి తరలించబడలేదు
పరిశీలకుడు
సమయం ముగిసినది,
ట్రేసర్
ఊరి,
yaml, ఇది రూబీ-కోర్‌తో మాత్రమే రవాణా చేయబడుతుంది. - రూబీని నిర్మించడానికి ఇప్పుడు C99 ప్రమాణానికి మద్దతు ఇచ్చే C కంపైలర్ అవసరం.
మూలం: opennet.ru