Ruby strings and symbols interview questions, with answers

The questions, with answers

1. 1.What is the difference between a string and a symbol in Ruby?

   In short: A symbol such as :name is an immutable, unique identifier; a string is mutable text, and two equal string literals are separate objects.

   Every occurrence of the symbol :done is the same object, so comparing symbols is as cheap as comparing two integers, and they are immutable. Strings are mutable text, and each string literal normally creates a new object. That makes symbols the natural choice for names: hash keys, method names passed to send or respond_to?, and fixed states such as :pending. Strings suit data that is built up, changed or shown to users. to_s and to_sym convert between them, but a symbol key and a string key are different keys in a hash.

   s1 = :done
   s2 = :done
   p s1.object_id == s2.object_id
   p :done.to_s, "done".to_sym
   # true
   # "done"
   # :done

2. 2.How do you format strings in Ruby?

   In short: Use format (or the % operator) with placeholders such as %d, %s and %.2f, and rjust, ljust and center for padding.

   format, also available as sprintf, builds a string from a template: %d formats an integer, %s a string, %.2f a float to two decimal places, and a width and 0 flag pad the result, so %05.2f gives 03.14. The % operator on a string does the same, as in "%s: %d" % ["a", 1]. For simple padding, rjust, ljust and center pad a string to a width with any character, which is handy for aligned tables. Most everyday text is built with double-quoted interpolation, "total: #{n}", which calls to_s on the embedded expression.

   puts format("%05.2f", 3.14159)
   puts "7".rjust(3, "0")
   puts "ab".center(6, "*")
   # 03.14
   # 007
   # **ab**

3. 3.What does freeze do to a Ruby string?

   In short: freeze makes the object immutable, so any later attempt to modify it raises FrozenError; frozen? tells you whether it is frozen.

   Calling freeze on an object prevents further changes to it: methods that modify it in place, such as upcase! or <<, raise FrozenError. Symbols, integers and nil are always frozen. The magic comment # frozen_string_literal: true at the top of a file makes every string literal in it frozen, which saves allocations and catches accidental mutation, and Ruby 3.4 warns when a literal without the comment is mutated, as a step toward frozen literals by default. freeze is shallow: a frozen array's elements can still change unless they are frozen too.

   s = "hi".freeze
   p s.frozen?
   s.upcase!
   # true
   # raises FrozenError

4. 4.What is the difference between upcase and upcase! in Ruby?

   In short: upcase returns a new string and leaves the original alone; the bang version upcase! changes the string in place.

   Many String methods come in pairs. The plain method, such as upcase, strip, sub or capitalize, returns a new string and leaves the receiver unchanged. The bang method, with a trailing !, modifies the receiver itself and returns it, or returns nil when there was nothing to change, so chaining bang methods is risky. The ! is a naming convention meaning "more dangerous than the plain version", usually because it mutates. Prefer the plain forms unless you are deliberately updating a string, for example in a loop that builds a large buffer.

   s = "ruby"
   t = s.upcase
   s.capitalize!
   puts s, t
   # Ruby
   # RUBY

5. 5.How do you split and join strings in Ruby?

   In short: split breaks a string into an array on a separator or pattern; join combines an array's elements into one string.

   "a,b,c".split(",") returns ["a", "b", "c"]. With no argument, split separates on runs of whitespace and ignores leading whitespace, and it also accepts a regular expression and a limit. The array method join does the reverse, with an optional separator. Related methods help with searching: include?, start_with? and end_with? return booleans, index returns a position or nil, and sub and gsub replace the first or every match. For comma-separated files with quoted fields, the csv library parses correctly where split would not.

   csv = "a,b,c"
   parts = csv.split(",")
   p parts
   puts parts.join("-")
   # ["a", "b", "c"]
   # a-b-c

6. 6.How do you use regular expressions with Ruby strings?

   In short: Regex literals are written /pattern/; =~ returns a match's index, match returns MatchData, scan finds every match and gsub replaces them.

   Ruby has regular expressions built into the language. str =~ /\d/ returns the index of the first match or nil, which also works as a condition. str.match(re) returns a MatchData object with captures by position or by name, scan returns every match as an array, and gsub replaces matches with a string, a hash or a block's result. After a successful match, $~ and $1 hold the last match data and first group. Ruby's regexes are Onigmo, with named groups, lookarounds and Unicode classes.

   s = "call 555-1234"
   p s.scan(/\d+/)
   p s =~ /\d/
   # ["555", "1234"]
   # 5

7. 7.Why do length and bytesize differ for a Ruby string?

   In short: length counts characters in the string's encoding, usually UTF-8, while bytesize counts the bytes those characters take.

   Ruby strings carry an encoding, UTF-8 by default for source literals, and most methods work in characters: length, reverse, chars and slicing all respect multibyte characters. bytesize reports the raw size in bytes, which is what matters for network protocols and storage limits. In "café", é takes two bytes, so length is 4 and bytesize is 5. Encoding problems usually come from data read as binary or in another encoding; force_encoding relabels a string and encode converts it, and valid_encoding? checks it.

   w = "café"
   p w.length, w.bytesize
   p w.chars.first(2)
   # 4
   # 5
   # ["c", "a"]

How the diagnostic asks it

One question from the Ruby bank, exactly as a sitting would show it. The bank has 3 on strings & symbols and 30 across Ruby.

puts :ok.equal?(:ok)
puts "ok".equal?("ok")
puts :ok.to_s == "ok"