How to Initialize Class Arrays in Ruby

At first you have a typo. Change Classto class. Next I suggest to use the initialize method. While creating a new object this is the perfect place to initialize instance variables.

class Something
  @@my_class_variable = [1]

  def initialize
    @something = []
  end

  def dosomething
    s = 5
    @something << s
  end

  def self.get_my_class_variable
    @@my_class_variable
  end
end

Your script will be read and executed from top to bottom and after this, you can access the class Something. While the parser reads your script/class/module you can define class variables (@@), execute mixins and extend the class with other modules. This is why you can define a class variable, but you can not define an instance variable. Because actually you have no instance object from your class. You only have a class object. In ruby everything is an object. And your class object has a defined class variable now:

Something.get_my_class_variable
# => [1]

Now you can create an instance from your class. With Something.new the initialize method will be invoked and your instance variable will be defined.

something = Something.new
something.dosomething
# => [5]

Later, if you are familar with this you can define getter and setter methods with attr_reader, attr_writer and attr_accessor for instance objects or cattr_reader, cattr_writer and cattr_accessor for class objects. For example:

class Something
  attr_reader :my_something

  def initialize
    @my_something = []
  end

  def dosomething
    s = 5
    @my_something << s
  end
end

something = Something.new
something.my_something
# => []
something.dosomething
# => [5]
something.my_something
# => [5]

Your problem in trying to access @something in your instance method is that, in the scope of instance methods, @ variables refer to instance variables, and your @something is a class instance variable.

@ variables are instance variables of the instance that is self when they are created. When @something was created, self was the class Something, not an instance of Something, which would be the case inside an instance method.

How then to access a class instance variable in an instance method? Like regular instance variables, this must be done via a method, as in attr_accessor. One way to do this is to use class << self to tell the Ruby interpreter that the enclosed code should be evaluated with the class (and not the instance) as self:

class C

  @foo = 'hello'

  class << self
    attr_accessor :foo  # this will be a class method
  end

  def test_foo  # this is, of course, an instance method
    puts self.class.foo  # or puts C.foo
  end
end

We can show that this works in irb:

2.3.0 :005 > C.foo
 => "hello"
2.3.0 :006 > C.new.test_foo
hello

You have correctly created a class instance variable, @something, and initialized it to an empty array. There are two ways for instances to obtain or change the value of that variable. One is to use the methods Object#instance_variable_get and Object#instance_variable_set (invoked on the class):

class Something
  @something = [] 
  def dosomething
    s = 5
    self.class.instance_variable_get(:@something) << s
  end
end

sthg = Something.new
sthg.dosomething     

Something.instance_variable_get(:@something)
   #=> 5

The other way is to create an accessor for the variable. There are several ways to do that. My preference is the following:

Something.singleton_class.send(:attr_accessor, :something)
Something.something #=> [5]

In your dosomething method you would write:

self.class.something << s