StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
20550335
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
2
CommunityOwnedDate
CreationDate
2013-12-12T17:36:24.573
FavoriteCount
0
LastActivityDate
2013-12-12T18:59:33.343
LastEditDate
2013-12-12T18:59:33.343
LastEditorUserId
179125
OwnerUserId
179125
ParentId
20549285
PostTypeId
2
Score
4
ViewCount
0
LastEditorDisplayName
text
Body
Inside a class definition (e.g. <code>class User ...</code>), <code>def encrypt ...</code> defines an instance method, whereas <code>def self.encrypt ...</code> defines a class method. <h2>Defining instance methods and class methods</h2> Suppose we defined the User class like this: <pre><code>class User def initialize(name) @name_instance_variable = name end # This is an instance method definition, creating a method called `encrypt` # on instances of the User class. def encrypt puts "Received User#encrypt instance method.\n" + "- `self` is an instance of #{ self.class }.\n" + "- `@name_instance_variable` is #{ @name_instance_variable.inspect }.\n" end # This is a class method definition, creating a method called `encrypt` on # the User class itself. def self.encrypt puts "Received User.encrypt class method.\n" + "- `self` is an instance of #{ self.class }.\n" + "- `@name_instance_variable` is #{ @name_instance_variable.inspect }.\n" end end </code></pre> <h3>Invoking an instance method</h3> Now we can create an instance of User with the constructor <code>User.new</code>, which (automatically) invokes <code>initialize</code> above: <pre><code>my_user = User.new("Tim") </code></pre> In <code>initialize</code>, the value we gave to the constructor is assigned to the instance variable <code>@name_instance_variable</code>. Now we can invoke instance methods on <code>my_user</code>, our instance of the User class: <pre><code>my_user.encrypt # => Received User#encrypt instance method. # - `self` is an instance of User. # - `@name_instance_variable` is "Tim". </code></pre> We can create another instance and give a different value to the constructor: <pre><code>User.new("Jordan").encrypt # => Received User#encrypt instance method. # - `self` is an instance of User. # - `@name_instance_variable` is "Jordan". </code></pre> <h3>Invoking a class method:</h3> We can also invoke class methods on the User class: <pre><code>User.encrypt # => Received User.encrypt class method. # - `self` is an instance of Class. # - `@name_instance_variable` is nil. </code></pre> We get <code>nil</code> for <code>@name_instance_variable</code> because the class method does not have access to any of the instances we created, and we haven't done anything that would assign a value to it. <h3>Another class method, and using one class method inside another</h3> After we've created the User class, we can also define a new class method like this: <pre><code>def User.create_remember_token puts "Received User.create_remember_token class method." # Now let's use the User.encrypt class method from within this method. encrypt # We could also write this, because inside this class method `self` refers # to the User class itself: # # self.encrypt # # This is equivalent too--almost (the difference appears when you use # inheritance, i.e. create a subclass of User, but that's beyond the scope # of this answer): # # User.encrypt # end </code></pre> ...that's equivalent (but not necessarily preferable) to: <pre><code>class User def self.create_remember_token # ... end end </code></pre> Now we have a <code>User.create_remember_token</code> class method, which works like this: <pre><code>User.create_remember_token # => Received User.create_remember_token class method. # Received User.encrypt class method. # - `self` is an instance of Class. # - `@name_instance_variable` is nil. </code></pre> <h3>Defining another instance method, and using instance methods inside other instance methods</h3> Suppose we defined another instance method: <pre><code>class User # An instance method this time: def create_remember_token puts "Received User#create_remember_token instance method.\n" "- `@name_instance_variable` is #{ @name_instance_variable }." encrypt # We could also write this, because inside this instance method `self` # refers to this instance of User: # # self.encrypt # end end </code></pre> Now we have a <code>User#create_remember_token</code> instance method, which does this: <pre><code>my_user = User.new("Alice") my_user.create_remember_token # => Received User#create_remember_token instance method. # - `@name_instance_variable` is "Alice." # Received User#encrypt instance method. # - `self` is an instance of User. # - `@name_instance_variable` is "Alice". </code></pre> <h3>Using class methods within instance methods</h3> Finally, there are two ways to invoke class methods from within instance methods. Suppose we defined our instance method like this instead: <pre><code>class User def create_remember_token puts "Received User#create_remember_token instance method." "- `@name_instance_variable` is #{ @name_instance_variable }." # Since `self` refers to this instance of User, `self.class` equals # the User class itself. self.class.encrypt # That's is (almost) equivalent to this: # # User.encrypt # # ("Almost" again because of the inheritance issue mentioned above.) # end end </code></pre> Now it will work like this: <pre><code>User.new("Bob").create_remember_token # => Received User#create_remember_token instance method. # - `@name_instance_variable` is "Alice." # Received User.encrypt class method. # - `self` is an instance of Class. # - `@name_instance_variable` is nil. </code></pre> Note that even though we invoked the class method <code>User.encrypt</code> inside of the instance method <code>User#encrypt</code>, the instance variable <code>@name_instance_variable</code> is still not available inside the class method. <h3>When to use a class method</h3> So why do class methods exist? Because you aren't always working with an instance. There are good examples of this in Rails. Suppose we have a "Comment" model. <code>Comment#update_attributes</code> is an instance method because it works with an instance of Comment. It knows about the instance's attributes and its internal state. When you use <code>update_attributes</code> you know that you're making changes to that instance of Comment. <code>Comment.find</code>, however, is a class method. When you use <code>Comment.find</code> you don't have an instance of Comment (yet). If <code>find</code> was an instance method we wouldn't be able to use it without first creating an instance: <pre><code>id = 6 comment = Comment.new.find(id) # => #<Comment id: 6, ...> </code></pre> ...and that doesn't make much sense. Rails could have done this another way, like defining a CommentFinder class, which makes a little more sense: <pre><code>comment_finder = CommentFinder.new comment = comment_finder.find(id) # => #<Comment id: 6, ...> </code></pre> ...and is actually pretty common in some languages (and even in some Ruby libraries; the popular <a href="https://en.wikipedia.org/wiki/Factory_method_pattern" rel="nofollow">factory pattern</a> does this). But in Rails they've decided to make this simpler by making this functionality a class method of the Comment class, so we can just do this: <pre><code>comment = Comment.find(id) # => #<Comment id: 6, ...> </code></pre> <h2>Final notes</h2> <ol> <li>You might've noticed that I keep referring to instance methods like this: <code>User#encode</code> and class methods like this: <code>User.encode</code>. This is a convention you'll see throughout Ruby and Rails' documentation and books and articles about both. A <code>#</code> after the class name means it's an instance method and a <code>.</code> means it's a class method.</li> <li>Ruby is a "message-passing" language. You don't really need to worry about the distinction, but knowing this is handy because of some of the terminology you might run into. When we write <code>my_user.encode_video</code> we're technically sending the "message" <code>encode_video</code> to the <code>my_user</code> object. <code>my_user</code> receives the message <code>encode_video</code>. Colloquially, we often say "I called the <code>encode</code> method" or "this code invokes <code>encode</code>," and it's fine to use those terms instead (and in truth more developers will probably understand them). You'll probably find code before too long, though, that does something like <code>my_user.send(:encode_video)</code>, or even <code>type = "video"; ... my_user.send("encode_#{type}")</code> which makes more sense when you understand that "send" means "call" or "invoke."</li> <li>Ruby is a very flexible language. Above in some of the output I wrote, "<code>self</code> is an instance of Class". That's not a mistake--in Ruby, even classes are objects, and any class you create will be an instance of the class named Class. There are even ways to define instance methods and instance variables on a class itself (rather than instances of it), but that's way beyond the scope of this answer. If you're dying of curiosity, google "<a href="https://www.google.com/search?q=eigenclass" rel="nofollow">eigenclass</a>."</li> </ol> I hope that's helpful.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POWhat is the difference between referring to the model directly and using self in class methods?
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USJordan Running
UserOwnerUserId
1. USJordan Running
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POWhat is the difference between referring to the model directly and using self in class methods?
 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
 VTAcceptedByOriginator
CommentsPostId
1. COthanks @Jordan - very thorough. will take me a bit to get through it lol
 singulars
 PostPostId
 PO
 UserUserId
 UStim
2. COwow - thank you - slow clap :)
 singulars
 PostPostId
 PO
 UserUserId
 UStim

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.