What's the difference between a string and a symbol in Ruby?

StackOverflow https://stackoverflow.com/questions/255078

  •  05-07-2019
  •  | 
  •  

Question

What's the difference between a string and a symbol in Ruby and when should you use one over the other?

Was it helpful?

Solution

The main difference is that multiple symbols representing a single value are identical whereas this is not true with strings. For example:

irb(main):007:0> :test.object_id
=> 83618
irb(main):008:0> :test.object_id
=> 83618
irb(main):009:0> :test.object_id
=> 83618

3 references to the symbol :test, all the same object.

irb(main):010:0> "test".object_id
=> -605770378
irb(main):011:0> "test".object_id
=> -605779298
irb(main):012:0> "test".object_id
=> -605784948

3 references to the string "test", all different objects.

This means that using symbols can potentially save a good bit of memory depending on the application. It is also faster to compare symbols for equality since they are the same object, comparing identical strings is much slower since the string values need to be compared instead of just the object ids.

As far as when to use which, I usually use strings for almost everything except things like hash keys where I really want a unique identifier, not a string.

OTHER TIPS

What are the differences between Symbols & Strings?

  1. Symbols are immutable: Their value remains constant.
  2. Multiple uses of the same symbol have the same object ID and are the same object compared to string which will be a different object with unique object ID, everytime.
  3. You can't call any of the String methods like #split on Symbols.

From Understanding Differences Between Symbols & Strings in Ruby

If you are chinese, you can also read 理解 Ruby Symbol

The statement 

foo = "bar"

creates a new object in memory. If we repeat the statement 

foo = "bar"

We create another object

to get it more clearly please try the below code on ruby console

foo = "bar"
puts "string #{foo} with object id = #{foo.object_id}"
foo = "bar"
puts "string #{foo} with object id = #{foo.object_id}"

you will get output like 

string bar with object id = 70358547221180
string bar with object id = 70358548927060

which clearly shows there are two different object for same string. Now if you use symbol it will create one object per symbol so

foo = :bar
puts "symbol #{foo} with object id = #{foo.object_id}"
foo = :bar
puts "symbol #{foo} with object id = #{foo.object_id}"

shows 

symbol bar with object id = 7523228
symbol bar with object id = 7523228

which means there is only one object for :bar

further Symbols are immutable and You can't call any of the String methods like #upcase, #split on Symbols.

Comparing Symbols are faster than comparing Strings.

Symbols can be thought of as constant/immutable strings that form a unique set that are effectively converted to memory pointers on the heap. This means comparing two symbols is fast because you are just comparing 2 integers (memory pointers.)

Strings are mutable so the memory pointer to their value on the heap can change after modification. This means comparison operations are slower because duplicates can exist that are semantically equivalent.

Uses

use Symbol when you are sure that the value will remain constant. Example use symbols for hash keys, use string when you want to change value or want to use string method on it.

An additional difference between String and Symbol is that a String has a lot more methods on it for string manipulation, while a Symbol is a relatively lean object.

Check out the documentation for the String class and the Symbol class.

A symbol is something you use to represent names and strings. You would want to use a symbol when you may have need to use a string several times as this far easier and more productive.

And just found this via google, which may offer greater detail: Here you go

Strings are Mutable , Symbols arre immutable
Note:Mutable objects can be changed after assignment while immutable objects can only be overwritten http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/

There are two main differences between String and Symbol in Ruby.

  1. String is mutable and Symbol is not

    • Because the String is mutable, it can be change in somewhere and can lead to the result is not correct.

    • Symbol is immutable.

  2. String is an Object so it needs memory allocation

    puts "abc".object_id # 70322858612020

    puts "abc".object_id # 70322846847380

    puts "abc".object_id # 70322846815460

In the other hand, Symbol will you the same object:

puts :abc.object_id # 1147868

puts :abc.object_id # 1147868

puts :abc.object_id # 1147868

So the String will take more time to use and to compare than Symbol.

You can read more here to fully understand:

Case where symbol can be disaster. Lets say you have params.map(&:to_sym) in your rails controller . Now here if you are converting the data provided by the user to symbol due to some reason then it could be dangerous. If the data provided by the user is too large and as we know that symbol is not a garbage collector, you might end up exhausting your server's memory which can takedown your website.

Symbols and strings are completely different this post has a little insight into the differences. As to when and where to use them, there is a pretty extensive post on this subject over on has many :through.

As a counterpoint, a friend of mine recently wrote a post titled "Ruby Rant" which gives another look at Ruby symbols.

symbol is immutable and string is mutable.

when we perform any operation on string then it create a new object and take memory. As we perform more and more operation on string means we are consuming more and more memory.

symbol is object that are immutable mean if we perform any operation then it performs changes in original object, It will not create any object, that's why it is more profitable.

for more info, you can click here

Licensed under: CC-BY-SA with attribution
Not affiliated with StackOverflow
scroll top