```html

Patrymau Dylunio yn Ruby: Gweithredu Iteratwr

Mae patrymau dylunio yn ddulliau a ddefnyddir yn gyffredin i ddatrys problemau penodol yn y broses o ddylunio meddalwedd. Mae un o'r patrymau hynny, sef y 'iteratwr', yn cynnig ffordd effeithiol o fynd trwy gasgliadau o ddata heb orfod datgelu eu strwythur mewnol. Yn yr erthygl hon, byddwn yn archwilio sut i weithredu'r iteratwr yn Ruby, gan ddefnyddio enghreifftiau cod a phwyntiau allweddol i'w hystyried.

Beth yw Iteratwr?

Mae iteratwr yn ddull a ddefnyddir i fynd trwy eitemau mewn casgliad. Mae'n caniatáu i ddefnyddwyr fynd trwy'r eitemau un ar un, gan beidio â gorfod gwybod sut mae'r casgliad wedi'i strwythuro. Mae hyn yn ddefnyddiol pan fydd angen i ni weithio gyda chasgliadau cymhleth fel rhestrau, setiau, neu hyd yn oed ddata mwy cymhleth fel cofrestriadau.

Pwysigrwydd Iteratwr

Mae gan y patwr iteratwr sawl manteision:

Hygyrchedd: Mae'n gwneud data yn haws i'w gyrchu heb orfod deall y strwythur mewnol.
Gweithredu: Mae'n caniatáu i ni greu cod sy'n hawdd ei gynnal a'i ddatblygu.
Rhyddhad: Mae'n ein rhyddhau o'r angen i reoli'r manylion yn ymwneud â'r casgliad.

Sut i Weithredu Iteratwr yn Ruby

Yn Ruby, gallwn greu iteratwr trwy ddefnyddio'r 'Enumerable' module, sy'n cynnig dulliau defnyddiol ar gyfer gweithredu iteratwr. Fodd bynnag, gallwn hefyd greu ein hunain iteratwr sy'n gweithio ar ein casgliad penodol. Gadewch i ni edrych ar sut i wneud hyn.

Creu Iteratwr Cynhwysol

Yn gyntaf, byddwn yn creu dosbarth sy'n cynrychioli ein casgliad. Byddwn yn ei alw'n 'MyCollection'. Mae'r dosbarth hwn yn cynnwys dull i ychwanegu eitemau a dull i fynd trwy'r eitemau hynny.

class MyCollection
  include Enumerable
  
  def initialize
    @items = []
  end
  
  def add(item)
    @items << item
  end
  
  def each(&block)
    @items.each(&block)
  end
end

Yn y cod uchod, rydym wedi creu dosbarth 'MyCollection' sy'n defnyddio 'Enumerable'. Mae gennym ddull 'add' i ychwanegu eitemau i'r casgliad, ac mae'r dull 'each' yn gweithredu'r iteratwr trwy fynd trwy bob eitem yn y casgliad.

Defnyddio ein Iteratwr

Bellach, gallwn ddefnyddio ein dosbarth 'MyCollection' i ychwanegu eitemau a defnyddio'r iteratwr i fynd trwy'r eitemau hynny. Dyma enghraifft o sut i wneud hynny:

collection = MyCollection.new
collection.add("Eitem 1")
collection.add("Eitem 2")
collection.add("Eitem 3")

collection.each do |item|
  puts item
end

Yn y cod hwn, rydym wedi creu enghraifft o 'MyCollection', ychwanegu tri eitem ato, ac yna defnyddio'r iteratwr i fynd trwy'r eitemau a'u printio. Mae'r canlyniad yn dangos pob eitem yn y casgliad.

Patrymau Iteratwr Eraill

Mae sawl dull o weithredu iteratwr yn Ruby. Gallwn ddefnyddio dulliau mwy cymhleth neu greu iteratwyr penodol ar gyfer ein hanghenion. Dyma rai enghreifftiau o batrymau iteratwr eraill y gallech eu hystyried:

Iteratwr Dwyfol

Gallwn greu iteratwr sy'n dychwelyd eitemau yn ôl ac ymlaen. Mae hyn yn ddefnyddiol os ydych am fynd trwy'r eitemau yn y drefn gwrthdro.

class MyBidirectionalCollection
  include Enumerable
  
  def initialize
    @items = []
  end
  
  def add(item)
    @items << item
  end
  
  def each(&block)
    @items.each(&block)
  end
  
  def reverse_each(&block)
    @items.reverse.each(&block)
  end
end

Mae'r dosbarth 'MyBidirectionalCollection' yn cynnwys dull 'reverse_each' sy'n caniatáu i ni fynd trwy'r eitemau yn y drefn gwrthdro. Gallwn ddefnyddio'r dull hwn yn yr un modd ag y defnyddiwn 'each'.

Iteratwr gyda Chyfyngiadau

Gallwn hefyd greu iteratwr sy'n gweithredu gyda chyfyngiadau penodol. Er enghraifft, gallwn greu iteratwr sy'n dychwelyd dim ond eitemau sy'n bodloni rhai meini prawf.

class MyFilteredCollection
  include Enumerable
  
  def initialize
    @items = []
  end
  
  def add(item)
    @items << item
  end
  
  def each(&block)
    @items.each(&block)
  end
  
  def filter(&block)
    @items.select(&block).each { |item| yield item }
  end
end

Mae'r dosbarth 'MyFilteredCollection' yn cynnwys dull 'filter' sy'n caniatáu i ni gymryd yn ganiataol eitemau sy'n bodloni meini prawf penodol. Gallwn ddefnyddio'r dull hwn i gael gwared ar eitemau nad ydym am eu gweld.

Casgliad

Mae iteratwyr yn offeryn pwerus yn Ruby sy'n caniatáu i ni fynd trwy gasgliadau o ddata yn effeithiol. Mae'r patrymau a drafodwyd yn yr erthygl hon yn cynnig dulliau amrywiol o weithredu iteratwr, gan gynnwys dulliau cynhwysol, dwyfol, a chyfyngedig. Mae'n bwysig deall y dulliau hyn i greu cod sy'n hawdd ei gynnal a'i ddatblygu.

Wrth i chi barhau i ddysgu am Ruby a phatrymau dylunio, cofiwch y gall iteratwyr fod yn rhan hanfodol o'ch arsenal. Mae'r gallu i fynd trwy ddata yn hawdd a phrosesu eitemau yn gwneud y broses ddatblygu yn llawer mwy effeithlon. Mae'n werth ymdrechu i ddeall sut i greu a defnyddio iteratwyr yn eich prosiectau Ruby.

Os oes gennych unrhyw gwestiynau neu os hoffech rannu eich profiadau gyda'r iteratwr yn Ruby, mae croeso i chi adael sylwadau isod.

```