The well-grounded Rubyist
In The Well-Grounded Rubyist, Third Edition expert authors David A. Black and Joseph Leo deliver Ruby mastery in an easy-to-read, casual style. You'll lock in core principles as you write your first Ruby programs. Then, you'll progressively build up to topics like reflection, threading, an...
Otros Autores: | , |
---|---|
Formato: | Libro electrónico |
Idioma: | Inglés |
Publicado: |
Shelter Island, NY :
Manning
[2019]
|
Edición: | Third edition |
Materias: | |
Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009630940006719 |
Tabla de Contenidos:
- Intro
- Copyright
- Brief Table of Contents
- Table of Contents
- Praise for the Second Edition
- Preface
- Acknowledgments
- About this book
- About the authors
- About the cover illustration
- Part 1. Ruby foundations
- Chapter 1. Bootstrapping your Ruby literacy
- 1.1. Basic Ruby language literacy
- 1.2. Anatomy of the Ruby installation
- 1.3. Ruby extensions and programming libraries
- 1.4. Out-of-the-box Ruby tools and applications
- Summary
- Chapter 2. Objects, methods, and local variables
- 2.1. Talking to objects
- 2.2. Crafting an object: the behavior of a ticket
- 2.3. The innate behaviors of an object
- 2.4. A close look at method arguments
- 2.5. Local variables and variable assignment
- Summary
- Chapter 3. Organizing objects with classes
- 3.1. Classes and instances
- 3.2. Instance variables and object state
- 3.3. Setter methods
- 3.4. Attributes and the attr_* method family
- 3.5. Inheritance and the Ruby class hierarchy
- 3.6. Classes as objects and message receivers
- 3.7. Constants up close
- 3.8. Nature vs. nurture in Ruby objects
- Summary
- Chapter 4. Modules and program organization
- 4.1. Basics of module creation and use
- 4.2. Modules, classes, and method lookup
- 4.3. The method_missing method
- 4.4. Class/module design and naming
- Summary
- Chapter 5. The default object (self), scope, and visibility
- 5.1. Understanding self, the current/default object
- 5.2. Determining scope
- 5.3. Deploying method-access rules
- 5.4. Writing and using top-level methods
- Summary
- Chapter 6. Control-flow techniques
- 6.1. Conditional code execution
- 6.2. Repeating actions with loops
- 6.3. Iterators and code blocks
- 6.4. Error handling and exceptions
- Summary
- Part 2. Built-in classes and modules
- Chapter 7. Built-in essentials
- 7.1. Ruby's literal constructors.
- 7.2. Recurrent syntactic sugar
- 7.3. Bang (!) methods and "danger"
- 7.4. Built-in and custom to_* (conversion) methods
- 7.5. Boolean states, Boolean objects, and nil
- 7.6. Comparing two objects
- 7.7. Inspecting object capabilities
- Summary
- Chapter 8. Strings, symbols, and other scalar objects
- 8.1. Working with strings
- 8.2. Symbols and their uses
- 8.3. Numerical objects
- 8.4. Times and dates
- Summary
- Chapter 9. Collection and container objects
- 9.1. Arrays and hashes in comparison
- 9.2. Collection handling with arrays
- 9.3. Hashes
- 9.4. Ranges
- 9.5. Sets
- Summary
- Chapter 10. Collections central: Enumerable and Enumerator
- 10.1. Gaining enumerability through each
- 10.2. Enumerable Boolean queries
- 10.3. Enumerable searching and selecting
- 10.4. Element-wise enumerable operations
- 10.5. Relatives of each
- 10.6. The map method
- 10.7. Strings as quasi-enumerables
- 10.8. Sorting enumerables
- 10.9. Enumerators and the next dimension of enumerability
- 10.10. Enumerator semantics and uses
- 10.11. Enumerator method chaining
- 10.12. Lazy enumerators
- Summary
- Chapter 11. Regular expressions and regexp-based string operations
- 11.1. What are regular expressions?
- 11.2. Writing regular expressions
- 11.3. Building a pattern in a regular expression
- 11.4. Matching, substring captures, and MatchData
- 11.5. Fine-tuning regular expressions with quantifiers, anchors, and modifiers
- 11.6. Converting strings and regular expressions to each other
- 11.7. Common methods that use regular expressions
- Summary
- Chapter 12. File and I/O operations
- 12.1. How Ruby's I/O system is put together
- 12.2. Basic file operations
- 12.3. Querying IO and File objects
- 12.4. Directory manipulation with the Dir class
- 12.5. File tools from the standard library
- Summary.
- Part 3. Ruby dynamics
- Chapter 13. Object individuation
- 13.1. Where the singleton methods are: the singleton class
- 13.2. Modifying Ruby's core classes and modules
- 13.3. BasicObject as ancestor and class
- Summary
- Chapter 14. Callable and runnable objects
- 14.1. Basic anonymous functions: the Proc class
- 14.2. Creating functions with lambda and ->
- 14.4. The eval family of methods
- 14.5. Concurrent execution with threads
- 14.6. Issuing system commands from inside Ruby programs
- Summary
- Chapter 15. Callbacks, hooks, and runtime introspection
- 15.1. Callbacks and hooks
- 15.2. Interpreting object capability queries
- 15.3. Introspection of variables and constants
- 15.4. Tracing execution
- 15.5. Callbacks and method inspection in practice
- Summary
- Chapter 16. Ruby and functional programming
- 16.1. Understanding pure functions
- 16.2. Immutability
- 16.3. Higher-order functions
- 16.4. Recursion
- Summary
- Index
- List of Figures
- List of Tables
- List of Listings.