A block என்பது ஒரு method-க்கு அனுப்பப்படும் குறிப்பிட்ட அளவு கோடுகளாகும், அவை { } (ஒரு வரி) அல்லது do...end (பல வரி) உள்ளடக்கப்பட்டிருக்கும். Blocks ஆனது Ruby-ன் தனிச்சிறப்பான, முக்கிய அம்சமாகும் — நீங்கள் methods-ற்கு behavior அனுப்புவதன் மூலம் iteration, callbacks, மற்றும் Ruby-ன் நேர்த்தியான, வெளிப்படையான style ஆனது இயங்குகிறது.
[, , ].each { || puts n }
[, , ].each ||
doubled = n *
puts doubled
ஒரு block ஆனது method-க்கு (இங்கே each) அனுப்பப்படுகிறது, அது ஒவ்வொரு element-க்கும் block-ஐ கூப்பிடுகிறது. |n| ஆனது block-ன் parameter-ஐ declare செய்கிறது (உள்ளே அனுப்பப்படும் மதிப்பு). இரண்டு syntax-களும் சமமாகவே இருக்கின்றன; convention ஆனது சுருக்க blocks-க்கு { } மற்றும் நீண்ட blocks-க்கு do...end உபயோகிக்கிறது.
[1, 2, 3, 4].map { |n| n * 2 } # [2, 4, 6, 8] — transform each
[1, 2, 3, 4].select { |n| n.even? } # [2, 4] — filter
[1, 2, 3, 4].reduce(0) { |sum, n| sum + n } # 10 — accumulate
3.times { |i| puts i } # 0, 1, 2
[1, 2, 3].each_with_index { |val, i| ... }
Blocks ஆனது Ruby-ன் iteration மற்றும் data transformation-ஐ செய்யும் முறையாகும் — நீங்கள் "என்ன செய்ய வேண்டும்" என்பதை block-ஆக அனுப்புகிறீர்கள், method ஆனது iteration-ஐ கையாள்கிறது. இது explicit loops-ஐ விட மிகவும் நேர்த்தியாக இருக்கிறது.
# blocks elegantly handle setup/teardown — the file is auto-closed after the block
File.open("data.txt") do |file|
puts file.read
end # file automatically closed here, even if an error occurs
Methods ஆனது setup/cleanup patterns-க்கான blocks-ஐ உபயோகிக்கலாம் (file-ஐ close செய்வது போன்ற) — method ஆனது resource-ஐ கையாள்கிறது, உங்கள் block-ஐ இடையில் கூப்பிடுகிறது.
[1, 2, 3].map { |n| n.to_s } # full block
[1, 2, 3].map(&:to_s) # shorthand — &:method calls that method on each element
["a", "b"].map(&:upcase) # ["A", "B"]
&:method shorthand ஆனது ஒரு concise idiom ஆகும் blocks-க்கு அவை ஒவ்வொரு element-ல் ஒரு method-ஐ மட்டும் கூப்பிடுகிறது.
Blocks ஆனது Ruby-ன் மிகவும் தனிச்சிறப்பான மற்றும் முக்கிய அம்சங்களில் ஒன்றாகும் — அவை Ruby எவ்வாறு வேலை செய்கிறது என்பதில் அடிப்படையாகவும் அதன் நேர்த்தியான, வெளிப்படையான style-ல் அடிப்படையாகவும் உள்ளன, ஆகவே அவற்றைப் புரிந்துகொள்வது Ruby development-க்கு அவசியமாகும்.
Blocks ஆனது methods-க்கு behavior அனுப்புவதற்கான வழியாகும், இது Ruby-ன் signature approach-ஐ iteration மற்றும் data transformation-க்கு முடக்குகிறது: நீங்கள் explicit loops-ஐ எழுதுவதற்குப் பதிலாக, நீங்கள் ஒவ்வொரு element-ல் என்ன செய்ய வேண்டும் என்பதை describe செய்கிற block-ஐ அனுப்புகிறீர்கள் (map, select, reduce, each), method ஆனது iteration-ஐ கையாள்கிறது — விளைவாக concise, readable, functional-style code ஆனது quintessentially Ruby ஆக இருக்கிறது.
Blocks ஆனது elegant resource management patterns-ஐ enable செய்கிறது (ஒரு method ஆனது setup/teardown-ஐ கையாள்கிறது, ஒரு file-ஐ auto-close செய்வது போன்ற, உங்கள் block-ஐ இடையில் கூப்பிடுகிறது).
Block syntax ({ } vs do...end), blocks எவ்வாறு parameters-ஐ பெறுகிறது (|n|), அவை Enumerable methods-க்கு எவ்வாறு power செய்கிறது அவை Ruby-ல் தொடர்ந்து தோன்றுகின்றன, மற்றும் &:method shorthand போன்ற idioms-ஐ புரிந்துகொள்வது foundational, must-know knowledge ஆகும் — blocks ஆனது idiomatic Ruby-ன் ஏறக்குறைய ஒவ்வொரு வரியிலும் தோன்றுகிறது (ஒவ்வொரு iteration, transformation, மற்றும் பல method calls).
Blocks ஆனது Ruby-ன் design மற்றும் expressive style-க்கு central ஆக இருப்பதால் — அதன் elegant iteration, callbacks, மற்றும் resource-management patterns-ஐ enable செய்வதால் — அவற்றை master செய்வது Ruby-ஐ படிப்பதற்கும் எழுதுவதற்கும் முற்றிலும் அவசியமாகும், மற்றும் அவை ஒரு defining feature ஆக இருக்கிறது Ruby-ன் approach-ஐ explicit loops-ல் நம்பிக்கை கொள்ளும் languages-ல் இருந்து வேறுபடுத்தி, அவற்றை language-ஐ புரிந்துகொள்வதற்கு ஒரு அடிக்கடி மற்றும் முக்கிய topic ஆக மாற்றுகிறது.