Ruby Notes for Professionals Ruby Programmation step by step (Chahdi, Othmane) (Z-Library)

📄 File Format: PDF

💾 File Size: 1.4 MB

📖 Read Online ⬇️ Download

Registered users can read the full content for free

Register as a Gaohf Library member to read the complete e-book online for free and enjoy a better reading experience.

📄 Page 1

(This page has no text content)

📄 Page 2

Contents 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

📄 Page 3

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

📄 Page 4

........................................................................................................................... ........... 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__

📄 Page 5

........................................................................................................................... ........................ 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

📄 Page 6

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 di erence ............................................................................................ 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 ...........................................................................................................................

📄 Page 7

............... 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

📄 Page 8

........................................................................................................................... .......... 35 Chapter 11: Strings ............................................................................................................. ......................................... 37 Section 11.1: Di erence 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

📄 Page 9

........................................................................................................................... ....... 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

📄 Page 10

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

📄 Page 11

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

📄 Page 12

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

📄 Page 13

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

📄 Page 14

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

📄 Page 15

........................................................................................................................... ..... 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

📄 Page 16

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 .............................................................................................................

📄 Page 17

............................ 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 Section 27.4: Using the missing method ................................................................................................................. 110 Chapter 28: Regular Expressions and Regex Based Operations ..................................................... 111 Section 28.1: =~ operator ...........................................................................................................................

📄 Page 18

................ 111 Section 28.2: Regular Expressions in Case Statements ........................................................................................ 111 Section 28.3: Groups, named and otherwise .......................................................................................................... 111 Section 28.4: Quantifiers ........................................................................................................................... ................ 112 Section 28.5: Common quick usage ........................................................................................................................ 113 Section 28.6: match? - Boolean Result ................................................................................................................... 113 Section 28.7: Defining a Regexp ........................................................................................................................... ... 113 Section 28.8: Character classes ........................................................................................................................... .... 114 Chapter 29: File and I/O Operations ............................................................................................................. . 116 Section 29.1: Writing a string to a file ...................................................................................................................... 116 Section 29.2: Reading from STDIN .......................................................................................................................... 116 Section 29.3: Reading from arguments with ARGV ............................................................................................... 116 Section 29.4: Open and closing a file ...................................................................................................................... 117 Section 29.5: get a single char of input ................................................................................................................... 117

📄 Page 19

Chapter 30: Ruby Access Modifiers ............................................................................................................. .... 118 Section 30.1: Instance Variables and Class Variables ........................................................................................... 118 Section 30.2: Access Controls ........................................................................................................................... ....... 120 Chapter 31: Design Patterns and Idioms in Ruby ..................................................................................... 123 Section 31.1: Decorator Pattern ........................................................................................................................... ..... 123 Section 31.2: Observer ........................................................................................................................... .................... 124 Section 31.3: Singleton ........................................................................................................................... .................... 125 Section 31.4: Proxy ........................................................................................................................... .......................... 126 Chapter 32: Loading Source Files ............................................................................................................. ........ 129 Section 32.1: Require files to be loaded only once ................................................................................................. 129 Section 32.2: Automatically loading source files ................................................................................................... 129 Section 32.3: Loading optional files .........................................................................................................................

📄 Page 20

129 Section 32.4: Loading files repeatedly .................................................................................................................... 130 Section 32.5: Loading several files .......................................................................................................................... 130 Chapter 33: Thread ............................................................................................................. ..................................... 131 Section 33.1: Accessing shared resources ............................................................................................................... 131 Section 33.2: Basic Thread Semantics .................................................................................................................... 131 Section 33.3: Terminating a Thread ........................................................................................................................ 132 Section 33.4: How to kill a thread ........................................................................................................................... . 132 Chapter 34: Range ............................................................................................................. ...................................... 133 Section 34.1: Ranges as Sequences ......................................................................................................................... 133 Section 34.2: Iterating over a range ........................................................................................................................ 133 Section 34.3: Range between dates ........................................................................................................................ 133