Delio â 'Rescue' a Gwybodaeth am Eithriadau yn Ruby

Mae Ruby, fel llawer o ieithoedd rhaglennu, yn cynnig dulliau i ddelio â phroblemau a all godi yn ystod gweithrediadau. Mae'r dulliau hyn yn cynnwys 'rescue', sy'n caniatáu i raglenni ddelio â gormod o eithriadau heb dorri. Yn yr erthygl hon, byddwn yn archwilio sut i ddefnyddio 'rescue' a sut i ddelio â gwahanol fathau o eithriadau yn Ruby.

Beth yw Eithriadau?

Mae eithriadau yn digwydd pan fydd rhywbeth yn mynd o'i le yn ystod gweithrediad. Gallai hyn fod yn ganlyniad i amrywiol resymau, megis:

Gweithrediadau ar ffeiliau nad ydynt yn bodoli
Gweithrediadau rhwydweithio sydd wedi methu
Gweithrediadau mathemategol sy'n cynhyrchu canlyniadau annormal, fel rhannu wrth sero

Mae Ruby yn caniatáu i chi ddelio â'r eithriadau hyn trwy ddefnyddio 'begin', 'rescue', a 'ensure'. Mae'r dull hwn yn eich galluogi i reoli'r eithriadau yn effeithiol a chynnal y rhaglen heb dorri.

Sut i Ddefnyddio 'Rescue'

Mae'r strwythur sylfaenol ar gyfer defnyddio 'rescue' yn Ruby yn edrych fel hyn:

begin
  # Cod sy'n gallu achosi eithriadau
rescue SomeExceptionClass
  # Cod i ddelio â'r eithriad
end

Mae 'begin' yn dechrau bloc o god, ac os bydd eithriad yn digwydd, bydd Ruby yn neidio i'r bloc 'rescue'. Gallwch benodi'r dosbarth eithriad penodol yr ydych am ei ddelio â, neu gallwch ddefnyddio 'rescue' heb ddosbarth i ddelio â phob eithriad.

Enghraifft Sylfaenol

Dyma enghraifft syml o ddefnyddio 'rescue' i ddelio â gormod o eithriadau:

def rhannu(a, b)
  begin
    a / b
  rescue ZeroDivisionError
    "Ni ellir rhannu wrth sero!"
  end
end

puts rhannu(10, 2)  # Dangosir 5
puts rhannu(10, 0)  # Dangosir "Ni ellir rhannu wrth sero!"

Yn yr enghraifft hon, pan fyddwn yn ceisio rhannu 10 wrth 0, bydd y rhaglen yn dychwelyd neges yn hytrach na chodi eithriad.

Delio â Mwy nag un Eithriad

Gallwch ddelio â mwy nag un eithriad yn y bloc 'rescue'. Mae hyn yn ddefnyddiol pan fyddwch yn gwybod y gallai sawl math o eithriadau godi. Gallwch wneud hyn trwy ddefnyddio 'rescue' gyda sawl dosbarth eithriad:

def darllen_ffeil(enw_ffeil)
  begin
    ffeil = File.open(enw_ffeil)
    # Cod i ddarllen y ffeil
  rescue Errno::ENOENT
    "Nid yw'r ffeil yn bodoli."
  rescue Errno::EACCES
    "Nid oes gennych ganiatâd i ddarllen y ffeil."
  end
end

puts darllen_ffeil("ffeiil_na_fydd_yn_bodoli.txt")  # Dangosir "Nid yw'r ffeil yn bodoli."
puts darllen_ffeil("ffeiil_di_ganiatad.txt")  # Dangosir "Nid oes gennych ganiatâd i ddarllen y ffeil."

Defnyddio 'Ensure'

Mae 'ensure' yn cynnig ffordd i sicrhau bod cod penodol yn cael ei weithredu, waeth beth fydd yn digwydd yn y bloc 'begin'. Mae hyn yn ddefnyddiol ar gyfer glanhau neu rywfaint o waith sy'n gorfod digwydd, fel cau ffeiliau neu ryddhau adnoddau.

def darllen_ffeil(enw_ffeil)
  begin
    ffeil = File.open(enw_ffeil)
    # Cod i ddarllen y ffeil
  rescue Errno::ENOENT
    "Nid yw'r ffeil yn bodoli."
  ensure
    ffeil.close if ffeil
  end
end

Yn yr enghraifft hon, bydd y ffeil yn cael ei chau, os yw wedi'i hagor, waeth beth fydd yn digwydd yn y bloc 'begin'.

Defnyddio 'Retry'

Gallwch ddefnyddio 'retry' i ailgychwyn y bloc 'begin' os bydd eithriad yn digwydd. Mae hyn yn ddefnyddiol pan fyddwch am roi cyfle arall i'r cod weithredu yn llwyddiannus.

def rhannu(a, b)
  begin
    a / b
  rescue ZeroDivisionError
    puts "Ni ellir rhannu wrth sero! Rhowch rif arall."
    b = gets.to_i
    retry
  end
end

puts rhannu(10, 0)  # Gofynnir am rif arall os bydd rhannu wrth sero

Yn yr enghraifft hon, os bydd y defnyddiwr yn ceisio rhannu wrth sero, bydd y rhaglen yn gofyn am rif arall a bydd yn ceisio rhannu eto.

Defnyddio 'rescue' gyda 'StandardError'

Os ydych am ddelio â phob eithriad sy'n deillio o 'StandardError', gallwch ddefnyddio 'rescue' heb ddosbarth penodol. Mae hyn yn ddefnyddiol pan nad ydych yn siŵr pa eithriadau a all godi.

begin
  # Cod sy'n gallu achosi eithriadau
rescue StandardError => e
  puts "Gwelwyd eithriad: #{e.message}"
end

Mae hyn yn caniatáu i chi gael gafael ar y neges eithriad a'i ddangos i'r defnyddiwr.

Casgliad

Mae delio â 'rescue' a gormod o eithriadau yn Ruby yn ffordd effeithiol o sicrhau bod eich rhaglen yn parhau i weithredu, hyd yn oed pan fydd problemau'n codi. Trwy ddefnyddio 'begin', 'rescue', 'ensure', a 'retry', gallwch reoli eithriadau yn effeithiol a chynnal profiad defnyddiwr gwell.

Mae'n bwysig cofio y gall eithriadau ddigwydd ar unrhyw adeg, felly mae'n syniad da i gynnwys dulliau i ddelio â nhw yn eich cod. Mae Ruby yn cynnig dulliau syml a chydlynol i wneud hyn, gan ei gwneud hi'n haws i ddatblygu rhaglenni cadarn a dibynadwy.

Gobeithio bod yr erthygl hon wedi rhoi gwybodaeth ddefnyddiol i chi am ddelio â 'rescue' a gormod o eithriadau yn Ruby. Peidiwch ag oedi i archwilio mwy o'r nodweddion hyn yn eich prosiectau eich hun!