როგორ მუშაობს yield მეთოდებში?

Question

Accepted Answer

**`yield`** იძახებს **ბლოკს**, რომელიც გადმოცემულია მეთოდს — იგი გადაცემს კონტროლს ბლოკს, სურვილის შემთხვევაში მეთოდ მეთოდს მნიშვნელობებს, შემდეგ კი აგრძელებს მეთოდს. ეს არის ის, თუ როგორ იძახებენ მეთოდები მათ მიერ მოცემულ ბლოკებს, და ეს არის მექანიზმი Ruby-ის გამეორების და მრავალი ელეგანტური პატერნის უკან.

## ძირითადი yield — გამოძახე მოცემული ბლოკი

```ruby
def greet
  puts "before"
  yield                    # calls the block passed to greet
  puts "after"
end

greet { puts "hello" }
# Output: before / hello / after
```

როდესაც მეთოდი `yield`-ს იძახებს, იგი ეშვებს ბლოკს, რომელიც მას გადმოცემული იყო (`{ }` ან `do...end`-ში). მეთოდი აკონტროლებს *როდის* (და რამდენჯერ) ბლოკი ეშვება.

## yield არგუმენტებით — გადაეცი მნიშვნელობები ბლოკს

```ruby
def each_pair
  yield("a", 1)          # pass values to the block's parameters
  yield("b", 2)
end

each_pair { |key, value| puts "#{key}: #{value}" }
# Output: a: 1 / b: 2
```

`yield(args)` გადაცემს მნიშვნელობებს ბლოკის პარამეტრებს (`|key, value|`) — ეს არის ის, თუ როგორ იძლევა გამეორების მეთოდები თითოეულ ელემენტს ბლოკს.

## გამეორების დანერგვა yield-ის საშუალებით

```ruby
def my_each(array)
  i = 0
  while i < array.length
    yield(array[i])        # yield each element to the block
    i += 1
  end
end

my_each([1, 2, 3]) { |n| puts n * 2 }   # 2, 4, 6
# this is essentially how Array#each works internally!
```

ეს აჩვენებს, თუ როგორ მუშაობენ Ruby-ის გამეორების მეთოდები (`each`, `map` და სხვა) შიგნით — ისინი `yield`-ს იძახებენ თითოეული ელემენტისთვის ბლოკ.

## block_given? და ბლოკის ჩაჭერა

```ruby
def maybe_yield
  if block_given?          # check whether a block was passed (avoid an error)
    yield
  else
    "no block"
  end
end

# explicitly capture the block as a parameter (with &)
def run(&block)            # &block captures the block as a Proc object
  block.call               # call it explicitly
end
```

`block_given?` შეამოწმებს, გადმოცემული იყო თუ არა ბლოკი (ერიდება `LocalJumpError`-ს), და `&block` ჩაჭერს ბლოკს როგორც Proc ობიექტი, რომელიც შეგიძლია შეინახო ან გადაწადო.

## რატომ მნიშვნელოვანი

`yield`-ის გაგება მნიშვნელოვანი Ruby ცოდნაა — ეს არის მექანიზმი, რომლითაც მეთოდები იძახებენ ბლოკებს, რაც Ruby-ის ხელმოკიდე გამეორების საფუძველია და მრავალი ელეგანტური პატერნის უკან დგას, ამიტომ მისი გაგება ნათელს ჰფენს Ruby-ის ფუნქციონირების ბევრ ასპექტს. `yield` იძახებს მეთოდს გადმოცემულ ბლოკს (კონტროლს გადაცემს მას, სურვილის შემთხვევაში მნიშვნელობებს გადაცემს), რაც ზუსტად ის არის, თუ როგორ მუშაობენ Ruby-ის გამეორების მეთოდები (`each`, `map`, `select`) შიგნით — ისინი `yield`-ს იძახებენ თითოეული ელემენტისთვის ბლოკ.

ამის გაგება მოხსნის Ruby-ის ბლოკზე დაფუძნებული გამეორების საიდუმლოებას და საშუალებას გაძლევს **დაწერო საკუთარი მეთოდები, რომლებიც ბლოკებს იღებენ** — ძლევა შესაძლებლობა გამოხატვის სპეციფიკური API-ების, მასშტაბური გამეორების, რესურსების მართვის მეთოდების (setup/teardown ბლოკის გარშემო) და DSL-ების შესაქმნელად.

`yield`-ის (ბლოკის იძახება, მნიშვნელობების გადაცემა მას), `block_given?`-ის (უსაფრთხოდ შეამოწმე, თუ არა გადმოცემული ბლოკი, ხარვეზების თავიდან აცილება) და `&block`-ის (ცალსახად ჩაჭერი ბლოკი როგორც Proc) ცოდნა მნიშვნელოვანია როგორც Ruby-ის გამეორების და ბლოკებს მიმღები მეთოდების გაგებისთვის, ასევე საკუთარი ბლოკზე დაფუძნებული მეთოდების დასაწერად.

ვინაიდან ბლოკები ცენტრალური Ruby-ის შემდეგ და `yield` არის ის, თუ როგორ იყენებენ მეთოდები მათ, `yield`-ის გაგება აღრმავებს Ruby-ის ყველაზე განმასხეველი მახასიათებლის (ბლოკების) გაგებას და აძლევს ძალას დაწერო ელეგანტური, ბლოკებს მიმღები მეთოდები, რომლებიც Ruby-ს გამომხატველს ხდის — ღირებული უნარი სუფთა API-ების აგებისთვის და ხშირი ინტერვიუს თემა, რომელიც ასახავს Ruby-ის ბლოკის მექანიზმის რეალური ფუნქციონირების გაგებას.