StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
1860362
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
3
CommunityOwnedDate
CreationDate
2009-12-07T14:38:16.313
FavoriteCount
0
LastActivityDate
2009-12-07T14:38:16.313
LastEditDate
LastEditorUserId
0
OwnerUserId
2988
ParentId
1859747
PostTypeId
2
Score
19
ViewCount
0
LastEditorDisplayName
text
Body
<blockquote> I want to create a simple linked list type of an object in ruby; where an instance variable in class points to another instance of same type. </blockquote> Just a quick note: the word type is a very dangerous word in Ruby, especially if you come from Java. Due to an historic accident, the word is used both in dynamic typing and in static typing to mean two only superficially related, but very different things. In dynamic typing, a type is a label that gets attached to a value (not a reference). Also, in Ruby the concept of type is much broader than in Java. In Java programmer's minds, "type" means the same thing as "class" (although that's not true, since Interfaces and primitives are also types). In Ruby, "type" means "what can I do with it". Example: in Java, when I say something is of type String, I mean it is a direct instance of the <code>String</code> class. In Ruby, when I say something is of type String, I mean it is either <ul> <li>a direct instance of the <code>String</code> class or </li> <li>an instance of a subclass of the <code>String</code> class or </li> <li>an object which responds to the <code>#to_str</code> method or </li> <li>an object which behaves indistinguishably from a String.</li> </ul> <blockquote> I want to populate and link all nodes; before the constructor is called and only once. Something that we'd usually do in Java Static block. </blockquote> In Ruby, everything is executable. In particular, there is no such thing as a "class declaration": a class body is just exectuable code, just like any other. If you have a list of method definitions in your class body, those are not declarations that are read by the compiler and then turned into a class object. Those are expressions that get executed by the evaluator one by one. So, you can put any code you like into a class body, and that code will be evaluated when the class is created. Within the context of a class body, <code>self</code> is bound to the class (remember, classes are just objects like any other). <blockquote> Initialize method is a constructor signature in ruby. Are there any rules around them? Like in Java you cannot call another constructor from a constructor if its not the first line (or after calling the class code?) </blockquote> Ruby doesn't have constructors. Constructors are just factory methods (with stupid restrictions); there is no reason to have them in a well-designed language, if you can just use a (more powerful) factory method instead. Object construction in Ruby works like this: object construction is split into two phases, allocation and initialization. Allocation is done by a public class method called <code>allocate</code>, which is defined as an instance method of class <code>Class</code> and is generally never overriden. It just allocates the memory space for the object and sets up a few pointers, however, the object is not really usable at this point. That's where the initializer comes in: it is an instance method called <code>initialize</code>, which sets up the object's internal state and brings it into a consistent, fully defined state which can be used by other objects. So, in order to fully create a new object, what you need to do is this: <pre><code>x = X.allocate x.initialize </code></pre> [Note: Objective-C programmers may recognize this.] However, because it is too easy to forget to call <code>initialize</code> and as a general rule an object should be fully valid after construction, there is a convenience factory method called <code>Class#new</code>, which does all that work for you and looks something like this: <pre><code>class Class def new(*args, &block) obj = alloc obj.initialize(*args, &block) return obj end end </code></pre> [Note: actually, <code>initialize</code> is private, so reflection has to be used to circumvent the access restrictions like this: <code>obj.send(:initialize, *args, &block)</code>] That, by the way, is the reason why to construct an object you call a public class method <code>Foo.new</code> but you implement a private instance method <code>Foo#initialize</code>, which seems to trip up a lot of newcomers. To answer your question: since an initializer method is just a method like any other, there are absolutely no restrictions as to what you can do whithin an initializer, in particular you can call <code>super</code> whenever, wherever, however and how often you want. BTW: since <code>initialize</code> and <code>new</code> are just normal methods, there is no reason why they need to be called <code>initialize</code> and <code>new</code>. That's only a convention, although a pretty strong one, since it is embodied in the core library. In your case, you want to write a collection class, and it is quite customary for a collection class to offer an alternative factory method called <code>[]</code>, so that I can call <code>List[1, 2, 3]</code> instead of <code>List.new(1, 2, 3)</code>. Just as a side note: one obvious advantage of using normal methods for object construction is that you can construct instances of anonymous classes. This is not possible in Java, for absolutely no sensible reason whatsoever. The only reason why it doesn't work is that the constructor has the same name as the class, and anonymous classes don't have a name, ergo there cannot be a constructor. Although I am not quite sure why you would need to run anything before object creation. Unless I am missing something, shouldn't a list basically be <pre><code>class List def initialize(head=nil, *tail) @head = head @tail = List.new(*tail) unless tail.empty? end end </code></pre> for a Lisp-style cons-list or <pre><code>class List def initialize(*elems) elems.map! {|el| Element.new(el)} elems.zip(elems.drop(1)) {|prv, nxt| prv.instance_variable_set(:@next, nxt)} @head = elems.first end class Element def initialize(this) @this = this end end end </code></pre> for a simple linked list?
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POStatic block in Ruby
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. This table or related slice is empty.
UserOwnerUserId
1. USJörg W Mittag
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POStatic block in Ruby
 singulars
 PostTypePostTypeId
 PTQuestion
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId
1. COgreat answer Thanks! Gave me a lot of insight.
 singulars
 PostPostId
 PO
 UserUserId
 USPriyank
2. COFantastic answer. Thank you!
 singulars
 PostPostId
 PO
 UserUserId
 USMike
3. COThanks for clear and complete answer!!!
 singulars
 PostPostId
 PO
 UserUserId
 USshift66

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.