The well-grounded Rubyist /

Afficher d'autres versions (2)

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

Description complète

Détails bibliographiques
Cote:Libro Electrónico
Auteurs principaux: Black, David A. (Auteur), Leo, Joseph (Auteur)
Format: Électronique eBook
Langue:Inglés
Publié: Shelter Island, NY : Manning Publications Co., [2019]
Édition:Third edition.
Sujets:
Ruby on rails (Electronic resource)
Ruby (Computer program language)
Object-oriented programming languages.
Open source software.
Ruby (Langage de programmation)
Langages orientés objet (Informatique)
Logiciels libres.
Object-oriented programming languages
Open source software
Accès en ligne:Texto completo (Requiere registro previo con correo institucional)
Table des matières:
  • 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
  • & gt
  • 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.

Documents similaires