Forum: Ruby Ruby loops and definitions help?

Announcement (2017-05-07): is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see and for other Rails- und Ruby-related community platforms.
2c2f3ce7125411ff78a1d3e902aa2a4d?d=identicon&s=25 Bob Sanders (adistarmid)
on 2009-05-15 11:21
Hello. I'm looking to construct a loop that defines an array of [apple,
banana, cherry] like this:

@apple = apple
@banana = banana
@cherry = cherry

I'm thinking it's something in this form:

[apple, banana, cherry].each do |attribute|
  @*attribute* = attribute

...but I have no idea what belongs in place of the *attribute*. Does
anyone know?
9e2504e0b74e5384af09ce8a660afac4?d=identicon&s=25 Pascal J. Bourguignon (Guest)
on 2009-05-15 11:51
(Received via mailing list)
Bob Sanders <> writes:

>   @*attribute* = attribute
> end
> ..but I have no idea what belongs in place of the *attribute*. Does
> anyone know?

Yes.  The objects in ruby do know if and when, how.  You must ask them!
For example, using ri(1).

irb(main):001:0> (ri "Object")

---------------------------------------------------------- Class: Object
     +Object+ is the parent class of all classes in Ruby. Its methods
     are therefore available to all objects unless explicitly

     +Object+ mixes in the +Kernel+ module, making the built-in kernel
     functions globally accessible. Although the instance methods of
     +Object+ are defined by the +Kernel+ module, we have chosen to
     document them here for clarity.

     In the descriptions of Object's methods, the parameter _symbol_
     refers to a symbol, which is either a quoted string or a +Symbol+
     (such as +:name+).


     Kernel(Array, Float, Integer, Pathname, String, URI, `, abort,
     at_exit, autoload, autoload?, binding, block_given?, callcc,
     caller, catch, chomp, chomp!, chop, chop!, eval, exec, exit, exit!,
     fail, fork, format, getc, gets, global_variables, gsub, gsub!,
     iterator?, lambda, load, local_variables, loop, method_missing,
     open, open, open_uri_original_open, p, pp, pretty_inspect, print,
     printf, proc, putc, puts, raise, rand, readline, readlines,
     require, scan, scanf, select, set_trace_func, sleep, split,
     sprintf, srand, sub, sub!, syscall, system, test, throw, trace_var,
     trap, untrace_var, warn, warn, y), PP::ObjectMixin(pretty_print,
     pretty_print_cycle, pretty_print_inspect,

     MatchingData:      rb_cMatch
     ENV:               envtbl
     ENV:               envtbl
     TOPLEVEL_BINDING:  rb_f_binding(ruby_top_self)
     STDIN:             rb_stdin
     STDOUT:            rb_stdout
     STDERR:            rb_stderr
     ARGF:              argf
     NIL:               Qnil
     TRUE:              Qtrue
     FALSE:             Qfalse
     DATA:              f
     ARGV:              rb_argv
     RUBY_VERSION:      v
     RUBY_PLATFORM:     p
     VERSION:           v
     RELEASE_DATE:      d
     PLATFORM:          p
     IPsocket:          rb_cIPSocket
     TCPsocket:         rb_cTCPSocket
     SOCKSsocket:       rb_cSOCKSSocket
     TCPserver:         rb_cTCPServer
     UDPsocket:         rb_cUDPSocket
     UNIXsocket:        rb_cUNIXSocket
     UNIXserver:        rb_cUNIXServer

Class methods:

Instance methods:
     ==, ===, =~, __id__, __send__, class, clone, dclone, display, dup,
     enum_for, eql?, equal?, extend, freeze, frozen?, hash, id, inspect,
     instance_eval, instance_of?, instance_variable_get,
     instance_variable_get, instance_variable_set,
     instance_variable_set, instance_variables, is_a?, kind_of?, method,
     methods, nil?, object_id, private_methods, protected_methods,
     public_methods, remove_instance_variable, respond_to?, send,
     singleton_method_added, singleton_method_removed,
     singleton_method_undefined, singleton_methods, taint, tainted?,
     to_a, to_enum, to_s, to_yaml, to_yaml_properties, to_yaml_style,
     type, untaint
irb(main):002:0> (ri "Object.instance_variable_set")

------------------------------------------- Object#instance_variable_set
     obj.instance_variable_set(symbol, obj)    => obj
     Sets the instance variable names by _symbol_ to _object_, thereby
     frustrating the efforts of the class's author to attempt to provide
     proper encapsulation. The variable did not have to exist prior to
     this call.

        class Fred
          def initialize(p1, p2)
            @a, @b = p1, p2
        fred ='cat', 99)
        fred.instance_variable_set(:@a, 'dog')   #=> "dog"
        fred.instance_variable_set(:@c, 'cat')   #=> "cat"
        fred.inspect                             #=> "#<Fred:0x401b3da8
@a=\"dog\", @b=99, @c=\"cat\">"

irb(main):003:0> ( ["apple","banana","cherry"] . each { | attribute |
(self . instance_variable_set( (("@" + attribute) . to_sym) ,
attribute)) } )
["apple", "banana", "cherry"]
irb(main):004:0> @apple
irb(main):005:0> @banana
irb(main):006:0> @cherry
irb(main):007:0> @pear

That said, an array like [apple, banana, cherry] will actually be an
array such as ["value of apple", 42, ["the",:value,0,"cherry"]].
If you want to build an array containing the name of the variable,
then  you have to make an array of symbols:

Then you will have to write:

irb(main):018:0> (begin
                    (apple = "value of apple")
                    (banana = 42)
                    (cherry = ["the",:value,0,"cherry"])
                    ( [:apple,:banana,:cherry] . each  { | variable |
(self . instance_variable_set( (("@" + (variable . to_s)) . to_sym) ,
(variable . to_s)))) })
[:apple, :banana, :cherry]
irb(main):025:0> @apple
"value of apple"
irb(main):026:0> @banana
irb(main):027:0> @cherry
["the", :value, 0, "cherry"]
This topic is locked and can not be replied to.