About ................................................................................................................................................................................... 1
Chapter 1: Getting started with Ruby Language .......................................................................................... 2
Section 1.1: Hello World ................................................................................................................................................. 2
Section 1.2: Hello World as a Self-Executable File—using Shebang (Unix-like operating systems only)
.................................................................................................................................................................................. 2
Section 1.3: Hello World from IRB ................................................................................................................................ 3
Section 1.4: Hello World without source files .............................................................................................................. 3
Section 1.5: Hello World with tk .................................................................................................................................... 3
Section 1.6: My First Method ......................................................................................................................................... 4
Chapter 2: Casting (type conversion) ................................................................................................................. 6
Section 2.1: Casting to a Float ...................................................................................................................................... 6
Section 2.2: Casting to a String .................................................................................................................................... 6
Section 2.3: Casting to an Integer ................................................................................................................................ 6
Section 2.4: Floats and Integers ................................................................................................................................... 6
Chapter 3: Operators .................................................................................................................................................. 8
Section 3.1: Operator Precedence and Methods ........................................................................................................ 8
Section 3.2: Case equality operator (===) ................................................................................................................. 10
Section 3.3: Safe Navigation Operator ...................................................................................................................... 11
Section 3.4: Assignment Operators ........................................................................................................................... 11
Section 3.5: Comparison Operators .......................................................................................................................... 12
Chapter 4: Variable Scope and Visibility ....................................................................................................... 13
Section 4.1: Class Variables ........................................................................................................................................ 13
Section 4.2: Local Variables ....................................................................................................................................... 14
Section 4.3: Global Variables ...................................................................................................................................... 15
Section 4.4: Instance Variables .................................................................................................................................. 16
Chapter 5: Environment Variables .................................................................................................................... 18
Section 5.1: Sample to get user profile path ............................................................................................................. 18
Chapter 6: Constants ................................................................................................................................................ 19
Section 6.1: Define a constant .................................................................................................................................... 19
Section 6.2: Modify a Constant .................................................................................................................................. 19
Section 6.3: Constants cannot be defined in methods ............................................................................................ 19
Section 6.4: Define and change constants in a class .............................................................................................. 19
Chapter 7: Special Constants in Ruby .............................................................................................................. 20
Section 7.1: __FILE__ .................................................................................................................................................. 20
Section 7.2: __dir__ ................................................................................................................................................... 20
Section 7.3: $PROGRAM_NAME or $0 ....................................................................................................................... 20
Section 7.4: $$ .............................................................................................................................................................. 20
Section 7.5: $1, $2, etc .................................................................................................................................................. 20
Section 7.6: ARGV or $* ............................................................................................................................................... 20
Section 7.7: STDIN ....................................................................................................................................................... 20
Section 7.8: STDOUT ................................................................................................................................................... 20
Section 7.9: STDERR .................................................................................................................................................... 20
Section 7.10: $stderr .................................................................................................................................................... 21
Section 7.11: $stdout ..................................................................................................................................................... 21
Section 7.12: $stdin ...................................................................................................................................................... 21
Section 7.13: ENV .......................................................................................................................................................... 21
,Chapter 8: Comments .............................................................................................................................................. 22
Section 8.1: Single & Multiple line comments ............................................................................................................ 22
Chapter 9: Arrays ....................................................................................................................................................... 23
Section 9.1: Create Array of Strings ........................................................................................................................... 23
Section 9.2: Create Array with Array::new ................................................................................................................ 23
Section 9.3: Create Array of Symbols ....................................................................................................................... 24
Section 9.4: Manipulating Array Elements ................................................................................................................ 24
Section 9.5: Accessing elements ................................................................................................................................ 25
Section 9.6: Creating an Array with the literal constructor [ ] ................................................................................ 26
Section 9.7: Decomposition ........................................................................................................................................ 26
Section 9.8: Arrays union, intersection and dierence ............................................................................................ 27
Section 9.9: Remove all nil elements from an array with #compact .................................................................... 28
Section 9.10: Get all combinations / permutations of an array ............................................................................. 28
Section 9.11: Inject, reduce .......................................................................................................................................... 29
Section 9.12: Filtering arrays ...................................................................................................................................... 30
Section 9.13: #map ...................................................................................................................................................... 30
Section 9.14: Arrays and the splat (*) operator ........................................................................................................ 31
Section 9.15: Two-dimensional array ........................................................................................................................ 31
Section 9.16: Turn multi-dimensional array into a one-dimensional (flattened) array ........................................ 32
Section 9.17: Get unique array elements ................................................................................................................... 32
Section 9.18: Create Array of numbers ..................................................................................................................... 32
Section 9.19: Create an Array of consecutive numbers or letters .......................................................................... 33
Section 9.20: Cast to Array from any object ............................................................................................................ 33
Chapter 10: Multidimensional Arrays ................................................................................................................ 35
Section 10.1: Initializing a 2D array ............................................................................................................................. 35
Section 10.2: Initializing a 3D array ............................................................................................................................ 35
Section 10.3: Accessing a nested array ..................................................................................................................... 35
Section 10.4: Array flattening ..................................................................................................................................... 35
Chapter 11: Strings ...................................................................................................................................................... 37
Section 11.1: Dierence between single-quoted and double-quoted String literals .............................................. 37
Section 11.2: Creating a String .................................................................................................................................... 37
Section 11.3: Case manipulation ................................................................................................................................. 38
Section 11.4: String concatenation ............................................................................................................................. 38
Section 11.5: Positioning strings .................................................................................................................................. 39
Section 11.6: Splitting a String ..................................................................................................................................... 40
Section 11.7: String starts with ..................................................................................................................................... 40
Section 11.8: Joining Strings ........................................................................................................................................ 40
Section 11.9: String interpolation ................................................................................................................................ 41
Section 11.10: String ends with ..................................................................................................................................... 41
Section 11.11: Formatted strings .................................................................................................................................. 41
Section 11.12: String Substitution ................................................................................................................................. 41
Section 11.13: Multiline strings ...................................................................................................................................... 41
Section 11.14: String character replacements ............................................................................................................ 42
Section 11.15: Understanding the data in a string ..................................................................................................... 43
Chapter 12: DateTime ............................................................................................................................................... 44
Section 12.1: DateTime from string ............................................................................................................................ 44
Section 12.2: New ......................................................................................................................................................... 44
Section 12.3: Add/subtract days to DateTime .......................................................................................................... 44
Chapter 13: Time .......................................................................................................................................................... 46
Section 13.1: How to use the strftime method ........................................................................................................... 46
, Section 13.2: Creating time objects ............................................................................................................................ 46
Chapter 14: Numbers ................................................................................................................................................ 47
Section 14.1: Converting a String to Integer .............................................................................................................. 47
Section 14.2: Creating an Integer ............................................................................................................................... 47
Section 14.3: Rounding Numbers ............................................................................................................................... 47
Section 14.4: Even and Odd Numbers ....................................................................................................................... 48
Section 14.5: Rational Numbers ................................................................................................................................. 48
Section 14.6: Complex Numbers ................................................................................................................................. 48
Section 14.7: Converting a number to a string ......................................................................................................... 49
Section 14.8: Dividing two numbers ........................................................................................................................... 49
Chapter 15: Symbols .................................................................................................................................................. 50
Section 15.1: Creating a Symbol ................................................................................................................................. 50
Section 15.2: Converting a String to Symbol ............................................................................................................. 50
Section 15.3: Converting a Symbol to String ............................................................................................................. 51
Chapter 16: Comparable ......................................................................................................................................... 52
Section 16.1: Rectangle comparable by area ........................................................................................................... 52
Chapter 17: Control Flow ......................................................................................................................................... 53
Section 17.1: if, elsif, else and end ............................................................................................................................... 53
Section 17.2: Case statement ..................................................................................................................................... 53
Section 17.3: Truthy and Falsy values ....................................................................................................................... 55
Section 17.4: Inline if/unless ........................................................................................................................................ 56
Section 17.5: while, until ............................................................................................................................................... 56
Section 17.6: Flip-Flop operator .................................................................................................................................. 57
Section 17.7: Or-Equals/Conditional assignment operator (||=) .............................................................................. 57
Section 17.8: unless ...................................................................................................................................................... 58
Section 17.9: throw, catch ............................................................................................................................................ 58
Section 17.10: Ternary operator ................................................................................................................................. 58
Section 17.11: Loop control with break, next, and redo ............................................................................................. 59
Section 17.12: return vs. next: non-local return in a block ........................................................................................ 61
Section 17.13: begin, end .............................................................................................................................................. 61
Section 17.14: Control flow with logic statements ..................................................................................................... 62
Chapter 18: Methods .................................................................................................................................................. 63
Section 18.1: Defining a method ................................................................................................................................. 63
Section 18.2: Yielding to blocks .................................................................................................................................. 63
Section 18.3: Default parameters ............................................................................................................................... 64
Section 18.4: Optional parameter(s) (splat operator) ............................................................................................. 65
Section 18.5: Required default optional parameter mix .......................................................................................... 65
Section 18.6: Use a function as a block ..................................................................................................................... 66
Section 18.7: Single required parameter ................................................................................................................... 66
Section 18.8: Tuple Arguments ................................................................................................................................... 66
Section 18.9: Capturing undeclared keyword arguments (double splat) .............................................................. 67
Section 18.10: Multiple required parameters ............................................................................................................. 67
Section 18.11: Method Definitions are Expressions .................................................................................................... 67
Chapter 19: Hashes ..................................................................................................................................................... 69
Section 19.1: Creating a hash ...................................................................................................................................... 69
Section 19.2: Setting Default Values .......................................................................................................................... 70
Section 19.3: Accessing Values ................................................................................................................................... 71
Section 19.4: Automatically creating a Deep Hash .................................................................................................. 72
Section 19.5: Iterating Over a Hash ........................................................................................................................... 73
Section 19.6: Filtering hashes ...................................................................................................................................... 74
, Section 19.7: Conversion to and from Arrays ........................................................................................................... 74
Section 19.8: Overriding hash function ...................................................................................................................... 74
Section 19.9: Getting all keys or values of hash ....................................................................................................... 75
Section 19.10: Modifying keys and values ................................................................................................................. 75
Section 19.11: Set Operations on Hashes ................................................................................................................... 76
Chapter 20: Blocks and Procs and Lambdas ............................................................................................... 77
Section 20.1: Lambdas ................................................................................................................................................ 77
Section 20.2: Partial Application and Currying ........................................................................................................ 78
Section 20.3: Objects as block arguments to methods ........................................................................................... 80
Section 20.4: Converting to Proc ............................................................................................................................... 80
Section 20.5: Blocks .................................................................................................................................................... 81
Chapter 21: Iteration ................................................................................................................................................. 83
Section 21.1: Each ......................................................................................................................................................... 83
Section 21.2: Implementation in a class .................................................................................................................... 84
Section 21.3: Iterating over complex objects ............................................................................................................ 84
Section 21.4: For iterator ............................................................................................................................................. 85
Section 21.5: Iteration with index ................................................................................................................................ 85
Section 21.6: Map ......................................................................................................................................................... 86
Chapter 22: Exceptions ............................................................................................................................................ 87
Section 22.1: Creating a custom exception type ...................................................................................................... 87
Section 22.2: Handling multiple exceptions .............................................................................................................. 87
Section 22.3: Handling an exception ......................................................................................................................... 88
Section 22.4: Raising an exception ............................................................................................................................ 90
Section 22.5: Adding information to (custom) exceptions ...................................................................................... 90
Chapter 23: Enumerators ....................................................................................................................................... 91
Section 23.1: Custom enumerators ............................................................................................................................ 91
Section 23.2: Existing methods ................................................................................................................................... 91
Section 23.3: Rewinding .............................................................................................................................................. 91
Chapter 24: Enumerable in Ruby ....................................................................................................................... 93
Section 24.1: Enumerable module .............................................................................................................................. 93
Chapter 25: Classes ................................................................................................................................................... 96
Section 25.1: Constructor ............................................................................................................................................ 96
Section 25.2: Creating a class .................................................................................................................................... 96
Section 25.3: Access Levels ........................................................................................................................................ 96
Section 25.4: Class Methods types ............................................................................................................................ 98
Section 25.5: Accessing instance variables with getters and setters .................................................................. 100
Section 25.6: New, allocate, and initialize ............................................................................................................... 101
Section 25.7: Dynamic class creation ..................................................................................................................... 101
Section 25.8: Class and instance variables ............................................................................................................ 102
Chapter 26: Inheritance ......................................................................................................................................... 104
Section 26.1: Subclasses ............................................................................................................................................ 104
Section 26.2: What is inherited? ............................................................................................................................... 104
Section 26.3: Multiple Inheritance ............................................................................................................................ 106
Section 26.4: Mixins ................................................................................................................................................... 106
Section 26.5: Refactoring existing classes to use Inheritance .............................................................................. 107
Chapter 27: method_missing ............................................................................................................................. 109
Section 27.1: Catching calls to an undefined method ............................................................................................ 109
Section 27.2: Use with block ..................................................................................................................................... 109
Section 27.3: Use with parameter ............................................................................................................................ 109