|
|
alias and BEGIN begin break case class def defined? do else elsif END end ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield
Basic types are numbers, strings, ranges, regexen, symbols, arrays, and hashes. Also included are files because they are used so often.
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
In all of the %() cases below, you may use any matching characters or any single character for delimiters. %[], %!!, %@@, etc.
'no interpolation'
"#{interpolation}, and backslashes\n"
%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)
\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)
<<identifier - interpolated, goes until identifier <<"identifier" - same thing <<'identifier' - no interpolation <<-identifier - you can indent the identifier by using "-" in front
Internalized String. Guaranteed to be unique and quickly comparable. Ideal for hash keys. Symbols may not contain \0 or be empty.
:symbol => :symbol
:'#{"without"} interpolation' => :"#{"without"} interpolation"
:"#{"with"} interpolation" => :"with interpolation"
%s(#{"without"} interpolation) => :"#{"without"} interpolation"
1..10
1...10
'a'..'z'
'a'...'z'
(1..10) === 5 => true
(1..10) === 10 => true
(1...10) === 10 => false
(1..10) === 15 => false
while gets # prints lines starting at 'start' and ending at 'end'
print if /start/../end/
end
class Comparable
# ...
def <=>(rhs)
# ...
end
def succ
# ...
end
end
range = RangeThingy.new(lower_bound)..RangeThingy.new(upper_bound)
Test out your regexen in irb or on: www.rubyxp.com
Usual recommended form:
str =~ /regex/
Lexical options:
/normal regex/iomx[neus]
%rXalternate formX (where X can be any character or pair () {} etc)
options:
/i case insensitive
/o only interpolate #{} blocks once
/m multiline mode - '.' will match newline
/x extended mode - whitespace is ignored
/[neus] encoding: none, EUC, UTF-8, SJIS, respectively
regex characters:
. 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
{m,n} at least m but most n previous regular expression
{m,n}? at least m but most n previous regular expression (non-greedy)
\1-9 nth previous captured group
\& whole match
\` pre-match
\' post-match
\+ highest group matched
\A beginning of a string
\b backspace(0x08)(inside[]only)
\b word boundary(outside[]only)
\B non-word boundary
\d digit, same as[0-9]
\D non-digit
\S non-whitespace character
\s whitespace character[ \t\n\r\f]
\W non-word character
\w word character[0-9A-Za-z_]
\z end of a string
\Z 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
(?>) nested anchored sub-regexp. stops backtracking.
(?imx-imx) turns on/off imx options for rest of regexp.
(?imx-imx:re) turns on/off imx options, localized in group.
special character classes:
[:alnum:] alpha-numeric characters [:alpha:] alphabetic characters [:blank:] whitespace - does not include tabs, carriage returns, etc [:cntrl:] control characters [:digit:] decimal digits [:graph:] graph characters [:lower:] lower case characters [:print:] printable characters [:punct:] punctuation characters [:space:] whitespace, including tabs, carriage returns, etc [:upper:] upper case characters [:xdigit:] hexadecimal digits
[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).
{1=>2, 2=>4, 3=>6}
{ expr => expr...}
Common methods include:
$global_variable @@class_variable @instance_variable [OtherClass::]CONSTANT local_variable
self the receiver of the current method nil the sole instance of the Class NilClass(represents false) true the sole instance of the Class TrueClass(typical true value) false the sole instance of the Class FalseClass(represents false) __FILE__ the current source file name. __LINE__ the current line number in the source file.
$! The exception information message set by 'raise'. $@ Array of backtrace of the last exception thrown. $& The string matched by the last successful match. $` The string to the left of the last successful match. $' The string to the right of the last successful match. $+ The highest group matched by the last successful match. $1 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 (or from $stdin if no files were given). $> The default output for print, printf. $stdout by default. $_ The last input line of string by gets or readline. $0 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. $DEBUG The status of the -d switch. $FILENAME Current input file from $<. Same as $<.filename. $LOAD_PATH The alias to the $:. $stderr The current standard error output. $stdin The current standard input. $stdout The current standard output. $VERBOSE The verbose flag, which is set by the -v switch. $-0 The alias to $/. $-a True if option -a is set. Read-only variable. $-d The alias to $DEBUG. $-F The alias to $;. $-i In in-place-edit mode, this variable holds the extension, otherwise nil. $-I The alias to $:. $-l True if option -l is set. Read-only variable. $-p True if option -p is set. Read-only variable. $-v The alias to $VERBOSE. $-w True if option -w is set.
TRUE The typical true value. FALSE The false itself. NIL The nil itself. STDIN The standard input. The default value for $stdin. STDOUT The standard output. The default value for $stdout. STDERR The standard error output. The default value for $stderr. ENV The hash contains current environment variables. ARGF The alias to the $<. ARGV The alias to the $*. DATA The file object of the script, pointing just after __END__. RUBY_VERSION The ruby version string (VERSION was deprecated). RUBY_RELEASE_DATE The release date string. RUBY_PLATFORM The platform identifier.
Terms are expressions that may be a basic type (listed above), a shell command, variable reference, constant reference, or method invocation.
(Top to bottom) :: . [] ** -(unary) +(unary) ! ~ * / % + - << >> & | ^ > >= < <= <=> == === != =~ !~ && || .. ... =(+=, -=...) not and or
All of the above are just methods except these:
=, ::, ., .., ..., !, not, &&, and, ||, or, !=, !~
In addition, assignment operators(+= etc.) are not user-definable.
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
bool-expr ? true-expr : false-expr
case target-expr
when comparison [, comparison]... [then]
body
when comparison [, comparison]... [then]
body
...
[else
body]
end
(comparisons may be regexen)
loop do
body
end
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
Nearly everything available in a method invocation is optional, consequently the syntax is very difficult to follow. Here are some examples:
invocation := [receiver ('::' | '.')] name [ parameters ] [ block ]
parameters := ( [param]* [, hashlist] [*array] [&aProc] )
block := { blockbody } | do blockbody end
Class names begin w/ capital character.
class Identifier [< superclass ]
expr..
end
# singleton classes, add methods to a single instance
class << obj
expr..
end
module Identifier
expr..
end
def method_name(arg_list, *list_expr, &block_expr)
expr..
end
# singleton method
def expr.identifier(arg_list, *list_expr, &block_expr)
expr..
end
class A
protected
def protected_method
# nothing
end
end
class B < A
public
def test_protected
myA = A.new
myA.protected_method
end
end
b = B.new.test_protected
Class Module provides the following utility methods:
alias :new :old 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.
invocation do ... end
invocation { ... }
Created via:
See class Proc for more information.
raise ExceptionClass[, "message"]
begin
expr..
[rescue [error_type [=> var],..]
expr..]..
[else
expr..]
[ensure
expr..]
end
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.
The essentials:
-0[octal] specify record separator (\0, if no argument). -a autosplit mode with -n or -p (splits $_ into $F). -c check syntax only. -Cdirectory cd to directory, before executing your script. --copyright print the copyright and exit. -d set debugging flags (set $DEBUG to true). -e 'command' one line of script. Several -e's allowed. -F regexp split() pattern for autosplit (-a). -h prints summary of the options. -i[extension] edit ARGV files in place (make backup if extension supplied). -Idirectory specify $LOAD_PATH directory (may be used more than once). -Kkcode specifies KANJI (Japanese) code-set. -l enable line ending processing. -n assume 'while gets(); ... end' loop around your script. -p assume loop like -n but print line also like sed. -rlibrary require the library, before executing your script. -s enable some switch parsing for switches after script name. -S look for the script using PATH environment variable. -T[level] turn on tainting checks. -v print version number, then turn on verbose mode. --version print the version and exit. -w turn warnings on for your script. -x[directory] strip off text before #! line and perhaps cd to directory. -X directory causes Ruby to switch to the directory. -y turns on compiler debug mode.
DLN_LIBRARY_PATH Search path for dynamically loaded modules. RUBYLIB Additional search paths. RUBYLIB_PREFIX Add this prefix to each item in RUBYLIB. Windows only. RUBYOPT Additional command line options. RUBYPATH With -S, searches PATH, or this value for ruby programs. RUBYSHELL Shell to use when spawning.
irb [options] [script [args]]
The essential options are:
-d Sets $DEBUG to true. Same as "ruby -d ..." -f Prevents the loading of ~/.irb.rc. -h Get a full list of options. -m Math mode. Overrides --inspect. Loads "mathn.rb". -r module Loads a module. Same as "ruby -r module ..." -v Prints the version and exits. --inf-ruby-mode Turns on emacs support and turns off readline. --inspect Turns on inspect mode. Default. --noinspect Turns off inspect mode. --noprompt Turns off the prompt. --noreadline Turns off readline support. --prompt Sets to one of 'default', 'xmp', 'simple', or 'inf-ruby'. --readline Turns on readline support. Default. --tracer Turns on trace mode.
Besides arbitrary ruby commands, the special commands are:
exit exits the current session, or the program fork block forks and runs the given block cb args changes to a secified binding source file loads a ruby file into the session irb [obj] starts a new session, with obj as self, if specified conf[.key[= val]] access the configuration of the session jobs lists the known sessions fg session switches to the specifed session kill session kills a specified session
Session may be specified via session#, thread-id, obj, or self.
require "irb/xmp" xmp "something to eval" # or: x = XMP.new x.puts "something to eval"
TODO: I don't have a freakin clue how to use the inferior ruby thing... I always fire up a shell in emacs... DOH!
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
= Level One Heading == Level Two Heading, and so on * bullet list - bullet list 1. numbered list [cat] labeled list cat:: labeled list, tabular format --- horizontal line (rule)
_italic_ italic text *bold* bold text +typewriter+ typewriter or mono-spaced text \+escaped+ escaped, not special formatting
http://example.com/index.html converts to external link, shows link [home]http://example.com/index.html converts to external link, shows "home" link:/some/file/on/my/disk converts to link to local file
# :yields: ... on method description, ... are yield parameters # :nodoc:[all] don't include this element in documentation, all for sub-elements too # :doc: force an element to be documented # :notnew: do not assume initialize arguments are for the new method # -- in comment stop rdoc processing # ++ in comment start rdoc processing again # :include:filename include filename at this point # :title:text set the title for this document to text # :main:name set the class, module, or file to appear on the index page
=begin the everything between a line beginning with `=begin' and that with `=end' will be skipped by the ruby interpreter. =end
Run `rdoc --help` for full listing. Here are the more common flags:
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
foo = Object.new
foo2 = SimpleDelegator.new(foo)
foo.hash == foo2.hash # => false
Foo = DelegateClass(Array)
class ExtArray<DelegateClass(Array)
...
end
monitor.add_observer(self)
...
def update
...
notify_observers(data, ...)
end
class Klass
include Singleton
# ...
end
a, b = Klass.instance, Klass.instance
a == b # => true
a.new # raises NoMethodError
Original URL: www.zenspider.com/Languages/Ruby/QuickRef.html $Author: ryand $ $Date: 2009/11/16 $ $Revision: #59 $