book

The Ruby Programming Language

by David Flanagan, Yukihiro Matsumoto

January 2008

Beginner to intermediate

446 pages

14h 45m

English

O'Reilly Media, Inc.

Read now

Unlock full access

David FlanaganYukihiro Matsumoto
Ruby Is Object-OrientedBlocks and IteratorsExpressions and Operators in RubyMethodsAssignmentPunctuation Suffixes and PrefixesRegexp and RangeClasses and ModulesRuby Surprises

The Ruby InterpreterDisplaying OutputInteractive Ruby with irbViewing Ruby Documentation with riRuby Package Management with gemMore Ruby TutorialsRuby Resources
How to Read This Book
CommentsEmbedded documentsDocumentation commentsLiteralsPunctuationIdentifiersCase sensitivityUnicode characters in identifiersPunctuation in identifiersKeywordsWhitespaceNewlines as statement terminatorsSpaces and method invocations
Block Structure in Ruby
Specifying Program EncodingSource, External, and Internal Encodings
Integer LiteralsFloating-Point LiteralsArithmetic in RubyBinary Floating-Point and Rounding Errors
String LiteralsSingle-quoted string literalsDouble-quoted string literalsUnicode escapesArbitrary delimiters for string literalsHere documentsBacktick command executionString literals and mutabilityThe String.new methodCharacter LiteralsString OperatorsAccessing Characters and SubstringsIterating StringsString Encodings and Multibyte CharactersMultibyte characters in Ruby 1.9The Encoding classMultibyte characters in Ruby 1.8
Hash LiteralsHash Codes, Equality, and Mutable Keys
Testing Membership in a Range
Object ReferencesImmediate valuesObject LifetimeObject IdentityObject Class and Object TypeObject EqualityThe equal? methodThe == operatorThe eql? methodThe === operatorThe =~ operatorObject OrderObject ConversionExplicit conversionsImplicit conversionsConversion functionsArithmetic operator type coercionsBoolean type conversionsCopying ObjectsMarshaling ObjectsFreezing ObjectsTainted and Untrusted Objects
Uninitialized Variables
Assigning to VariablesAssigning to ConstantsAssigning to Attributes and Array ElementsAbbreviated AssignmentParallel AssignmentSame number of lvalues and rvaluesOne lvalue, multiple rvaluesMultiple lvalues, single array rvalueDifferent numbers of lvalues and rvaluesThe splat operatorParentheses in parallel assignmentThe value of parallel assignment
Unary + and –Exponentiation: **Arithmetic: +, –, *, /, and %Shift and Append: << and >>Complement, Union, Intersection: ~, &, |, and ^Comparison: <, <=, >, >=, and <=>Equality: ==, !=, =~, !~, and ===Boolean Operators: &&, ||, !, and, or, notRanges and Flip-Flops: .. and ...Boolean flip-flopsConditional: ?:Assignment OperatorsThe defined? OperatorStatement ModifiersNonoperators
ifelseelsifReturn valueif As a ModifierunlesscaseThe ?: Operator
while and untilwhile and until As ModifiersThe for/in Loop
Numeric IteratorsEnumerable ObjectsWriting Custom IteratorsEnumeratorsExternal IteratorsIteration and Concurrent Modification
Block SyntaxThe Value of a BlockBlocks and Variable ScopePassing Arguments to a BlockBlock Parameters in Ruby 1.9
returnbreakbreak with a valuenextnext and block valueredoretrythrow and catch
Exception Classes and Exception ObjectsThe methods of exception objectsCreating exception objectsDefining new exception classesRaising Exceptions with raiseHandling Exceptions with rescueNaming the exception objectHandling exceptions by typePropagation of exceptionsExceptions during exception handlingretry in a rescue clauseThe else ClauseThe ensure Clauserescue with Method, Class, and Module Definitionsrescue As a Statement Modifier
Threads for ConcurrencyFibers for CoroutinesFiber arguments and return valuesImplementing generators with fibersAdvanced fiber featuresContinuations
Method Return ValueMethods and Exception HandlingInvoking a Method on an ObjectDefining Singleton MethodsUndefining Methods
Operator MethodsMethod Aliases
Optional ParenthesesRequired Parentheses
Parameter DefaultsVariable-Length Argument Lists and ArraysPassing arrays to methodsMapping Arguments to ParametersHashes for Named ArgumentsBlock ArgumentsUsing & in method invocation
Creating ProcsProc.newKernel.lambdaKernel.procLambda LiteralsInvoking Procs and LambdasThe Arity of a ProcProc EqualityHow Lambdas Differ from ProcsReturn in blocks, procs, and lambdasBreak in blocks, procs and lambdasOther control-flow statementsArgument passing to procs and lambdas
Closures and Shared VariablesClosures and Bindings
Unbound Method Objects
Applying a Function to an EnumerableComposing FunctionsPartially Applying FunctionsMemoizing FunctionsSymbols, Methods, and Procs
Creating the ClassInstantiating a PointInitializing a PointDefining a to_s MethodAccessors and AttributesDefining OperatorsArray and Hash Access with [ ]Enumerating CoordinatesPoint EqualityOrdering PointsA Mutable PointQuick and Easy Mutable ClassesA Class MethodConstantsClass VariablesClass Instance Variables
Inheriting MethodsOverriding MethodsOverriding private methodsAugmenting Behavior by ChainingInheritance of Class MethodsInheritance and Instance VariablesInheritance and Class VariablesInheritance of Constants
new, allocate, and initializeFactory Methodsdup, clone, and initialize_copymarshal_dump and marshal_loadThe Singleton Pattern
Modules as NamespacesNested namespacesModules As MixinsIncludable Namespace Modules
The Load PathExecuting Loaded CodeWrapped loadsAutoloading Modules
Class Method Lookup
Ancestry and ModulesDefining Classes and Modules
Bindings and evalinstance_eval and class_evalinstance_exec and class_exec
Querying, Setting, and Testing Variables
Listing and Testing For MethodsObtaining Method ObjectsInvoking MethodsDefining, Undefining, and Aliasing MethodsHandling Undefined MethodsSetting Method Visibility
Delaying and Repeating Execution: after and everyThread Safety with Synchronized Blocks
Unicode Codepoint Constants with const_missingTracing Method Invocations with method_missingSynchronized Objects by Delegation
Defining Methods with class_evalDefining Methods with define_method
Tracing Files Loaded and Classes DefinedChaining Methods for Thread SafetyChaining Methods for Tracing
Simple XML Output with method_missingValidated XML Output with Method Generation
Formatting TextPacking and Unpacking Binary StringsStrings and Encodings
Regexp LiteralsRegexp Factory MethodsRegular Expression SyntaxPattern Matching with Regular ExpressionsGlobal variables for match dataPattern matching with stringsSearch and replaceRegular expression encoding
Numeric MethodsThe Math ModuleDecimal ArithmeticComplex NumbersRational NumbersVectors and MatricesRandom Numbers
Enumerable ObjectsIterating and converting collectionsEnumerators and external iteratorsSorting collectionsSearching collectionsSelecting subcollectionsReducing collectionsArraysCreating arraysArray size and elementsAltering array elementsIterating, searching, and sorting arraysArray comparisonArrays as stacks and queuesArrays as setsAssociative array methodsMiscellaneous array methodsHashesCreating hashesIndexing hashes and testing membershipStoring keys and values in a hashRemoving hash entriesArrays from hashesHash iteratorsDefault valuesHashcodes, key equality, and mutable keysMiscellaneous hash methodsSetsCreating setsTesting, comparing, and combining SetsAdding and deleting set elementsSet iteratorsMiscellaneous set methods
File and Directory NamesListing DirectoriesTesting FilesCreating, Deleting, and Renaming Files and Directories
Opening StreamsOpening filesKernel.openStringIOPredefined streamsStreams and EncodingsReading from a StreamReading linesReading entire filesReading bytes and charactersWriting to a StreamRandom Access MethodsClosing, Flushing, and Testing Streams
A Very Simple ClientA Very Simple ServerDatagramsA More Complex ClientA Multiplexing ServerFetching Web Pages
Thread LifecycleThe main threadThreads and unhandled exceptionsThreads and VariablesThread-private variablesThread-local variablesThread SchedulingThread prioritiesThread preemption and Thread.passThread StatesQuerying thread stateAltering state: pausing, waking, and killing threadsListing Threads and Thread GroupsThreading ExamplesReading files concurrentlyA Multithreaded ServerConcurrent iteratorsThread Exclusion and DeadlockDeadlockQueue and SizedQueueCondition Variables and Queues
Common OptionsWarnings and Information OptionsEncoding OptionsText Processing OptionsMiscellaneous Options
Predefined Modules and ClassesTop-Level ConstantsGlobal VariablesGlobal settingsException-handling globalsStreams and text-processing globalsPattern-matching globalsCommand-line option globalsPredefined Global FunctionsKeyword functionsText input, output, and manipulation functionsOS methodsWarnings, failures, and exitingReflection functionsConversion functionsMiscellaneous Kernel functionsUser-Defined Global Functions
Input FunctionsDeprecated Extraction FunctionsReporting FunctionsOne-Line Script Shortcuts
Invoking OS CommandsForking and ProcessesTrapping SignalsTerminating Programs
Tainted DataRestricted Execution and Safe LevelsSafe level 0Safe Level 1Safe level 2Safe level 3Safe level 4

Content preview from The Ruby Programming Language

Chapter 10. The Ruby Environment

This chapter is a catch-all for Ruby programming topics that have not been discussed elsewhere. Most of the features covered here have to do with the interface between Ruby and the operating system on which it is running. As such, some of these features are OS-dependent. Similarly, many of the features may be implementation dependent: not every Ruby interpreter will implement them in the same way. Topics covered include:

The Ruby interpreter’s command-line arguments and environment variables.
The top-level execution environment: global functions, variables, and constants.
Shortcuts for text processing scripts: global functions, variables, and interpreter options, usually inspired by the Perl programming language, that make it possible to write short but powerful Ruby programs for processing text files.
OS commands: running shell commands and invoking executables in the underlying operating system. These are features that allow Ruby to be used as a scripting or “glue” language.
Security: how to reduce the risk of SQL injection and similar attacks with Ruby’s tainting mechanism, and how to “sandbox” untrusted Ruby code with $SAFE execution levels.