Cynghorion a Thriciau Debugio Ruby

Mae debugio yn rhan hanfodol o ddatblygu meddalwedd, ac mae Ruby, gyda'i symlrwydd a'i harddwch, yn cynnig nifer o offer a dulliau i helpu datblygwyr i ddod o hyd i wallau yn eu cod. Yn yr erthygl hon, byddwn yn archwilio rhai cynghorion a thriciau defnyddiol ar gyfer debugio Ruby, gan ei gwneud yn haws i chi ddod o hyd i'r problemau a'u datrys.

1. Defnyddio'r Offer Debugio Ruby

Mae Ruby yn cynnig offer debugio pwerus sy'n eich galluogi i archwilio eich cod yn fanwl. Mae'r offer hyn yn cynnwys:

byebug - Mae'n cynnig rhyngwyneb syml i ddadansoddi cod Ruby.
pry - Mae'n caniatáu i chi argraffu gwerthoedd yn ystod gweithrediadau.
debugger - Mae'n cynnig dulliau i stopio'r rhaglen ar bwynt penodol.

1.1 Defnyddio byebug

Mae byebug yn un o'r offer debugio mwyaf poblogaidd ar gyfer Ruby. Gallwch ei ddefnyddio i stopio'r rhaglen ar bwynt penodol a dadansoddi'r cyflwr. I'w ddefnyddio, dilynwch y camau canlynol:

# Gosodwch byebug yn eich prosiect
gem install byebug

# Ychwanegwch y llinell hon i'r lleoliad lle rydych am stopio
require 'byebug'
byebug

Pan fyddwch yn cyrraedd y llinell byebug, bydd y rhaglen yn stopio, a gallwch ddefnyddio gorchmynion fel next, step, a continue i archwilio'r cod.

1.2 Defnyddio pry

Mae pry yn offeryn arall sy'n ddefnyddiol ar gyfer debugio. Mae'n cynnig rhyngwyneb rhyngweithiol sy'n eich galluogi i archwilio'r cod yn ystod ei weithrediad. I'w ddefnyddio, dilynwch y camau canlynol:

# Gosodwch pry yn eich prosiect
gem install pry

# Ychwanegwch y llinell hon i'r lleoliad lle rydych am stopio
require 'pry'
binding.pry

Pan fyddwch yn cyrraedd binding.pry, byddwch yn cael gorchymyn rhyngweithiol lle gallwch archwilio'r amgylchedd.

2. Defnyddio Gorchmynion Debugio

Mae Ruby yn cynnig nifer o orchmynion debugio sy'n eich galluogi i archwilio'r cod yn fanwl. Dyma rai o'r gorchmynion mwyaf defnyddiol:

puts - Defnyddiwch puts i argraffu gwerthoedd i'r console.
p - Mae p yn argraffu'r gwerth yn y ffordd symlaf.
inspect - Defnyddiwch inspect i gael gwell dealltwriaeth o'r gwrthrychau.

2.1 Defnyddio puts a p

Mae puts a p yn ddau orchymyn syml sy'n ddefnyddiol ar gyfer debugio. Gallwch eu defnyddio i argraffu gwerthoedd yn ystod gweithrediadau. Er enghraifft:

def cyfanswm(a, b)
  puts "Y gwerthoedd a: #{a}, b: #{b}"
  a + b
end

cyfanswm(5, 10)

Mae'r cod uchod yn argraffu'r gwerthoedd cyn dychwelyd y canlyniad.

3. Defnyddio Gwerthoedd a Gwrthrychau

Mae deall gwerthoedd a gwrthrychau yn Ruby yn hanfodol ar gyfer debugio. Mae'n bwysig gwybod sut i archwilio a dadansoddi gwrthrychau i ddod o hyd i wallau. Dyma rai cynghorion:

Defnyddiwch class i ddysgu am ddirprwy a strwythur gwrthrychau.
Defnyddiwch methods i archwilio'r dulliau sydd ar gael ar wrthrychau.
Defnyddiwch instance_variables i weld y newidynnau sydd ar gael ar wrthrychau.

3.1 Archwilio Gwrthrychau

Gallwch ddefnyddio'r gorchymyn methods i weld pa ddulliau sydd ar gael ar wrthrych. Er enghraifft:

class Person
  attr_accessor :name, :age

  def initialize(name, age)
    @name = name
    @age = age
  end
end

person = Person.new("John", 30)
puts person.methods.sort

Mae'r cod uchod yn argraffu'r holl ddulliau sydd ar gael ar y gwrthrych person.

4. Defnyddio Gweithdrefnau a Chyfnodau

Mae gweithdrefnau a chyfnodau yn ffordd dda o drefnu eich cod a gwneud debugio yn haws. Mae'n bwysig defnyddio gweithdrefnau i rannu cod yn ddarnau llai a haws i'w dadansoddi.

Defnyddiwch weithdrefnau i ddelio â phrosesau penodol.
Defnyddiwch gyfnodau i gadw trac o'r cyflwr.
Defnyddiwch enghreifftiau i brofi gweithdrefnau.

4.1 Defnyddio Gweithdrefnau

Gallwch greu gweithdrefnau i ddelio â phrosesau penodol. Er enghraifft:

def cyfrif(a, b)
  a + b
end

def argraffu_cyfrif(a, b)
  puts "Y cyfrif o #{a} a #{b} yw: #{cyfrif(a, b)}"
end

argraffu_cyfrif(5, 10)

Mae'r cod uchod yn creu gweithdrefn i gyfrif a'i argraffu.

5. Defnyddio Testunau a Chymorth

Mae testunau a chymorth yn hanfodol ar gyfer debugio. Mae'n bwysig defnyddio testunau i gadw trac o'r cyflwr a chymorth i ddadansoddi'r cod.

Defnyddiwch raise i godi eithriad pan fydd problem yn codi.
Defnyddiwch begin...rescue i ddelio â phroblemau.
Defnyddiwch logger i gofrestru gwybodaeth am y broses.

5.1 Defnyddio raise a rescue

Gallwch ddefnyddio raise i godi eithriad pan fydd problem yn codi. Er enghraifft:

def rhif(a)
  raise "Mae'n rhaid i a fod yn rhif" unless a.is_a?(Numeric)
  a * 2
end

begin
  puts rhif("test")
rescue => e
  puts "Cafodd eithriad: #{e.message}"
end

Mae'r cod uchod yn codi eithriad os nad yw'r gwerth a roddir yn rhif.

6. Casglu a Dadansoddi Data Debugio

Mae casglu a dadansoddi data debugio yn hanfodol ar gyfer deall problemau yn eich cod. Mae'n bwysig defnyddio dulliau i gasglu gwybodaeth am y broses.

Defnyddiwch puts i argraffu gwybodaeth.
Defnyddiwch logger i gofrestru gwybodaeth.
Defnyddiwch binding.pry i archwilio'r cyflwr.

6.1 Defnyddio logger

Gallwch ddefnyddio logger i gofrestru gwybodaeth am y broses. Er enghraifft:

require 'logger'

logger = Logger.new(STDOUT)
logger.info("Mae'r rhaglen yn dechrau")

def rhif(a)
  logger.info("Y gwerth a roddwyd yw: #{a}")
  a * 2
end

puts rhif(5)

Mae'r cod uchod yn cofrestru gwybodaeth am y broses.

Casgliad

Mae debugio yn rhan hanfodol o ddatblygu meddalwedd, ac mae Ruby yn cynnig nifer o offer a dulliau i helpu datblygwyr i ddod o hyd i wallau yn eu cod. Trwy ddefnyddio'r cynghorion a'r triciau a drafodwyd yn yr erthygl hon, gallwch wneud debugio yn haws ac yn fwy effeithiol. Cofiwch, mae'r broses hon yn cymryd amser a phrofiad, felly peidiwch â phoeni os nad ydych yn dod o hyd i'r ateb ar unwaith. Mae pob cam yn eich helpu i ddod yn ddatblygwr gwell!