1. Trang chủ
  2. » Công Nghệ Thông Tin

Tài liệu tự học lập trình - ruby cookbook recipes for object oriented scripting (2nd ed ) carlson richardson 2015 03 25

990 3,1K 0
Tài liệu được quét OCR, nội dung có thể không chính xác

Đang tải... (xem toàn văn)

Tài liệu hạn chế xem trước, để xem đầy đủ mời bạn chọn Tải xuống

THÔNG TIN TÀI LIỆU

Thông tin cơ bản

Định dạng
Số trang 990
Dung lượng 9,05 MB

Nội dung

Tài liệu tự học lập trình - ruby cookbook recipes for object oriented scripting (2nd ed ) carlson richardson 2015 03 25

Trang 1

PROGRAMMING LANGUAGES/RUBYRuby CookbookISBN: 978-1-449-37371-9US $49.99 CAN $57.99“Programmersdon’tlivebylanguagesyn-taxalone,butbyeverylineofconcretecodetheywrite.Tothatend,thisbookisfilledwithpracticalrecipes,tips,knowledge,andwisdom.IhopeitleadsreaderstothenextstepofRubyprogramming.—Yukihiro (Matz) Matsumoto”Creator of RubyTwitter: @oreillymediafacebook.com/oreillyWhy spend time on coding problems that others have already solved when

you could be making real progress on your Ruby project? This updated cookbook provides more than 350 recipes for solving common problems, on topics ranging from basic data structures, classes, and objects, to web development, distributed programming, and multithreading.

Revised for Ruby 2.1, each recipe includes a discussion on why and how the solution works You’ll find recipes suitable for all skill levels, from Ruby newbies to experts who need an occasional reference With Ruby Cookbook, you’ll not only save time, but keep your brain percolating with new ideas as well.

Recipes cover:

■ Data structures including strings, numbers, date and time, arrays, hashes, files, and directories

■ Using Ruby’s code blocks, also known as closures

■ OOP features such as classes, methods, objects, and modules

■ XML and HTML, databases and persistence, and graphics and other formats

■ Web development with Rails and Sinatra

■ Internet services, web services, and distributed programming

■ Software testing, debugging, packaging, and distributing

■ Multitasking, multithreading, and extending Ruby with other languages

Lucas Carlson founded AppFog, a PaaS that leverages the open source Cloud Foundry project A professional developer for 20 years, he specializes in Ruby on

Rails development Lucas has written Programming for PaaS and Ruby Cookbook, First Edition (both O’Reilly) He maintains a website at http://www.lucascarlson.net/.

Trang 2

PROGRAMMING LANGUAGES/RUBYRuby CookbookISBN: 978-1-449-37371-9US $49.99 CAN $57.99“Programmersdon’tlivebylanguagesyn-taxalone,butbyeverylineofconcretecodetheywrite.Tothatend,thisbookisfilledwithpracticalrecipes,tips,knowledge,andwisdom.IhopeitleadsreaderstothenextstepofRubyprogramming.—Yukihiro (Matz) Matsumoto”Creator of RubyTwitter: @oreillymediafacebook.com/oreillyWhy spend time on coding problems that others have already solved when

you could be making real progress on your Ruby project? This updated cookbook provides more than 350 recipes for solving common problems, on topics ranging from basic data structures, classes, and objects, to web development, distributed programming, and multithreading.

Revised for Ruby 2.1, each recipe includes a discussion on why and how the solution works You’ll find recipes suitable for all skill levels, from Ruby newbies to experts who need an occasional reference With Ruby Cookbook, you’ll not only save time, but keep your brain percolating with new ideas as well.

Recipes cover:

■ Data structures including strings, numbers, date and time, arrays, hashes, files, and directories

■ Using Ruby’s code blocks, also known as closures

■ OOP features such as classes, methods, objects, and modules

■ XML and HTML, databases and persistence, and graphics and other formats

■ Web development with Rails and Sinatra

■ Internet services, web services, and distributed programming

■ Software testing, debugging, packaging, and distributing

■ Multitasking, multithreading, and extending Ruby with other languages

Lucas Carlson founded AppFog, a PaaS that leverages the open source Cloud Foundry project A professional developer for 20 years, he specializes in Ruby on

Rails development Lucas has written Programming for PaaS and Ruby Cookbook, First Edition (both O’Reilly) He maintains a website at http://www.lucascarlson.net/.

Trang 3

Lucas Carlson and Leonard Richardson

Ruby Cookbook

Trang 4

978-1-449-37371-9[M]

Ruby Cookbook

by Lucas Carlson and Leonard Richardson

Copyright © 2015 Lucas Carlson and Leonard Richardson All rights reserved.Printed in the United States of America.

Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.

O’Reilly books may be purchased for educational, business, or sales promotional use Online editions arealso available for most titles (http://safaribooksonline.com) For more information, contact our corporate/

institutional sales department: 800-998-9938 or corporate@oreilly.com.

Editors: Brian Anderson and Allyson MacDonaldProduction Editor: Matthew Hacker

Proofreader: Rachel MonaghanIndexer: Angela Howard

Interior Designer: David FutatoCover Designer: Ellie VolckhausenIllustrator: Rebecca Demarest

July 2006: First EditionMarch 2015: Second Edition

Revision History for the Second Edition

2015-03-10: First Release

See http://oreilly.com/catalog/errata.csp?isbn=9781449373719 for release details.

The O’Reilly logo is a registered trademark of O’Reilly Media, Inc Ruby Cookbook, the cover image of a

side-striped jackal, and related trade dress are trademarks of O’Reilly Media, Inc.

Trang 5

For Yoscelina, my muse and inspiration for everything great I have ever accomplished.For Hugh and Valentina, the most incredible miracles ever.

For Tess, who sat by me the whole time.

—Lucas Carlson

For Sumana.

Trang 7

Table of Contents

Preface xvii

1 Ruby 2.1 1

1.1 What’s Different Between Ruby 1.8 and 2.1? 2

1.2 YARV (Yet Another Ruby VM) Bytecode Interpreter 91.3 Syntax Changes 111.4 Keyword Arguments 141.5 Performance Enhancements 151.6 Refinements 161.7 Debugging with DTrace and TracePoint 171.8 Module Prepending 191.9 New Methods 211.10 New Classes 231.11 New Standard Libraries 261.12 What’s Next? 272 Strings 29

2.1 Building a String from Parts 33

2.2 Substituting Variables into Strings 35

2.3 Substituting Variables into an Existing String 37

2.4 Reversing a String by Words or Characters 39

2.5 Representing Unprintable Characters 40

2.6 Converting Between Characters and Values 43

2.7 Converting Between Strings and Symbols 44

2.8 Processing a String One Character at a Time 45

2.9 Processing a String One Word at a Time 47

2.10 Changing the Case of a String 49

2.11 Managing Whitespace 50

Trang 8

2.12 Testing Whether an Object Is String-Like 52

2.13 Getting the Parts of a String You Want 53

2.14 Word-Wrapping Lines of Text 54

2.15 Generating a Succession of Strings 56

2.16 Matching Strings with Regular Expressions 59

2.17 Replacing Multiple Patterns in a Single Pass 61

2.18 Validating an Email Address 63

2.19 Classifying Text with a Bayesian Analyzer 66

3 Numbers 69

3.1 Parsing a Number from a String 70

3.2 Comparing Floating-Point Numbers 73

3.3 Representing Numbers to Arbitrary Precision 76

3.4 Representing Rational Numbers 79

3.5 Generating Random Numbers 80

3.6 Converting Between Numeric Bases 82

3.7 Taking Logarithms 83

3.8 Finding Mean, Median, and Mode 86

3.9 Converting Between Degrees and Radians 89

3.10 Multiplying Matrices 90

3.11 Solving a System of Linear Equations 94

3.12 Using Complex Numbers 97

3.13 Simulating a Subclass of Fixnum 99

3.14 Doing Math with Roman Numbers 103

3.15 Generating a Sequence of Numbers 109

3.16 Generating Prime Numbers 112

3.17 Checking a Credit Card Checksum 116

4 Date and Time 119

4.1 Finding Today’s Date 122

4.2 Parsing Dates, Precisely or Fuzzily 126

4.3 Printing a Date 129

4.4 Iterating Over Dates 134

4.5 Doing Date Arithmetic 135

4.6 Counting the Days Since an Arbitrary Date 138

4.7 Converting Between Time Zones 140

4.8 Checking Whether Daylight Saving Time Is in Effect 142

4.9 Converting Between Time and DateTime Objects 144

4.10 Finding the Day of the Week 147

4.11 Handling Commercial Dates 149

4.12 Running a Code Block Periodically 150

Trang 9

4.14 Adding a Timeout to a Long-Running Operation 155

5 Arrays 157

5.1 Iterating Over an Array 159

5.2 Rearranging Values Without Using Temporary Variables 163

5.3 Stripping Duplicate Elements from an Array 165

5.4 Reversing an Array 166

5.5 Sorting an Array 167

5.6 Ignoring Case When Sorting Strings 169

5.7 Making Sure a Sorted Array Stays Sorted 170

5.8 Summing the Items of an Array 175

5.9 Sorting an Array by Frequency of Appearance 177

5.10 Shuffling an Array 179

5.11 Getting the N Smallest Items of an Array 180

5.12 Building a Hash from an Array 183

5.13 Extracting Portions of Arrays 185

5.14 Computing Set Operations on Arrays 188

5.15 Partitioning or Classifying a Set 191

6 Hashes 197

6.1 Using Symbols as Hash Keys 200

6.2 Creating a Hash with a Default Value 201

6.3 Adding Elements to a Hash 203

6.4 Removing Elements from a Hash 205

6.5 Using an Array or Other Modifiable Object as a Hash Key 206

6.6 Keeping Multiple Values for the Same Hash Key 209

6.7 Iterating Over a Hash 210

6.8 Iterating Over a Hash in Insertion Order 213

6.9 Printing a Hash 214

6.10 Inverting a Hash 216

6.11 Choosing Randomly from a Weighted List 217

6.12 Building a Histogram 220

6.13 Remapping the Keys and Values of a Hash 222

6.14 Extracting Portions of Hashes 223

6.15 Searching a Hash with Regular Expressions 224

7 Files and Directories 227

7.1 Checking to See If a File Exists 230

7.2 Checking Your Access to a File 232

7.3 Changing the Permissions on a File 234

7.4 Seeing When a File Was Last Used 237

7.5 Listing a Directory 239

Trang 10

7.6 Reading the Contents of a File 242

7.7 Writing to a File 246

7.8 Writing to a Temporary File 247

7.9 Picking a Random Line from a File 249

7.10 Comparing Two Files 250

7.11 Performing Random Access on “Read-Once” Input Streams 254

7.12 Walking a Directory Tree 256

7.13 Locking a File 259

7.14 Backing Up to Versioned Filenames 262

7.15 Pretending a String Is a File 265

7.16 Redirecting Standard Input or Output 268

7.17 Processing a Binary File 270

7.18 Deleting a File 274

7.19 Truncating a File 275

7.20 Finding the Files You Want 277

7.21 Finding and Changing the Current Working Directory 279

8 Code Blocks and Iteration 281

8.1 Creating and Invoking a Block 284

8.2 Writing a Method That Accepts a Block 286

8.3 Binding a Block Argument to a Variable 289

8.4 Blocks as Closures: Using Outside Variables Within a Code Block 291

8.5 Writing an Iterator Over a Data Structure 293

8.6 Changing the Way an Object Iterates 296

8.7 Writing Block Methods That Classify or Collect 298

8.8 Stopping an Iteration 300

8.9 Looping Through Multiple Iterables in Parallel 302

8.10 Hiding Setup and Cleanup in a Block Method 306

8.11 Coupling Systems Loosely with Callbacks 308

9 Objects and Classes 313

9.1 Managing Instance Data 316

9.2 Managing Class Data 318

9.3 Checking Class or Module Membership 321

9.4 Writing an Inherited Class 323

9.5 Overloading Methods 326

9.6 Validating and Modifying Attribute Values 328

9.7 Defining a Virtual Attribute 330

9.8 Delegating Method Calls to Another Object 331

9.9 Converting and Coercing Objects to Different Types 334

9.10 Getting a Human-Readable Printout of Any Object 339

Trang 11

9.12 Using Keyword Arguments 343

9.13 Calling a Superclass’s Method 345

9.14 Creating an Abstract Method 347

9.15 Freezing an Object to Prevent Changes 350

9.16 Making a Copy of an Object 353

9.17 Declaring Constants 356

9.18 Implementing Class and Singleton Methods 358

9.19 Controlling Access by Making Methods Private 360

10 Modules and Namespaces 365

10.1 Simulating Multiple Inheritance with Mixins 366

10.2 Extending Specific Objects with Modules 370

10.3 Mixing in Class Methods 372

10.4 Implementing Enumerable: Write One Method, Get 48 Free 373

10.5 Avoiding Naming Collisions with Namespaces 377

10.6 Automatically Loading Libraries as Needed 378

10.7 Including Namespaces 380

10.8 Initializing Instance Variables Defined by a Module 382

10.9 Automatically Initializing Mixed-in Modules 383

10.10 Prepending Modules 386

11 Reflection and Metaprogramming 389

11.1 Finding an Object’s Class and Superclass 390

11.2 Listing an Object’s Methods 391

11.3 Listing Methods Unique to an Object 394

11.4 Getting a Reference to a Method 396

11.5 Fixing Bugs in Someone Else’s Class 398

11.6 Listening for Changes to a Class 400

11.7 Checking Whether an Object Has Necessary Attributes 403

11.8 Responding to Calls to Undefined Methods 404

11.9 Automatically Initializing Instance Variables 409

11.10 Avoiding Boilerplate Code with Metaprogramming 410

11.11 Metaprogramming with String Evaluations 413

11.12 Evaluating Code in an Earlier Context 415

11.13 Undefining a Method 417

11.14 Aliasing Methods 420

11.15 Doing Aspect-Oriented Programming 423

11.16 Enforcing Software Contracts 425

12 XML and HTML 431

12.1 Checking That XML Is Well Formed 432

12.2 Extracting Data from a Document’s Tree Structure 434

Trang 12

12.3 Extracting Data While Parsing a Document 436

12.4 Navigating a Document with XPath 438

12.5 Converting an XML Document into a Hash 441

12.6 Validating an XML Document 444

12.7 Substituting XML Entities 445

12.8 Creating and Modifying XML Documents 448

12.9 Compressing Whitespace in an XML Document 452

12.10 Guessing a Document’s Encoding 453

12.11 Converting from One Encoding to Another 454

12.12 Extracting All the URLs from an HTML Document 456

12.13 Transforming Plain Text to HTML 459

12.14 Converting HTML Documents from the Web into Text 460

12.15 Creating a Simple Feed Aggregator 463

13 Graphics and Other File Formats 469

13.1 Thumbnailing Images 470

13.2 Adding Text to an Image 473

13.3 Converting One Image Format to Another 476

13.4 Graphing Data 479

13.5 Adding Graphical Context with Sparklines 482

13.6 Symmetrically Encrypting Data 485

13.7 Parsing Comma-Separated Data 487

13.8 Parsing Not-Quite-Comma-Separated Data 489

13.9 Generating and Parsing Excel Spreadsheets 490

13.10 Compressing and Archiving Files with Gzip and Tar 492

13.11 Reading and Writing ZIP Files 495

13.12 Reading and Writing Configuration Files 497

13.13 Generating PDF Files 499

13.14 Representing Data as MIDI Music 503

14 Databases and Persistence 507

14.1 Serializing Data with YAML 511

14.2 Serializing Data with Marshal 514

14.3 Persisting Objects with Madeleine 515

14.4 Indexing Unstructured Text with SimpleSearch 518

14.5 Indexing Structured Text with Ferret 520

14.6 Using Berkeley DB Databases 524

14.7 Controlling MySQL on Unix 525

14.8 Finding the Number of Rows Returned by a Query 526

14.9 Talking Directly to a MySQL Database 528

14.10 Talking Directly to a PostgreSQL Database 531

Trang 13

14.12 Building Queries Programmatically 538

14.13 Validating Data with ActiveRecord 542

14.14 Preventing SQL Injection Attacks 544

14.15 Using Transactions in ActiveRecord 547

14.16 Adding Hooks to Table Events 549

14.17 Adding Taggability with a Database Mixin 551

15 Internet Services 555

15.1 Grabbing the Contents of a Web Page 556

15.2 Making an HTTPS Web Request 559

15.3 Customizing HTTP Request Headers 561

15.4 Performing DNS Queries 563

15.5 Sending Mail 565

15.6 Reading Mail with IMAP 569

15.7 Reading Mail with POP3 574

15.8 Being an FTP Client 577

15.9 Being a Telnet Client 579

15.10 Being an SSH Client 583

15.11 Copying a File to Another Machine 585

15.12 Being a BitTorrent Client 587

15.13 Pinging a Machine 588

15.14 Writing an Internet Server 589

15.15 Parsing URLs 592

15.16 Writing a CGI Script 595

15.17 Setting Cookies and Other HTTP Response Headers 598

15.18 Handling File Uploads via CGI 600

15.19 Running Servlets with WEBrick 603

15.20 Creating a Real-World HTTP Client 609

16 Web Development: Ruby on Rails 613

16.1 Writing a Simple Rails Application to Show System Status 616

16.2 Passing Data from the Controller to the View 619

16.3 Creating a Layout for Your Header and Footer 621

16.4 Redirecting to a Different Location 624

16.5 Displaying Templates with Render 626

16.6 Integrating a Database with Your Rails Application 629

16.7 Understanding Pluralization Rules 633

16.8 Creating a Login System 636

16.9 Storing Hashed User Passwords in the Database 640

16.10 Escaping HTML and JavaScript for Display 642

16.11 Setting and Retrieving Session Information 643

16.12 Setting and Retrieving Cookies 645

Trang 14

16.13 Extracting Code into Helper Functions 647

16.14 Refactoring the View into Partial Snippets of Views 649

16.15 Adding Dynamic Effects with script.aculo.us 653

16.16 Generating Forms for Manipulating Model Objects 655

16.17 Creating an Ajax Form 660

16.18 Exposing Web Services on Your Website 664

16.19 Sending Mail with Rails 666

16.20 Automatically Sending Error Messages to Your Email 669

16.21 Documenting Your Website 671

16.22 Unit-Testing Your Website 672

16.23 Using breakpoint in Your Web Application 676

17 Web Development: Sinatra 679

17.1 Developing a Minimalistic Web-Services–Based Application 680

17.2 Writing a Simple Sinatra Application to Show System Status 681

17.3 Creating a Layout for Your Header and Footer 682

17.4 Passing Data from the Controller to the View 683

17.5 Redirecting to a Different Location 685

17.6 Integrating a Database with Your Sinatra Application 686

17.7 Setting Status Codes and Headers 688

17.8 Setting and Retrieving Session Information 688

17.9 Setting and Retrieving Cookies 690

17.10 Sending Mail with Sinatra 691

17.11 Building RESTful Web Services on Your Website 692

17.12 Creating RESTful JavaScript Clients for Your Web Services 695

18 Web Services and Distributed Programming 697

18.1 Searching for Books on Amazon 699

18.2 Finding Photos on Flickr 702

18.3 Writing an XML-RPC Client 705

18.4 Writing a SOAP Client 707

18.5 Writing a SOAP Server 709

18.6 Charging a Credit Card 710

18.7 Finding the Cost to Ship Packages via UPS or FedEx 712

18.8 Sharing a Hash Between Any Number of Computers 713

18.9 Implementing a Distributed Queue 717

18.10 Creating a Shared “Whiteboard” 719

18.11 Securing DRb Services with Access Control Lists 722

18.12 Automatically Discovering DRb Services with Rinda 724

18.13 Proxying Objects That Can’t Be Distributed 726

18.14 Storing Data on Distributed RAM with MemCached 729

Trang 15

18.16 A Remote-Controlled Jukebox 734

19 Testing, Debugging, Optimizing, and Documenting 741

19.1 Running Code Only in Debug Mode 742

19.2 Raising an Exception 744

19.3 Handling an Exception 746

19.4 Retrying After an Exception 748

19.5 Adding Logging to Your Application 750

19.6 Creating and Understanding Tracebacks 752

19.7 Writing Unit Tests 755

19.8 Running Unit Tests 758

19.9 Testing Code That Uses External Resources 761

19.10 Using debug to Inspect and Change the State of Your Application 765

19.11 Documenting Your Application 768

19.12 Profiling Your Application 772

19.13 Benchmarking Competing Solutions 775

19.14 Running Multiple Analysis Tools at Once 777

20 Packaging and Distributing Software 781

20.1 Finding Libraries by Querying Gem Respositories 782

20.2 Installing and Using a Gem 785

20.3 Requiring a Specific Version of a Gem 787

20.4 Uninstalling a Gem 790

20.5 Reading Documentation for Installed Gems 791

20.6 Packaging Your Code as a Gem 792

20.7 Distributing Your Gems 795

20.8 Installing and Creating Standalone Packages with setup.rb 796

21 Automating Tasks with Rake 801

21.1 Automatically Running Unit Tests 803

21.2 Automatically Generating Documentation 805

21.3 Cleaning Up Generated Files 808

21.4 Automatically Building a Gem 809

21.5 Gathering Statistics About Your Code 811

21.6 Publishing Your Documentation 814

21.7 Running Multiple Tasks in Parallel 816

21.8 Creating a Generic Project Rakefile 817

22 Multitasking and Multithreading 825

22.1 Running a Daemon Process on Unix 826

22.2 Creating a Windows Service 829

22.3 Doing Two Things at Once with Threads 833

Trang 16

22.4 Synchronizing Access to an Object 835

22.5 Terminating a Thread 838

22.6 Running a Code Block on Many Objects Simultaneously 840

22.7 Limiting Multithreading with a Thread Pool 843

22.8 Driving an External Process with popen 846

22.9 Capturing the Output and Error Streams from a Unix Shell Command 848

22.10 Controlling a Process on Another Machine 849

22.11 Avoiding Deadlock 851

23 User Interface 855

23.1 Resources 856

23.2 Getting Input One Line at a Time 857

23.3 Getting Input One Character at a Time 859

23.4 Parsing Command-Line Arguments 861

23.5 Testing Whether a Program Is Running Interactively 864

23.6 Setting Up and Tearing Down a Curses Program 865

23.7 Clearing the Screen 866

23.8 Determining Terminal Size 868

23.9 Changing Text Color 870

23.10 Reading a Password 871

23.11 Allowing Input Editing with Readline 872

23.12 Making Your Keyboard Lights Blink 874

23.13 Creating a GUI Application with Tk 876

23.14 Creating a GUI Application with wxRuby 880

23.15 Creating a GUI Application with Ruby/GTK 884

23.16 Using AppleScript to Get User Input 888

24 Extending Ruby with Other Languages 891

24.1 Writing a C Extension for Ruby 892

24.2 Using a C Library from Ruby 896

24.3 Calling a C Library Through SWIG 899

24.4 Writing Inline C in Your Ruby Code 902

24.5 Using Java Libraries with JRuby 904

25 System Administration 909

25.1 Scripting an External Program 910

25.2 Managing Windows Services 912

25.3 Running Code as Another User 913

25.4 Running Periodic Tasks Without cron or at 915

25.5 Deleting Files That Match a Regular Expression 916

25.6 Renaming Files in Bulk 919

Trang 17

25.8 Automating Backups 925

25.9 Normalizing Ownership and Permissions in User Directories 926

25.10 Killing All Processes for a Given User 930

25.11 Using Puppet for DevOps System Administration 932

Index 935

Trang 19

Preface

Life Is Short

This is a book of recipes: solutions to common problems, copy-and-paste code snip‐pets, explanations, examples, and short tutorials.

This book is meant to save you time Time, as they say, is money, but a span of time isalso a piece of your life Our lives are better spent creating new things than fightingour own errors, or trying to solve problems that have already been solved We presentthis book in the hope that the time it saves, distributed across all its readers, willgreatly outweigh the time we spent creating it.

The Ruby programming language is itself a wonderful time-saving tool It makes youmore productive than other programming languages because you spend more timemaking the computer do what you want, and less wrestling with the language Butthere are many ways for a Ruby programmer to spend time without accomplishinganything, and we’ve encountered them all:

• Time spent writing Ruby implementations of common algorithms.

• Time spent debugging Ruby implementations of common algorithms.

• Time spent discovering and working around Ruby-specific pitfalls.

• Time spent on repetitive tasks (including repetitive programming tasks!) thatcould be automated.

• Time spent duplicating work that someone else has already made publiclyavailable.

• Time spent searching for a library that does x.

• Time spent evaluating and deciding between the many libraries that do x.

• Time spent learning how to use a library because of poor or outdateddocumentation.

Trang 20

• Time lost staying away from a useful technology because it seems intimidating.We, and the many contributors to this book, recall vividly our own wasted hours anddays We’ve distilled our experiences into this book so that you don’t waste your time

—or at least so you waste it enjoyably on more interesting problems.

Our other goal is to expand your interests If you come to this book wanting to gener‐ate algorithmic music with Ruby then, yes, Recipe 13.14 will save you time over start‐ing from scratch It’s more likely that you’d never considered the possibility until now.Every recipe in this book was developed and written with these two goals in mind: tosave you time, and to keep your brain active with new ideas.

Audience

This cookbook is aimed at people who know at least a little bit of Ruby, or who know

a fair amount about programming in general This isn’t a Ruby tutorial (see “OtherResources” on page xxv below for some real tutorials), but if you’re already familiarwith a few other programming languages, you should be able to pick up Ruby byreading through the first 10 chapters of this book and typing in the code listings asyou go.

We’ve included recipes suitable for all skill levels, from those who are just starting outwith Ruby, to experts who need an occasional reference We focus mainly on genericprogramming techniques, but we also cover specific application frameworks (likeRuby on Rails and GUI libraries) and best practices (like unit testing).

Even if you just plan to use this book as a reference, we recommend that you skimthrough it once to get a picture of the problems we solve This is a big book, but itdoesn’t solve every problem If you pick it up and you can’t find a solution to your

problem, or one that nudges you in the right direction, then you’ve lost time.

If you skim through this book once beforehand, you’ll get a fair idea of the problemswe cover in this book, and you’ll get a better hit rate You’ll know when this book canhelp you, and when you should consult other books, do a web search, ask a friend, orget help some other way.

The Structure of This Book

Trang 21

A brand new chapter covers what has changed since Ruby 1.8 when the first versionof this book was released:

Chapter 1, Ruby 2.1, covers what is new in Ruby 2.1.The next six chapters cover Ruby’s built-in data structures:

Chapter 2, Strings, contains recipes for building, processing, and manipulatingstrings of text We devote a few recipes specifically to regular expressions (Recipe2.16 through Recipe 2.18), but our focus is on Ruby-specific issues, and regularexpressions are a very general tool If you haven’t encountered them yet, or justfind them intimidating, we recommend you go through an online tutorial or

Mastering Regular Expressions by Jeffrey Friedl (O’Reilly).

Chapter 3, Numbers, covers the representation of different types of numbers: realnumbers, complex numbers, arbitrary-precision decimals, and so on It alsoincludes Ruby implementations of common mathematical and statistical algo‐rithms, and explains some Ruby quirks you’ll run into if you create your ownnumeric types (Recipe 3.13 and Recipe 3.14).

Chapter 4, Date and Time, covers Ruby’s two interfaces for dealing with time: theone based on the C time library, which may be familiar to you from other pro‐gramming languages, and the one implemented in pure Ruby, which is moreidiomatic.

Chapter 5, Arrays, introduces the array, Ruby’s simplest compound data type.Many of an array’s methods are actually methods of the Enumerable mixin; thismeans you can apply many of these recipes to hashes and other data types Somefeatures of Enumerable are covered in this chapter (Recipe 5.4 and Recipe 5.6),and some are covered in Chapter 8.

Chapter 6, Hashes, covers the hash, Ruby’s other basic compound data type.Hashes make it easy to associate objects with names and find them later (hashes

are sometimes called lookup tables or dictionaries, two telling names) It’s easy to

use hashes along with arrays to build deep and complex data structures.

Chapter 7, Files and Directories, covers techniques for reading, writing, andmanipulating files Ruby’s file access interface is based on the standard C filelibraries, so it may look familiar to you This chapter also covers Ruby’s standardlibraries for searching and manipulating the filesystem; many of these recipesshow up again in Chapter 25.

The first six chapters deal with specific algorithmic problems The next four are moreabstract: they’re about Ruby idiom and philosophy If you can’t get the Ruby languageitself to do what you want, or you’re having trouble writing Ruby code that looks theway Ruby “should” look, the recipes in these chapters may help:

Trang 22

Chapter 8, Code Blocks and Iteration, contains recipes that explore the possibili‐

ties of Ruby’s code blocks (also known as closures).

Chapter 9, Objects and Classes, covers Ruby’s take on object-oriented program‐ming It contains recipes for writing different types of classes and methods, and afew recipes that demonstrate capabilities of all Ruby objects (such as freezing andcloning).

Chapter 10, Modules and Namespaces, covers Ruby’s modules These constructsare used to “mix” new behavior into existing classes and to segregate functional‐ity into different namespaces.

Chapter 11, Reflection and Metaprogramming, covers techniques for programati‐cally exploring and modifying Ruby class definitions.

Chapter 7 covers basic file access, but doesn’t touch much on specific file formats Wedevote three chapters to popular ways of storing data:

Chapter 12, XML and HTML, shows how to handle the most popular data inter‐change formats The chapter deals mostly with parsing other people’s XML docu‐ments and web pages (but see Recipe 12.8).

Chapter 13, Graphics and Other File Formats, covers data interchange formatsother than XML and HTML, with a special focus on generating and manipulat‐ing graphics.

Chapter 14, Databases and Persistence, covers the best Ruby interfaces to datastorage formats, whether you’re serializing Ruby objects to disk, or storing struc‐tured data in a database This chapter demonstrates everything from differentways of serializing data and indexing text, to the Ruby client libraries for popularSQL databases, to full-blown abstraction layers like ActiveRecord that save youfrom having to write SQL at all.

Currently the most popular use of Ruby is in network applications (mostly throughRuby on Rails) We devote three chapters to different types of applications:

Chapter 15, Internet Services, kicks off our networking coverage by illustrating awide variety of clients and servers written with Ruby libraries.

Chapter 16, Web Development: Ruby on Rails, covers the web application frame‐work that’s been driving so much of Ruby’s recent popularity.

Chapter 17, Web Development: Sinatra, covers a popular micro-web framework.• Chapter 18, Web Services and Distributed Programming, covers two techniques

Trang 23

structures between programs running on a set of computers, all of which youcontrol.

We then have three chapters on the auxilliary tasks that surround the main program‐ming work of a project:

Chapter 19, Testing, Debugging, Optimizing, and Documenting, focuses mainly onhandling exception conditions and creating unit tests for your code There arealso several recipes on the processes of debugging and optimization.

Chapter 20, Packaging and Distributing Software, mainly deals with Ruby’s Gempackaging system and the RubyForge server that hosts many gem files Many rec‐ipes in other chapters require that you install a particular gem, so if you’re notfamiliar with gems, we recommend you read Recipe 20.2 in particular The chap‐ter also shows you how to create and distribute gems for your own projects.• Chapter 21, Automating Tasks with Rake, covers the most popular Ruby build

tool With Rake, you can script common tasks like running unit tests or packag‐ing your code as a gem Though it’s usually used in Ruby projects, Rake is ageneral-purpose build language that you can use wherever you might use Make.We close the book with four chapters on miscellaneous topics:

Chapter 22, Multitasking and Multithreading, shows how to use threads to domore than one thing at once, and how to use Unix subprocesses to run externalcommands.

Chapter 23, User Interface, covers user interfaces (apart from the web interface,which was covered in Chapter 16) We discuss the command-line interface,character-based GUIs with Curses and HighLine, GUI toolkits for various plat‐forms, and more obscure kinds of user interface (Recipe 23.11).

Chapter 24, Extending Ruby with Other Languages, focuses on hooking up Rubyto other languages, either for performance or to get access to more libraries Mostof the chapter focuses on getting access to C libraries, but there is one recipeabout JRuby, the Ruby implementation that runs on the Java Virtual Machine(Recipe 24.5).

Chapter 25, System Administration is full of self-contained programs for doingadministrative tasks, usually using techniques from other chapters The recipeshave a heavy focus on Unix administration, but there are some resources forWindows users (including Recipe 25.2), and some cross-platform scripts.

Trang 24

How the Code Listings Work

Learning from a cookbook means performing the recipes Some of our recipes definebig chunks of Ruby code that you can simply plop into your program and use withoutreally understanding them (Recipe 21.8 is a good example) But most of the recipesdemonstrate techniques, and the best way to learn a technique is to practice it.We wrote the recipes, and their code listings, with this in mind Most of our listingsact like unit tests for the concepts described in the recipe: they poke at objects andshow you the results.

Now, a Ruby installation comes with an interactive interpreter called irb Within an

irb session, you can type in lines of Ruby code and see the output immediately Youdon’t have to create a Ruby program file and run it through the interpreter.

Most of our recipes are presented in a form that you can type or copy/paste directlyinto an irb session To study a recipe in depth, we recommend that you start an irb

session and run through the code listings as you read it You’ll have a deeper under‐standing of the concept if you do it yourself than if you just read about it Once you’redone, you can experiment further with the objects you defined while running thecode listings.

Sometimes we want to draw your attention to the expected result of a Ruby expres‐sion We do this with a Ruby comment containing an ASCII arrow that points to theexpected value of the expression This is the same arrow irb uses to tell you the valueof every expression you type.

We also use textual comments to explain some pieces of code Here’s a fragment ofRuby code that we’ve formatted with comments as we would in a recipe:

1+2 # => 3

# On a long line, the expected value goes on a new line:

Math.sqrt(10)

# => 7.41619848709566

To display the expected output of a Ruby expression, we use a comment that has no

ASCII arrow, and that always goes on a new line:puts "This string is self-referential."

# This string is self-referential.

Trang 25

1When a program’s behavior depends on the current time, the random number generator, or the presence ofcertain files on disk, you might not get the exact same results we did, but they should be similar.

irb(main):003:0> puts "This string is self-referential."

This string is self-referential.=> nil

If you’re reading this book in electronic form, you can copy and paste the code frag‐ments into irb The Ruby interpreter will ignore the comments, but you can use themto make sure your answers match ours, without having to look back at the text (butyou should know that typing in the code yourself, at least the first time, is better forcomprehension):$irbirb(main):001:0> 1 + 2 # => 3=> 3irb(main):002:0>irb(main):003:0* # On a long line, the expected value goes on a new line:irb(main):004:0* Math.sqrt(1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10)=> 7.41619848709566irb(main):005:0> # => 7.41619848709566irb(main):006:0*

irb(main):007:0* puts "This string is self-referential."

This string is self-referential.=> nil

irb(main):008:0> # This string is self-referential.

We don’t cut corners Most of our recipes demonstrate a complete irb session fromstart to finish, and they include any imports or initialization necessary to illustrate thepoint we’re trying to make If you run the code exactly as it is in the recipe, youshould get the same results we did.1 This fits in with our philosophy that code sam‐ples should be unit tests for the underlying concepts In fact, we tested our code sam‐ples like unit tests, with a Ruby script that parses recipe texts and runs the code list‐ings.

The irb session technique doesn’t always work Rails recipes have to run within Rails.Curses recipes take over the screen and don’t play well with irb So sometimes weshow you standalone files We present them in the following format:

#!/usr/bin/ruby -w

# sample_ruby_file.rb: A sample file

1+2

Math.sqrt(10)

puts "This string is self-referential."

Whenever possible, we’ll also show what you’ll get when you run this program; forexample, we might show a screenshot of a GUI program, or a record of the program’soutput when run from the Unix command line:

Trang 26

$ ruby sample_ruby_file.rbThis string is self-referential.

Note that the output of sample_ruby_file.rb looks different from the same codeentered into irb Here, there’s no trace of the addition and the square root operations,because they produce no output.

Installing the Software

Ruby comes preinstalled on Mac OS X and most Linux installations Windowsdoesn’t come with Ruby, but it’s easy to get it with the One-Click Installer.

If you’re on a Unix/Linux system and you don’t have Ruby installed (or you want toupgrade), your distribution’s package system may make a Ruby package available OnDebian GNU/Linux, it’s available as the package ruby-[version]: for instance,

ruby-1.8 or ruby-1.9 Red Hat Linux calls it ruby; so does the DarwinParts systemon Mac OS X.

If all else fails, download the Ruby source code and compile it yourself You can getthe Ruby source code through FTP or HTTP by visiting http://www.ruby-lang.org/.Many of the recipes in this book require that you install third-party libraries in theform of Ruby gems In general, we prefer standalone solutions (using only the Rubystandard library) to solutions that use gems, and gem-based solutions to ones thatrequire other kinds of third-party software.

If you’re not familiar with gems, consult Chapter 20 as needed With RubyGems builtin, it’s easy to install many other pieces of Ruby code When a recipe says somethinglike “Ruby on Rails is available as the rails gem,” you can issue the following com‐mand from the command line (again, as the superuser):

$ gem install rails

The RubyGems library will download the rails gem (and any other gems on which itdepends) and automatically install them You should then be able to run the code inthe recipe, exactly as it appears.

Trang 27

Platform Differences, Version Differences, and OtherHeadaches

Except where noted, the recipes describe cross-platform concepts, and the code itselfshould run the same way on Windows, Linux, and Mac OS X Most of the platformdifferences and platform-specific recipes show up in the final chapters: Chapters 22,23, and 25 (but see the introduction to Chapter 7 for a note about Windowsfilenames).

We wrote and tested the recipes using Ruby version 1.8.4 and Rails version 1.1.2, thelatest stable versions as of the time of writing In a couple of places we mention codechanges you should make if you’re running Ruby 1.9 (the latest unstable version as ofthe time of writing) or 2.0.

Despite our best efforts, this book may contain unflagged platform-specific code, notto mention plain old bugs We apologize for these in advance of their discovery Ifyou have problems with a recipe, check out the errata for this book (see the section“Comments and Questions” on page xxvii below).

In several recipes in this book, we modify standard Ruby classes like Array to addnew methods (see, for instance, Recipe 2.10, which defines a new method called

String#capitalize_first_letter) These methods are then available to everyinstance of that class in your program This is a fairly common technique in Ruby:both Rails and the aforementioned Facets Core library do it It’s somewhat controver‐sial, though, and it can cause problems (see Recipe 9.4 for an in-depth discussion), sowe felt we should mention it here in the Preface, even though it might be too techni‐cal for people who are new to Ruby.

If you don’t want to modify the standard classes, you can put the methods we demon‐strate into a subclass, or define them in the Kernel namespace: that is, define capitalize_first_letter_of_string instead of reopening String and defining capitalize_first_letter inside it.

Other Resources

If you need to learn Ruby, the standard reference is Programming Ruby: The Prag‐matic Programmer’s Guide by Dave Thomas, Chad Fowler, and Andy Hunt (Prag‐

matic Programmers) The first edition is available online in HTML format, but it’s outof date The second edition is much better and is available as a printed book or asPDF It’s a much better idea to buy the second edition.

For Rails, the standard book is Agile Web Development with Rails by Dave Thomas,

David Hansson, Leon Breedt, and Mike Clark (Pragmatic Programmers) There are

Trang 28

also two books like this one that focus exclusively on Rails: Rails Cookbook by Rob

Orsini (O’Reilly) and Rails Recipes by Chad Fowler (Pragmatic Programmers).

Many people come to Ruby already knowing one or more programming languages.You might find it frustrating to learn Ruby with a big book that thinks it has to teach

you programming and Ruby For such people, we recommend “Ruby User’s Guide”by Ruby creator Yukihiro Matsumoto It’s a short read, and it focuses on what makesRuby different from other programming languages Its terminology is a little out ofdate, and it presents its code samples through the obsolete eval.rb program (use irb

instead), but it’s the best short introduction we know of.

If you are a Java programmer who wants to learn Ruby, check out the blog entry“Coming to Ruby from Java” by Francis Hwang C++ programmers will also benefitfrom much of what’s in here.

Finally, Ruby’s built-in modules, classes, and methods come with excellent documen‐

tation (much of it originally written for Programming Ruby) You can read this docu‐

mentation online at http://www.ruby-doc.org/core/ and http://www.ruby-doc.org/stdlib/ You can also look it up on your own Ruby installation by using the ri com‐mand Pass in the name of a class or method, and ri will give you the correspondingdocumentation Here are a few examples:

$ ri Array # A class$ ri Array.new # A class method$ ri Array#compact # An instance method

Conventions Used in This Book

The following typographical conventions are used in this book:Plain text

Indicates menu titles, menu options, menu buttons, and keyboard accelerators(such as Alt and Ctrl).

Italic

Indicates new terms, URLs, email addresses, and Unix utilities.

Constant width

Indicates commands, options, switches, variables, attributes, keys, functions,types, classes, namespaces, methods, modules, properties, parameters, values,objects, events, event handlers, XML tags, HTML tags, macros, programs, libra‐ries, filenames, pathnames, directories, the contents of files, or the output fromcommands.

Constant width bold

Trang 29

Constant width italic

Shows text that should be replaced with user-supplied values.

Using Code Examples

This book is here to help you get your job done In general, you may use the code inthis book in your programs and documentation You do not need to contact us forpermission unless you’re reproducing a significant portion of the code For example,writing a program that uses several chunks of code from this book does not require

permission Selling or distributing a CD-ROM of examples from O’Reilly books does

require permission Answering a question by citing this book and quoting examplecode does not require permission Incorporating a significant amount of example

code from this book into your product’s documentation does require permission.

We appreciate, but do not require, attribution An attribution usually includes the

title, author, publisher, and ISBN For example: “Ruby Cookbook, Second Edition, by

Lucas Carlson and Leonard Richardson Copyright 2015 Lucas Carlson and LeonardRichardson, 978-1-449-37371-9.”

If you feel your use of code examples falls outside fair use or the permission givenabove, feel free to contact us at permissions@oreilly.com.

Comments and Questions

Please address comments and questions concerning this book to the publisher:O’Reilly Media, Inc.

1005 Gravenstein Highway NorthSebastopol, CA 95472

800-998-9938 (in the United States or Canada)707-829-0515 (international or local)

707-829-0104 (fax)

We have a web page for this book, where we list errata, examples, and any additionalinformation You can access this page at http://bit.ly/ruby_cookbook_2e.

To comment or ask technical questions about this book, send email to bookques‐tions@oreilly.com.

For more information about our books, conferences, Resource Centers, and theO’Reilly Network, see our website at http://www.oreilly.com.

Trang 30

Acknowledgments

First we’d like to thank our editor, Michael Loukides, for his help and for acquiescingto our use of his name in recipe code samples, even when we turned him into a talk‐ing frog The production editor, Colleen Gorman, was also very helpful.

This book would have taken longer to write and been less interesting without ourcontributing authors, who, collectively, wrote over 60 of these recipes The roll ofnames includes: Steve Arniel, Ben Bleything, Antonio Cangiano, Mauro Cicio, Maur‐ice Codik, Thomas Enebo, Pat Eyler, Bill Froelich, Rod Gaither, Ben Giddings,Michael Granger, James Edward Gray II, Stefan Lang, Kevin Marshall, MatthewPalmer Chetan Patil, Alun ap Rhisiart, Garrett Rooney, John-Mason Shackelford, PhilTomson, and John Wells They saved us time by lending their knowledge of variousRuby topics, and they enriched the book with their ideas.

This book would be of appallingly low quality were it not for our technical reviewers,who spotted dozens of bugs, platform-specific problems, and conceptual errors: JohnN Alegre, Dave Burt, Bill Dolinar, Simen Edvardsen, Shane Emmons, Edward Faulk‐ner, Dan Fitzpatrick, Bill Guindon, Stephen Hildrey, Meador Inge, Eric Jacoboni,Julian I Kamil, Randy Kramer, Alex LeDonne, Steven Lumos, Keith Rosenblatt, GeneTani, and R Vrajmohan.

Trang 31

CHAPTER 1Ruby 2.1

When the first edition of Ruby Cookbook was published in 2006, Ruby 1.8.4 was the

state of the art and Rails had just reached 1.0 Eight years and more than 100 stablereleases later, the latest version is now Ruby 2.1.1 and Rails has just reached 4.1.0.Over the last eight years, a lot has changed, both big and small:

• A bytecode interpreter replaced the old Ruby MRI.• RubyGems and Rake became part of the standard library.

• SOAP and Curses have moved out of the standard library into RubyGems.• New syntax primitives have been added for hashes, procs, and more.• New methods like Object#tap and String#prepend have been added.• New classes like BasicObject, Fiber, and TracePoint have been added.• The MD5 standard library was renamed Digest::MD5.

• And much more…

The end result is a cleaner language that runs faster and more efficiently than everbefore For example, a simple Rails application is 167–200% faster in Ruby 2.1than 1.8.

For all that has changed, there is thankfully very little that has been broken in termsof backward compatibility The vast majority of code written for Ruby 1.8 will workin Ruby 2.1 without any modifications However, and somewhat obviously, if youwrite code for Ruby 2.1, it will likely not work in Ruby 1.8 with some of the syntaxchanges introduced.

In between Ruby 1.8 and 2.1 were two other major releases: 1.9 and 2.0 In this chap‐ter, we will group all the changes from versions 1.9 through 2.1 together instead of

Trang 32

pointing out the specific dot release in which a feature was added or modified Forexample, the YARV bytecode interpreter was added only in Ruby 1.9.4, but we willtalk about it as just one of the many differences between Ruby 1.8 and 2.1.

1.1 What’s Different Between Ruby 1.8 and 2.1?

Problem

You want to know the major differences between Ruby 1.8 and 2.1.

Solution

Table 1-1 shows the major changes between Ruby 1.8 and 2.1.

Table 1-1 Major changes by type between Ruby 1.8 and 2.1

TypeAboutNote

New syntax→The → operator can replace lambda for brevity.New syntaxArrayYou can use %i(foo bar baz) to specify

[:foo, :bar, :baz] for brevity.

New syntaxdefYou can define methods like def foo(x: 1); puts x; end.

New classBasicObjectNew root in class hierarchy.

New syntaxHashYou can use {a: 1, b: 2}, which is like {:a => 1, :b => 2}, for brevity.

New syntaxrYou can apply the r suffix to numbers to specify rationalslike 1.2r.

New classGC::ProfilerProfiles the garbage collector.New classEncodingRepresents a character encoding.

New classEnumerator::LazyDelays running enumerations until absolutely necessary.New classFiberLightweight processes.

New classGemRubyGems.

Trang 33

TypeAboutNote

New classRubyVMThe Ruby interpreter.New classSocket::IfaddrInterface address class.New classTracePointDTrace-like inspection class.New methodArray.try_convertTries to convert obj into an array.

New methodArray#rotateCreates a new array by rotating the existing array.New methodArray#keep_ifDeletes every element where the block evaluates to false.New methodArray#sampleChooses a random element.

New methodArray#repeated_permutationAll repeated permutations.New methodArray#repeated_combinationAll repeated combinations.New methodHash#to_hUbiquitous hash conversion.

New methodHash#default_proc=You can now set the default proc after initialization.New methodHash#keyAn inverted hash lookup.

New methodHash#keep_ifDeletes every key-value pair where the block evaluates tofalse.New methodHash#assocSearches through the hash comparing obj with the keyusing ==.New methodHash#rassocSearches through the hash comparing obj with thevalue using ==.

New methodHash#flattenA one-dimensional flattening of this hash.New methodHash#compare_by_identityCompares hashes by their identity.New methodEnumerable#to_hUbiquitous hash conversion.

New methodEnumerable#flat_mapCreates array with the concatenated results of runningblock once for every element in enum.

New methodEnumerable#each_entryCalls block once for each element in self, passing thatelement as a parameter, converting multiple values from

yield to an array.

Trang 34

TypeAboutNote

New methodEnumerable#each_with_objectIterates the given block for each element with anarbitrary object, and returns the initially given object.New methodEnumerable#chunkEnumerates over the items, chunking them together

based on the return value of the block.New methodEnumerable#slice_beforeCreates an enumerator for each chunked element.New methodEnumerable#lazyDelays running enumerations until absolutely necessary.New methodException#causeKeeps track of the root cause of raised errors.New methodGC.statInspects the garbage collector.

New method Kernel#dir Director name of FILE.

New method Kernel#callee Called name of the current method as a symbol.New methodKernel#caller_locationsArray of backtrace location objects.

New methodKernel#spawnSimilar to Kernel.system but doesn’t wait for thecommand to finish

New methodKernel#require_relativeTries to load the library named string relative to therequiring file’s path.

New methodKernel#HashUbiquitous hash instantiator.New methodKernel#RationalUbiquitous rational instantiator.New methodKernel#ComplexUbiquitous complex instantiator.New methodModule#class_variable_getGets class variable.

New methodModule#class_variable_setSets class variable.New methodModule#remove_class_variableRemoves class variable.

Trang 35

TypeAboutNote

New methodModule#prependAn alternative to Module#include that appends(overwrites) class methods.

New methodModule#public_instance_methodPublic instance methods.

New methodModule#refineAllows you to refine an existing class.

New methodModule#usingAllows you to apply monkey patches in a scoped way.New methodIO#wait_writableWaits until a file becomes writable.

New methodObject#!~Returns true if two objects do not match (using the =~

method).

New methodObject#singleton_classReturns the singleton class of obj.New methodObject#untrustMarks obj as untrusted.

New methodObject#untrusted?Returns true if the object is untrusted.New methodObject#trustRemoves the untrusted mark from obj.New methodObject#remove_instance_vari

able

Removes the named instance variable from obj.New methodObject#public_sendUnlike Object#send, this calls public methods only.New methodObject#public_methodSimilar to method, this searches public method only.New methodObject#singleton_methodsLists one-off methods.

New methodObject#define_singleton_methodCreates a one-off method.

New methodObject#tapTaps into a method chain to perform operations onintermediate results.

New methodRange#bsearchBinary search available in arrays.

New methodRange#cover?Is obj between the begin and end of the range?New methodSocket.getifaddrsAccesses network interfaces.

New methodString#ascii_only?Returns true for a string that has only ASCII characters.New methodString#clearMakes a string empty.

Trang 36

TypeAboutNote

New methodString#chrA one-character string at the beginning of the string.New methodString#encodeEncodes a string with an encoding.

New methodString#getbyteReturns a byte as an integer.New methodString#setbyteModifies a byte as integer.New methodString#bytesliceA substring of one byte at a position.New methodString#scrubRemoves garbage bytes from strings.New methodString#codepointsInteger ordinals of the characters in str.New methodString#prependPrepends a given string.

New methodString#ordReturns the integer ordinal of a one-character string.New methodString#each_codepointEnumerates the integerized values of the string.New methodString#encodingAn encoding object that represents the encoding of the

string.

New methodString#force_encodingForces an encoding.

New methodString#bA copied string whose encoding is ASCII-8BIT.New methodString#valid_encoding?True for a string that is encoded correctly.New methodString#to_rReturns rational number.

Trang 38

TypeAboutNoteNew standardlibrary debug Provides debugger and breakpoints.New standardlibrarye2mmapExceptions to messages map.New standardlibraryfiddleA libffi wrapper.New standardlibraryminitestDrop-in replacement for test unit.New standardlibraryobjspaceObject allocation tracing profiling tool.New standardlibrary prime The set of all prime numbers.New standardlibraryripperParses your Ruby code into a symbolic expression tree.New standardlibraryshellwordsManipulates strings according to the word parsing rulesof bash.Moved to corerubygemsNo longer an external library and no need to requirerubygems

Trang 39

TypeAboutNote

Moved to

RubyGems rinda You can use gem install rubysl-rinda.Removed libraryfinalizeReplaced by objspace.

Removed libraryjcodeUTF-8 support is now default; $KCODE is not necessary.Removed librarywsdlNo longer a standard library.

Removed libraryftoolsMerged into fileutils.Removed librarygeneratorNo longer a standard library.Removed libraryimportenvNo longer a standard library.Removed librarymailreadNo longer a standard library.Removed librarypingNo longer a standard library.Removed libraryrunitNo longer a standard library.Removed librarytcltklibNo longer a standard library.Removed libraryWin32APINo longer a standard library.Removed libraryxsdNo longer a standard library.

1.2 YARV (Yet Another Ruby VM) Bytecode Interpreter

Problem

You want to understand more about the Ruby interpreter changes between Ruby 1.8and 2.1.

Solution

Since Ruby started in 1995, it originally used the MRI (Matz’s Ruby Interpreter) tointerpret Ruby code Written in C, the MRI (also known as CRuby) was the de factoreference implementation of the Ruby spec until Ruby 1.9.0 was released in 2007.With Ruby 1.9.0, the interpreter was changed from MRI to YARV (Yet AnotherRuby VM).

One of the biggest differences between MRI and YARV was the introduction of abytecode interpreter With any programming language, the first step to running your

Trang 40

code is to tokenize and parse its syntax The MRI would mix parsing syntax with exe‐cuting your code, which ended up being prone to memory leaks and slow executiontimes The YARV interpreter separates parsing from the running of your code.The bytecode interpreter takes the syntax tree and passes it to a virtual machine emu‐lator that knows how to translate the bytecode into machine code The emulator istuned and optimized for the underlying hardware and knows how to translateinstructions to PowerPC or x86 instructions The result in more efficient execution,less memory usage, and a faster language.

Discussion

To understand bytecode interpreters better, let’s examine a simple Ruby syntax tree

(also known as S-expressions):

require 'ripper'

Ripper.sexp("1+1")

# => [:program, [[:binary, [:@int, "1", [1, 0]], :+, [:@int, "1", [1, 2]]]]]

If you have any familiarity with Lisp, you may notice some similarities between a syn‐tax tree and any Lisp dialect For example, let’s replace the brackets with parenthesesand see if the code looks any more familiar:(program (binary (int10)) + (int12)) ))

The reason that S-expressions look like Lisp is because essentially Lisp is a program‐ming language built directly with S-expressions.

Ngày đăng: 07/01/2017, 20:49

TỪ KHÓA LIÊN QUAN

w