Menene jeri da yadda ake amfani da su?

Question

Accepted Answer

A **Jeri** wakilin tazara na ƙiyaye — `(1..10)` ga lambobi, `('a'..'z')` ga haruffa, da sauransu. Jeraye abubuwa ne da alaƙa da ayyuka masu amfani, ana amfani da su don itera, yanke, gwajin balantan, da `case` daidaita. Sune gindin Ruby mai taƙaitawa da bayyananniya.

## Ƙirƙirar jeraye (.. da ...)

```ruby
(1..5)        # INCLUSIVE — 1, 2, 3, 4, 5 (includes the end)
(1...5)       # EXCLUSIVE — 1, 2, 3, 4 (excludes the end)
('a'..'e')    # 'a', 'b', 'c', 'd', 'e' — works on letters too
```

Differensin mahimmaci: **`..` ya haɗa ƙarshe**, **`...` ya toshe shi** (ƙarƙashin bari uku "yana tutup ƙarshe"). Abin da za a tuna shi.

## Itera da juyawa

```ruby
(1..5).each { |n| puts n }       # iterate — 1 to 5
(1..5).to_a                       # [1, 2, 3, 4, 5] — convert to an array
(1..10).map { |n| n * 2 }         # ranges support Enumerable methods
(1..100).sum                       # 5050
(1..10).select(&:even?)            # [2, 4, 6, 8, 10]
```

Jeraye sun haɗa da Enumerable, don haka sun goyi bayyanin `each`, `map`, `select`, da sauransu — da `to_a` sai a ɗauke su zuwa jeri.

## Gwajin balantan (mai wayo)

```ruby
(1..100).include?(50)    # true
(1..100).cover?(50)       # true — faster (doesn't iterate, just checks endpoints)

age = 25
(18..65).include?(age)    # check if a value falls in a range
```

`include?`/`cover?` gwaji balantan mai wayo (musamman `cover?`, wanda kawai gwajaye ƙarshen maraka ba tare da itera ba).

## Jeraye a cikin bayyanun case da yanke

```ruby
# case/when with ranges — clean range-based branching
grade = case score
        when 90..100 then "A"
        when 80..89 then "B"
        when 0..79 then "F"
        end

# array/string slicing with ranges
[10, 20, 30, 40, 50][1..3]    # [20, 30, 40] — slice by range
"hello world"[0..4]            # "hello" — substring by range

# endless/beginless ranges (Ruby 2.6+)
arr[2..]                        # from index 2 to the end
(1..)                           # 1 to infinity (with lazy evaluation)
```

## Me ya sa yana mahimmanci

Jeraye gindin Ruby mai amfani da bayyananniya, ana amfani da su a yawancin wuraren gida, don haka fahimtar su ƙaƙƙarfan ilimi ne na yau da gida.

Su sune marɓi wakilin tazara (lambobi, haruffa) kuma suna bayyana a wasu jiya masu yawa: **itera** (`(1..5).each` — wata hanyar taƙaitawa don itera akan jere), **yanke** jeri da kamus (`arr[1..3]`, `str[0..4]` — cire wasu sassa mai wayo), **gwajin balantan** (`include?`/`cover?` — gwajaye idan ƙimar ta faɗi a tazara, tare da `cover?` yana aiki ta hanyar gwajaye ƙarshen maraka kawai), kuma musamman **`case`/`when` daidaita** (taƙaitawan yanke dangane da jeri, kamar kita ta score tazara — wata saniya ta gida, lathine).

Fahimtar mahimmancin **`..` (da ƙarshe) da `...` (tsofe ƙarshe)** bambanci yana buƙatacciya don amfani da jeraye daidai (kuma wani gindin ruɗi).

Sanin cewa jeraye sun haɗa da Enumerable (don haka su goyi bayyanin `map`/`select`/da sauransu), yadda ake amfani da su don itera, yanke, balantan, da daidaita, da sabbin abubuwa (jeraye marasa iyaka/jeraye marasa farki) ya ƙunshi ayyukan gida.

Tunda jeraye suna bayyana sau da yawa a cikin Ruby mai yuwuwar haɗi (itera, yanke, danye dangane da jeri, bincike jini), kuma tun da su wata hanyar taƙaitawa, bayyananniya don aiki da tazara, fahimtar jeraye — sune jiki (da ƙarshe da waje), ayyuka, da ayyukan gida (itera, yanke, balantan, case daidaita) — ƙaƙƙarfan, aƙi-dangantaccen ilimi ne don rubuta taƙaitaccen, idiomatic Ruby wanda ya ɗauka jeri da tazara mai wayo.