notebooks/Strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings in Ruby\n",
    "\n",
    "There are many methods in the **`String`** class like:\n",
    "\n",
    "- **`reverse`** that gives a backwards version of the string (`reverse` does not change the original string).\n",
    "- **`length`** that tells us the number of characters (including spaces) in the string.\n",
    "- **`upcase`** changes every lowercase letter to uppercase, and **`downcase`** changes every uppercase letter to lowercase.\n",
    "- **`swapcase`** switches the case of every letter in the string.\n",
    "- **`capitalize`** is just like `downcase`, except that it switches the first character to uppercase (if it is a letter).\n",
    "- **`slice`** gives you a substring of a larger string.\n",
    "\n",
    "The methods `upcase`, `downcase`, `swapcase` and `capitalize` have corresponding methods that modify a string in place rather than creating a new one: `upcase!`, `downcase!`, `swapcase!` and `capitalize!`. Assuming you don't need the original string, these methods will save memory, specially if the string is large.\n",
    "\n",
    "We know that `String` literals are sequences of characters between singles or double quotation marks. The difference between the two forms is the amount of processing Ruby does on the string while constructiong the literal.\n",
    "\n",
    "In the _**single-quoted**_ case, Ruby does very little:\n",
    "\n",
    "  - The backslash works to escape another backslash, so that the second backslash is not itself interpreted as an escape character.\n",
    "  - A backslash is not special if the character that follows it is anything other than a quote or a backslash. For example, `a\\b` and `a\\\\b` are equal.\n",
    "\n",
    "In the _**double-quoted**_ case, Ruby does more work:\n",
    "\n",
    "  1. It looks for substitutions - sequences that start with a backslash character - and replaces them with some binary value.\n",
    "  2. Expression interpolation. Within the string, the sequence `#{expression}` is replaced by the value of expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Good night, Satish\n",
      "Good night, Talim\n"
     ]
    }
   ],
   "source": [
    "def say_goodnight(name)\n",
    "    result = \"Good night, #{name}\"\n",
    "    return result\n",
    "end\n",
    "puts say_goodnight 'Satish'\n",
    "\n",
    "def say_goodnight2(name)\n",
    "    \"Good night, #{name}\"\n",
    "end\n",
    "puts say_goodnight2 'Talim'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is to be noted that every time a string literal is used in an assignment or as a parameter, a new `String` object is created.\n",
    "\n",
    "Strings are objects of class `String`. The `String` class has more than 75 standard methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "  - [Listing all methods of a class object](#Listing-all-methods-of-a-class-object)\n",
    "  - [Comparing two strings for equality](#Comparing-two-strings-for-equality)\n",
    "  - [Using `%w`](#Using-%w)\n",
    "  - [Character Set](#Character-Set)\n",
    "  - [Character Encoding](#Character-Encoding)\n",
    "  - [Encoding class](#Encoding-class)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listing all methods of a class object\n",
    "\n",
    "- `String.methods.sort`\n",
    "\n",
    "Shows you a list of methods that the `Class` object `String` responds to.\n",
    "\n",
    "- `String.instance_methods.sort`\n",
    "\n",
    "This method tells you all the instance methods that instances of `String` are endowed with.\n",
    "\n",
    "- `String.instance_methods(false).sort`\n",
    "\n",
    "With this method, you can view a class's instance methods without those of the class's ancestors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparing two strings for equality\n",
    "\n",
    "Strings have several methods for testing equality.\n",
    "\n",
    "- The most common one is `==`.\n",
    "- Another equality-test instance method, `String.eql?`, tests two strings for identical content. It returns the same result as `==`.\n",
    "- A third instance method, `String.equal?`, tests whether two strings are the same object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Both Strings (s1, s2) have identical content\n",
      "Both Strings (s1, s2) have identical content\n",
      "Two Strings (s1, s2) are not identical objects\n",
      "Two Strings (s1, s3) are identical objects\n"
     ]
    }
   ],
   "source": [
    "s1 = 'Jonathan'\n",
    "s2 = 'Jonathan'\n",
    "s3 = s1\n",
    "\n",
    "if s1 == s2\n",
    "    puts 'Both Strings (s1, s2) have identical content'\n",
    "else\n",
    "    puts 'Both Strings (s1, s2) do not have identical content'\n",
    "end\n",
    "\n",
    "if s1.eql?(s2)\n",
    "    puts 'Both Strings (s1, s2) have identical content'\n",
    "else\n",
    "    puts 'Both Strings (s1, s2) do not have identical content'\n",
    "end\n",
    "\n",
    "if s1.equal?(s2)\n",
    "    puts 'Two Strings (s1, s2) are identical objects'\n",
    "else\n",
    "    puts 'Two Strings (s1, s2) are not identical objects'\n",
    "end\n",
    "\n",
    "if s1.equal?(s3)\n",
    "    puts 'Two Strings (s1, s3) are identical objects'\n",
    "else\n",
    "    puts 'Two Strings (s1, s3) are not identical objects'\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using `%w`\n",
    "\n",
    "Sometimes creating arrays of words can be a pain, what with all the quotes and commas. Fortunately, Ruby has a shorcut: `%w` does just what we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ann\n",
      "Susan\n",
      "Ann\n",
      "Susan\n"
     ]
    }
   ],
   "source": [
    "names1 = ['ann', 'richard', 'william', 'susan', 'pat']\n",
    "puts names1[0].capitalize\n",
    "puts names1[3].capitalize\n",
    "\n",
    "names2 = %w{ ann richard william susan pat }\n",
    "puts names2[0].capitalize\n",
    "puts names2[3].capitalize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Character Set\n",
    "\n",
    "A character set, or more specifically, a coded character set is a ser of character symbols, each of which has a unique numerical ID, which is called the character's code point.\n",
    "\n",
    "An example of a character set is the 128-character ASCII character set, which is mostly made up of the letters, numbers, and punctuation used in the English language. The most expansive character set in common use is the _Universal Character Set_ (UCS), as defined in the Unicode standard, which contains over 1.1 million code points.\n",
    "\n",
    "The letter A, for example is assigned a magic number by the Unicode consortium which is written like this: `U+0041`. A string `\"Hello\"` which, in Unicode, corresponds to these five code points:\n",
    "\n",
    "`U+0048 U+0065 U+006C U+006C U+006F`\n",
    "\n",
    "Just a bunch of code points. Numbers, really. We haven't yet said anything about how to store this in memory. That's where encodings come in."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Character Encoding\n",
    "\n",
    "UTF-8 can be used for storing your string of Unicode code points, those magic U+ numbers, in memory using 8 bit bytes. In UTF-8, every code point from 0-127 is stored in a single byte. Only code points 128 and above are stored using 2, 3, in fact, up to 6 bytes. This has the neat side effect that English text looks exactly the same in UTF-8 as it did in ASCII.\n",
    "\n",
    "**It does not make sense to have a string without knowing what encoding it uses**. Thus, if you have a string, you have to know what encoding it is in or you cannot interpret it or display it to users correctly.\n",
    "\n",
    "Ruby supports the idea of character encodings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encoding class\n",
    "\n",
    "Objects of class **`Encoding`** each represent a different character encoding. The **`Encoding.list`** method returns a list of the built-in encodings.\n",
    "\n",
    "Ruby has a way of setting the encoding on a file-by-file basis using a new magic comment. If the first line of a file is a comment (or the second line if the first line is a `#!`shebang line), Ruby scans it looking for the string `coding:`. If it finds it, Ruby then skips any spaces and looks for the (case-insensitive) name of an encoding. Thus, to specify that source file is in UTF-8 encoding, you can write this:\n",
    "\n",
    "```ruby\n",
    "# coding: utf-8\n",
    "```\n",
    "\n",
    "As Ruby is just scanning for `coding:`, you could also write the following:\n",
    "\n",
    "```ruby\n",
    "# encoding: utf-8\n",
    "```\n",
    "\n",
    "**Note**: Ruby writes a byte sequence `\\xEF\\xBB\\xBF` at the start of a source fle, when you use _utf-8_.\n",
    "\n",
    "If nothing overrides the setting, the default encoding for source is US-ASCII."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "UTF-8\n"
     ]
    }
   ],
   "source": [
    "# encoding: utf-8\n",
    "\n",
    "# λ is the Greek character Lambda here\n",
    "puts 'λ'.length\n",
    "puts 'λ'.bytesize\n",
    "puts 'λ'.encoding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can refer to all the detail of the `String` class [here](https://ruby-doc.org/core-3.0.0/String.html)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 3.0.0",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "3.0.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}