Hey!
I have been trying to find a goto function in ruby…
Like this:
foo: bar
If blabla then GOTO foo
Is there any command for exiting the app?
And how do I search ex a textfile for a certain word and delete it?
if value == “2”
system(‘clear’)
print “[Opening file…]\n\n”
r_file = File.open( “file”, “a”) #Wrote this so I wouldn’t get an
error like “File doesn’t exist”.
r_file = File.open( “file”, “r”)
print “-----\n”
print r_file.read
print “-----”
print “\n”
system (‘ruby note.rb’) #is there anyway to restart or goto the
beginning of the script?
end
Note that your script opens the file over and over again and never
closes it. This can cause problems - especially since you do it with
different modes.
I want the script to start over again… for example…
When the user made an input and pressed return I want the script to
“restart” or jump to the beginning…
I want the script to start over again… for example…
When the user made an input and pressed return I want the script to
“restart” or jump to the beginning…
I wouldn’t recommend making this a habit but:
% cat cc.rb
x = 0
bar = callcc {|cc| cc}
puts “Hello”
x += 1
bar.call(bar) unless x == 3
puts “x is #{x}”
% cat cc.rb
x = 0
bar = callcc {|cc| cc}
puts “Hello”
x += 1
bar.call(bar) unless x == 3
puts “x is #{x}”
Yikes, someone asks questions which indicate that they
are a novice programmer and you throw continuations at them?
Isn’t that like throwing someone in the deep end of the pool and
seeing if they can swim? Or maybe it is like holding them under
water and seeing if they have gills?
Fasby wrote:
I don’t really understand…
I want the script to start over again… for example…
When the user made an input and pressed return I want the script to
“restart” or jump to the beginning…
You can use ‘next’ to begin the next iteration of a loop:
loop {
your code here
if startover?
next # will cause loop to start over
end
more stuff here
if quit?
break # to get out of the loop entirely
end
print "-----"
print "\n"
system ('ruby note.rb') #is there anyway to restart or goto the
beginning of the script?
end
Thanks!
There is a reason why there are no gotos in Ruby or the vast majority
of modern languages. They are the complete antithesis of good program
design. You should be writing something more like this:
while value == 2
begin
system(“clear”) # This is a pretty bad idea - it’s not portable and
completely unneccesary.
puts “[Opening file…]”
puts
File.open(“file”, “r”) do |file|
puts “—”
puts file.read
puts “—”
end
system(“ruby note.rb”) # What is this for?
rescue Errno:ENOENT
puts “File does not exist.”
end
end
This program properly handles file closing and uses exception handling
to pick up problems with opening the file. Exceptions and simple loops
can produce the same result as any GOTO mess while maintaining good
structure. I would avoid system() as well, but you may have your
reasons for using it.
I want the script to start over again… for example…
When the user made an input and pressed return I want the script to
“restart” or jump to the beginning…
Let me introduce you to my good friend: structured programming. I’m sure
you’ll get along marvelous once you get to know each other.
The BASIC construct of “goto” is rightfully considered harmful for
programs above a certain complexity. It’s not present in Ruby in any
direct way that would let you jump around a program’s structure
arbitrarily. (Actually, that’s a lie, but I’ll hold the continuations
for
the sake of simplicity.)
If you want a script to start over, the easiest way is to put all the
logic of the script into a function / procedure / whatever, and
repeatedly
call that one in a loop like Darren and Robert indicated.
If you want the script to react to user input, you could for example do:
def do_stuff_with_file(r_file)
# Most of your original code goes here.
end
should_print_file = true
while should_print_file
# Better way to avoid file not found errors - you're creating a
completely
# useless temporary file as a workaround.
File.open(‘file’) { | r_file | do_stuff_with_file(r_file) } if
File.exist? (‘file’)
puts('Print file again? [y/n]')
should_print_file = (gets[0] == 'y') # Flaky bit, should be more
There is a reason why there are no gotos in Ruby or the vast majority
puts “—”
to pick up problems with opening the file. Exceptions and simple loops
can produce the same result as any GOTO mess while maintaining good
structure. I would avoid system() as well, but you may have your
reasons for using it.
Naa, Im just testing to create something simple… I think thats the
best way of learning…
So the system() thingy is just for test.
the system(“ruby note.rb”) was just a solution to get the script to
“restart”, I know it’s a bad way but I had to try it. The system(clear)
was just so the screen was cleared.
programs above a certain complexity. It’s not present in Ruby in any
direct way that would let you jump around a program’s structure
arbitrarily. (Actually, that’s a lie, but I’ll hold the continuations for
the sake of simplicity.)
Obligatory response:
In some very rare circumstances, using gotos does in fact have a
rightful
place in code. In very long switch/case statements in C code, a very
well structured (and properly named) set of labels/gotos can make code
much cleaner, and easier to understand, than if they were not used. But
I’ll say again, this is very rare.
I want the script to start over again… for example…
programs above a certain complexity. It’s not present in Ruby in any
have a rightful
place in code. In very long switch/case statements in C code, a very
well structured (and properly named) set of labels/gotos can make code
much cleaner, and easier to understand, than if they were not
used. But
I’ll say again, this is very rare.
I have to respectfully disagree. Having actively used C (among many
others) since 1986 up until now for professional development, I NEVER
found a good use for it, even in my early days. Especially in
switch/case statements ;-). It may be very well structured in the
beginning, becoming a total mess with time. Never had very long
switch/case statements even on very big projects either. This is where
lookup tables with function pointers come in handy, for one.
On Wed, 16 Aug 2006 04:07:26 +0200, Eero S. [email protected] wrote:
Since no-one mentioned it, how about a throw/catch solution?
Throw / catch is for hairier nonlocal returns, he wanted to repeat
something using goto. Looping with a break or an end condition is easier
to understand (YMMV) if you don’t need to get a result value of any
sort.
But yes, that would also work. Especially since you can implement any
control construct with ruby’s throw / catch if you’re stark raving mad
enough.
On Wed, 16 Aug 2006 04:07:26 +0200, Eero S. [email protected] wrote:
Since no-one mentioned it, how about a throw/catch solution?
Throw / catch is for hairier nonlocal returns, he wanted to repeat
something using goto. Looping with a break or an end condition is
easier to understand (YMMV) if you don’t need to get a result value
of any sort. But yes, that would also work. Especially since you
can implement any control construct with ruby’s throw / catch if
you’re stark raving mad enough.
Even if you need a return value you can break with a value. I.e.,
“One serious obstacle to the adoption of good programming languages
is the notion that everything has to be sacrificed for speed. In
computer languages as in life, speed kills.” – Mike Vanier
I don’t really understand…
You call File.open() but you do not call #close(). Note that there are
other means to read from a file, e.g you can do File.readlines or
File.read. See RDOC here RDoc Documentation
I want the script to start over again… for example…
When the user made an input and pressed return I want the script to
“restart” or jump to the beginning…
The BASIC construct of “goto” is rightfully considered harmful for
programs above a certain complexity. It’s not present in Ruby in any
direct way that would let you jump around a program’s structure
arbitrarily. (Actually, that’s a lie, but I’ll hold the continuations
for the sake of simplicity.)
It is often said that continuations are as powerful as goto.
But is there a way to jump forward with continuations, without
rewriting the code to use additional methods?
