This document provides a quick reference for the Ruby programming language, covering topics like general syntax rules, data types, variables, operators, control expressions, classes and modules, exceptions, and the standard library. It includes short descriptions and syntax examples for core Ruby concepts like strings, arrays, hashes, regular expressions, methods, and blocks in 3 sentences or less.
This document provides a summary of key Ruby concepts including variables, conditional statements, functions, objects, arrays, hashes, and iteration. It explains that variables are created through assignment and can contain letters, numbers, or underscores. Conditional statements like if/else use equality checks. Functions are defined with def and can take parameters and return values. The core data types are objects, arrays, and hashes. Arrays use indexes to access elements while hashes use keys to map to values. Iteration allows processing each element with blocks.
From my November 3, 2011 talk at MNPHP. Regular expressions are a powerful tool available in nearly every programming language or platform, including PHP. I go over the history of POSIX vs. PCRE, examples in PHP, and optimizations on how to write faster expressions.
The document discusses string manipulation and regular expressions. It provides explanations of regular expression syntax including brackets, quantifiers, predefined character ranges, and flags. It also summarizes PHP functions for regular expressions like ereg(), eregi(), ereg_replace(), split(), and sql_regcase(). Practical examples of using these functions are shown.
This is the ninth set of slightly updated slides from a Perl programming course that I held some years ago.
I want to share it with everyone looking for intransitive Perl-knowledge.
A table of content for all presentations can be found at i-can.eu.
The source code for the examples and the presentations in ODP format are on https://github.com/kberov/PerlProgrammingCourse
The document discusses regular expressions and text processing in Python. It covers various components of regular expressions like literals, escape sequences, character classes, and metacharacters. It also discusses different regular expression methods in Python like match, search, split, sub, findall, finditer, compile and groupdict. The document provides examples of using these regular expression methods to search, find, replace and extract patterns from text.
This document provides an overview of hashes in Perl programming. It defines a hash as a set of key-value pairs where keys are not pre-declared and can be created during assignment. Functions for working with hash elements include exists(), defined(), and delete(). Other hash functions include each() to iterate over elements, keys() to return a list of all keys, and values() to return a list of all values.
PHP is one of the simplest server-side languages out there, and it was designed primarily for web development. Learning PHP is good not only because it adds ...
The document provides an introduction to Perl programming and regular expressions. It begins with simple Perl programs to print text and take user input. It then covers executing external commands, variables, operators, loops, and file operations. The document also introduces regular expressions, explaining patterns, anchors, character classes, alternation, grouping, and repetition quantifiers. It provides examples and discusses principles for matching strings with regular expressions.
This document provides a summary of key Ruby concepts including variables, conditional statements, functions, objects, arrays, hashes, and iteration. It explains that variables are created through assignment and can contain letters, numbers, or underscores. Conditional statements like if/else use equality checks. Functions are defined with def and can take parameters and return values. The core data types are objects, arrays, and hashes. Arrays use indexes to access elements while hashes use keys to map to values. Iteration allows processing each element with blocks.
From my November 3, 2011 talk at MNPHP. Regular expressions are a powerful tool available in nearly every programming language or platform, including PHP. I go over the history of POSIX vs. PCRE, examples in PHP, and optimizations on how to write faster expressions.
The document discusses string manipulation and regular expressions. It provides explanations of regular expression syntax including brackets, quantifiers, predefined character ranges, and flags. It also summarizes PHP functions for regular expressions like ereg(), eregi(), ereg_replace(), split(), and sql_regcase(). Practical examples of using these functions are shown.
This is the ninth set of slightly updated slides from a Perl programming course that I held some years ago.
I want to share it with everyone looking for intransitive Perl-knowledge.
A table of content for all presentations can be found at i-can.eu.
The source code for the examples and the presentations in ODP format are on https://github.com/kberov/PerlProgrammingCourse
The document discusses regular expressions and text processing in Python. It covers various components of regular expressions like literals, escape sequences, character classes, and metacharacters. It also discusses different regular expression methods in Python like match, search, split, sub, findall, finditer, compile and groupdict. The document provides examples of using these regular expression methods to search, find, replace and extract patterns from text.
This document provides an overview of hashes in Perl programming. It defines a hash as a set of key-value pairs where keys are not pre-declared and can be created during assignment. Functions for working with hash elements include exists(), defined(), and delete(). Other hash functions include each() to iterate over elements, keys() to return a list of all keys, and values() to return a list of all values.
PHP is one of the simplest server-side languages out there, and it was designed primarily for web development. Learning PHP is good not only because it adds ...
The document provides an introduction to Perl programming and regular expressions. It begins with simple Perl programs to print text and take user input. It then covers executing external commands, variables, operators, loops, and file operations. The document also introduces regular expressions, explaining patterns, anchors, character classes, alternation, grouping, and repetition quantifiers. It provides examples and discusses principles for matching strings with regular expressions.
This chapter discusses working with text and numbers in PHP. It covers defining and manipulating strings, including validating, formatting, and changing case. Functions for selecting, replacing, and exploding parts of strings are described. Working with numbers, math operators, variables, and number formatting functions are also summarized. Key string functions include substr(), str_replace(), printf(), and number functions include rand(), round(), pow(), and abs().
This document provides an introduction to Perl and BioPerl for bioinformatics. It discusses Jennifer Dommer and Vivek Gopalan from the National Institute of Allergy and Infectious Diseases presenting on Perl programming principles including variables, flow control, loops, file manipulation and regular expressions. It then provides an overview of BioPerl and how it can be used for tasks like working with sequence data. Examples are given throughout to demonstrate various Perl coding concepts.
The document discusses topics related to practicing bioinformatics including:
- Installing and working with the TextPad text editor
- Regular expressions (regex), including patterns, quantifiers, anchors, grouping, alternation, and variable interpolation
- Using regex memory variables ($1, $2, etc.) to extract matched substrings
- The s/// substitution operator and tr/// translation operator
- Applying these skills to tasks like finding restriction enzyme cut sites in DNA sequences
The document discusses PHP concepts including:
- PHP is a server-side scripting language used for web development and can be used as an alternative to Microsoft ASP.
- XAMPP is an open-source cross-platform web server bundle that can be used to test PHP scripts locally.
- PHP has different data types including strings, integers, floats, booleans, and arrays.
- PHP includes various operators, conditional statements like if/else, and loops like while and foreach to control program flow.
- Functions allow code reusability and modularity in PHP programs. Built-in and user-defined functions are discussed.
- Arrays are a special variable type that can hold multiple values,
This document introduces regular expressions (regex) in PHP. It discusses the basic syntax of regex including patterns, indicators, quantifiers and logical operators. It provides examples of using the ereg and preg functions in PHP to perform matches and replacements using both POSIX and Perl-compatible regex. Common regex rules are also explained including matching characters, character classes, beginning/end of string, alternation and quantifiers.
Perl is an interpreted, general-purpose programming language originally developed for text manipulation and now used widely for a variety of tasks including system administration, web development, and more. It has a small number of basic data types (scalars, arrays, hashes) and supports both procedural and object-oriented programming. Key elements of Perl include its C-style syntax, dynamic typing, and emphasis on practical solutions over purity.
The document provides an overview of regular expressions (regex) in Perl. It discusses how to use regex to check if a pattern exists in a string, extract matches, open and read/write files, define functions, pass values to functions, return values from functions, use Perl modules, and enable strict usage. Key topics include regex patterns like ^, $, *, +, escaping special characters, extracting matched subgroups, opening/closing files, and creating reusable modules.
This document provides an overview of the Perl programming language. It covers what Perl is, how to create and run Perl scripts, scalar and array variables, hashes, control structures like if/else and loops, file operations, and common Perl functions like split and join. Advanced Perl concepts like subroutines, regular expressions, and object-oriented programming are also mentioned. Resources for learning more about Perl like documentation, books, and mailing lists are provided at the end.
1. The document discusses the history and features of the Ruby programming language. It was created in the mid-1990s by Yukihiro Matsumoto in Japan and was influenced by other languages like Perl, Smalltalk, Eiffel, Ada, and LISP. Ruby supports object-oriented, functional, and imperative programming paradigms.
2. The document provides an introduction to some basic concepts in Ruby including variables, data types, methods, blocks, and control structures. It explains how to define variables, write methods with parameters and returns values, pass blocks to methods, and use conditional and looping statements.
3. The document covers various Ruby string functions and regular expressions. It demonstrates
This document provides an overview of using the Perl programming language for bioinformatics applications. It introduces Perl variables like scalars, arrays, and hashes. It also covers flow control and loops. The document demonstrates how to open and read/write files in Perl. It provides examples of commonly used bioinformatics tools that incorporate Perl components and recommends resources for learning more about Perl and BioPerl.
The document provides an overview of basic PHP syntax and concepts, including:
1. PHP scripting blocks start with <?php and end with ?>. Variables, comments, and code lines must follow certain syntax rules.
2. Variables can store different data types and are declared with a $ sign. Arrays allow storing multiple values in one variable and can be numeric, associative, or multidimensional.
3. Common functions for manipulating strings include concatenation, finding length and position. Switch statements and loops like while are used for conditional logic and repetition.
A Perl subroutine is a block of code that performs a specific task. Subroutines allow code to be reused and executed from different parts of a program with different parameters. They are defined using the "sub" keyword followed by the subroutine name and code block. Subroutines can accept arguments, return values, and contain private variables scoped to the subroutine using the "my" keyword. This modular approach improves code organization, reusability, and maintainability.
Perl is a general-purpose programming language created by Larry Wall in 1987. It supports both procedural and object-oriented programming. Perl is useful for tasks like web development, system administration, text processing and more due to its powerful built-in support for text processing and large collection of third-party modules. Basic Perl syntax includes variables starting with $, @, and % for scalars, arrays, and hashes respectively. Conditional and looping constructs like if/else, while, and for are also supported.
Full-day tutorial for the dutch php conference 2011 giving a very quick tour around all the various areas of the ZCE syllabus and some tips on the exam styles
This document discusses regular expressions (regexes) in Perl programming. It provides three examples that demonstrate extracting date values from a string using different regex techniques. It then discusses some key regex concepts like quantifiers, grouping, anchors, character classes and more. Code examples are provided to illustrate each concept. The goal is to help readers better understand how to leverage the powerful regex engine in Perl to perform complex text matching and manipulation tasks.
Strings,patterns and regular expressions in perlsana mateen
The document provides an introduction to regular expressions (regex). It discusses that regex allow for defining patterns to match strings. It then covers simple regex patterns and operators like character classes, quantifiers, alternations, grouping and anchors. The document also discusses more advanced regex topics such as back references, match operators, substitution operators, and the split operator.
The document provides an overview of SQL and PHP for working with databases. It discusses SQL concepts like creating and modifying tables, inserting and selecting data. It then covers connecting to databases from PHP, executing SQL queries from PHP, and processing HTML forms to insert data into databases using PHP. Key topics include SQL syntax for common operations, the basic PHP code for connecting to MySQL, running queries, and retrieving result rows, and using the $_POST array to access form data submitted to a PHP processing page.
PHP is a scripting language commonly used for web development. It allows dynamic generation of web page content through embedded PHP code. Some key things PHP can do include interacting with databases, processing user input, file handling, and more. PHP code is embedded within HTML using <?php ?> tags and variables, control structures, and other programming elements allow writing logic and dynamic functionality.
The document discusses various techniques for querying databases and generating reports from the query results using Perl. It provides examples of using DBI and SQL to query databases and format output, techniques for binding variables, preparing queries, and fetching and printing rows. Additional examples show merging and transforming tabular data for different output formats.
The document contains short phrases and sayings about life lessons and wisdom. It discusses themes of kindness, perseverance in the face of challenges, finding purpose through helping others, the importance of actions over words, doubting those who claim to have found all the answers, and finding happiness through simplicity.
This chapter discusses working with text and numbers in PHP. It covers defining and manipulating strings, including validating, formatting, and changing case. Functions for selecting, replacing, and exploding parts of strings are described. Working with numbers, math operators, variables, and number formatting functions are also summarized. Key string functions include substr(), str_replace(), printf(), and number functions include rand(), round(), pow(), and abs().
This document provides an introduction to Perl and BioPerl for bioinformatics. It discusses Jennifer Dommer and Vivek Gopalan from the National Institute of Allergy and Infectious Diseases presenting on Perl programming principles including variables, flow control, loops, file manipulation and regular expressions. It then provides an overview of BioPerl and how it can be used for tasks like working with sequence data. Examples are given throughout to demonstrate various Perl coding concepts.
The document discusses topics related to practicing bioinformatics including:
- Installing and working with the TextPad text editor
- Regular expressions (regex), including patterns, quantifiers, anchors, grouping, alternation, and variable interpolation
- Using regex memory variables ($1, $2, etc.) to extract matched substrings
- The s/// substitution operator and tr/// translation operator
- Applying these skills to tasks like finding restriction enzyme cut sites in DNA sequences
The document discusses PHP concepts including:
- PHP is a server-side scripting language used for web development and can be used as an alternative to Microsoft ASP.
- XAMPP is an open-source cross-platform web server bundle that can be used to test PHP scripts locally.
- PHP has different data types including strings, integers, floats, booleans, and arrays.
- PHP includes various operators, conditional statements like if/else, and loops like while and foreach to control program flow.
- Functions allow code reusability and modularity in PHP programs. Built-in and user-defined functions are discussed.
- Arrays are a special variable type that can hold multiple values,
This document introduces regular expressions (regex) in PHP. It discusses the basic syntax of regex including patterns, indicators, quantifiers and logical operators. It provides examples of using the ereg and preg functions in PHP to perform matches and replacements using both POSIX and Perl-compatible regex. Common regex rules are also explained including matching characters, character classes, beginning/end of string, alternation and quantifiers.
Perl is an interpreted, general-purpose programming language originally developed for text manipulation and now used widely for a variety of tasks including system administration, web development, and more. It has a small number of basic data types (scalars, arrays, hashes) and supports both procedural and object-oriented programming. Key elements of Perl include its C-style syntax, dynamic typing, and emphasis on practical solutions over purity.
The document provides an overview of regular expressions (regex) in Perl. It discusses how to use regex to check if a pattern exists in a string, extract matches, open and read/write files, define functions, pass values to functions, return values from functions, use Perl modules, and enable strict usage. Key topics include regex patterns like ^, $, *, +, escaping special characters, extracting matched subgroups, opening/closing files, and creating reusable modules.
This document provides an overview of the Perl programming language. It covers what Perl is, how to create and run Perl scripts, scalar and array variables, hashes, control structures like if/else and loops, file operations, and common Perl functions like split and join. Advanced Perl concepts like subroutines, regular expressions, and object-oriented programming are also mentioned. Resources for learning more about Perl like documentation, books, and mailing lists are provided at the end.
1. The document discusses the history and features of the Ruby programming language. It was created in the mid-1990s by Yukihiro Matsumoto in Japan and was influenced by other languages like Perl, Smalltalk, Eiffel, Ada, and LISP. Ruby supports object-oriented, functional, and imperative programming paradigms.
2. The document provides an introduction to some basic concepts in Ruby including variables, data types, methods, blocks, and control structures. It explains how to define variables, write methods with parameters and returns values, pass blocks to methods, and use conditional and looping statements.
3. The document covers various Ruby string functions and regular expressions. It demonstrates
This document provides an overview of using the Perl programming language for bioinformatics applications. It introduces Perl variables like scalars, arrays, and hashes. It also covers flow control and loops. The document demonstrates how to open and read/write files in Perl. It provides examples of commonly used bioinformatics tools that incorporate Perl components and recommends resources for learning more about Perl and BioPerl.
The document provides an overview of basic PHP syntax and concepts, including:
1. PHP scripting blocks start with <?php and end with ?>. Variables, comments, and code lines must follow certain syntax rules.
2. Variables can store different data types and are declared with a $ sign. Arrays allow storing multiple values in one variable and can be numeric, associative, or multidimensional.
3. Common functions for manipulating strings include concatenation, finding length and position. Switch statements and loops like while are used for conditional logic and repetition.
A Perl subroutine is a block of code that performs a specific task. Subroutines allow code to be reused and executed from different parts of a program with different parameters. They are defined using the "sub" keyword followed by the subroutine name and code block. Subroutines can accept arguments, return values, and contain private variables scoped to the subroutine using the "my" keyword. This modular approach improves code organization, reusability, and maintainability.
Perl is a general-purpose programming language created by Larry Wall in 1987. It supports both procedural and object-oriented programming. Perl is useful for tasks like web development, system administration, text processing and more due to its powerful built-in support for text processing and large collection of third-party modules. Basic Perl syntax includes variables starting with $, @, and % for scalars, arrays, and hashes respectively. Conditional and looping constructs like if/else, while, and for are also supported.
Full-day tutorial for the dutch php conference 2011 giving a very quick tour around all the various areas of the ZCE syllabus and some tips on the exam styles
This document discusses regular expressions (regexes) in Perl programming. It provides three examples that demonstrate extracting date values from a string using different regex techniques. It then discusses some key regex concepts like quantifiers, grouping, anchors, character classes and more. Code examples are provided to illustrate each concept. The goal is to help readers better understand how to leverage the powerful regex engine in Perl to perform complex text matching and manipulation tasks.
Strings,patterns and regular expressions in perlsana mateen
The document provides an introduction to regular expressions (regex). It discusses that regex allow for defining patterns to match strings. It then covers simple regex patterns and operators like character classes, quantifiers, alternations, grouping and anchors. The document also discusses more advanced regex topics such as back references, match operators, substitution operators, and the split operator.
The document provides an overview of SQL and PHP for working with databases. It discusses SQL concepts like creating and modifying tables, inserting and selecting data. It then covers connecting to databases from PHP, executing SQL queries from PHP, and processing HTML forms to insert data into databases using PHP. Key topics include SQL syntax for common operations, the basic PHP code for connecting to MySQL, running queries, and retrieving result rows, and using the $_POST array to access form data submitted to a PHP processing page.
PHP is a scripting language commonly used for web development. It allows dynamic generation of web page content through embedded PHP code. Some key things PHP can do include interacting with databases, processing user input, file handling, and more. PHP code is embedded within HTML using <?php ?> tags and variables, control structures, and other programming elements allow writing logic and dynamic functionality.
The document discusses various techniques for querying databases and generating reports from the query results using Perl. It provides examples of using DBI and SQL to query databases and format output, techniques for binding variables, preparing queries, and fetching and printing rows. Additional examples show merging and transforming tabular data for different output formats.
The document contains short phrases and sayings about life lessons and wisdom. It discusses themes of kindness, perseverance in the face of challenges, finding purpose through helping others, the importance of actions over words, doubting those who claim to have found all the answers, and finding happiness through simplicity.
Este documento trata sobre el peso. Define el peso como la fuerza con la que un cuerpo es atraído por la gravedad de la Tierra. Explica que el peso de un cuerpo depende de su masa y de la fuerza gravitatoria del lugar, por lo que un cuerpo pesa menos en la Luna que en la Tierra. Finalmente, define el peso como la fuerza de atracción que ejerce la masa de la Tierra sobre cualquier cuerpo situado en su superficie.
Ruby is a 15-month-old Great Dane adopted from Blue Cross in Hyderabad, India. She was found as a stray on the Vijaywada-Hyderabad highway 7 months ago by truck drivers. Ruby now lives with her owners and has some secret animal friends named Nazi and Tippy. She is also the proud character of her own comic strip found on the official Ruby blog and comic strip website.
Ruby é uma linguagem dinâmica e de código aberto focada em simplicidade e produtividade, com sintaxe elegante e fácil de ler. Tudo em Ruby é um objeto e a linguagem suporta classes, módulos, blocos e métodos dinâmicos. Ferramentas como IRB, rubygems e frameworks de teste facilitam o desenvolvimento em Ruby.
Plunging Into Perl While Avoiding the Deep End (mostly)Roy Zimmer
This document provides an introduction to the Perl programming language. It discusses Perl nomenclature, attributes, variables, scopes, file input/output, string manipulation, regular expressions, and the DBI module for connecting to databases from Perl scripts. Examples are provided for common Perl programming tasks like reading files, splitting strings, formatting output, and executing SQL queries.
This document provides an overview of the Ruby programming language. It discusses that Ruby is an object-oriented scripting language created by Yukihiro Matsumoto, and can run on various platforms like Windows, Mac OS, and UNIX. It also summarizes key Ruby concepts like Interactive Ruby Shell (IRb), syntax, data types, variables, and predefined variables.
You Can Do It! Start Using Perl to Handle Your Voyager NeedsRoy Zimmer
This document provides an introduction to the Perl programming language. It discusses Perl nomenclature, basic syntax like variables and data types, control structures, file input/output, regular expressions, and more. The goal is to get readers started using Perl for their needs.
The document provides an overview of the Ruby programming language for Perl programmers. Some key points:
- Ruby is an object-oriented scripting language that is interpreted, not compiled. It draws influences from Perl, Smalltalk, Lisp, and C.
- Ruby supports functional, aspect-oriented, and design-by-contract programming paradigms. It is well-suited for practices like extreme programming.
- Core concepts include classes, modules, blocks/iterators, exceptions, regular expressions and strings. Common data structures include arrays, hashes, ranges and more.
- Examples demonstrate basic syntax like variables, loops, conditions, classes and modules. Ruby emphasizes flexibility, dynamism and "
This document provides an overview of the Ruby programming language for Perl programmers. Ruby is a dynamic, reflective, object-oriented scripting language that is similar to Perl in many ways but also differs in its stronger object-oriented focus. The document discusses Ruby's syntax, core classes, object model, modules, blocks and iterators, and other features.
The document provides an overview of the Ruby programming language for Perl programmers. Some key points:
- Ruby is an object-oriented scripting language that is interpreted, not compiled. It borrows concepts from Perl, Smalltalk, Lisp, and C but has a stronger object orientation than Perl.
- Ruby places an emphasis on flexibility, dynamism, and a "human-oriented" design with principles like "least surprise." It aims to provide multiple ways to accomplish tasks.
- The document discusses Ruby's syntax, basic programming concepts like classes and modules, and core library classes like Array, IO, and String. It also notes Ruby's support for paradigms like functional programming.
This document provides an overview of the Ruby programming language for Perl programmers. Ruby is an interpreted, object-oriented scripting language that is very similar to Perl in many ways, such as its syntax for regular expressions and control structures like loops and conditionals. However, Ruby differs from Perl in that it was designed from the start to be object-oriented and highly dynamic. The document discusses Ruby's core concepts like classes, modules, blocks and iterators in detail and provides many code examples to illustrate Ruby's syntax and features.
This document provides an overview of the Ruby programming language for Perl programmers. Ruby is an interpreted, object-oriented scripting language that is very similar to Perl but also introduces significant differences. Both languages are suitable for tasks like text processing and system administration scripts. Ruby places a stronger emphasis on object-oriented principles and is more dynamic than Perl.
The document provides an overview of the Ruby programming language for Perl programmers. Some key points:
- Ruby is an object-oriented scripting language that is interpreted, not compiled. It draws influences from Perl, Smalltalk, Lisp, and C.
- Ruby supports functional, aspect-oriented, and design-by-contract programming paradigms. It is well-suited for practices like extreme programming.
- Core concepts include classes, modules, blocks/iterators, exceptions, regular expressions and strings. Common data structures include arrays, hashes, ranges and more.
- Examples demonstrate basic syntax like variables, loops, conditions, classes and modules. Ruby emphasizes flexibility, dynamism and "
The document provides an overview of the Ruby programming language for Perl programmers. Some key points:
- Ruby is an object-oriented scripting language that is interpreted, not compiled. It draws influences from Perl, Smalltalk, Lisp, and C.
- Ruby supports functional, aspect-oriented, and design-by-contract programming paradigms. It is well-suited for practices like extreme programming.
- Core concepts include classes, modules, blocks/iterators, exceptions, regular expressions and strings. Common data structures include arrays, hashes, ranges and more.
- Examples demonstrate basic syntax like variables, loops, conditions, classes and modules. Ruby emphasizes flexibility, dynamism and "
The document provides an overview of the Ruby programming language for Perl programmers. Some key points:
- Ruby is an object-oriented scripting language that is interpreted, not compiled. It draws influences from Perl, Smalltalk, Lisp, and C.
- Ruby supports features like classes, modules, blocks/iterators, exceptions, regular expressions and threads. Everything in Ruby is an object.
- Compared to Perl, Ruby is more object-oriented, dynamic, and has built-in support for threads. Syntax also differs in some key ways.
- The document provides examples of basic Ruby syntax like variables, loops, conditions, classes and modules to illustrate how the language works.
This document provides an overview of the Ruby programming language for Perl programmers. Ruby is an interpreted, object-oriented scripting language that is very similar to Perl in many ways, such as its syntax for regular expressions and special variables, but differs in its stronger emphasis on object-oriented principles and more dynamic features. The document discusses Ruby's history and influences, basic syntax, core classes and modules, functional programming capabilities, and ease of extension.
This document provides an overview of the Ruby programming language for Perl programmers. Ruby is an interpreted, object-oriented scripting language that is very similar to Perl in many ways, such as its syntax for regular expressions and special variables, but differs in its stronger emphasis on object-oriented principles and more dynamic features. The document discusses Ruby's history and influences, basic syntax, core programming concepts like classes and modules, and ways that Ruby code can be easily extended.
The document provides an overview of the Ruby programming language for Perl programmers. Some key points:
- Ruby is an object-oriented scripting language that is interpreted, not compiled. It draws influences from Perl, Smalltalk, Lisp, and C.
- Ruby supports features like classes, modules, blocks/iterators, exceptions, regular expressions and threads. Everything in Ruby is an object.
- Compared to Perl, Ruby is more object-oriented, dynamic, and has built-in support for threads. Syntax also differs in some areas like conditionals.
- The document provides examples of common Ruby constructs like classes, modules, loops, conditions and built-in core classes like Array, IO
The document provides an overview of the Ruby programming language for Perl programmers. Some key points:
- Ruby is an object-oriented scripting language that is interpreted, not compiled. It draws influences from Perl, Smalltalk, Lisp, and C.
- Ruby supports functional, aspect-oriented, and design-by-contract programming paradigms. It is well-suited for practices like extreme programming.
- Core concepts include classes, modules, blocks/iterators, exceptions, regular expressions and strings. Common data structures include arrays, hashes, ranges and more.
- Examples demonstrate basic syntax like variables, loops, conditions, classes and modules. Ruby emphasizes flexibility, dynamism and "
This document provides an overview of the Ruby programming language for Perl programmers. Ruby is a dynamic, reflective, object-oriented scripting language that is interpreted, not compiled. It draws influences from Perl, Smalltalk, Lisp, and other languages. Some key points covered include Ruby's object-oriented design, syntax similarities and differences compared to Perl, core classes and features like blocks/iterators, modules and mixins, exceptions, and Ruby's open and flexible nature.
The document provides an overview of the Ruby programming language for Perl programmers. Some key points:
- Ruby is an object-oriented scripting language that is interpreted, not compiled. It draws influences from Perl, Smalltalk, Lisp, and C.
- Ruby supports functional, aspect-oriented, and design-by-contract programming paradigms. It is well-suited for practices like extreme programming.
- Core concepts include classes, modules, blocks/iterators, exceptions, regular expressions and strings. Common data structures include arrays, hashes, ranges and more.
- Examples demonstrate basic syntax like variables, loops, conditions, classes and modules. Ruby emphasizes flexibility, dynamism and "
This document summarizes Perl predefined variables, listing the variable name, description, and example use for each. There are over 50 predefined variables described, including scalars like $_, arrays like @ARGV, and hashes like %ENV that provide useful information and functionality to Perl programs.
Shell scripting involves writing scripts using bash commands. Key elements include:
1) Variables to store and manipulate data. Variables can hold strings or numbers.
2) Control structures like if/else, case, and loops (for, while, until) to make decisions and repeat tasks.
3) Functions to organize code into reusable blocks.
4) Reading/writing files for input/output.
5) Trapping signals like interrupts to handle errors gracefully.
Regular expressions are very commonly used to process and validate text data. Unfortunately, they suffer from various limitations. I will discuss the limitations and illustrate how using grammars instead can be an improvement. I will make the examples oncrete using parsing libraries in a couple of representative languages, although the ideas are language-independent.
I will emphasize ease of use, since one reason for the overuse of regular expressions is that they are so easy to pull out of one's toolbox.
Rethinking Kållered │ From Big Box to a Reuse Hub: A Transformation Journey ...SirmaDuztepeliler
"Rethinking Kållered │ From Big Box to a Reuse Hub: A Transformation Journey Toward Sustainability"
The booklet of my master’s thesis at the Department of Architecture and Civil Engineering at Chalmers University of Technology. (Gothenburg, Sweden)
This thesis explores the transformation of the vacated (2023) IKEA store in Kållered, Sweden, into a "Reuse Hub" addressing various user types. The project aims to create a model for circular and sustainable economic practices that promote resource efficiency, waste reduction, and a shift in societal overconsumption patterns.
Reuse, though crucial in the circular economy, is one of the least studied areas. Most materials with reuse potential, especially in the construction sector, are recycled (downcycled), causing a greater loss of resources and energy. My project addresses barriers to reuse, such as difficult access to materials, storage, and logistics issues.
Aims:
• Enhancing Access to Reclaimed Materials: Creating a hub for reclaimed construction materials for both institutional and individual needs.
• Promoting Circular Economy: Showcasing the potential and variety of reusable materials and how they can drive a circular economy.
• Fostering Community Engagement: Developing spaces for social interaction around reuse-focused stores and workshops.
• Raising Awareness: Transforming a former consumerist symbol into a center for circular practices.
Highlights:
• The project emphasizes cross-sector collaboration with producers and wholesalers to repurpose surplus materials before they enter the recycling phase.
• This project can serve as a prototype for reusing many idle commercial buildings in different scales and sizes.
• The findings indicate that transforming large vacant properties can support sustainable practices and present an economically attractive business model with high social returns at the same time.
• It highlights the potential of how sustainable practices in the construction sector can drive societal change.
1. Ruby QuickRef
11/29/2005 12:35 AM
Sitemap | Search || Zen Spider Website / The Language Freak / Ruby / Ruby QuickRef
Ruby QuickRef
Contents:
Contents
Language
General Syntax Rules
Reserved words
Types
Numbers
Strings
Backslashes
Here Docs
Ranges
Regexen
Arrays
Hashes
Files
Mode Strings
Variables
Pseudo variables
Pre-defined variables
Pre-defined global constants
Expressions
Terms
Operators and Precedence
Control Expressions
Invoking a Method
Defining a Class
Defining a Module
Defining a Method
Access Restriction
Accessors
Aliasing
Blocks, Closures, and Procs
Blocks/Closures
Proc Objects
Exceptions, Catch, and Throw
Standard Library
Built-in Library
Class Hierarchy
Modules
Standard Library
Tools
ruby
Command Line Options
Environment Variables
irb
xmp
ruby-mode
Debugger
rdoc
Mindshare, Idiom and Patterns
Object Design
Visitor Pattern
Class SimpleDelegator, DelegateClass
Module Observer
http://www.zenspider.com/Languages/Ruby/QuickRef.html
Page 1 of 14
2. Ruby QuickRef
11/29/2005 12:35 AM
Module Singleton
Other Third-party Libraries
Racc
Test::Unit
Language
General Syntax Rules
Comments start with a pound/sharp (#) character and go to EOL.
Ruby programs are sequence of expressions.
Each expression is delimited by semicolons(;) or newlines unless obviously incomplete (e.g. trailing '+').
Backslashes at the end of line does not terminate expression.
Reserved words
alias
do
in
return
while
and
else
module
self
yield
BEGIN
elsif
next
super
begin
END
nil
then
break
end
not
true
case
ensure
or
undef
class
false
redo
unless
def
for
rescue
until
defined
if
retry
when
Types
Basic types are numbers, strings, ranges, regexen, symbols, arrays, and hashes. Also included are files because they
are used so often.
Numbers
123 1_234 123.45 1.2e-3 0xffff (hex) 0b01011 (binary) 0377 (octal)
?a
ASCII character
?C-a
Control-a
?M-a
Meta-a
?M-C-a Meta-Control-a
:symbol Integer corresponding to identifiers, variables, and operators.
Strings
In all of the %() cases below, you may use any matching characters or any single character for delimiters. %[], %!!,
%@@, etc.
'no interpolation'
"#{interpolation}, and backslashesn"
%q(no interpolation)
%Q(interpolation and backslashes)
%(interpolation and backslashes)
`echo command interpretation with interpolation and backslashes`
%x(echo command interpretation with interpolation and backslashes)
Backslashes
t (tab), n (newline), r (carriage return), f (form feed), b
(backspace), a (bell), e (escape), s (whitespace), nnn (octal),
xnn (hexadecimal), cx (control x), C-x (control x), M-x (meta x),
M-C-x (meta control x)
Here Docs
<<identifier
<<"identifier"
<<'identifier'
<<-identifier
-
interpolated, goes until identifier
same thing
no interpolation
you can indent the identifier by using "-" in front
Ranges
1..10
'a'..'z'
(1..10) === 5 => true
(1..10) === 15 => false
while gets # prints lines starting at 'start' and ending at 'end'
http://www.zenspider.com/Languages/Ruby/QuickRef.html
Page 2 of 14
3. Ruby QuickRef
11/29/2005 12:35 AM
while gets # prints lines starting at 'start' and ending at 'end'
print if /start/../end/
end
class RangeThingy
# ...
def <=>(rhs)
# ...
end
def succ
# ...
end
end
range = RangeThingy.new(lower_bound)..RangeThingy.new(upper_bound)
Regexen
/normal regex/iomx[neus]
%r|alternate form|
options:
/i
/o
/m
/x
/[neus]
case insensitive
case insensitive
multiline mode - '.' will match newline
extended mode - whitespace is ignored
encoding: none, EUC, UTF-8, SJIS, respectively
regex characters:
.
[ ]
[^ ]
*
*?
+
+?
?
|
( )
^
$
#{m,n}
#{m,n}?
A
b
B
b
d
D
S
s
W
w
z
Z
(?# )
(?: )
(?= )
(?! )
(?ix-ix)
(?ix-ix: )
any character except newline
any single character of set
any single character NOT of set
0 or more previous regular expression
0 or more previous regular expression(non greedy)
1 or more previous regular expression
1 or more previous regular expression(non greedy)
0 or 1 previous regular expression
alternation
grouping regular expressions
beginning of a line or string
end of a line or string
at least m but most n previous regular expression
at least m but most n previous regular expression(non greedy)
beginning of a string
backspace(0x08)(inside[]only)
non-word boundary
word boundary(outside[]only)
digit, same as[0-9]
non-digit
non-whitespace character
whitespace character[ tnrf]
non-word character
word character[0-9A-Za-z_]
end of a string
end of a string, or before newline at the end
comment
grouping without backreferences
zero-width positive look-ahead assertion
zero-width negative look-ahead assertion
turns on/off i/x options, localized in group if any.
turns on/off i/x options, localized in non-capturing group.
Arrays
[1, 2, 3]
%w(foo bar baz)
%W(foo bar baz #{var})
Indexes may be negative, and they index backwards (eg -1 is last element).
http://www.zenspider.com/Languages/Ruby/QuickRef.html
Page 3 of 14
4. Ruby QuickRef
11/29/2005 12:35 AM
Hashes
{1=>2, 2=>4, 3=>6}
{ expr => expr...}
Files
Common methods include:
File.join(p1, p2, ... pN) => "p1/p2/.../pN" platform independent paths
File.new(path, modestring="r") => file
File.new(path, modenum [, permnum]) => file
File.open(fileName, aModeString="r") {|file| block} -> nil
File.open(fileName [, aModeNum [, aPermNum ]]) {|file| block} -> nil
IO.foreach(path, sepstring=$/) {|line| block}
IO.readlines(path) => array
Mode Strings
r
Read-only, starts at beginning of file (default mode).
r+
Read-write, starts at beginning of file.
w
Write-only, truncates existing file to zero length or creates a new file for writing.
w+
Read-write, truncates existing file to zero length or creates a new file for reading and writing.
a
Write-only, starts at end of file if file exists, otherwise creates a new file for writing.
a+
Read-write, starts at end of file if file exists, otherwise creates a new file for reading and writing.
b
(DOS/Windows only) Binary file mode (may appear with any of the key letters listed above).
Variables
$global_variable
@instance_variable
[OtherClass::]CONSTANT
local_variable
Pseudo variables
self
nil
true
false
__FILE__
__LINE__
the
the
the
the
the
the
receiver of the current method
sole instance of the Class NilClass(represents false)
sole instance of the Class TrueClass(typical true value)
sole instance of the Class FalseClass(represents false)
current source file name.
current line number in the source file.
Pre-defined variables
$!
$@
$&
$`
$'
$+
$1
$~
$=
$/
$
$,
$;
$.
$<
The exception information message set by 'raise'.
Array of backtrace of the last exception thrown.
The string matched by the last successful pattern match in this scope.
The string to the left of the last successful match.
The string to the right of the last successful match.
The last bracket matched by the last successful match.
The Nth group of the last successful match. May be > 1.
The information about the last match in the current scope.
The flag for case insensitive, nil by default.
The input record separator, newline by default.
The output record separator for the print and IO#write. Default is nil.
The output field separator for the print and Array#join.
The default separator for String#split.
The current input line number of the last file that was read.
The virtual concatenation file of the files given on command line.
http://www.zenspider.com/Languages/Ruby/QuickRef.html
Page 4 of 14
5. Ruby QuickRef
$>
$_
$0
$*
$$
$?
$:
$"
$DEBUG
$FILENAME
$LOAD_PATH
$stderr
$stdin
$stdout
$VERBOSE
$-0
$-a
$-d
$-F
$-i
$-I
$-l
$-p
$-v
11/29/2005 12:35 AM
The default output for print, printf. $stdout by default.
The last input line of string by gets or readline.
Contains the name of the script being executed. May be assignable.
Command line arguments given for the script sans args.
The process number of the Ruby running this script.
The status of the last executed child process.
Load path for scripts and binary modules by load or require.
The array contains the module names loaded by require.
The status of the -d switch.
Current input file from $<. Same as $<.filename.
The alias to the $:.
The current standard error output.
The current standard input.
The current standard output.
The verbose flag, which is set by the -v switch.
The alias to $/.
True if option -a is set. Read-only variable.
The alias to $DEBUG.
The alias to $;.
In in-place-edit mode, this variable holds the extention, otherwise nil.
The alias to $:.
True if option -l is set. Read-only variable.
True if option -p is set. Read-only variable.
The alias to $VERBOSE.
Pre-defined global constants
TRUE
FALSE
NIL
STDIN
STDOUT
STDERR
ENV
ARGF
ARGV
DATA
RUBY_VERSION
RUBY_RELEASE_DATE
RUBY_PLATFORM
The
The
The
The
The
The
The
The
The
The
The
The
The
typical true value.
false itself.
nil itself.
standard input. The default value for $stdin.
standard output. The default value for $stdout.
standard error output. The default value for $stderr.
hash contains current environment variables.
alias to the $<.
alias to the $*.
file object of the script, pointing just after __END__.
ruby version string (VERSION was depricated).
relase date string.
platform identifier.
Expressions
Terms
Terms are expressions that may be a basic type (listed above), a shell command, variable reference, constant
reference, or method invocation.
Operators and Precedence
(Top to bottom)
::
[]
**
-(unary) +(unary) ! ~
* / %
+ << >>
&
| ^
> >= < <=
<=> == === != =~ !~
&&
||
.. ...
=(+=, -=...)
not
and or
All of the above are just methods except these:
http://www.zenspider.com/Languages/Ruby/QuickRef.html
Page 5 of 14
6. Ruby QuickRef
11/29/2005 12:35 AM
=, .., ..., !, not, &&, and, ||, or, !=, !~
In addition, assignment operators(+= etc.) are not user-definable.
Control Expressions
if bool-expr [then]
body
elsif bool-expr [then]
body
else
body
end
unless bool-expr [then]
body
else
body
end
expr if
bool-expr
expr unless bool-expr
case target-expr
when comparison [, comparison]... [then]
body
when comparison [, comparison]... [then]
body
...
[else
body]
end
(comparisons may be regexen)
while bool-expr [do]
body
end
until bool-expr [do]
body
end
begin
body
end while bool-expr
begin
body
end until bool-expr
for name[, name]... in expr [do]
body
end
expr.each do | name[, name]... |
body
end
expr while bool-expr
expr until bool-expr
break terminates loop immediately.
redo immediately repeats w/o rerunning the condition.
next starts the next iteration through the loop.
retry restarts the loop, rerunning the condition.
Invoking a Method
Nearly everything available in a method invocation is optional, consequently the syntax is very difficult to follow.
Here are some examples:
http://www.zenspider.com/Languages/Ruby/QuickRef.html
Page 6 of 14
7. Ruby QuickRef
11/29/2005 12:35 AM
method
obj.method
Class::method
method(arg1, arg2)
method(arg1, key1 => val1, key2 => val2, aval1, aval2) #{ block }
method(arg1, *[arg2, arg3]) becomes: method(arg1, arg2, arg3)
invocation := [receiver ('::' | '.')] name [ parameters ] [ block ]
parameters := ( [param]* [, hashlist] [*array] [&aProc] )
block
:= { blockbody } | do blockbody end
Defining a Class
Classnames begin w/ capital character.
class Identifier [< superclass ]
expr..
end
# singleton classes, add methods to a single instance
class << obj
expr..
end
Defining a Module
module Identifier
expr..
end
Defining a Method
def method_name(arg_list, *list_expr, &block_expr)
expr..
end
# singleton method
def expr.identifier(arg_list, *list_expr, &block_expr)
expr..
end
All items of the arg list, including parens, are optional.
Arguments may have default values (name=expr).
Method_name may be operators (see above).
The method definitions can not be nested.
Methods may override operators: .., |, ^, &, <=>, ==, ===, =~, >, >=, <, <=, +, -, *, /, %, **, <<, >>, ~, +@, -@, [], []=
(2 args)
Access Restriction
public - totally accessable.
protected - accessable only by instances of class and direct descendants. Even through hasA relationships. (see below)
private - accessable only by instances of class.
Restriction used w/o arguments set the default access control.
Used with arguments, sets the access of the named methods and constants.
class A
protected
def protected_method
# nothing
end
end
class B < A
public
def test_protected
myA = A.new
http://www.zenspider.com/Languages/Ruby/QuickRef.html
Page 7 of 14
8. Ruby QuickRef
11/29/2005 12:35 AM
myA.protected_method
end
end
b = B.new.test_protected
Accessors
Class Module provides the following utility methods:
attr_reader <attribute>[, <attribute>]...
Creates a read-only accessor for each <attribute>.
attr_writer <attribute>[, <attribute>]...
Creates a write-only accessor for each <attribute>.
attr <attribute> [, <writable>]
Equivalent to "attr_reader <attribute>; attr_writer <attribute> if <writable>"
attr_accessor <attribute>[, <attribute>]...
Equivalent to "attr <attribute>, TRUE" for each argument.
Aliasing
alias
:old :new
alias_method :new, :old
Creates a new reference to whatever old referred to. old can be any existing method, operator, global. It may not be a
local, instance, constant, or class variable.
Blocks, Closures, and Procs
Blocks/Closures
blocks must follow a method invocation:
invocation do ... end
invocation { ... }
Blocks remember their variable context, and are full closures.
Blocks are invoked via yield and may be passed arguments.
Brace form has higher precidence and will bind to the last parameter if invocation made w/o parens.
do/end form has lower precidence and will bind to the invocation even without parens.
Proc Objects
Created via:
Kernel#proc
Proc#new
By invoking a method w/ a block argument.
See class Proc for more information.
Exceptions, Catch, and Throw
Exception
StandardError
LocalJumpError
SystemStackError
ZeroDivisionError
RangeError
FloatDomainError
SecurityError
ThreadError
IOError
EOFError
ArgumentError
IndexError
http://www.zenspider.com/Languages/Ruby/QuickRef.html
Page 8 of 14
9. Ruby QuickRef
11/29/2005 12:35 AM
RuntimeError
TypeError
SystemCallError
Errno::*
RegexpError
SignalException
Interrupt
fatal
NoMemoryError
ScriptError
LoadError
NameError
SyntaxError
NotImplementedError
SystemExit
begin
expr..
[rescue [error_type [=> var],..]
expr..]..
[else
expr..]
[ensure
expr..]
end
The default error_type for resuce is StandardError, not Exception.
Standard Library
Ruby comes with an extensive library of classes and modules. Some are built-in, and some are part of the standard
library. You can distinguish the two by the fact that the built-in classes are in fact, built-in. There are no dot-rb files
for them.
Built-in Library
Class Hierarchy
Object
Hash
Symbol
IO
File
Continuation
File::Stat
Data
NilClass
Exception (see tree above)
Array
Proc
String
Numeric
Float
Integer
Bignum
Fixnum
Regexp
Thread
Module
Class
ThreadGroup
Method
UnboundMethod
http://www.zenspider.com/Languages/Ruby/QuickRef.html
Page 9 of 14
10. Ruby QuickRef
11/29/2005 12:35 AM
Struct
Struct::Tms
TrueClass
Time
Dir
Binding
Range
MatchData
FalseClass
Modules
Comparable
Enumerable
Errno
FileTest
GC
Kernel
Marshal
Math
ObjectSpace
Precision
Process
Standard Library
The essentials:
benchmark.rb a simple benchmarking utility
cgi-lib.rb decode CGI data - simpler than cgi.rb
cgi.rb CGI interaction
date.rb date object (compatible)
debug.rb ruby debugger
delegate.rb delegate messages to other object
English.rb access global variables by english names
fileutils.rb file utility methods for copying, moving, removing, etc.
find.rb traverse directory tree
jcode.rb UTF-8 and Japanese String helpers (replaces String methods)
net/*.rb Networking classes of all kinds
observer.rb observer desing pattern library (provides Observable)
open-uri.rb good wrapper for net/http, net/https and net/ftp
open3.rb open subprocess connection stdin/stdout/stderr
ostruct.rb python style object (freeform assignment to instance vars)
parsearg.rb argument parser using getopts
pp prettier debugging output, 'p' on steroids.
profile.rb ruby profiler - find that slow code!
pstore.rb persistent object strage using marshal
rexml/*.rb XML toolkit
singleton.rb singleton design pattern library
stringio lets you use an IO attached to a string.
tempfile.rb temporary file that automatically removed
test/unit unit testing framework
time.rb extension to Time class with a lot of converters
tracer.rb execution tracer
webrick Fairly spiffy web server
yaml alternative readable serialization format
Tools
ruby
Command Line Options
http://www.zenspider.com/Languages/Ruby/QuickRef.html
Page 10 of 14
11. Ruby QuickRef
-0[octal]
-a
-c
-Cdirectory
--copyright
-d
-e 'command'
-F regexp
-h
-i[extension]
-Idirectory
-Kkcode
-l
-n
-p
-rlibrary
-s
-S
-T[level]
-v
--version
-w
-x[directory]
-X directory
-y
11/29/2005 12:35 AM
specify record separator (0, if no argument).
autosplit mode with -n or -p (splits $_ into $F).
check syntax only.
cd to directory, before executing your script.
print the copyright and exit.
set debugging flags (set $DEBUG to true).
one line of script. Several -e's allowed.
split() pattern for autosplit (-a).
prints summary of the options.
edit ARGV files in place (make backup if extension supplied).
specify $LOAD_PATH directory (may be used more than once).
specifies KANJI (Japanese) code-set.
enable line ending processing.
assume 'while gets(); ... end' loop around your script.
assume loop like -n but print line also like sed.
require the library, before executing your script.
enable some switch parsing for switches after script name.
look for the script using PATH environment variable.
turn on tainting checks.
print version number, then turn on verbose mode.
print the version and exit.
turn warnings on for your script.
strip off text before #! line and perhaps cd to directory.
causes Ruby to switch to the directory.
turns on compiler debug mode.
Environment Variables
DLN_LIBRARY_PATH
RUBYLIB
RUBYLIB_PREFIX
RUBYOPT
RUBYPATH
RUBYSHELL
Search path for dynamically loaded modules.
Additional search paths.
Add this prefix to each item in RUBYLIB. Windows only.
Additional command line options.
With -S, searches PATH, or this value for ruby programs.
Shell to use when spawning.
irb
irb [options] [script [args]]
The essential options are:
-d
-f
-h
-m
-r module
-v
--inf-ruby-mode
--inspect
--noinspect
--noprompt
--noreadline
--prompt
--readline
--tracer
Sets $DEBUG to true. Same as "ruby -d ..."
Prevents the loading of ~/.irb.rc.
Get a full list of options.
Math mode. Overrides --inspect. Loads "mathn.rb".
Loads a module. Same as "ruby -r module ..."
Prints the version and exits.
Turns on emacs support and turns off readline.
Turns on inspect mode. Default.
Turns off inspect mode.
Turns off the prompt.
Turns off readline support.
Sets to one of 'default', 'xmp', 'simple', or 'inf-ruby'.
Turns on readline support. Default.
Turns on trace mode.
Besides arbitrary ruby commands, the special commands are:
exit
fork block
cb args
source file
irb [obj]
conf[.key[= val]]
jobs
fg session
kill session
exits the current session, or the program
forks and runs the given block
changes to a secified binding
loads a ruby file into the session
starts a new session, with obj as self, if specified
access the configuration of the session
lists the known sessions
switches to the specifed session
kills a specified session
Session may be specified via session#, thread-id, obj, or self.
http://www.zenspider.com/Languages/Ruby/QuickRef.html
Page 11 of 14
12. Ruby QuickRef
11/29/2005 12:35 AM
xmp
require "irb/xmp"
xmp "something to eval" # or:
x = XMP.new
x.puts "something to eval"
ruby-mode
TODO: I don't have a freakin clue how to use the inferior ruby thing... I always fire up a shell in emacs... DOH!
Debugger
To invoke the debugger:
ruby -r debug ...
To use the debugger:
b[reak] [file:|class:]<line|method
b[reak] [class.]<line|method
set breakpoint to some position
wat[ch] expression
set watchpoint to some expression
cat[ch] exception
set catchpoint to an exception
b[reak]
list breakpoints
cat[ch]
show catchpoint
del[ete][ nnn]
delete some or all breakpoints
disp[lay] expression
add expression into display expression list
undisp[lay][ nnn]
delete one particular or all display expressions
c[ont]
run until program ends or hit breakpoint
s[tep][ nnn]
step (into methods) one line or till line nnn
n[ext][ nnn]
go over one line or till line nnn
w[here]
display frames
f[rame]
alias for where
l[ist][ (-|nn-mm)]
list program, - lists backwards
nn-mm lists given lines
up[ nn]
move to higher frame
down[ nn]
move to lower frame
fin[ish]
return to outer frame
tr[ace] (on|off)
set trace mode of current thread
tr[ace] (on|off) all
set trace mode of all threads
q[uit]
exit from debugger
v[ar] g[lobal]
show global variables
v[ar] l[ocal]
show local variables
v[ar] i[nstance] object
show instance variables of object
v[ar] c[onst] object
show constants of object
m[ethod] i[nstance] obj
show methods of object
m[ethod] class|module
show instance methods of class or module
th[read] l[ist]
list all threads
th[read] c[ur[rent]]
show current thread
th[read] [sw[itch]] nnn
switch thread context to nnn
th[read] stop nnn
stop thread nnn
th[read] resume nnn
resume thread nnn
p expression
evaluate expression and print its value
h[elp]
print this help
everything else
evaluate
empty
repeats the last command
rdoc
=begin
the everything between a line beginning with `=begin' and
that with `=end' will be skipped by the interpreter.
=end
FIX: there is a lot more to rdoc.
Mindshare, Idiom and Patterns
http://www.zenspider.com/Languages/Ruby/QuickRef.html
Page 12 of 14
13. Ruby QuickRef
11/29/2005 12:35 AM
Object Design
Visitor Pattern
By defining the method #each and including Enumerable, you get to use all the methods in Enumerable:
class Mailbox
include Enumerable
# ...
def each
@mail.each do
# ...
yield
end
end
end
Class SimpleDelegator, DelegateClass
foo = Object.new
foo2 = SimpleDelegator.new(foo)
foo.hash == foo2.hash # => false
Foo = DelegateClass(Array)
class ExtArray<DelegateClass(Array)
...
end
Module Observer
monitor.add_observer(self)
...
def update
...
notify_observers(data, ...)
end
Module Singleton
class Klass
include Singleton
# ...
end
a, b = Klass.instance, Klass.instance
a == b # => true
a.new # raises NoMethodError
Other Third-party Libraries
Racc
See i.loveruby.net /en /man /racc
Test::Unit
assert(boolean, message=nil)
assert_block(message="assert_block failed.") do ... end
assert_equal(expected, actual, message=nil)
assert_in_delta(expected_float, actual_float, delta, message="")
assert_instance_of(klass, object, message="")
assert_kind_of(klass, object, message="")
assert_match(pattern, string, message="")
assert_nil(object, message="")
assert_no_match(regexp, string, message="")
assert_not_equal(expected, actual, message="")
assert_not_nil(object, message="")
assert_not_same(expected, actual, message="")
assert_nothing_raised(*args)
assert_nothing_thrown(message="") do ... end
assert_operator(object1, operator, object2, message="")
http://www.zenspider.com/Languages/Ruby/QuickRef.html
Page 13 of 14