Procs a Lambdas yn Ruby: Esboniad

Mae Ruby yn iaith raglennu sy'n cynnig llawer o nodweddion pwerus, ac un o'r rhai mwyaf defnyddiol yw'r gallu i ddefnyddio procs a lambdas. Mae'r ddau yn ddulliau o greu blociau o god sy'n gallu cael eu hailddefnyddio, ond maent yn gweithredu mewn ffyrdd ychydig yn wahanol. Yn yr erthygl hon, byddwn yn archwilio'r gwahaniaethau rhwng procs a lambdas, sut i'w defnyddio, a pham y gallant fod yn ddefnyddiol yn eich cod Ruby.

Beth yw Proc?

Mae proc (cynhelwr) yn ddull o greu bloc o god a all gael ei storio mewn newidyn. Mae procs yn caniatáu i chi greu cod a all gael ei ail-ddefnyddio yn hawdd. Mae procs yn cael eu creu gan ddefnyddio'r clas Proc neu drwy ddefnyddio'r gair allweddol proc.

Sut i greu Proc

Dyma enghraifft o sut i greu proc:

my_proc = proc { |x| puts "Y gwerth yw: #{x}" }

Gallwch nawr alw'r proc hwn gyda gwerth penodol:

my_proc.call(10)  # Bydd yn argraffu "Y gwerth yw: 10"

Beth yw Lambda?

Mae lambda yn debyg i proc, ond mae ganddo rai gwahaniaethau pwysig. Mae lambdas yn gweithredu fel gweithredwyr, sy'n golygu eu bod yn gorfod derbyn y nifer gywir o ddirprwyadau. Os na chaiff y nifer gywir o ddirprwyadau ei rhoi, bydd yn codi gwall.

Sut i greu Lambda

Dyma enghraifft o sut i greu lambda:

my_lambda = ->(x) { puts "Y gwerth yw: #{x}" }

Gallwch alw'r lambda yn yr un modd â proc:

my_lambda.call(20)  # Bydd yn argraffu "Y gwerth yw: 20"

Gwahaniadau rhwng Procs a Lambdas

Er bod procs a lambdas yn debyg, mae rhai gwahaniaethau allweddol rhwng y ddau:

Gwerth Derbyn: Mae lambda yn gorfod derbyn y nifer gywir o ddirprwyadau, tra bod proc yn derbyn unrhyw nifer o ddirprwyadau.
Gwrthdaro: Os byddwch chi'n defnyddio return yn lambda, bydd yn dychwelyd i'r gweithredwr sy'n ei alw. Fodd bynnag, os byddwch chi'n defnyddio return yn proc, bydd yn dychwelyd i'r lleoliad ble cafodd y proc ei greu.
Gweithrediad: Mae lambdas yn gweithredu fel gweithredwyr, tra bod procs yn gweithredu fel blociau o god.

Pan i Ddefnyddio Procs a Lambdas

Mae dewis rhwng proc a lambda yn dibynnu ar y sefyllfa. Os ydych chi am greu cod sy'n hawdd ei ail-ddefnyddio ac nad ydych chi'n poeni am y nifer o ddirprwyadau, efallai y bydd proc yn ddigon. Fodd bynnag, os ydych chi am sicrhau bod y nifer o ddirprwyadau yn gywir, mae lambda yn dewis gwell.

Enghreifftiau o Ddefnydd Procs a Lambdas

Dyma rai enghreifftiau o ble gall procs a lambdas fod yn ddefnyddiol:

Defnyddio Proc i Ail-ddefnyddio Cod

def greet(name, greeting_proc)
  greeting_proc.call(name)
end

my_greeting = proc { |name| puts "Helo, #{name}!" }
greet("Ceri", my_greeting)  # Bydd yn argraffu "Helo, Ceri!"

Defnyddio Lambda i Sicrhau Gwerthoedd Cywir

def calculate_area(length, width, area_lambda)
  area_lambda.call(length, width)
end

my_area_lambda = ->(length, width) { length * width }
area = calculate_area(5, 10, my_area_lambda)  # Bydd yn dychwelyd 50
puts "Ardal: #{area}"

Casgliad

Mae procs a lambdas yn ddulliau pwerus yn Ruby sy'n eich galluogi i greu cod a all gael ei ail-ddefnyddio. Mae'r ddau yn cynnig manteision, ond mae'n bwysig deall y gwahaniaethau rhwng y ddau er mwyn eu defnyddio'n effeithiol. Trwy ddeall sut i ddefnyddio procs a lambdas, gallwch wella strwythur a chynnal eich cod Ruby.

Felly, pan fyddwch chi'n ysgrifennu cod Ruby nesaf, cofiwch am y pŵer a gynhelir gan procs a lambdas. Mae'n bosib y byddant yn eich helpu i greu cod mwy clir a chynheliedig!