ਇੱਕ block ਕੋਡ ਦਾ ਇੱਕ ਖੰਡ ਹੈ ਜੋ ਇੱਕ method ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, { } (ਇੱਕ ਲਾਈਨ) ਜਾਂ do...end (ਮਲਟੀ-ਲਾਈਨ) ਵਿੱਚ ਬੰਦ ਹੁੰਦਾ ਹੈ। Blocks ਰੂਬੀ ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼, ਕੇਂਦਰੀ ਵਿਸ਼ੇਸ਼ਤਾ ਹਨ — ਇਹ ਉਹ ਤਰੀਕਾ ਹਨ ਜਿਸ ਨਾਲ ਤੁਸੀਂ methods ਨੂੰ ਵਿਵਹਾਰ ਪਾਸ ਕਰਦੇ ਹੋ, iteration, callbacks, ਅਤੇ ਰੂਬੀ ਦੇ elegant, expressive ਸਟਾਈਲ ਨੂੰ ਸ਼ਕਤੀ ਦਿੰਦੇ ਹੋ।
[, , ].each { || puts n }
[, , ].each ||
doubled = n *
puts doubled
ਇੱਕ block ਇੱਕ method ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ (ਇੱਥੇ each), ਜੋ ਹਰੇਕ ਤੱਤ ਲਈ block ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। |n| block ਦੇ parameter ਨੂੰ ਦਿਖਾਉਂਦਾ ਹੈ (ਪਾਸ ਕੀਤੀ ਗਈ ਵੈਲਯੂ)। ਦੋਨੋਂ syntaxes ਬਰਾਬਰ ਹਨ; 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 ਉਹ ਤਰੀਕਾ ਹਨ ਜਿਸ ਨਾਲ ਰੂਬੀ iteration ਅਤੇ data transformation ਕਰਦੀ ਹੈ — ਤੁਸੀਂ "ਕੀ ਕਰਨਾ ਹੈ" ਇੱਕ block ਦੇ ਤੌਰ ਤੇ ਪਾਸ ਕਰਦੇ ਹੋ, ਅਤੇ method iteration ਨੂੰ ਸਾਂਭਾਲਦਾ ਹੈ। ਇਹ explicit loops ਤੋਂ ਵਧੇਰੇ elegant ਹੈ।
# 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 blocks ਨੂੰ setup/cleanup patterns ਲਈ ਵਰਤ ਸਕਦੇ ਹਨ (ਜਿਵੇਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਕਿ ਇੱਕ file ਬੰਦ ਹੈ) — 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 blocks ਲਈ ਇੱਕ ਸੰਖੇਪ idiom ਹੈ ਜੋ ਸਿਰਫ ਹਰੇਕ ਤੱਤ ਤੇ ਇੱਕ method ਕਾਲ ਕਰਦੇ ਹਨ।
Blocks ਰੂਬੀ ਦੀ ਸਭ ਤੋਂ ਵਿਸ਼ੇਸ਼ ਅਤੇ ਕੇਂਦਰੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹਨ — ਉਹ ਬੁਨਿਆਦੀ ਹਨ ਕਿ ਰੂਬੀ ਕਿਵੇਂ ਕਾਰਜ ਕਰਦੀ ਹੈ ਅਤੇ ਇਸ ਦੇ elegant, expressive ਸਟਾਈਲ ਲਈ, ਇਸ ਲਈ ਉਨ੍ਹਾਂ ਨੂੰ ਸਮਝਣਾ ਕਿਸੇ ਵੀ ਰੂਬੀ development ਲਈ ਜ਼ਰੂਰੀ ਹੈ।
Blocks ਉਹ ਤਰੀਕਾ ਹਨ ਜਿਸ ਨਾਲ ਤੁਸੀਂ methods ਨੂੰ ਵਿਵਹਾਰ ਪਾਸ ਕਰਦੇ ਹੋ, ਜੋ ਰੂਬੀ ਦੇ ਹਸਤਾਖਰ ਵਾਲੇ iteration ਅਤੇ data transformation ਦੀ ਪਹੁੰਚ ਨੂੰ ਸ਼ਕਤੀ ਦਿੰਦੇ ਹਨ: explicit loops ਲਿਖਣ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਹਰੇਕ ਤੱਤ ਨਾਲ ਕੀ ਕਰਨਾ ਹੈ ਉਸ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੋਇਆ ਇੱਕ block ਪਾਸ ਕਰਦੇ ਹੋ (map, select, reduce, each), ਅਤੇ method iteration ਨੂੰ ਸਾਂਭਾਲਦਾ ਹੈ — ਨਤੀਜੇ ਵਜੋਂ concise, readable, functional-style ਕੋਡ ਜੋ quintessentially Ruby ਹੈ।
Blocks elegant resource management patterns ਨੂੰ ਵੀ ਯਾਸ ਕਰਦੇ ਹਨ (ਇੱਕ method setup/teardown ਨੂੰ ਸਾਂਭਾਲਦਾ ਹੈ, ਜਿਵੇਂ ਇੱਕ file ਨੂੰ auto-closing ਕਰਨਾ, ਆਪਣੇ block ਨੂੰ ਵਿਚਕਾਰ ਕਾਲ ਕਰਦਾ ਹੈ)।
Block syntax ({ } ਬਨਾਮ do...end), ਕਿਵੇਂ blocks parameters ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ (|n|), ਕਿਵੇਂ ਉਹ Enumerable methods ਨੂੰ ਸ਼ਕਤੀ ਦਿੰਦੇ ਹਨ ਜੋ ਰੂਬੀ ਵਿੱਚ ਲਗਾਤਾਰ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ, ਅਤੇ idioms ਜਿਵੇਂ &:method shorthand ਨੂੰ ਸਮਝਣਾ foundational, must-know ਗਿਆਨ ਹੈ — blocks practically ਰੂਬੀ ਦੀ ਹਰੇਕ ਲਾਈਨ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ (ਹਰੇਕ iteration, transformation, ਅਤੇ ਬਹੁਤ ਸਾਰੇ method calls)।
eBlocks ਰੂਬੀ ਦੇ ਡਿਜ਼ਾਈਨ ਅਤੇ expressive ਸਟਾਈਲ ਨਾਲ ਕੇਂਦਰੀ ਹਨ — ਇਸ ਦੀ elegant iteration, callbacks, ਅਤੇ resource-management patterns ਨੂੰ ਯਾਸ ਕਰਦੇ ਹਨ — ਉਨ੍ਹਾਂ ਨੂੰ master ਕਰਨਾ ਰੂਬੀ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਲਈ ਬਿਲਕੁਲ ਜ਼ਰੂਰੀ ਹੈ, ਅਤੇ ਉਹ ਇੱਕ ਪਰਿਭਾਸ਼ਿਤ ਵਿਸ਼ੇਸ਼ਤਾ ਹਨ ਜੋ explicit loops 'ਤੇ ਨਿਰਭਰ ਰਹਿਣ ਵਾਲੀਆਂ ਭਾਸ਼ਾਵਾਂ ਤੋਂ ਰੂਬੀ ਦੀ ਪਹੁੰਚ ਨੂੰ ਵੱਖ ਕਰਦਾ ਹੈ, ਇਨ੍ਹਾਂ ਨੂੰ ਭਾਸ਼ਾ ਨੂੰ ਸਮਝਣ ਲਈ ਇੱਕ ਵਾਰ-ਵਾਰ ਅਤੇ ਮਹੱਤਵਪੂਰਨ ਵਿਸ਼ਾ ਬਣਾਦਿੰਦੇ ਹਾ।