ಅಭಿವೃದ್ಧಿಯ ಒಂದು ವರ್ಷದ ನಂತರ ಬಿಡುಗಡೆ , ಡೈನಾಮಿಕ್ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಇದು ಪ್ರೋಗ್ರಾಂ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ ಮತ್ತು ಪರ್ಲ್, ಜಾವಾ, ಪೈಥಾನ್, ಸ್ಮಾಲ್‌ಟಾಕ್, ಐಫೆಲ್, ಅದಾ ಮತ್ತು ಲಿಸ್ಪ್‌ನ ಅತ್ಯುತ್ತಮ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ. ಪ್ರಾಜೆಕ್ಟ್ ಕೋಡ್ ಅನ್ನು 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 (ಕಾಪಿ-ಆನ್-ರೈಟ್). - ಪಟ್ಟಿಯಲ್ಲಿರುವ ಸ್ಥಾನವನ್ನು ಆಧರಿಸಿ ಪ್ರತ್ಯೇಕ ವಾದಗಳನ್ನು ಸಿದ್ಧಪಡಿಸುವುದು ("ಡೆಫ್ ಫೂ(ಎ,ಬಿ,ಸಿ)") ಮತ್ತು ಕೀವರ್ಡ್‌ಗಳು ("ಡೆಫ್ ಫೂ(ಕೀ: ವ್ಯಾಲ್)"). ಕೀವರ್ಡ್‌ಗಳು ಮತ್ತು ಸ್ಥಾನದ ಆಧಾರದ ಮೇಲೆ ಸ್ವಯಂಚಾಲಿತ ಆರ್ಗ್ಯುಮೆಂಟ್ ಪರಿವರ್ತನೆಯನ್ನು ಅಸಮ್ಮತಿಸಲಾಗಿದೆ ಮತ್ತು ರೂಬಿ 3.0 ಶಾಖೆಯಲ್ಲಿ ಬೆಂಬಲಿಸುವುದಿಲ್ಲ. ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಕೊನೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಕೀವರ್ಡ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳಾಗಿ ಬಳಸಲು, ಕೀವರ್ಡ್-ಆಧಾರಿತ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಕೊನೆಯ ಹ್ಯಾಶ್ ಪ್ಯಾರಾಮೀಟರ್‌ನಂತೆ ರವಾನಿಸಲು ಮತ್ತು ಕೊನೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಸ್ಥಾನಿಕ ಮತ್ತು ಕೀವರ್ಡ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳಾಗಿ ವಿಭಜಿಸಲು ಅಸಮ್ಮತಿಸಲಾಗಿದೆ.
ಡೆಫ್ ಫೂ (ಕೀಲಿ: 42); ಅಂತ್ಯ; foo({ಕೀ: 42}) #ಎಚ್ಚರ
ಡೆಫ್ ಫೂ (**kw); ಅಂತ್ಯ; foo({ಕೀ: 42}) #ಎಚ್ಚರ
ಡೆಫ್ ಫೂ (ಕೀಲಿ: 42); ಅಂತ್ಯ; foo(**{ಕೀಲಿ: 42}) # ಸರಿ
ಡೆಫ್ ಫೂ (**kw); ಅಂತ್ಯ; foo(**{ಕೀಲಿ: 42}) # ಸರಿಡೆಫ್ ಫೂ(h, **kw); ಅಂತ್ಯ; foo(ಕೀಲಿ: 42) # ಎಚ್ಚರಿಕೆ
ಡೆಫ್ ಫೂ (ಎಚ್, ಕೀ: 42); ಅಂತ್ಯ; foo(ಕೀಲಿ: 42) # ಎಚ್ಚರಿಕೆ
ಡೆಫ್ ಫೂ(h, **kw); ಅಂತ್ಯ; foo({ಕೀ: 42}) # ಸರಿ
ಡೆಫ್ ಫೂ (ಎಚ್, ಕೀ: 42); ಅಂತ್ಯ; foo({ಕೀ: 42}) # ಸರಿಡೆಫ್ ಫೂ(h={}, ಕೀ: 42); ಅಂತ್ಯ; foo("ಕೀ" => 43, ಕೀ: 42) #ಎಚ್ಚರಿಕೆ
ಡೆಫ್ ಫೂ(h={}, ಕೀ: 42); ಅಂತ್ಯ; foo({"key" => 43, key: 42}) # ಎಚ್ಚರಿಕೆ
ಡೆಫ್ ಫೂ(h={}, ಕೀ: 42); ಅಂತ್ಯ; foo({"ಕೀ" => 43}, ಕೀ: 42) # ಸರಿಡೆಫ್ ಫೂ(ಆಯ್ಕೆ={}); ಅಂತ್ಯ; foo(ಕೀಲಿ: 42) # ಸರಿ
ಡೆಫ್ ಫೂ(h, **nil); ಅಂತ್ಯ; foo(ಕೀಲಿ: 1) # ವಾದ ದೋಷ
ಡೆಫ್ ಫೂ(h, **nil); ಅಂತ್ಯ; foo(**{key: 1}) # ವಾದ ದೋಷ
ಡೆಫ್ ಫೂ(h, **nil); ಅಂತ್ಯ; foo("str" => 1) # ವಾದ ದೋಷ
ಡೆಫ್ ಫೂ(h, **nil); ಅಂತ್ಯ; foo({ಕೀ: 1}) # ಸರಿ
ಡೆಫ್ ಫೂ(h, **nil); ಅಂತ್ಯ; foo({"str" => 1}) # ಸರಿh = {}; ಡೆಫ್ ಫೂ(*ಎ) ಅಂತ್ಯ; foo(**h) # [] h = {}; ಡೆಫ್ ಫೂ(ಎ) ಅಂತ್ಯ; foo(**h) # {} ಮತ್ತು ಎಚ್ಚರಿಕೆ
h = {}; def foo(*a) a end; foo(h) # [{}] h = {}; ಡೆಫ್ ಫೂ(ಎ) ಎ ಎಂಡ್; foo(h) # {} - ಬ್ಲಾಕ್ ನಿಯತಾಂಕಗಳಿಗಾಗಿ ಸಂಖ್ಯೆಯ ಡೀಫಾಲ್ಟ್ ವೇರಿಯಬಲ್ ಹೆಸರುಗಳನ್ನು ಬಳಸುವುದು.
[1, 2, 3].ಪ್ರತಿಯೊಂದೂ { @1 } # ನಂತೆ [1, 2, 3] ಅನ್ನು ಹಾಕುತ್ತದೆ.ಪ್ರತಿ { |i| ನಾನು ಇರಿಸುತ್ತದೆ }
- ಯಾವುದೇ ಆರಂಭಿಕ ಮೌಲ್ಯವಿಲ್ಲದ ಶ್ರೇಣಿಗಳಿಗೆ ಪ್ರಾಯೋಗಿಕ ಬೆಂಬಲ.
ary[..3] # ಅದೇ ary [0..3] rel. ಅಲ್ಲಿ (ಮಾರಾಟ: ..100)
- Enumerable#tally ವಿಧಾನವನ್ನು ಸೇರಿಸಲಾಗಿದೆ, ಇದು ಪ್ರತಿ ಅಂಶವು ಎಷ್ಟು ಬಾರಿ ಸಂಭವಿಸುತ್ತದೆ ಎಂದು ಎಣಿಕೆ ಮಾಡುತ್ತದೆ.
["a", "b", "c", "b"].tally
#=> {“a”=>1, “b”=>2, “c”=>1} - ಅಕ್ಷರಶಃ "ಸ್ವಯಂ" ನೊಂದಿಗೆ ಖಾಸಗಿ ವಿಧಾನವನ್ನು ಕರೆಯಲು ಅನುಮತಿಸಲಾಗಿದೆ
ಡೆಫ್ ಫೂ
ಕೊನೆಯಲ್ಲಿ
ಖಾಸಗಿ: foo
ಸ್ವಯಂ.ಫೂ - ಸೋಮಾರಿ ಗಣತಿದಾರರಿಂದ ನಿಯಮಿತ ಎಣಿಕೆಯನ್ನು ರಚಿಸಲು ಗಣತಿದಾರ::ಲೇಜಿ#ಉತ್ಸಾಹದ ವಿಧಾನವನ್ನು ಸೇರಿಸಲಾಗಿದೆ (ಗಣತಿದಾರ::ಲೇಜಿ).
a = %w(foo bar baz)
ಇ = 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-cache" 1000 ರಿಂದ 100 ರವರೆಗೆ.
- CGI.escapeHTML, ಮಾನಿಟರ್ ಮತ್ತು MonitorMixin ನ ಸುಧಾರಿತ ಕಾರ್ಯಕ್ಷಮತೆ.
- ಮಾಡ್ಯೂಲ್#ಹೆಸರು, true.to_s, false.to_s, ಮತ್ತು nil.to_s ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ವಸ್ತುವಿಗೆ ಬದಲಾಗದೆ ಇರುವ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
- RubyVM ::InstructionSequence#to_binary ವಿಧಾನದಿಂದ ರಚಿಸಲಾದ ಬೈನರಿ ಫೈಲ್‌ಗಳ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲಾಗಿದೆ;
- ಸೇರಿದಂತೆ ಅಂತರ್ನಿರ್ಮಿತ ಘಟಕಗಳ ನವೀಕರಿಸಿದ ಆವೃತ್ತಿಗಳು
ಬಂಡ್ಲರ್ 2.1.2, ರೂಬಿಜೆಮ್ಸ್ 3.1.2,
ರ್ಯಾಕ್ 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,
ಪ್ರತಿನಿಧಿ
ಗೆಟ್ಟಾಪ್ಲಾಂಗ್,
ನೆಟ್-ಪಾಪ್,
net-smtp
ಓಪನ್ 3,
ಅಂಗಡಿ,
ಸಿಂಗಲ್ಟನ್. ಮಾನಿಟರ್ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು rubygems.org ಗೆ ಸರಿಸಲಾಗಿಲ್ಲ
ವೀಕ್ಷಕ
ಸಮಯ ಮೀರಿದೆ
ಟ್ರೇಸರ್,
ಉರಿ,
ಯಮಲ್, ಇವುಗಳನ್ನು ರೂಬಿ-ಕೋರ್‌ನಲ್ಲಿ ಮಾತ್ರ ಸರಬರಾಜು ಮಾಡಲಾಗುತ್ತದೆ. - ರೂಬಿಯನ್ನು ನಿರ್ಮಿಸಲು ಈಗ C99 ಮಾನದಂಡವನ್ನು ಬೆಂಬಲಿಸುವ C ಕಂಪೈಲರ್ ಅಗತ್ಯವಿದೆ.
ಮೂಲ: opennet.ru