Delio â Chymhorthion Gorchmynion gyda `ARGV` yn Ruby

Mae Ruby yn iaith raglennu sy'n cynnig llawer o nodweddion defnyddiol, un ohonynt yw'r gallu i dderbyn a phrosesu cymhorthion gorchmynion. Mae hyn yn caniatáu i ddefnyddwyr roi gwybodaeth i'r rhaglen pan fyddant yn ei rhedeg o'r gornel gorchmynion. Yn yr erthygl hon, byddwn yn archwilio sut i ddefnyddio `ARGV` i ddelio â chymhorthion gorchmynion yn Ruby, gan ddarparu enghreifftiau a chymhellion i'ch helpu i ddeall y broses.

Beth yw `ARGV`?

Mae `ARGV` yn array (dull) yn Ruby sy'n cynnwys yr holl gymhorthion gorchmynion a roddwyd pan fydd y rhaglen yn cael ei rhedeg. Mae'n caniatáu i chi dderbyn data gan y defnyddiwr heb orfod gofyn am input yn ystod y rhaglen. Mae'n hawdd iawn ei ddefnyddio, ac mae'n cynnig dull syml o ddelio â gwybodaeth ychwanegol.

Sut i ddefnyddio `ARGV`

Mae defnyddio `ARGV` yn Ruby yn syml. Mae'r cymhorthion gorchmynion yn cael eu rhoi fel rhestr o eitemau, a gallwch eu defnyddio yn eich rhaglen. Dyma'r camau sylfaenol i'w dilyn:

# Defnyddio ARGV yn Ruby
puts "Cymhorthion gorchmynion: #{ARGV.inspect}"

Yn y cod uchod, rydym yn defnyddio `puts` i argraffu'r cymhorthion gorchmynion a dderbyniwyd. Mae `ARGV.inspect` yn rhoi golwg fanwl ar y data yn y dull.

Enghreifftiau o ddefnyddio `ARGV`

Gadewch i ni edrych ar rai enghreifftiau ymarferol o sut i ddefnyddio `ARGV` yn Ruby.

Enw a Chyfrif

Dyma enghraifft syml sy'n derbyn enw a chyfrif, ac yna'n argraffu neges wedi'i phersonoli:

# rhaglen sy'n derbyn enw a chyfrif
if ARGV.length != 2
  puts "Defnydd: ruby rhaglen.rb [enw] [cyfrif]"
  exit
end

enw = ARGV[0]
cyfrif = ARGV[1].to_i

puts "Helo, #{enw}! Mae gennych #{cyfrif} o negeseuon."

Yn y rhaglen hon, rydym yn gwirio a yw'r nifer cywir o gymhorthion gorchmynion wedi'u rhoi. Os na, rydym yn rhoi cyfarwyddyd i'r defnyddiwr. Os yw'r data yn iawn, rydym yn argraffu neges wedi'i phersonoli.

Gweithredu Gweithrediadau Mathemategol

Gallwn hefyd ddefnyddio `ARGV` i wneud gweithrediadau mathemategol. Dyma enghraifft sy'n derbyn dau rif a'i gymhwyso:

# rhaglen sy'n derbyn dau rif a'u hychwanegu
if ARGV.length != 2
  puts "Defnydd: ruby rhaglen.rb [rhif1] [rhif2]"
  exit
end

rhif1 = ARGV[0].to_f
rhif2 = ARGV[1].to_f
canlyniad = rhif1 + rhif2

puts "Y canlyniad o ychwanegu #{rhif1} a #{rhif2} yw #{canlyniad}."

Yn yr enghraifft hon, rydym yn derbyn dau rif, yn eu troi'n rifau ffloat, ac yna'n eu hychwanegu. Mae'r canlyniad yn cael ei argraffu i'r gornel gorchmynion.

Gweithredu Gorchmynion gyda `ARGV`

Mae `ARGV` hefyd yn ddefnyddiol ar gyfer gweithredu gorchmynion. Gallwch ddefnyddio'r cymhorthion gorchmynion i benderfynu pa weithred i'w gweithredu. Dyma enghraifft sy'n dangos sut i wneud hyn:

# rhaglen sy'n gweithredu gorchmynion
if ARGV.length != 2
  puts "Defnydd: ruby rhaglen.rb [gorchymyn] [rhif]"
  exit
end

gorchymyn = ARGV[0]
rhif = ARGV[1].to_i

case gorchymyn
when "hynny"
  puts "Y rhif yw: #{rhif}"
when "dwylo"
  puts "Y rhif wedi'i ddwylo yw: #{rhif * 2}"
else
  puts "Gorchymyn annilys."
end

Yn yr enghraifft hon, rydym yn derbyn gorchymyn a rhif, ac yna'n defnyddio `case` i benderfynu pa weithred i'w gweithredu. Mae hyn yn dangos sut y gall `ARGV` helpu i wneud rhaglenni mwy rhyngweithiol.

Gweithredu Gwybodaeth Ychwanegol

Mae `ARGV` hefyd yn cynnig cyfle i dderbyn gwybodaeth ychwanegol. Gallwch ddefnyddio'r cymhorthion gorchmynion i ddarparu gwybodaeth am ffeiliau, cyfeiriadau, neu unrhyw ddata arall sydd ei angen ar eich rhaglen. Dyma enghraifft sy'n darllen cynnwys ffeil:

# rhaglen sy'n darllen ffeil
if ARGV.length != 1
  puts "Defnydd: ruby rhaglen.rb [ffei]l"
  exit
end

ffeil = ARGV[0]

if File.exist?(ffeil)
  puts "Darllen cynnwys o #{ffeil}:"
  puts File.read(ffeil)
else
  puts "Nid yw'r ffeil #{ffeil} yn bodoli."
end

Yn yr enghraifft hon, rydym yn derbyn enw ffeil, yn gwirio a yw'n bodoli, ac yna'n darllen a'i argraffu. Mae hyn yn dangos sut y gall `ARGV` helpu i ddelio â ffeiliau yn hawdd.

Casgliad

Mae `ARGV` yn nodwedd grymus yn Ruby sy'n caniatáu i chi dderbyn cymhorthion gorchmynion yn hawdd. Mae'n cynnig dull syml o ddelio â gwybodaeth ychwanegol, gan ei gwneud yn hawdd i greu rhaglenni rhyngweithiol. Trwy ddefnyddio `ARGV`, gallwch greu rhaglenni sy'n ymateb i ddata a roddwyd gan y defnyddiwr, gan wneud eich rhaglenni yn fwy defnyddiol a chyffrous.

Gobeithio bod yr erthygl hon wedi rhoi gwybodaeth fanwl i chi am sut i ddefnyddio `ARGV` yn Ruby. Peidiwch ag oedi cyn dechrau ar eich prosiect nesaf a defnyddio `ARGV` i wneud eich rhaglenni'n fwy rhyngweithiol!