=begin # Mon Nov 25 04:00:10 JST 2002 = オブジェクト指向スクリプト言語 Ruby リファレンスマニュアル version 1.6.8 対応 原著：まつもとゆきひろ == 執筆者募集中 このリファレンスをよりよいものにするために 随時((<執筆者募集>))中です。あなたの参加を待ってます。 == 目次 * ((<更新履歴|URL:http://www.ruby-lang.org/~kazu/man-1.6/>)) * ((<はじめに>)) * (()) * (()) * (()) * ((<環境変数>)) * Ruby 言語仕様 * ((<オブジェクト>)) * ((<クラス>)) * ((<実行>)) * ((<終了処理>)) * ((<スレッド|Ruby スレッド>)) * ((<セキュリティモデル>)) * ((<正規表現>)) * (()) * ((<字句構造>)) * ((<プログラム>)) * ((<変数と定数>)) * ((<リテラル>)) * ((<演算子式>)) * ((<制御構造>)) * ((<メソッド呼出し>)) * ((<クラス／メソッドの定義>)) * 標準ライブラリ * ((<組込み関数>)) * ((<組込み変数>)) * ((<組込み定数>)) * ((<組込みクラス／モジュール／例外クラス>)) * ((<添付ライブラリ>)) * (()) * (()) * (()) * (()) * (()) * (()) * 付録 * ((<疑似BNFによるRubyの文法>)) * (()) * (()) * (()) * (()) * (()) * (()) * (()) * (()) * (()) * (()) * (()) * ((<索引|method>)) * ((<機能別索引>)) * ((<配布条件>)) = 執筆者募集 下の「Link」で参照されるページにRubyリファレンスマニュアルの記述が不完 全な部分が含まれています。 あなたの記述をみんな待ってます。よろしく。 RDというフォーマットで書きます。 RDとは何ぞやという人は(())を見てみましょう。 == 執筆の心得 (1) できるだけリンクを張る。(ただし同じ言葉に対してのリンクはうるさくなら ないように) (1) 記述を追加したいが内容に関していまいち自信がなかったりする場合、以下の いずれかの方法で問い合わせる * footnote に (('((- これであってる？-))')) などと書く * マニュアル執筆編集に関する議論をするためのメーリングリスト rubyist@freeml.com(((<参加方法|URL:http://www.freeml.com/ml_info.php?ml=rubyist>))) に確認する。 * 広くRubyコミュニティと議論したい場合は (()) に 「この記述怪しいんですが。。。」などと問い合わせる。 * MLに参加してない人は((<あらい|URL:mailto:jca02266@nifty.ne.jp>))宛 に直接問い合わせても構わないです。 * 記述内容にわかりにくい箇所とかもあれば上記の方法で問い合わせてくだ さいませ。できるだけ改善したいと思います。 その他雑多なことに関しては (())も参照してください。 ((<作業中のページ>)) (()) = やること(やるかもしれないこと) これらの課題や方針については rubyist ML で議論されています(議論されて ない場合もあります:-p)。 * 2002-04-19: Method の良い実例を → (()) ？ * 2002-04-19: Continuation の良い実例を → (()), (()), ((<"ruby-src:ruby/rough/lib/generator.rb">)) 集大成？→ (()) (話の発端 (()) 追いかけてみると面白い。目と脳ミソが疲 れるけど) * 2002-04-16: (()) (()), (()) の紹介。 * 2002-03-04: getoptsの変更((()))への追随(commit待ち)。 -> なんだっけ？確か書いたと思う。(()) の「おそらく1.6.8」 とかいう記述は直さなきゃね。 * 追加された添付ライブラリについてのページを(まだなければ)用意する。 * 「new は initialize を呼ぶ。そうでないコンストラクタ(openとか)は initializeを呼ばない」ことを明記する チェック完 -> Proc Thread は難しいので保留 * メソッドの返り値の明記 ENV と ARGF がまだ。疲れたわい。 チェック完 -> Thread, Proc, 組込み関数 Object, Array, Binding, Continuation, Data, Exception, Dir, FalseClass, File::Stat, Hash, IO, File, MatchData, Method, UnboundMethod, Module, Class, Numeric, Integer, Bignum, Fixnum, Float, Proc, Process::Status, Range, Regexp, String, Struct, Symbol, Thread, ThreadGroup, Time, TrueClass, NilClass, Comparable, Enumerable, Errno, File::Constants, FileTest, GC, Kernel, Marshal, Math, ObjectSpace, Precision, Process, Signal, 全例外クラス * 2001-05-09: Marshal の制限について書く((())) * footnote の整理(まだちょっと残ってる→その後、また書いちゃった footnote はpending項目としても使っている) * 暗黙の型変換について書く(本当に書く？元気がなくなった) * 文書スタイルの確立 * RDP との統合 (→ライブラリは取り込んだ。RAAの紹介ページなんかも欲しいなとか言ってみる) * 演算子の説明(一般的な用法 rubyの演算子は再定義可能なので→うーん) * self の説明(コンテキストの説明) * クラスもオブジェクトであることに言及する。 * object.c の図を載せる？ * クラス階層について詳細を(include はクラス階層への挿入) * (())の図を載せる * できるだけすべてのメソッドに簡潔な実例をつけるようにする。 = (どなたかが)やったこと * allocation framework (1.7 feature) のことも書く -> 2002-04-10: 簡単に書いた * 定義も実行文であることにふれる。(class や module 文で) * 直接ではないけど、一応前に「((<クラス／メソッドの定義/クラス定義>))」で書いた * ((<索引>))ページの更新(演算子形式等も索引に載るように) * (())ページで解決？->解決 * MethodList 化 * 2002-01-14: クラス、モジュール等主なものはは完了。あとはぼちぼちやる。 * このマニュアルの配布条件を決める(？) * 2001-12-25: ((<配布条件>)) * 2001-04-28: Rubyの終了処理について書く((())) * 2001-05-11: ((<終了処理>)) * 「Rubyの文法」再構成に伴い、全体の記述の見直しと(('(())')) と参照している箇所を修正する * 2001-05-11: やった。 * (()) の参照の仕方のページ * ページだけ作った * (())でちょっと使ってみた * 完了したつもり * Ruby FAQをここに取り込む * 完了したみたい * 「Rubyの文法」の再編成(検討中) * 2001-02-26 やった。どう？ - あらい * 拡張ライブラリリファレンスマニュアル(書く人いる？) * RDP に行ったみたい = shim * (()) * 古いバージョンの Ruby に新しいバージョンで導入された新機能や 新モジュールを付加・提供するものです。ちょうど詰め木の役割をする ことから、「Ruby Shim」と名付けられました。 == 背景 巷の声を聞くに曰く: 「こんな機能が欲しい、と要望したら、開発版ではこう実現されている、 と教えてもらった。でも、安定版で使えないんじゃ救われない！」 「結局、便利だから開発版の機能を安定版でも実装して使うことにした。 でも、きっとみんな同じようなことをやっているんだろうな。。」 「開発版の追っかけをしていて、自分用のプログラムやライブラリでは 新機能をどんどん使っている。でも安定版じゃ動かないから、人には 使ってもらいにくい。」 「開発版にしかないモジュールをいくつか使いたいが、個別に入手して インストールするのは大変。それに、開発版にしかないこのモジュール、 そのままじゃ安定版で動かないよね。。」 == 目的 (1) Ruby 開発版の新機能のうち、安定版でも実現・追加可能なものを 実装する。また新規追加モジュール群も安定版用にアレンジし、 これらをすべて一まとめにして配布する。 (2) 1. により、開発版の新機能の早期のテスト・評価・利用を促進し、 来たる次期安定版の品質の向上を図りつつ、ユーザのスムーズな 版の移行をサポートする。 (3) 各拡張ごとの独立性を確保し、テスト済みの実装を提供することで、 部分的に切り取っての利用にも対応する。(段階的な移行に役立つ) == 名前 「Ruby Shim」 shim : 隙間に入れる詰め木の意 == 方針 === 互換レイヤについて (1) 安定版の挙動は極力変えない。追加や拡張にとどめる。名前空間も むやみに汚染しない。これにより、動いていたものが動かなくなる という心配をせずに Shim を使える。 (2) Shim で追加・拡張された部分の後方互換性は追わない。開発版の 仕様に追随する。 (3) できるだけ、(だいたいクラス・モジュール単位で見て)拡張同士が 依存しないようにして、部分的な利用も可能にしておく。 (4) 完璧は目指さない。無理もしない。Shim で実装されないことが我慢 できないほど開発版の機能に浸かってしまった人には、少々の追加 リスクとコストを負って移行してもらえばいい。 === 追加モジュールについて (1) 各モジュールのメンテナに一任。開発版と同期するもよし、安定版 向けリリースということで慎重に保守するもよし。 (2) メンテナが、安定版用のものは保守するつもりがないという場合、 Shim の committer が適宜開発版と同期する。(意思の表明がない 場合のデフォルト - 負担は強いません) == その他 開発版で廃止・変更された機能を使うと警告を出すようなオプション またはツールを作ると、移行に大いに役立つかもしれない。余力が出て きたら考えよう。 あまりに違いが大きかったり、実装が難しいクラス・モジュールは、 場合によってはまるごと拡張モジュールとして(クラス名の頭に Ruby18 などと付けて)提供する手もあるかも。ただし、需要と余力次第。 = はじめに Rubyは手軽なオブジェクト指向プログラミングのためのインタプリタ言語です。 Rubyは(Perlのような)テキスト処理やシステム管理のための豊富な機能を持っています。 また、Rubyは単純で、分かりやすく、簡単に拡張できます。 もし、簡単なオブジェクト指向のための言語を求めていたり、 Perlは見にくいと感じていたり、 Lispの考え方は好きだがあの括弧の多さには困ると感じているなら、 Rubyはまさにぴったりです。 Rubyの特長は次の通りです。 : インタプリタ Rubyはインタプリタ言語ですので プログラムを実行するためにコンパイルする必要はありません。 : 変数に型が無い (動的型付け) Rubyの変数はどのような型のデータも格納する事ができますので、 変数の型について心配する必要はありません。 半面、コンパイル時のチェックは弱くなります。 : 変数宣言が不要 Rubyでは変数を宣言無しで使う事ができます。 変数の種類(ローカル変数、グローバル変数、インスタンス変数など)は 変数名から知る事ができます。 : 単純な文法 Rubyの文法はEiffelからわずかに影響を受けた単純なものです。 : ユーザによるメモリ管理が不要 Rubyはメモリ管理を自動的に行います。 どこからもアクセスされなくなったオブジェクトは インタプリタに組込みのガーベージコレクタによって回収されます。 : 全てがオブジェクト Rubyははじめから純粋なオブジェクト指向言語として設計されています。 整数のような基本的なデータ型をはじめとして、 全てのデータをオブジェクトとして統一的に取り扱えます。 : クラス、継承、メソッド Rubyは クラス、継承、メソッドのようなオブジェクト指向言語として基本的な機能は 当然持っています。 : 特異メソッド ある特定のオブジェクトにメソッドを付加することができます。 たとえば、GUIのあるボタンを押された時の動作を メソッドとして記述するような使い方ができますし、 これを応用してプロトタイプベースの オブジェクト指向プログラミングも可能です(やりたければね)。 : モジュールによるMix-in Rubyは多重継承は複雑さの源であるという見地から、 意図的に多重継承を持っていませんが、 モジュールを使ってクラス階層を横断して実装を共有できます。 この機能を"Mix-in"と呼びます。 : イテレータ ループの抽象化を行うイテレータという機能があります。 : クロージャ 手続きをオブジェクトとして扱う機能があります。 このオブジェクト化された手続きのことをクロージャと呼びます。 : 強力な文字列操作/正規表現 Perlをお手本とした強力な文字列操作や正規表現検索の機能があります。 : 多倍長整数 組込みの多倍長整数機能がありますので、 メモリが許す限り、非常に大きな整数の演算もできます。 たとえば、400の階乗なども簡単に計算できます。 : 例外処理機能 例外処理機能は例外的な状況への対処が簡単に書けます。 : OSへの直接アクセス Rubyは(UNIXの)ほとんどのシステムコールの呼び出し機能を持っています。 Rubyだけでシステムプログラミングも可能です。 : ダイナミックローディング OSが許せば、オブジェクトファイルを実行時に読み込む機能が提供されます。 = Rubyの起動 * (()) * (()) Rubyインタプリタの起動は以下の書式のコマンドラインにより行います。 ruby [ option ...] [ -- ] [ programfile ] [ argument ...] ここで、(({option})) は後述の(()) のいずれかを指定します。(({--})) は、オプション列の終りを明示するため に使用できます。(({programfile})) は、Ruby スクリプトを記述したファイ ルです。これを省略したり`(({-}))' を指定した場合には標準入力を Ruby ス クリプトとみなします。 (({programfile})) が `(({#!}))' で始まるファイルである場合、特殊な解釈 が行われます。詳細は後述の(()) を参照 してください (({argument})) に指定した文字列は組込み定数 ((<組込み定数/ARGV>)) の初 期値として設定されます。標準のシェルがワイルドカードを展開しない環境 ((()))では、Ruby インタプリタが自前でワイルドカードを展開して ((<組込み変数/ARGV>)) に設定します。この場合ワイルドカードとして `(({*}))', `(({?}))', `(({[]}))', `(({**/}))' が使用できます ((()) と異なり `(({{..}}))' は使えません)。Win32 環境で、 ワイルドカード展開を抑止したい場合は引数をシングルクォート(') で括りま す。 == コマンドラインオプション Rubyインタプリタは以下のコマンドラインオプションを受け付けま す。基本的にPerlのものと良く似ています。 : (({-0((|数字|))})) 入力レコードセパレータ(`((<組込み変数/"$/">))')を8進数で指定します。 数字を指定しない場合はヌルキャラクタがセパレータになります ($/ = "\0" と同じ)。 数の後に他のスイッチがあっても構いません。 (({-00}))で, パラグラフモード($/=""と同じ), (({-0777}))で (そのコードを持つ文字は存在しないので)全ファイルを一度に読み 込むモード($/=nilと同じ)に設定できます。 : (({-a})) `-n'や`-p'とともに用いて, オートスプリットモードをONにします。 オートスプリットモードでは各ループの先頭で, $F = $_.split が実行されます。`-n'か`-p'オプションが同時に指定されない限り, このオプションは意味を持ちません。 : (({-C ((|directory|))})) スクリプト実行前に指定されたディレクトリに移動します。 : (({-c})) スクリプトの内部形式へのコンパイルのみを行い, 実行しません。コンパイル終 了後, 文法エラーが無ければ, "Syntax OK"と出力します。 : (({--copyright})) 著作権表示をします。 : (({-K((|c|))})) Rubyの処理する漢字コードを指定します。 Rubyは指定された文字 が `E'または`e'の場合は文字列やアクセスするファイルの内容の コードがEUCであると仮定します。同様に`S'または`s'の場合は SJIS、'U'または'u'の場合はUTF-8として処理します。 `N'は漢字を処理しません。デフォルトはN(NONE)です。 このオプションは将来文字コードの取扱いが変更された場合等には 変更される可能性があります。 : (({-d})) : (({--debug})) デバッグモードでスクリプトを実行します。((<組込み変数/$DEBUG>)) を true にします。 : (({-e ((|script|))})) コマンドラインからスクリプトを指定します。(({-e}))オ プションを付けた時には引数からスクリプトファイル名を取りませ ん。 (({-e})) オプションを複数指定した場合、各スクリプトの間に改行を 挟んで解釈します。 以下は等価です。 ruby -e "5.times do |i|" -e "puts i" -e "end" ruby -e "5.times do |i| puts i end" ruby -e "5.times do |i|; puts i; end" : (({-F((|regexp|))})) 入力フィールドセパレータ(((<組込み変数/$;>)))の値を文字列にセッ トします。 : (({-h})) : (({--help})) コマンドラインオプションの概要を表示します。 : (({-i[((|extension|))]})) 引数で指定されたファイルの内容を置き換える(in-place edit)こ とを指定します。元のファイルは拡張子をつけた形で保存されます。 拡張子がなければ、バックアップは行われず、変更されたファイル だけが残ります。 例: % echo matz > /tmp/junk % cat /tmp/junk matz % ruby -p -i.bak -e '$_.upcase!' /tmp/junk % cat /tmp/junk MATZ % cat /tmp/junk.bak matz : (({-I ((|directory|))})) ファイルをロードするパスを指定(追加)します。指定されたディレ クトリはRubyの配列変数(((<組込み変数/$:>)))に追加されます。 : (({-l})) 行末の自動処理を行います。まず、((<組込み変数/$\>)) を ((<組込み変数/"$/">)) と同じ値に設定し, (({print}))での出力 時に改行を付加するようにします。それから, (({-n})) フラグまたは(({-p}))フラグが指定されていると (({gets})) で読み込まれた各行の最後に対して (({String#chop!}))を行います。 : (({-n})) このフラグがセットされるとプログラム全体が (({sed -n}))や(({awk})) のように while gets ... end で囲まれているように動作します. : (({-p})) (({-n}))フラグとほぼ同じですが, 各ループの最後に変数 ((<組込み変数/$_>)) の値を出力するようになります。 例: % echo matz | ruby -p -e '$_.tr! "a-z", "A-Z"' MATZ : (({-r ((|feature|))})) スクリプト実行前に ((|feature|)) で指定されるライブラリを ((<組込み関数/require>)) します。 `-n'オプション、`-p'オプションとともに使う時に特に有効です。 : (({-s})) スクリプト名に続く, `-'で始まる引数を解釈して, 同名のグローバル変数に値 を設定します。`--'なる引数以降は解釈を行ないません。該当する引数は ((<組込み定数/ARGV>)) から取り除かれます。 例: #! /usr/local/bin/ruby -s # prints "true" if invoked with `-xyz' switch. print "true\n" if $xyz : (({-S})) スクリプト名が`/'で始まっていない場合, 環境変数 (({PATH}))の値を使ってスクリプトを探すことを指定しま す。 これは、(({#!}))をサポートしていないマシンで、 (({#!})) による実行をエミュレートするために、以下の ようにして使うことができます: #!/bin/sh exec ruby -S -x $0 "$@" #! ruby システムは最初の行により、スクリプトを(({/bin/sh})) に渡します。(({/bin/sh}))は2行目を実行しRubyインタプリタを起動します。 Rubyインタプリタは(({-x})) オプションにより`#!'で始まり, "ruby"という文字列を含む行までを 読み飛ばします。 システムによっては ((<組込み変数/$0>))は必ずしもフルパスを含まな いので、`-S'を用いてRubyに必要に応じてスクリプトを探すように 指示する必要があります。 : (({-T[((|level|))]})) 不純度チェックを行います。((|level|)) を指定すると安全度レベルをその レベルに設定します。((|level|)) 省略時は 1 を指定したのと同じです。 CGIプログラムなどでは(({-T1})) 程度を指定しておく方が良いでしょう。 システム変数(({$SAFE})) に指定したレベルがセットされます。 : (({-v})) : (({--verbose})) 冗長モード。起動時にバージョンの表示を行い, システム変数 ((<組込み変数/$VERBOSE>))をtrueにセットします。この変数がtrueで ある時, いくつかのメソッドは実行時に冗長なメッセージを出力し ます。`-v'オプションが指定されて, それ以外の引数がない時には バージョンを表示した後, 実行を終了します(標準入力からのスク リプトを待たない). : (({--version})) Rubyのバージョンを表示します。 : (({-w})) バージョンの表示を行う事無く冗長モードになります。 : (({-x[((|directory|))]})) メッセージ中のスクリプトを取り出して実行します。スクリプトを 読み込む時に、`#!'で始まり, "ruby"という文字列を含む行までを 読み飛ばします。スクリプトの終りは(({EOF}))(ファイル の終り), (({^D}))(コントロールD), (({^Z}))(コ ントロールZ)または予約語(({__END__}))で指定されます。 ディレクトリ名を指定すると、スクリプト実行前に指定されたディ レクトリに移動します。 : (({-y})) : (({--yydebug})) コンパイラデバッグモード。スクリプトを内部表現にコンパイルす る時の構文解析の過程を表示します。この表示は非常に冗長なので, コンパイラそのものをデバッグする人以外には必要ないと思います。 == インタプリタ行の解釈 コマンドラインに指定したスクリプトが `(({#!}))' で始まるファイルで、そ の行に `(({ruby}))' という文字列を((*含まない場合*))、OSに代わって `(({#!}))' に続く文字列をコマンドラインとみなしてそのインタプリタを起 動します。このときコマンドラインで指定した引数はそのインタプリタに渡さ れます。 例えば、以下のシェルスクリプトを ruby で実行すると sh を起動します。 #!/bin/sh -vx echo "$@" この行に `(({ruby}))' という文字列が((*含まれる場合*))は、その文字列よ り左側は無視され、右側に `(({-}))'で始まる語があればオプションとして解 釈します。 ここで指定したオプションは、コマンドラインでの指定に追加されます。これ はそのスクリプトで指定すべきオプションを埋め込むために使います。例えば 以下の行で始まるスクリプトはコマンドラインに (({-Ke})) オプションを指 定したのと同じ効果になります。 #! ruby -Ke = Win32 Windows95/98/Me/NT/2000/XP などを総称してWin32と呼ぶ。 Windows3.1 では (())版Rubyが(たぶん)動く。 Win32上でのRubyは、おおざっぱにいうと * (())版Ruby * (())Ruby の2種類にわけることができる。 このマニュアルでは、本文で Win32版 と言うと主に(特に断りがない限り)、 Win32ネイティブ版を指しているのであしからず。逆に Unix について書いて いる部分は Cygwin にも当てはまることが多い。複雑だ。 = Dir ディレクトリ内の要素を順に返すディレクトリストリーム操作のためのクラス。 == スーパークラス: * (()) == インクルードしているモジュール: * (()) == クラスメソッド: --- Dir[pattern] --- Dir.glob(pattern) --- Dir.glob(pattern) {|file| ...} --- Dir.glob(pattern[, flags]) (()) --- Dir.glob(pattern[, flags]) {|file| ...} (()) ワイルドカードの展開を行った結果を文字列の配列として返します。 ブロックが与えられたときはワイルドカードにマッチしたファイルを 引数にそのブロックを 1 つずつ評価して (({nil})) を返します パターンを空白(スペース、タブ、改行)あるいは "\0" で区切って 1 度 に複数のパターンを指定することもできます。 p Dir.glob("f* b*") => ["foo", "bar"] ワイルドカードには以下のものがあります。 * (({*})) 空文字列を含む任意の文字列と一致します。 * (({?})) 任意の一文字と一致します。 * (({[ ]})) 鈎括弧内のいずれかの文字と一致します。(({-})) でつな がれた文字は範囲を表します。鈎括弧の中の最初の文字が (({^})) である時には含まれない文字と一致します。 ((({^})) の代わりに (({!})) も同じ意味で使えます。((-ksh に合わ せた?-))) * (({{ }})) コンマで区切られた文字列の組合せに展開します。例えば、 (({foo{a,b,c}}))は(({fooa})), (({foob})), (({fooc}))に展開されそれぞれに対してマッチ判定を行います。 括弧は入れ子にすることができます。例えば、 (({{foo,bar{foo,bar}}})) は (({foo})), (({barfoo})), (({barbar})) のそれぞれにマッチします。 * (({**/})) ワイルドカード (({*/})) の0回以上の繰り返しを意味し、 ディレクトリを再帰的にたどってマッチを行います。 例えば, (({foo/**/bar})) は (({foo/bar})), (({foo/*/bar})), (({foo/*/*/bar})) ... (以下無限に続く)に対してそれぞれ マッチ判定を行います。 (()): ワイルドカードはバックスラッシュによりエスケープすることがで きます。(ダブルクォートの文字列中では 2 重にエスケープする必要がある ことに注意してください) また、空白類に特殊な意味はなくなりました((({"\0"}))の効果は残っています)。 1.6と同様の処理を期待する場合は、不要な空白は(({String#chomp}))などで 適切に除去するか、(({gsub(/[ \t\n]/, "\0")}))で変換しておく必要が あります。 (()): 省略可能な第二引数には (()) に指定できるフラグ と同様のフラグを指定できます。このフラグを指定することでマッチの挙 動を変更することができます。 --- Dir.chdir([path]) --- Dir.chdir([path]) {|path| ... } (()) カレントディレクトリを ((|path|)) に変更します。 ((|path|)) を省略した場合、環境変数 (({HOME})) または (({LOGDIR})) が設定されていればそのディレクトリに移動します。 カレントディレクトリの変更に成功すれば 0 を返します。失敗した場合 は例外 (()) が発生します。 (()): ブロックが指定された場合、ディレクトリの変更はブロックの実行中に限 られます。これは以下と等価です。 savedir = Dir.pwd Dir.chdir(newdir) begin ... ensure Dir.chdir(savedir) end ブロックが指定されたときのこのメソッドの戻り値はブロックの実行結果 です。 --- Dir.chroot(path) ルートディレクトリを ((|path|)) に変更します。 (()) を参照のこと。スーパーユーザだけがルー トディレクトリを変更できます。 元のルートディレクトリに戻る方法はありません。 ルートディレクトリの変更に成功すれば 0 を返します。失敗した場合は 例外 (()) が発生します。 --- Dir.delete(path) --- Dir.rmdir(path) --- Dir.unlink(path) ディレクトリを削除します。ディレクトリは空でなければいけませ ん。 ディレクトリの削除に成功すれば 0 を返します。失敗した場合は例外 (()) が発生します。 --- Dir.entries(path) ディレクトリ ((|path|)) に含まれるファイルエントリ名の 配列を返します。以下と同じです。 def dir_s_entries( path ) Dir.open(path) {|d| return d.to_a } end --- Dir.foreach(path) {|file| ...} ((|path|))のディレクトリの要素に対して繰り返すイテレー タ。このメソッドは以下と同じ働きをします。 dir = Dir.open(path) begin dir.each {|file| ... } ensure dir.close end (({nil})) を返します。 --- Dir.getwd --- Dir.pwd カレントディレクトリのフルパスを返します。 カレントディレクトリの取得に失敗した場合は例外 (()) が発生します(が、普通は失敗することはありません)。 --- Dir.mkdir(path[, mode]) ((|path|)) という新しいディレクトリを作ります。パーミッションは ((|mode|)) で指定された値(デフォルトは 0777)に umask をかけた ((({mode & ~umask}))) 値になります((())) を 参照)。 ディレクトリの作成に成功すれば 0 を返します。失敗した場合は例外 (()) が発生します。 --- Dir.new(path) --- Dir.open(path) --- Dir.open(path) {|dir| ...} ((|path|))に対するディレクトリストリームをオープンして返します。 オープンに失敗した場合は例外 (()) が発生します。 (({open()}))はブロックを指定することができます。 ブロックを指定して呼び出した場合は、ディレクトリストリームを 与えられてブロックが実行されます。ブロックの実行が終了すると、 ディレクトリは自動的にクローズされます。 (()): ブロックが指定されたときのこのメソッドの戻り値はブロックの実行結果 です。((-version 1.6 では (({nil})) 固定です-)) == メソッド: --- close ディレクトリストリームをクローズします。以降のディレクトリに 対する操作は例外 (()) を発生させます。 クローズに成功すれば (({nil})) を返します。失敗した場合は例外 (()) が発生します。 --- each {|item| ... } ディレクトリの各要素に対してブロックを評価します。 (({self})) を返します。 --- pos --- tell ディレクトリストリームの現在の位置を整数で返します。 Dir.open("/tmp") {|d| d.each {|f| p d.pos } } --- pos=(pos) --- seek(pos) ディレクトリストリームの読み込み位置を ((|pos|)) に移動させます。 ((|pos|))は(()) で与えられた値でなければなりま せん。 (({pos=})) は右辺を返します。(({seek})) は (({self})) を返します。 --- read ディレクトリストリームから次の要素を読み出して返します。最後の要素 まで読み出していれば (({nil})) を返します。 ディレクトリの読み出しに失敗した場合は例外 (()) が発 生します。 --- rewind ディレクトリストリームの読み込み位置を先頭に移動させます。 (({self})) を返します。 = 環境変数 Rubyインタプリタは以下の環境変数を参照します。 : (({RUBYOPT})) Rubyインタプリタにデフォルトで渡すオプションを指定します。 * (({sh系})) RUBYOPT='-Ke -rkconv' export RUBYOPT * (({csh系})) setenv RUBYOPT '-Ke -rkconv' * (({MS-DOS系})) set RUBYOPT=-Ke -rkconv : (({RUBYPATH})) (()) オプション指定時に、環境変数 (({PATH})) による Ruby スクリプトの探索に加えて、この環境変数で指定したディレクトリも 探索対象になります。((({PATH})) の値よりも優先します)。 * (({sh系})) RUBYPATH=$HOME/ruby:/opt/ruby export RUBYPATH * (({csh系})) setenv RUBYPATH $HOME/ruby:/opt/ruby * (({MS-DOS系})) set RUBYPATH=%HOME%\ruby:\opt\ruby : (({RUBYLIB})) Rubyライブラリの探索パス((<組込み変数/$:>))のデフォル ト値の前にこの環境変数の値を付け足します。 * (({sh系})) RUBYLIB=$HOME/ruby/lib:/opt/ruby/lib export RUBYLIB * (({csh系})) setenv RUBYLIB $HOME/ruby/lib:/opt/ruby/lib * (({MS-DOS系})) set RUBYLIB=%HOME%\ruby\lib:\opt\ruby\lib : (({RUBYLIB_PREFIX})) この環境変数は (())版、(())版、(())版、 (())版のrubyでのみ有効です。 この環境変数の値は、path1;path2 あるいは path1 path2 という形式で、 Rubyライブラリの探索パス((<組込み変数/$:>))の先頭部分 がpath1にマッチした場合に、これをpath2に置き換えます。 * (({MS-DOS系})) set RUBYLIB_PREFIX=/usr/local/lib/ruby;d:/ruby : (({RUBYSHELL})) この環境変数は (())版、(())版、(())版のrubyで のみ有効です。 ((<組込み関数/system>)) でコマンドを実行するときに使用するシェル を指定します。この環境変数が省略されていれば(({COMSPEC}))の値を 使用します。 : (({PATH})) ((<組込み関数/system>))などでコマンドを実行するときに検索するパスです。 設定されていないとき(nilのとき)は (({"/usr/local/bin:/usr/ucb:/usr/bin:/bin:."})) で検索されます。 = DJGPP 16 bit OS である DOS上で 32 bit な環境を実現する DOS エクステンダとい う奴とそのコンパイル環境(という説明でいいのかな？)。かなり古い環境だが、 今も利用者はいるらしい。 (()) 参照。 = Cygwin Win32 上で (()) をエミュレートする環境。Windows 上でまさに Unix を使っているような感覚が味わえる。GNU ユーティリティのおかげで下手な商 用 Unix よりもある意味使いやすい。Cygwin環境でコンパイルされた実行ファ イルは (({cygwin1.dll})) がリンクされ、この DLL が Unix のシステムコー ル等をエミュレートしてくれる。 Cygwin を使う人にとって本当に必要な環境が Unix なのか Windows なのかは 謎。(何事も行き過ぎはよくない。中間こそが心地よいのかもしれない) (()) を参照。 Cygwin版Rubyは、(({cygwin1.dll}))を必要とする反面、Unix版との互換性が 高いので、Unix用のスクリプトが変更なしに 動く可能性が高くて便利である。しかし、日本語パス名((-(({表}))や(({ソ}))のように2バイト目に(({\}))を含むもの-))が扱えないなど、 Cygwin 環境自体の制約を受ける。 = mswin32 VC++ で作られた ruby を mswin32版 と呼んでいる。 →(()) = mingw32 --> (()) = OS2 良く知らない。EMX というコンパイル環境(やはり gcc の port)があり、OS2 での ruby のコンパイルはこれを前提としているのかもしれない。本当によく は知らない。 = Object 全てのクラスのスーパークラス。 オブジェクトの一般的な振舞いを定義します。 == インクルードしているモジュール: * (()) == メソッド: --- self == other (({self})) と ((|other|)) が等しいかどうか判定します。 デフォルトでは (({equal?})) と同じ効果です。 このメソッドは各クラスの性質に合わせて再定義するべきです。 --- self =~ other 古いタイプの正規表現比較 (({obj =~ /RE/})) をサポートす るためのメソッドです。デフォルトは (()) と同じ働きをします。 ((-あらい 2002-01-13: 本当は違う (())-)) --- self === other このメソッドは ((<制御構造/case>)) 文での比較に用いられます。デフォルトは (()) と同じ働きをしますが、 この挙動はサブクラスで所属性のチェックを実現するため 適宜再定義されます。 --- become(obj) (()) (({self})) の内容を ((|obj|)) ですり替えます。((|obj|)) は、 (({self})) と同じクラスのインスタンスである必要があります。そうで なければ例外 (()) が発生します。 class Foo end p obj = Foo.new obj.instance_eval { @v = 1 } p obj.become(Foo.new) obj.instance_eval { p @v } => ruby 1.7.3 (2002-08-30) [i586-linux] # -:6: [BUG] Segmentation fault ruby 1.7.3 (2002-08-30) [i586-linux] (({self})) を返します。 --- class --- type レシーバのクラスを返します。 (()): type は、version 1.7 では、(()) となりました。 --- clone --- dup オブジェクトの複製を作ります。 (({clone})) は (({freeze}))、(({taint}))、特異メソッドなどの情報も 含めた完全な複製を、(({dup})) はオブジェクトの内容のみの複製を 作ります。 (({clone})) や (({dup})) は「浅い(shallow)」コピーであることに注意 してください。オブジェクト自身を複製するだけで、オブジェクトの指し ている先(たとえば配列の要素など)までは複製しません。 また複製したオブジェクトに対して obj.equal?(obj.clone) は一般に成立しませんが ((-version 1.6 では、0.equal?(0.clone) が成立してしまいます-))、 obj == obj.clone は多くの場合に成立します。 (({true})), (({false})), (({nil})), (()) オブジェクトなど を複製しようとすると例外 (()) が発生します。 (()): version 1.7 では、(()) オブジェクトなど immutable(内容不 変)であるオブジェクトを複製しようとすると例外 (()) が発 生します。 --- display([out=$defout]) オブジェクトを ((|out|)) に出力します。以下のように定義できます。 class Object def display(out=$defout) out.print to_s end end --- eql?(other) 二つのオブジェクトが等しいかどうかを判定します。このメソッドは (()) でふたつのキーが等しいかどうかを判定するのに使われます。 このメソッドを再定義した時には (()) メソッ ドも再定義しなければなりません。 (({eql?})) のデフォルトの定義は (({equal?})) と同じくオブジェクト の同一性判定になっています。 --- equal?(other) (({other})) が (({self})) 自身の時、真を返します。 このメソッドを再定義してはいけません。 --- extend(module ... ) 引数で指定したモジュールで定義されているメソッドが (({self})) の 特異メソッドとして追加されます。あるオブジェクトだけにモジュール の機能を追加したいときに使用します。 module Foo def a 'ok' end end obj = Object.new obj.extend Foo p obj.a #=> "ok" (({extend})) の機能は、「特異クラスに対する (())」 と言い替えることもできます。 (()): 引数に複数のモジュールを指定した場合、最後 の引数から逆順に extend を行います。 --- freeze オブジェクトの内容の変更を禁止します。 フリーズされたオブジェクトの変更は例外 (()) を発生させます。 --- frozen? オブジェクトの内容の変更が禁止されているときに真を返します。 --- hash オブジェクトのハッシュ値を返します。(()) クラスで オブジェクトを格納するのに用いられています。(({A.eql?(B)})) が 成立する時は必ず (({A.hash == B.hash})) も成立しなければ いけません。(({eql?}))を再定義した時には必ずこちらも合わせて 再定義してください。 デフォルトでは、(()) と同じ値をハッシュ値とし ます。ただし、(()), (()), (()) だけは組込 みのハッシュ関数が使用されます(これを変えることはできません)。 hash を定義する場合は、一様に分布する任意の整数を返すようにします (現在の実装では、返り値の内部表現を 65439 (1.7 なら 536870917) ((-あらい 2002-01-13: 素数じゃなくていいのかな？-)) で割った余りをハッシュ値とします((-あらい 2002-01-13: 本当はこれを 更に内部のテーブルサイズで割った余りが使用されます。 あらい 2002-02-24: これは素数になりました(())-))。 --- id --- __id__ --- object_id (()) 各オブジェクトに対して一意な整数を返します。あるオブジェクトに対し てどのような整数が割り当てられるかは不定です。 (({id})) メソッドの再定義に備えて別名 (({__id__})) が用意されて おり、ライブラリでは後者の利用が推奨されます。また (({__id__})) を 再定義すべきではありません。 --- inspect オブジェクトを人間が読める形式の文字列に変換します。 --- instance_eval(expr, [fname, [lineno=1]]) --- instance_eval {|obj| ... } オブジェクトのコンテキストで文字列 ((|expr|)) を評価してその結果を返 します。 ((|fname|))、((|lineno|)) が与えられた場合は、ファイル ((|fname|))、 行番号 ((|lineno|)) にその文字列があるかのようにコンパイルされ、ス タックトレース表示などのファイル名／行番号を差し替えることができま す。 ブロックが与えられた場合にはそのブロックをオブジェクトのコンテキス トで評価してその結果を返します。ブロックの引数 ((|obj|)) には (({self})) が渡されます。 オブジェクトのコンテキストで評価するとは (({self})) をそのオブジェ クトにして実行するということです。また、文字列／ブロック中でメソッ ドを定義すれば (({self})) の特異メソッドが定義されます。 ただし、ローカル変数だけは (({instance_eval})) の外側のスコープと 共有します。 ((*注*)): メソッド定義の中で instance_eval のブロックを使用してメ ソッド定義を行うと、"nested method definition" とコンパイルエラー になります。これは、現在の ruby パーサの制限です。 def foo instance_eval { def bar # <- ネストしたメソッド定義と判断される "bar" end } end # => -:4: nested method definition 文字列で渡す形式を使えば、この制限は回避できます。 def foo instance_eval %Q{ def bar "bar" end } end # foo を実行すると関数(厳密には foo のレシーバのメソッド) bar # を定義する foo p bar # => "bar" (()), (()) も参照してください。 --- instance_of?(klass) (({self})) がクラス ((|klass|)) の直接のインスタンスである時、 真を返します。(({obj.instance_of?(c)})) が成立する時には、常に (({obj.kind_of?(c)})) も成立します。 --- instance_variables オブジェクトのインスタンス変数名を文字列の配列として返します。 ((<組込み関数/local_variables>)), ((<組込み関数/global_variables>)), (()), (()), (()) も参照してください。 --- is_a?(mod) --- kind_of?(mod) (({self})) が、クラス ((|mod|)) とそのサブクラス、および モジュール ((|mod|)) をインクルードしたクラスとそのサブクラス、 のいずれかのインスタンスであるとき真を返します。 module M end class C < Object include M end class S < C end obj = S.new p obj.is_a? S # true p obj.is_a? M # true p obj.is_a? C # true p obj.is_a? Object # true p obj.is_a? Hash # false --- method(name) (({self})) のメソッド ((|name|)) をオブジェクト化した (()) オブジェクトを返します。((|name|)) は (()) または文字列で指定します。 (()) も参照してください。 --- method_missing(name, args, ... ) 呼びだされたメソッドが定義されていなかった時、Ruby がこのメソッド を呼び出します。呼び出しに失敗したメソッドの名前 ((())) とそ の時の引数が ((|name|)) と ((|arg ...|)) に渡されます。 デフォルトではこのメソッドは例外 (()) を発生させます。 --- methods --- public_methods そのオブジェクトが理解できるpublicメソッド名の一覧を配列とし て返します。 (()), (()), も参照してください。 --- nil? レシーバが (({nil})) かどうかをチェックします。 --- private_methods そのオブジェクトが理解できるprivateメソッド名の 一覧を配列として返します。 (()), も参照してください。 --- protected_methods そのオブジェクトが応答できる protected メソッド名の 一覧を文字列の配列で返します。 (()), も参照してください。 --- respond_to?(name[, priv=false]) オブジェクトが public メソッド ((|name|)) を持つとき真。 ((|name|))は (()) または文字列です。((|priv|)) が 真のときは private メソッドに対しても真を返します。 --- send(name[, args ... ]) --- send(name[, args ... ]) { .... } --- __send__(name[, args ... ]) --- __send__(name[, args ... ]) { ... } オブジェクトのメソッド ((|name|)) を、引数に ((|args|)) を 渡して呼び出します。ブロック付きで呼ばれたときはブロックも そのまま引き渡します。メソッド名 ((|name|)) は文字列か (()) です。 (({send})) が再定義された場合に備えて別名 (({__send__})) も 用意されており、ライブラリではこちらを使うべきです。また (({__send__})) は再定義すべきではありません。 (({send})), (({__send__})) は、((<クラス／メソッドの定義/呼び出し制限>)) にかかわらず任意のメソッドを呼び出せます。 --- singleton_methods([all=false]) そのオブジェクトに対して定義されている特異メソッド名の一覧を 配列として返します。 (()): 省略可能な引数 ((|all|)) に真を指定すれば 特異クラスがインクルードしているモジュールのメソッドも対象になります。 obj = Object.new module Foo def foo end end class < ["bar"] p obj.singleton_methods true #=> ["bar", "foo"] あるいは、(()) は特異クラスに対するイ ンクルードなので以下も同様になります。 obj = Object.new module Foo def foo end end obj.extend(Foo) p obj.singleton_methods #=> [] p obj.singleton_methods true #=> ["foo"] --- taint オブジェクトの「汚染マーク」をセットします。 オブジェクトの汚染に関しては((<セキュリティモデル>))を参照してください。 --- tainted? オブジェクトの「汚染マーク」がセットされている時真を返します。 オブジェクトの汚染に関しては((<セキュリティモデル>))を参照してください。 --- to_a オブジェクトを配列に変換します。普通に配列に変換できない オブジェクトは、自身のみを含む長さ 1 の配列に変換されます ((()): この挙動は将来なくなるかもしれません。1.7 では警告が出ます)。 例 p( {'a'=>1}.to_a ) # [["a", 1]] p ['array'].to_a # ["array"] p 1.to_a # [1] p 'str'.to_a # ["str"] --- to_ary オブジェクトの配列への暗黙の変換が必要なときに内部で呼ばれます。 ((-to_ary, to_hash, to_int, to_str は、説明の便宜上このページに書 いてますが、デフォルトでは (({Object})) のメソッドとしては定義され ていません-)) このメソッドが定義されたオブジェクトが単独で多重代入の右辺に 現れた場合にも呼ばれます。 class Foo def to_ary [1, 2, 3] end end a, b, c = Foo.new p [a, b, c] => [1, 2, 3] --- to_hash オブジェクトのハッシュへの暗黙の変換が必要なときに内部で呼ばれます。 --- to_int オブジェクトの整数への暗黙の変換が必要なときに内部で呼ばれます。 --- to_s オブジェクトの文字列表現を返します。 ((<組込み関数/print>)) や ((<組込み関数/sprintf>)) は文字列以外の オブジェクトが引数に渡された場合このメソッドを使って文字列に変換し ます。 --- to_str オブジェクトの文字列への暗黙の変換が必要なときに呼ばれます。 --- untaint オブジェクトの「汚染マーク」を取り除きます。汚染マークを取り 除くことによる危険性はプログラマが責任を負う必要があります。 セキュリティレベルが3以上の場合は例外 (()) を 発生します。 オブジェクトの汚染に関しては((<セキュリティモデル>))を参照してください。 == プライベートメソッド: --- initialize ユーザ定義クラスのオブジェクト初期化メソッド。このメソッドは (()) から新しく生成されたオブジェクトの初期化 のために呼び出されます。デフォルトの動作ではなにもしません。サブク ラスではこのメソッドを必要に応じて再定義されることが期待されていま す。(({initialize})) には (()) に与えられた引 数がそのまま渡されます。 また (({initialize})) という名前を持つメソッドは自動的に private に 設定されます。 --- remove_instance_variable(name) オブジェクトからインスタンス変数 ((|name|)) を取り除き、そのインス タンス変数に設定されていた値を返します。((|name|)) は (()) か文字列です。 オブジェクトがインスタンス変数 ((|name|)) を持たない場合は例外 (()) が発生します。 class Foo def foo @foo = 1 p remove_instance_variable :@foo # => 1 p remove_instance_variable :@foo # => instance variable @foo not defined (NameError) end end Foo.new.foo (()), (()) も参照してください。 --- singleton_method_added(name) 特異メソッドが追加された時にインタプリタから呼び出されます。 ((|name|)) には追加されたメソッド名が (()) で渡されます。 class Foo def singleton_method_added(name) puts "singleton method \"#{name}\" was added" end end obj = Foo.new def obj.foo end => singleton method "foo" was added 通常のメソッドの追加に対するフックには (())を使います。 --- singleton_method_removed(name) (()) 特異メソッドが (()) に より削除された時にインタプリタから呼び出されます。 ((|name|)) には削除されたメソッド名が (()) で渡されます。 class Foo def singleton_method_removed(name) puts "singleton method \"#{name}\" was removed" end end obj = Foo.new def obj.foo end class << obj remove_method :foo end => singleton method "foo" was removed 通常のメソッドの削除に対するフックには (())を使います。 --- singleton_method_undefined(name) (()) 特異メソッドが (()) または ((<クラス／メソッドの定義/undef>)) により未定義にされた時にインタプリタ から呼び出されます。 ((|name|)) には未定義にされたメソッド名が (()) で渡されます。 class Foo def singleton_method_undefined(name) puts "singleton method \"#{name}\" was undefined" end end obj = Foo.new def obj.foo end def obj.bar end class << obj undef_method :foo end obj.instance_eval {undef bar} => singleton method "foo" was undefined singleton method "bar" was undefined 通常のメソッドの未定義に対するフックには (()) を使います。 = NameError 未定義のローカル変数や定数を使用したときに発生します。 == スーパークラス: * (()) ((())) * (()) ((())) = Proc (({Proc})) はブロックをコンテキスト(ローカル変数のスコープやスタックフ レーム)とともにオブジェクト化した手続きオブジェクトです。(({Proc})) は ローカル変数のスコープを導入しないことを除いて名前のない関数のように使 えます((())は (({Proc})) ローカル の変数として使えます)。 (({Proc})) がローカル変数のスコープを保持していることは以下の例で 変数 var を参照できていることからわかります。 var = 1 $foo = Proc.new { var } var = 2 def foo $foo.call end p foo # => 2 (({Proc})) を生成したメソッドからリターンしてしまった後は (({Proc})) からの ((<制御構造/return>)), ((<制御構造/retry>)) は例外 (()) を発生させます。 def foo proc { return } end foo.call # => in `call': return from proc-closure (LocalJumpError) イテレータに対して (({Proc})) オブジェクトを `&' を指定して 渡すとイテレータブロックのように動作しますが、厳密には以下の 違いがあります((-あらい 2002-02-20: 現在 1.6、1.7 共にこの制限 はありませんが、まだ流動的なようです (())-))。 # 問題なし (1..5).each { break } # LocalJumpError proc = Proc.new { break } (1..5).each(&proc) # => break from proc-closure (LocalJumpError) これは、(({Proc})) オブジェクトがイテレータブロックとして振舞う際の制 限です。 == スーパークラス: * (()) == クラスメソッド: --- Proc.new --- Proc.new { ... } ブロックをコンテキストとともにオブジェクト化して返します。 ブロックを指定しなければ、このメソッドを呼び出したメソッドがブロッ クを伴うときに、それを (({Proc})) オブジェクトとして生成して返しま す。 def foo pr = Proc.new pr.call(1,2,3) end foo {|args| p args } # => [1, 2, 3] これは以下と同じです(厳密には引数の解釈の仕方が異なります。 (()) を参照してください)。 def foo yield(1,2,3) end foo {|args| p args } # => [1, 2, 3] 呼び出し元のメソッドがブロックを伴わなければ、例外 (()) が発生します。 def foo Proc.new end foo # => -:2:in `new': tried to create Proc object without a block (ArgumentError) from -:2:in `foo' from -:4 (({Proc.new})) は、(({Proc#initialize})) が定義されていれば オブジェクトの初期化のためにこれを呼び出します。このことを 除けば、((<組込み関数/proc>)) と同じです。 == メソッド: --- self[arg ...] --- call(arg ... ) 手続きオブジェクトを実行してその結果を返します。引数はブロックの引 数にそのまま(多重代入のルールに従い)代入されます。 --- arity (({Proc}))オブジェクトの引数の数を返します。(({self})) が引数の数 を可変長で受け取れる場合 -(最低限必要な数+1) を返します。 --- binding (()) (({Proc})) オブジェクトが保持するコンテキストを (()) オブ ジェクトで返します。 --- to_proc (()) (({self})) を返します。 --- to_s (()) (({self})) の文字列表現を返します。可能なら (({self})) を生成した ソースファイル名、行番号を含みます。 p Proc.new { true }.to_s => "#" --- yield(arg ... ) (()) (()) と同じですが、引数の数のチェックを行いません。 pr = Proc.new {|a,b,c| p [a,b,c]} pr.yield(1) #=> [1, nil, nil] pr.yield(1,2,3,4) #=> [1, 2, 3] pr.call(1) #=> wrong # of arguments (4 for 3) (ArgumentError) これは ((<メソッド呼出し/yield>)) と同じ動作です。 def foo yield(1) end foo {|a,b,c| p [a,b,c]} = Binding ローカル変数のテーブルと (({self}))、モジュールのネストなどの情報を保 持するオブジェクトのクラス。組み込み関数 ((<組込み関数/binding>)) によっ てのみ生成され、((<組込み関数/eval>)) の第 2 引数に使用します。 またトップレベルの Binding オブジェクトとして組み込み定数 ((<組込み定数/TOPLEVEL_BINDING>)) が用意されています。 == スーパークラス: * (()) = LocalJumpError スコープを出てしまった (()) からの ((<制御構造/return>)), ((<制御構造/break>)), ((<制御構造/next>)), ((<制御構造/redo>)), ((<制御構造/retry>)) で発生します。 (()) の例を参照してください。 == スーパークラス: * (()) == メソッド --- exitstatus (()) 例外 (({LocalJumpError})) を発生させた break や return に指定した 戻り値を返します。 def foo proc { return 10 } end begin foo.call rescue LocalJumpError p $!.exitstatus end => ruby 1.7.2 (2002-02-14) [i586-linux] 10 pr = proc { break 5 } def bar(&pr) pr.yield end begin bar(&pr) rescue LocalJumpError p $!.exitstatus end => ruby 1.7.2 (2002-02-14) [i586-linux] 5 = NilClass (({nil})) のクラス。偽変数(の値) (({nil})) は (({NilClass})) クラスの 唯一のインスタンスです。(({nil})) は (({false})) オブジェクトとともに 偽を表し、その他の全てのオブジェクトは真です。 == スーパークラス: * (()) == メソッド: --- self & other 常に (({false})) を返します。 --- self | other --- self ^ other ((|other|)) が真なら true を偽なら (({false})) を返します。 --- nil? 常に (({true})) を返します。 --- to_a 空の配列(({[]}))を返します。 --- to_f (()) 0.0 を返します。 --- to_i 0 を返します。 --- to_s 空文字列(({""}))を返します。 = TrueClass (({true})) のクラス。(({true})) は (({TrueClass})) クラスの唯一のイン スタンスです。(({true})) は真を表す代表のオブジェクトです。 == スーパークラス: * (()) == メソッド: --- self & other ((|other|)) が真なら (({true})) を偽なら (({false})) を返します。 --- self | other 常に (({true})) を返します。 --- self ^ other ((|other|)) が真なら (({false})) を偽なら (({true})) を返します。 = FalseClass (({false})) のクラス。(({false})) は (({FalseClass})) クラスの唯一のイ ンスタンスです。(({false})) は (({nil})) オブジェクトとともに偽を表し、 その他の全てのオブジェクトは真です。 == スーパークラス: * (()) == メソッド: --- self & other 常に (({false})) を返します。 --- self | other --- self ^ other ((|other|)) が真なら (({true})) を偽なら (({false})) を返します。 = Rubyの終了処理 Ruby はスクリプトの終端に達した場合や捕捉していない例外が発生した場 合に終了します(関数 ((<組込み関数/exit>)) や ((<組込み関数/abort>)) 、メインスレッドに対する (()) などは (()) 例外を発生させます)。終了時には以下 の処理が順に実行されます。 (1) すべてのスレッドを (()) する。 (1) Ruby の疑似シグナル SIGEXIT のハンドラが登録されていればそれを実 行する(((<組込み関数/trap>)) を参照)。 (1) ((<制御構造/END>)) ブロック(END { ... } または関数 ((<組込み関数/at_exit>)) で指定したブロック)が登録されていれば、 そのブロックを登録とは逆順に実行する。このブロックの実行中に発生 した大域脱出はそのブロックの処理を中断するが。スクリプトはまだ終 了しない。 (1) (()) により、ファイナ ライザが登録されていればそれらを実行する(実行順序は不定) ファイナライザ実行中に発生した大域脱出はそのファイナライザの処理 を中断するが、スクリプトはまだ終了しない。 (1) (()) により終了する このとき渡される終了ステータス値は終了方法によります。 例えば、 * ((<組込み関数/exit>)) に渡した引数 * (()) による例外以外は 1 * (()) を明示的に raise したときは 0 ((-(()): (()) を明示的に raise したときでも 1 で終了するようになった-)) 関数 ((<組込み関数/exit!>)) による終了は、((<_exit(2)|manual page>)) を実行するだけで、上記の処理はいずれも行われません。 = Thread Ruby のスレッドを表現するクラスです。 (({Thread})) を使うことで並行プログラミングが可能になります。スレッド はメモリ空間を共有して同時に実行される制御の流れです。ただし、現在の実 装では Ruby インタプリタは時分割でスレッドを実行しますので、スレッドを 使うことで実行速度が速くなることはありません。 プログラムの開始と同時に生成されるスレッドを((*メインスレッド*)) と呼 びます。なんらかの理由でメインスレッドが終了する時には、他の全てのスレッ ドもプログラム全体も終了します。ユーザからの割込みによって発生した例外 はメインスレッドに送られます。 スレッドの起動時に指定したブロックの実行が終了するとスレッドの実行も終 了します。ブロックの終了は正常な終了も例外などによる異常終了も含みます。 Ruby のスレッドスケジューリングは優先順位付のラウンドロビンです。一定 時間毎、あるいは実行中のスレッドが権利を放棄したタイミングでスケジュー リングが行われ、その時点で実行可能なスレッドのうち最も優先順位が高いも のにコンテキストが移ります。 : スレッドと例外 あるスレッドで例外が発生し、そのスレッド内で rescue で捕捉されなかっ た場合、通常はそのスレッドだけがなにも警告なしに終了されます。ただ しその例外で終了するスレッドを (({Thread#join})) で待っている他の スレッドがある場合、その待っているスレッドに対して、同じ例外が再度 発生します。 begin t = Thread.new do Thread.pass # メインスレッドが確実にjoinするように raise "unhandled exception" end t.join rescue p $! # => "unhandled exception" end また、以下の 3 つの方法により、いずれかのスレッドが例外によって終 了した時に、インタプリタ全体を中断させるように指定することができま す。 * 組込み変数 ((<組込み変数/$DEBUG>)) を真に設定する(デバッグモード) ruby インタプリタを (()) 付きで起動した場合も同様。 * (()) でフラグを設定する。 * (()) で指定 したスレッドのフラグを設定する。 上記3つのいずれかが設定されていた場合、インタプリタ全体が中断されます。 : スレッドの状態 個々のスレッドは、以下の実行状態を持ちます。これらの状態は (()) や (()) によって見ることができます。 p Thread.new {sleep 1} # => # : run (実行or実行可能状態) 生成されたばかりのスレッドや (()) や (()) で起こされたスレッドはこの状態です。 (()) でスレッドの終了を待っているスレッドもスレッドの 終了によりこの状態になります。 この状態のスレッドは「生きて」います。 : sleep (停止状態) (()) や (()) により停止されたスレッ ドはこの状態になります。 この状態のスレッドは「生きて」います。 : aborting (終了処理中) (()) 等で終了されるスレッドは一時的にこの状態になりま す。この状態から停止状態(stop)になることもあります。 この状態のスレッドはまだ「生きて」います。 : dead (終了状態) (()) 等で終了したスレッドはこの状態になります。この状 態のスレッドはどこからも参照されていなければ GC によりメモリ上から なくなります。 この状態のスレッドは「死んで」います。 == スーパークラス: * (()) == クラスメソッド: --- Thread.abort_on_exception いずれかのスレッドが例外によって終了した時に、インタプリタ全体を中 断させるかどうかのフラグの値を返します。 --- Thread.abort_on_exception = yes_no いずれかのスレッドが例外によって終了した時に、インタプリタ全体を中 断させるかどうかのフラグを設定します。通常あるスレッドで起こった例 外は、(()) などで検出されない限りそのスレッ ドだけをなにも警告を出さずに終了させます。 ((|yes_no|)) を返します。 --- Thread.critical --- Thread.critical = yes_no 真である間、スレッドの切替えを行いません。カレントスレッドが停止 (stop)した場合やシグナルに割り込まれた場合には、自動的に (({false})) になります。 ただし、(()) によりスレッドを生成した場合にはそ のスレッドは実行されます。また、(()) により明 示的に切替えることもできます。 ((|yes_no|)) を返します。 ((*注意*)): I/O や GC、拡張ライブラリがからむとこのフラグは無視さ れることもあります。排他制御を行うにはこのメソッドに頼らず (()) や (()) を使うべきです。 --- Thread.current 現在実行中のスレッド(カレントスレッド)を返します。 --- Thread.exit カレントスレッドの実行を終了します。 カレントスレッドを返します。 ((-あらい 2001-10-14: p (Thread.new { Thread.exit }.value) は、false を表示します。Thread.exit や Thread#kill ではス レッドの終了結果を設定していないためです (())-)) カレントスレッドが唯一のスレッドであるなら、((<組込み関数/exit>))(0) により終了します。 --- Thread.kill(thread) 指定したスレッドの実行を終了させます。既に終了しているスレッドに対 しては何もしません。 ((|thread|)) を返します。((-exit と同様 Thread の終了結果を設定しません-)) --- Thread.list 生きているスレッドのうち、実行中(run)または停止中(stop)のスレッド の配列を返します。 ((-(()): version 1.7 では、aborting 状態であるスレッド も要素に含まれます。つまり「生きている」スレッドの配列を返します-)) --- Thread.main メインスレッドを返します。 --- Thread.new([arg, ...]) { ... } --- Thread.start([arg, ...]) { ... } --- Thread.fork([arg, ...]) { ... } スレッドを生成して、ブロックの評価を開始します。 引数はそのままブロックに渡されます。スレッドの開始と同時にその スレッド固有のローカル変数に値を渡すために使用します。 生成したスレッドを返します。 例えば、以下のコードは間違いです。スレッドの実行が開始される前に 変数 i が書き変わる可能性があるからです。 for i in 1..5 Thread.start { p i } end 上の例は以下のように書き直すべきです。 for i in 1..5 Thread.start(i) {|t| p t } end --- Thread.pass 他のスレッドに実行権を譲ります。実行中のスレッドの状態を変えずに、 他の実行可能状態のスレッドに制御を移します(明示的なスケジューリン グ)。 (({nil})) を返します。 --- Thread.stop 他のスレッドから (()) メソッドで再起動されるまで、カレ ントスレッドの実行を停止します。 (({nil})) を返します。 == メソッド: --- self[name] ((|name|)) に対応したスレッドに固有のデータを取り出しま す。((|name|)) は文字列か (()) で指定します。 ((|name|)) に対応するスレッド固有データがなければ (({nil})) を返し ます。 --- self[name] = val ((|val|)) を ((|name|)) に対応するスレッド固有のデータとして格納し ます。((|name|)) は文字列か (()) で指定します。 ((|val|)) に (({nil})) を指定するとそのスレッド固有データは削除さ れます。 ((|val|)) を返します。 --- abort_on_exception そのスレッドが例外によって終了した時に、インタプリタ全体を中断する かどうかのフラグの値を返します。 --- abort_on_exception = yes_no そのスレッドが例外によって終了した時に、インタプリタ全体を中断させ るかどうかのフラグを設定します。 ((|yes_no|)) を返します。 --- alive? スレッドが「生きている」時、(({true})) を返します。 (()) が真を返すなら、このメソッドも真 です。 --- exit --- kill スレッドの実行を終了させます。 (({self})) を返します。 --- join --- join(limit) (()) スレッド (({self})) の実行が終了するまで、カレントスレッドを停止し ます。(({self})) が例外により終了していれば、その例外がカレントス レッドに対して発生します。 (({self})) を返します。 (()): 引数 limit を指定すると、limit 秒でタイム アウトし、(({nil})) を返します。 以下は、生成したすべてのスレッドの終了を待つ例です。 threads = [] threads.push(Thread.new { n = rand(5); sleep n; n }) threads.push(Thread.new { n = rand(5); sleep n; n }) threads.push(Thread.new { n = rand(5); sleep n; n }) threads.each {|t| t.join} --- key?(name) ((|name|)) に対応したスレッドに固有のデータが定義されていれば (({true})) を返します。((|name|)) は文字列か (()) で指定し ます。 --- keys (()) スレッド固有データに関連づけられたキーの配列を返します。キーは (()) で返されます。 th = Thread.current th[:foo] = 'FOO' th['bar'] = 'BAR' p th.keys #=> [:bar, :foo] --- priority スレッドの優先度を返します。優先度のデフォルト値は 0 で、この値の 大きいスレッドは小さいスレッドよりも優先度が高くなります。 --- priority = val スレッドの優先度を設定します。負の値も指定できます。 (({val})) を返します。 ((-(()): version 1.6.5 までは (({self})) を返し ていました-)) --- raise([error_type,][message][,traceback]) そのスレッドで強制的に例外を発生させます。 引数の意味については組込み関数 ((<組込み関数/raise>)) を参照してく ださい。 Thread.new { sleep 1 Thread.main.raise "foobar" } begin sleep rescue p $!, $@ end => # ["-:3"] --- run 停止状態(stop)のスレッドを再開させます。 (()) と異なりすぐにスレッドの切り替え を行います。死んでいるスレッドに対して実行すると (()) が発生します。 (({self})) を返します。 --- safe_level (({self})) のセーフレベルを返します。カレントスレッドの (({safe_level})) は、((<組込み変数/$SAFE>)) と同じです。 セーフレベルについては((<セキュリティモデル>))を参照してください。 --- status 生きているスレッドの状態を文字列 "run"、"sleep", "aborting" のいず れかで返します。正常終了したスレッドに対して (({false}))、例外によ り終了したスレッドに対して (({nil})) を返します。 ((-(()): version 1.6.5 までは、終了処理中 (aborting)のスレッドに対しては "run" を返していました-)) (()) が真を返すなら、このメソッドも真です。 --- stop? スレッドが終了(dead)あるいは停止(stop)している時、(({true})) を返 します。 --- value スレッド (({self})) が終了するまで待ち((()) と同じ)、 そのスレッドのブロックが返した値を返します。スレッド実行中に例外が 発生した場合には、その例外を再発生させます。 以下は、生成したすべてのスレッドの終了を待ち結果を出力する例です。 threads = [] threads.push(Thread.new { n = rand(5); sleep n; n }) threads.push(Thread.new { n = rand(5); sleep n; n }) threads.push(Thread.new { n = rand(5); sleep n; n }) threads.each {|t| p t.value} 最後の行で、待ち合わせを行っていることがわかりにくいと思うなら以下 のように書くこともできます。 threads.each {|t| p t.join.value} --- wakeup 停止状態(stop)のスレッドを実行可能状態(run)にします。死んでいるス レッドに対して実行すると (()) が発生します。 (({self})) を返します。 = Monitor ((<執筆者募集>)) = SystemExit (({ruby})) を終了させます。((-exitとは少し違いがあります。(())-)) == スーパークラス: * (()) = メソッド: --- status (()) ((<組込み関数/exit>)) により終了したとき、その引数(終了ステータス) を返します。 begin exit(1) rescue SystemExit p $! p $!.status end => # 1 SystemExit の例外を故意に発生させた場合の値は (({nil})) です。 begin raise SystemExit, "bogus exit" rescue SystemExit p $! p $!.status end => # nil = ObjectSpace 全てのオブジェクトを操作するためのモジュール。 == モジュール関数: --- ObjectSpace._id2ref(id) オブジェクト ID((()))からオブジェクトを得ます。 対応するオブジェクトが存在しなければ例外 (()) が発生し ます。 --- ObjectSpace.define_finalizer(obj, proc) --- ObjectSpace.define_finalizer(obj) {|id| ...} ((|obj|)) が解放されるときに実行されるファイナライザ ((|proc|)) を 登録します。同じオブジェクトについて複数回呼ばれたときは置き換えで はなく追加登録されます。 ((|proc|)) には、ファイナライザとして (()) オブジェクトを渡 します。ブロックを指定した場合は、そのブロックが ((|proc|)) になり ます(しかし、後述の問題があるのでブロックでファイナライザを登録す るのは難しいです)。 ファイナライザ ((|proc|)) には引数として ((|obj|)) の ID((())) が渡されます。 以下は、(({define_finalizer})) の使い方の悪い例です。 class Foo def initialize ObjectSpace.define_finalizer(self) { puts "foo" } end end Foo.new GC.start これは、渡された ((|proc|)) の (({self})) が ((|obj|)) を参照しつ づけるため。そのオブジェクトが GC の対象になりません。 ((<"ruby-src:ruby/lib/tempfile.rb">)) は、ファイナライザの使い方の 良い例になっています。これは、クラスのコンテキストで (()) を 生成することで上記の問題を回避しています。 class Bar def Bar.callback proc { puts "bar" } end def initialize ObjectSpace.define_finalizer(self, Bar.callback) end end Bar.new GC.start ((|proc|)) の呼び出しで発生した大域脱出(exitや例外)は無視されます。 これは、スクリプトのメイン処理が GC の発生によって非同期に中断され るのを防ぐためです。不安なうちは (()) オプションで 事前に例外の発生の有無を確認しておいた方が良いでしょう。 class Baz def initialize ObjectSpace.define_finalizer self, eval %q{ proc { raise "baz" rescue puts $! raise "baz2" puts "baz3" } }, TOPLEVEL_BINDING end end Baz.new GC.start # => baz --- ObjectSpace.each_object([class_or_module]) {|object| ...} ((|class_or_module|)) と (()) の関係にある全ての オブジェクトに対して繰り返します。引数が省略された時には全てのオブ ジェクトに対して繰り返します。 ((|class_or_module|)) に (()) や (()) を指定しても 何も繰り返しません。 繰り返した数を返します。 --- ObjectSpace.garbage_collect どこからもアクセスされなくなったオブジェクトを回収します。 (()) と同じです。 (({nil})) を返します。 --- ObjectSpace.undefine_finalizer(obj) ((|obj|)) に対するファイナライザをすべて解除します。 ((|obj|)) を返します。 以下は、ファイナライザの古いインタフェースです。使用すると警告メッセー ジが出力されます。 --- ObjectSpace.add_finalizer(proc) ((|proc|)) をファイナライザとして設定します。 (()) で指定したオブジェクトが開放され る時、そのオブジェクトの ID(c.f (()))を引数に ファイナライザが評価されます。 ((|proc|)) を返します。 このメソッドは、obsolete です。代わりに (()) を使用してください --- ObjectSpace.call_finalizer(obj) ((|obj|)) をファイナライザの対象オブジェクトとして設定します。 ((|obj|)) を返します。 このメソッドは、obsolete です。 --- ObjectSpace.finalizers 現在登録されているファイナライザの配列を返します。 このメソッドは、obsolete です。 --- ObjectSpace.remove_finalizer(proc) 指定した ((|proc|)) をファイナライザから取り除きます。 ((|proc|)) を返します。 このメソッドは、obsolete です。代わりに (()) を使用してくださ い。 = manual page (({foo(1)}))という記述はマニュアルページの参照を示します(Unixでの話)。 $ man 1 foo などとして参照します。 数字はセクション番号を示します。例えば * 1 コマンド * 2 システムコール * 3 ライブラリ関数 などと分類わけされています。各セクションの意味は (({intro(1)})) などに 説明がありますのでそちらも参照してください。 環境によってはシステムコールがライブラリ関数として実装されている 場合もあるので (({socket(2)})) が $ man 2 socket でなく $ man 3 socket の場合もあります。大抵セクションは省略して $ man socket として参照すれば良いでしょう。 詳細は (({man(1)})) を参照してください。 UNIX 環境を触れない人は * (()) * (()) * (()) * (()) * (()) * (()) などを参照してください(この他にも情報があれば教えてください)。 = セキュリティモデル RubyにはCGI等のプログラミングを安全に行うことを助ける為に、セキュリティ 機構が備わっています。 Rubyのセキュリティモデルは「オブジェクトの汚染」と「セーフレベル」という 仕組みによってなりたっています。 == オブジェクトの汚染 Rubyではオブジェクトは「汚染されている」とみなされることがあります。この しくみは大きく分けて二つの使われ方をします。 ひとつ目は、信用できない入力をもとに作られたオブジェクトを「汚染されてい る」とみなし、「危険な操作」の引数として使えないようにすることです。悪意 あるデータによって、プログラムが意図しない動作をする事を防ぐことを目的と しています。 もうひとつは、信用しているオブジェクト(汚染されていないオブジェクト)を 信用できないプログラムから守るという使い方です。セーフレベル4で汚染されて いないオブジェクトへの操作が大幅に制限されるのはこの事を意図しています。 オブジェクトの汚染に関連するメソッド : Object#taint オブジェクトを汚染する : Object#tainted? オブジェクトが汚染されている場合に真を返す : Object#untaint オブジェクトの汚染を取り除く == セーフレベル 各スレッドは固有の「セーフレベル」を持っています。セーフレベルが高くなるほ ど、行える操作は制限されます。セーフレベルはスレッドローカル変数$SAFEで 設定します。 $SAFEに関するルール * プログラム開始時の$SAFEの値は0 * 各スレッドは作られた時点での親スレッドの$SAFEの値を引き継ぐ * $SAFEの値を現在の値より小く変更する事はできない 原則として、各セキュリティレベルにはそれ以下のセキュリティレベルの制限も 適用されます。たとえばレベル1で許されない操作はレベル2でも行えません。 === レベル 0 デフォルトのセーフレベルです。 ==== 汚染されるオブジェクト * IOや環境変数、コマンドライン引数(ARGV)から得られた文字列 (環境変数PATHだけは特別) 環境変数PATHだけは例外で、値に危険なパスを含む場合のみ汚染されます。 ここでは危険なパスとは誰でも変更／書き込みが可能なパスをいいます。 ルートディレクトリから階層が順番にチェックされ、一箇所でも誰でも 変更可能な個所があればそのパスは危険とみなされます。 ==== 禁止される操作 * 特になし === レベル 1 ==== 汚染されるオブジェクト * レベル0と同様 ==== 禁止される操作 * 汚染された文字列を引数とした以下の操作 * Dir, IO, File、FileTestのクラスメソッド、メソッド * ファイルテスト演算子の使用、ファイルの更新時刻比較 * 外部コマンド実行(system, exec, ``) * eval (レベル4の説明も参照) * トップレベルへのload(第二引数を指定してラップすれば実行可能) * require * trap * 外部コマンド実行(環境変数PATHに危険なパスを含んでいる場合のみ) === レベル 2 信用しているプログラムで信用できないデータを処理する為のレベルです。 CGI等でユーザからの入力を処理するのに適しています。 ==== 汚染されるオブジェクト * レベル1と同様 ==== 禁止される操作 レベル1の制限に加え、以下の操作が禁止されます。 * Dir.chdir Dir.chroot Dir.mkdir Dir.rmdir * File.chown File.chmod File.umask File.truncate File#lstat File#chmod File#chown File#delete File#unlink File#truncate File#flock およびFileTestモジュールのメソッド * IO#ioctl, IO#fctrl * Process.fork Process.setpgid Process.setsid Process.setpriority Process.egid= Process.kill * 危険なパスからのload * 汚染された文字列を引数にしてのload(ラップされていても) * syscall * exit! * trap === レベル 3 生成される全てのオブジェクトが汚染されます。レベル4でプログラムを実行す る環境を作り上げるのに適しています。 ==== 汚染されるオブジェクト * 生成される全てのオブジェクト ==== 禁止される操作 レベル2の制限に加え、以下の操作が禁止されます。 * Object#untaint === レベル 4 信用することのできないプログラムを実行するためのレベルです。 このレベルではレベル3では禁止されている「汚染された文字列のeval」が許可 されています。(evalで実行すると危険な操作は全て禁止されているからです。) ==== 汚染されるオブジェクト * レベル3と同様 ==== 禁止される操作 レベル3の制限(上記のとおりevalは除く)に加え、以下の操作が禁止されます。 * Object#taint * トップレベルの定義の変更(autoload, load, include) * 既存のメソッドの再定義 * Objectクラスの定義の変更 * 汚染されていないクラスやモジュールの定義の変更 およびクラス変数の変更 * 汚染されていないオブジェクトの状態の変更 * 汚染されていないグローバル変数の変更 * 汚染されていないIOやFileを使用する処理 * IOへの出力 * プログラムの終了(exit, abort) (なおout of memoryでもfatalにならない) * 他のスレッドに影響が出るThreadクラスの操作 および他のスレッドのThread#[] * ObjectSpace._id2ref * 環境変数の変更 * srand == セーフレベルに関するその他の詳細 * requireは$SAFE = 0で実行される * Level 1以上では起動時に以下の違いがある * 環境変数 RUBYLIB を $: に加えない * カレントディレクトリを $: に加えない * 環境変数 RUBYOPT を処理しない * 以下のスイッチを使用できない -s -S -e -r -i -I -x (スクリプトがsetgid, setuidされている時も同様) * 標準入力からのプログラム読み込みを行わない (スクリプトがsetgid, setuidされている時も同様) * レベル3以上で作られたProcはその時点でのセーフレベルを記憶する そのProcオブジェクトが汚染されたままcallされると、 記憶していたセーフレベルで実行される。 * 汚染されたMethodオブジェクトがcallされるとレベル4で実行される * 汚染された文字列を trap/trace_var の第二引数に指定する とレベル4で実行される (()): version 1.7 では、汚染された文字列を第二引数に指定して trap/trace_var を実行するとその時点で例外 (()) が 発生する。 * レベル4以上ではout of memoryでも (()) にならない。 == 使用例 一端高くした$SAFEレベルを低く変更する事はできませんが、以下のようにスレッ ドを使うことで、プログラムの一部だけを高いセーフレベルで実行することが可 能です。 例: def safe(level) result = nil Thread.start { $SAFE = level result = yield }.join result end safe(4) { puts "hello" } # $SAFEなので例外 puts "world" # 外側は影響を受けない == 拡張ライブラリでの扱い * 拡張ライブラリではオブジェクトの汚染状態を適切に伝播させる必要があります。 * グローバルな状態を変更する場合や外部とのやりとりの前にセキュリティレベルを チェックする必要があります。 = SecurityError セキュリティ上の問題が起きたときに発生します。 ((<セキュリティモデル>)) も参照してください。 == スーパークラス: * (()) = fatal 致命的なエラー(内部的なエラー)のときに発生します。 例えば: * デッドロックが発生したとき * ((|-x|))オプションや((|-C|))オプションで指定されたディレクトリに移動 できないとき * inplace edit((()) オプション指定)できないとき などです。(({fatal})) というオブジェクトは通常の方法では見えません。 == スーパークラス: * (()) = 正規表現 * ((<正規表現/後方参照>)) * ((<正規表現/文字クラス>)) * ((<正規表現/バックトラック>)) 以下は、ruby がサポートする正規表現記号(メタ文字)の一覧です。 * \を伴わない英数字 はメタ文字ではない * \を伴う記号 はメタ文字ではない という規則があります。 以下の説明の中で「多バイト文字に対応した正規表現」とは、 ((<組込み変数/$KCODE>)) が設定されているか、あるいは明示的に漢字オプショ ン(((<リテラル/正規表現リテラル>))を参照)を指定するなどで多バイト文字 にマッチする正規表現を指します。 * (({^})) 行頭。文字列の先頭や改行文字の直後の位置にマッチします。 * (({$})) 行末。文字列の末尾や改行文字の直前の位置にマッチします。 * (({.})) 改行を除く任意の 1 文字にマッチします。正規表現オプション m (複数行 モード。((<リテラル/正規表現リテラル>))を参照)では、改行を含む任意の 1 文字にマッチします。 多バイト文字に対応した正規表現では、その 1 文字(1 バイトでなく)とマッ チします。 また、不完全な多バイト文字の一部(その文字だけでは多バイト文字かバイ ナリかASCIIか判断が付かない場合)とはマッチしません。 p /./e =~ "あ"[0,1] # => nil * (({\w})) 英数字。(({[0-9A-Za-z_]})) と同じ。 多バイト文字に対応した正規表現では、日本語のいわゆる全角文字にもマッ チします。 * (({\W})) 非英数字。(({\w})) 以外の一文字。 * (({\s})) 空白文字。(({[ \t\n\r\f]})) と同じ * (({\S})) 非空白文字。(({[ \t\n\r\f]})) 以外の一文字。 * (({\d})) 数字。(({[0-9]})) と同じ * (({\D})) 非数字 * (({\A})) 文字列先頭。(({^})) とは異なり改行の有無には影響しません。 * (({\Z})) 文字列末尾。文字列が改行で終っていればその改行の直前にマッチします。 * (({\z})) 文字列末尾。(({$})) や (({\Z})) とは異なり改行の有無には影響しません。 * (({\b})) 文字クラス指定の外では語境界 ((({\w})) と (({\W})) のあいだにマッチ)。 文字クラス指定内ではバックスペース (0x08)。 * (({\B})) 非語境界 * (({\G})) 前回マッチした箇所(の直後)にマッチ (幅を持たない)。 初回だけは先頭位置にマッチします(\Aと同じ)。 (()) や、(()) で使用できます。前回マッチし た場所の後からマッチさせたい場合に使用します。 簡単な(あまり役に立たない)例は以下。 ((-より良い例があれば、書き換えてください。役に立つ。わかりやすい が原則-)) # 先頭から3桁ずつの数値を(数値が続く限り)取り出す。 str = "123456 789" str.scan(/\G\d\d\d/) {|m| p m } * (({[ ]})) 文字クラス指定。((<正規表現/文字クラス>))を参照。 * (({*})) 直前の表現の 0 回以上の繰り返し。できるだけ長くマッチしようとする。 * (({*?})) 直前の表現の 0 回以上の繰り返し (最短一致) * (({+})) 直前の表現の 1 回以上の繰り返し * (({+?})) 直前の表現の 1 回以上の繰り返し (最短一致) * (({{m}})) * (({{m,}})) * (({{m,n}})) それぞれ直前の正規表現の * m 回 * m 回以上 * m 回以上、最大 n 回 の繰り返し。(({{,n}})) や、(({{,}})) に対するマッチは必ず失敗する。 str = "foofoofoo" p str[/(foo){1}/] # => "foo" p str[/(foo){2,}/] # => "foofoofoo" p str[/(foo){1,2}/] # => "foofoo" 正規表現 (({?})), (({*})), (({+})) はそれぞれ (({{0,1}})), (({{0,}})) (({{1,}})) と同じです。 * (({{m}?})) * (({{m,}?})) * (({{m,n}?})) それぞれ直前の正規表現の * m 回 * m 回以上 * m 回以上、最大 n 回 の繰り返し(最短一致)。 * (({?})) 直前の正規表現の 0 または 1 回の繰り返し。 * (({??})) 直前の正規表現の 0 または 1 回の繰り返し(最短一致) * (({|})) 選択 * (({( )})) 正規表現のグループ化。括弧の中の正規表現にマッチした文字列は後方参照 のために記憶されます。 * (({\1})), (({\2})) ... (({\((|n|))})) 後方参照(back reference)。((<正規表現/後方参照>))を参照。 * (({(?# )})) コメント。括弧の中の任意の文字列は無視されます。 * (({(?: )})) 後方参照を伴わないグループ化。 * (({(?= )})) 先読み(lookahead)。 パターンによる位置指定(幅を持たない) (?=re1)re2 という表現は、re1 と re2 両方にマッチするものにマッチする正規表現で す。 re1(?=re2) という表現は、後に re2 とマッチする文字列が続く、正規表現 re1 です。 p /foo(?=bar)/ =~ "foobar" # => 0 p $& # => "foo" (bar の部分の情報はない) * (({(?! )})) 否定先読み(negative lookahead)。 パターンの否定による位置指定(幅を持たない) (?!re1)re2 という表現は、re1 にマッチしないが re2 にはマッチする正規表現です。 # 000 を除く 3 桁の数字 re = /(?!000)\d\d\d/ p re =~ "000" # => nil p re =~ "012" # => 0 p re =~ "123" # => 0 # C 言語の識別子 ([A-Za-z_] で始まり、[0-9A-Za-z_] が続く文字列) /\b(?![0-9])\w+\b/ * (({(?> )})) ((<正規表現/バックトラック>))を抑止する。 この表現はまだ試験実装中です。将来なくなる可能性もありますので、 そのつもりで使ってください。特に汎用ライブラリなどで使ってはいけません。 * (({(?ixm-ixm)})) 正規表現中でのiオプション、xオプション、mオプションのon/off。オプショ ンについては((<リテラル/正規表現リテラル>))を参照。 re = /A(?i)a(?-i)A/ p re =~ "AaA" # => 0 p re =~ "AAA" # => 0 p re =~ "AAa" # => nil * (({(?ixm-ixm: )})) 括弧内のiオプション、xオプション、mオプションのon/off。括弧の範囲内 で設定 re = /A(?i:a)A/ p re =~ "AaA" # => 0 p re =~ "AAA" # => 0 p re =~ "AAa" # => nil == 後方参照 正規表現 (({\1 \2 ... \n})) は、後方参照です。((|n|)) 番目の括弧(正規 表現 (({( )})) グルーピング)にマッチした文字列にマッチします。 /((foo)bar)\1\2/ は、 /((foo)bar)foobarfoo/ と同じです。 例: re = /(foo|bar|baz)\1/ p re =~ 'foofoo' # => 0 p re =~ 'barbar' # => 0 p re =~ 'bazbaz' # => 0 p re =~ 'foobar' # => nil 対応する括弧は、後方参照よりも左側にないといけません。 対応する括弧の中に後方参照があれば常にマッチに失敗します。 また、対応する括弧がない 1 桁の後方参照も常にマッチに失敗します。 p /(\1)/ =~ "foofoofoo" # => nil p /(foo)\2/ =~ "foo\2" # => nil 2 桁以上の後方参照も指定できますが、((<リテラル/バックスラッシュ記法>)) の (({\nnn})) (8進 nnn に対応する文字)と混同しないように注意する必要が あります。数値が 1 桁なら常に後方参照です。2 桁以上の指定では、対応す る括弧がなければ 8 進コードと見なされます。 また、逆に正規表現中に 8 進で 1 桁のコードを記述するには \01 など 0 で 始める必要があります(\0 という後方参照はないので曖昧になりません)。 p /\1/ =~ "\1" # => nil # 対応する括弧のない後方参照 p /\01/ =~ "\1" # => 0 8 進コード p /\11/ =~ "\11" # => 0 8 進コード # 8 進コード (対応する括弧がないので) p /(.)\10/ =~ "1\10" # => 0 # 後方参照 (対応する括弧があるので) p /((((((((((.))))))))))\10/ =~ "aa" # => 0 # 8 進コード(ただし、"\0" + "8" になっている # \08 という 8 進コードはないので) p /(.)\08/ =~ "1\0008" # => 0 # 後方参照に続けて数字を書きたいなら括弧でグループ化して区切る # などするしかない。 p /(.)(\1)1/ =~ "111" # => 0 == 文字クラス 正規表現 (({[ ]})) は、文字クラス指定です。[] 内に列挙したいずれかの一 文字にマッチします。 例えば、/[abc]/ は、"a", "b", "c" いずれか一文字にマッチします。 ASCIIコード順で連続する文字列は間に `-' を置いて /[a-c]/ のように書 くこともできます。また、先頭が `^' であれば指定した文字以外の一文字 とマッチします。 先頭以外にある `^' はその文字そのものとマッチします。また、先頭、末 尾にある `-' は、その文字そのものとマッチします。 p /[a^]/ =~ "^" # => 0 p /[-a]/ =~ "-" # => 0 p /[a-]/ =~ "-" # => 0 p /[-]/ =~ "-" # => 0 空の文字クラスはエラーになります。 p /[]/ =~ "" p /[^]/ =~ "^" # => invalid regular expression; empty character class: /[^]/ 先頭(あるいは否定の "^" の直後)にある "]" は、文字クラスの終りではなく "]" そのものを表します。 p /[]]/ =~ "]" # => 0 p /[^]]/ =~ "]" # => nil "^", "-", "]" そして "\\"(バックスラッシュ)は、バックスラッシュでエス ケープして、その文字にマッチさせることができます。 p /[\^]/ =~ "^" # => 0 p /[\-]/ =~ "-" # => 0 p /[\]]/ =~ "]" # => 0 p /[\\]/ =~ "\\" # => 0 [] 内には文字列と同じ((<リテラル/バックスラッシュ記法>))と、 正規表現 \w, \W, \s, \S, \d, \D (これらは文字クラスの略記法です)が 使用できます。 ((- 文字クラスの中では . や * はバックスラッシュでエスケープする 必要はありません。(しても構いません。) -)) 否定による以下のような文字クラスは改行文字にもマッチすることに 注意してください(正規表現 \W,\D も同様)。 p /[^a-z]/ =~ "\n" # => 0 文字クラスの中では以下の特殊な指定が使用できますが、この機能は将来に渡っ てサポートされるとは約束されていません(なのでここでは詳細は書きません 詳細を知りたい方は (()) 等のマニュアルを参照して ください)。 [:alnum:] 数字とアルファベット 0-9a-zA-Z [:alpha:] アルファベット a-zA-Z [:blank:] 空白類 [:cntrl:] コントロール文字 [:digit:] 数字 [:graph:] 空白を除く印字可能な可視文字 [:lower:] 小文字 [:print:] 可視文字 [:punct:] 記号 [:space:] 空白文字 [:upper:] 大文字 [:xdigit:] 16進文字 例: ("[]" を含めて "[:...:]" が1文字を表していることに注意。 文字クラスの "[]" ではない) p /[[:alnum:][:cntrl:]]/ =~ "a\x01" # => 0 注: 全角文字は考慮されません。正規表現が漢字にマッチするように指定さ れていても [:alpha:] などは、全角のアルファベットとはマッチしません。 p /[[:alpha:]]/e =~ "Ａ" # => nil == バックトラック ((-(()) 以下のスレッドも参照してください。-)) (({(?> )})) という特殊な括弧で正規表現をかこむと、その括弧の中の表現に マッチした部分ではバックトラックが起こりません。その意味を例を挙げて 見てみます。 例えば通常の正規表現では p /(a*)ab/ === 'aaab' はマッチします。その過程は以下のようになります。 (1) 正規表現 (({a*})) がインデックス 0 で (({a})) みっつにマッチする (2) 正規表現 (({a})) がマッチに失敗 (3) 正規表現 (({a*})) がマッチした分を少し「あきらめさせて」、 (({a})) ふたつにマッチさせる (バックトラックする) (4) 正規表現 (({a})) が (({a})) にマッチする (5) 正規表現 (({b})) が (({b})) にマッチする しかしこの正規表現の括弧を (({(?> )})) に変えるとマッチしなくなります。 その過程は以下のようになります。 (1) 正規表現 (({a*})) がインデックス 0 で (({a})) みっつにマッチする (2) 正規表現 (({a})) がマッチに失敗 (3) (({a*})) がマッチした分をすこし減らして試したいが、 抑止指定されているのですぐに失敗する (4) 正規表現 (({a*})) がインデックス 1 で (({a})) ふたつにマッチする 以下同じように失敗して、最終的にマッチ全体が失敗します。 ひらたく言うと、通常の正規表現の基本が「欲張りマッチ」なのに対して、 (({(?> )})) は一回取ったものは絶対に離さない「超欲張りマッチ」を行います。 = String 文字列クラス。任意の長さのバイト列を扱うことができます。 このクラスのメソッドのうち名前が (({!})) で終るものは文字列の中身を 直接変更します。このような場合は (({!})) のついていない同じ名前の メソッドを使うほうが概して安全です。たとえば以下のような場合に問題に なることがあります。 def foo(arg) arg.sub!(/good/, 'bad') arg end s = 'verygoodname' p foo(s) # => 'verybadname' p s # => 'verybadname' また日本語文字列を正しく処理するためには組込み変数 ((<組込み変数/$KCODE>)) を 文字コードにあわせて設定しておく必要があります。 ((-あらい 2002-01-24: 覚書: $KCODE の影響はほとんどの場合 String よりも Regexp に対して。String に影響を与える部分として何がある かを書くこと。「Shift_JIS の 2 バイト目に \ が含まれても正しく扱う」(←これは Stringというより字句解析器)、 upcase, downcase, swapcase, capitalize, inspect, split, gsub, scan は、 $KCODE を設定すれば、日本語を意識して正しく処理する。(どのように影響 するか書くこと)-)) ((-あらい 2002-01-24: inspect は、漢字をバックスラッシュ記法の8進で表 示するか、漢字で表示するかの違い。gsub, scan は、実装の都合で漢字を意 識しているのであくまでも Regexp が漢字を認識しているのだという理解で良 いと思う。split は、split('') の処理がバイト単位か文字単位かの違い。 もうちょい調べること-)) String クラスは自身をバイト列として扱います。例えば str[1] は str の内 容がなんであれ 2 バイト目の文字コードを返します。日本語文字列に対して (バイト単位でなく)文字単位の処理を行わせたい場合は (()) を使 用します。((-jcode はもう obsolete にしようよ……あおき-)) ((-あらい 2002-01-13: 代替物がないからそれはないよね-)) == スーパークラス: * (()) == インクルードしているモジュール: * (()) * (()) == クラスメソッド: --- String.new(string) ((|string|)) と同じ内容の新しい文字列を作成して返します。 (()): 引数を省略した場合は空文字列を 生成して返します。 == メソッド: --- self + other 文字列を連結した新しい文字列を返します。 例: p 'abc' + 'def' #=> 'abcdef' --- self * times 文字列の内容を ((|times|)) 回だけ繰り返した新しい文字列を作成して 返します。 例: p "abc" * 4 #=> "abcabcabcabc" --- self % args 文字列のフォーマット。引数をフォーマット文字列((({self})))で書式化 した文字列を返します。 ((|args|)) が配列であれば sprintf(self, *args) と同じです。それ以外の場合は、 sprintf(self, args) と同じです。詳細は (())を参照してください。 p "%#x" % 10 # => "0xa" p "%#x,%#o" % [10, 10] # => "0xa,012" --- self == other --- self > other --- self >= other --- self < other --- self <= other 文字列の比較。変数 ((<組込み変数/$=>)) の値が真である時、比較はア ルファベットの大文字小文字を無視して行われます。 ((({$=}))変数はいずれ廃止されることになっています (()) を参照) --- self << other --- concat(other) 文字列 ((|other|)) の内容を (({self})) に連結します。 ((|other|)) が 0 から 255 の範囲の (()) である場合は その 1 バイトを末尾に追加します。 (({self})) を返します。 --- self =~ other 正規表現 ((|other|)) とのマッチを行います。マッチが成功すればマッ チした位置のインデックスを、そうでなければ (({nil})) を返します。 ((|other|)) が文字列であった場合にはこれを正規表現にコンパイルして (({self})) に対するマッチを行います。 いずれの場合も組込み変数 ((<組込み変数/$~>)) にマッチに関する情報 が設定されます。 ((|other|)) が正規表現でも文字列でもない場合は other =~ self を行います。 --- ~ self (({self})) を正規表現にコンパイルして、組込み変数 (({$_})) に対して マッチを行いマッチした位置のインデックスを返します。 (({$_ =~ self})) と同じです。 (({$_})) が文字列でなければ (({nil})) を返します。 (()): $_ =~ Regexp.compile(Regexp.quote(self)) と同じです。 --- self[nth] ((|nth|)) 番目のバイトを整数(文字コード)で返します(逆に文字コード から文字列を得るには (()) を使います)。 ((|nth|)) が負の場合は文字列の末尾から数えます。 ((|nth|)) が範囲外を指す場合は (({nil})) を返します。 例: p 'bar'[2] # => 114 p 'bar'[2] == ?r # => true p 'bar'[-1] # => 114 p 'bar'[3] # => nil p 'bar'[-4] # => nil --- self[nth, len] ((|nth|)) バイト番目から長さ ((|len|)) バイトの部分文字列を返しま す。((|nth|)) が負の場合は文字列の末尾から数えます。 ((|nth|)) が範囲外を指す場合は (({nil})) を返します。 --- self[substr] (({self})) が ((|substr|)) を含む場合、一致した文字列を生成して 返します。 ((-あらい 2001-11-04 実際には引数に渡したオブジェクトをその まま返してます(例を参照)。ただし、この挙動は将来代わる可能性 があります(())-)) ((|substr|)) を含まなければ (({nil})) を返します。 substr = "bar" result = "foobar"[substr] p result # => "bar" p substr.equal? result # => true (将来のリリースでは false かも # しれない。実際、version 1.7.2 # では false になる) --- self[regexp] --- self[regexp, nth] (()) ((|regexp|)) にマッチする最初の部分文字列を返します。組込み変数 ((<組込み変数/$~>)) にマッチに関する情報が設定されます。 ((|regexp|)) にマッチしない場合 (({nil})) を返します。 p "foobar"[/bar/] # => "bar" p $~.begin(0) # => 3 (()): 引数 ((|nth|)) を指定した場合は、((|regexp|)) の、((|nth|)) 番目の 括弧にマッチする最初の部分文字列を返します。((|nth|)) が 0 の場合 は、マッチした部分文字列全体を返します。マッチしなかった場合や ((|nth|)) に対応する括弧がなければ (({nil})) を返します。 p "foobar"[/bar/] # => "bar" p $~.begin(0) # => 3 p "def getcnt(line)"[ /def\s*(\w+)/, 1 ] # => "getcnt" --- self[first..last] インデックス ((|first|)) から ((|last|)) までのバイトを含む 新しい文字列を作成して返します。 . 0 1 2 3 4 5 (インデックス) -6 -5 -4 -3 -2 -1 (負のインデックス) | a | b | c | d | e | f | |<--------->| 'abcdef'[0..2] # => 'abc' |<----->| 'abcdef'[4..5] # => 'ef' |<--------->| 'abcdef'[2..4] # => 'cde' ((|last|)) が文字列の長さ以上のときは(文字列の長さ - 1)を指定 したものとみなされます。 ((|first|)) が 0 より小さいか文字列の長さより大きいとき、 および (({first > last + 1})) であるときは (({nil})) を 返します。ただし ((|first|)) および ((|last|)) のどちらか または両方が負の数のときは一度だけ文字列の長さを足して 再試行します。 例: 'abcd'[ 2 .. 1] # => "" 'abcd'[ 2 .. 2] # => "c" 'abcd'[ 2 .. 3] # => "cd" 'abcd'[ 2 .. 4] # => "cd" 'abcd'[ 2 .. -1] # => "cd" # str[f..-1] は「f 文字目から 'abcd'[ 2 .. -2] # => "c" # 文字列の最後まで」を表す慣用句 'abcd'[ 1 .. 2] # => "bc" 'abcd'[ 2 .. 2] # => "c" 'abcd'[ 3 .. 2] # => "" 'abcd'[ 4 .. 2] # => nil 'abcd'[-3 .. 2] # => "bc" 'abcd'[-4 .. 2] # => "abc" 'abcd'[-5 .. 2] # => nil --- self[first...last] 文字列先頭を 0 番目の隙間、末尾を self.length 番目の隙間として、 ((|first|)) 番目の隙間から ((|last|)) 番目の隙間までに含まれる バイト列を含んだ新しい文字列を作成して返します。 文字列と「隙間」の模式図 0 1 2 3 4 5 6 (隙間番号) -6 -5 -4 -3 -2 -1 (負の隙間番号) | a | b | c | d | e | f | |<--------->| 'abcdef'[0...3] # => 'abc' |<----->| 'abcdef'[4...6] # => 'ef' |<--------->| 'abcdef'[2...5] # => 'cde' ((|last|)) が文字列の長さよりも大きいときは文字列の長さを 指定したものとみなされます。 (({first})) が 0 より小さいか文字列の長さより大きいとき、 および (({first > last})) であるときは (({nil})) を返します。 ただし ((|first|)) と ((|last|)) のどちらかまたは両方が負の数 であるときは一度だけ文字列の長さを足して再試行します。 例: 'abcd'[ 2 ... 3] # => "c" 'abcd'[ 2 ... 4] # => "cd" 'abcd'[ 2 ... 5] # => "cd" 'abcd'[ 1 ... 2] # => "b" 'abcd'[ 2 ... 2] # => "" 'abcd'[ 3 ... 2] # => nil 'abcd'[-3 ... 2] # => "b" 'abcd'[-4 ... 2] # => "ab" 'abcd'[-5 ... 2] # => nil --- self[nth]=val ((|nth|)) 番目のバイトを文字列 ((|val|)) で置き換えます。 ((|val|)) が 0 から 255 の範囲の整数である場合、文字コード とみなしてその文字で置き換えます。 ((|val|)) を返します。 --- self[nth, len]=val ((|nth|)) バイト番目から長さ ((|len|)) バイトの部分文字 列を文字列 ((|val|)) で置き換えます。((|nth|)) が負の場 合は文字列の末尾から数えます。 ((|val|)) を返します。 --- self[substr]=val 文字列中の ((|substr|)) に一致する最初の部分文字列を文字列 ((|val|)) で置き換えます。 (({self})) が ((|substr|)) を含まない場合、例外 (()) が発生します。 ((|val|)) を返します。 --- self[regexp]=val --- self[regexp, nth]=val (()) 正規表現 ((|regexp|)) にマッチする最初の部分文字列を文字列 ((|val|)) で置き換えます。 正規表現がマッチしなければ例外 (()) が発生します。 ((|val|)) を返します。 (()): 引数 ((|nth|)) を指定した場合は、正規表現 ((|regexp|)) の ((|nth|)) 番目の括弧にマッチする最初の部分文字列を文字列 ((|val|)) で置き換えます。((|nth|)) が 0 の場合は、マッチした部分文字列全体 を ((|val|)) で置き換えます。 正規表現がマッチしない場合や ((|nth|)) に対応する括弧が なければ例外 (()) が発生します。 --- self[first..last]=val --- self[first...last]=val ((|first|)) から ((|last|)) までの部分文字列を文字列 ((|val|)) で 置き換えます。 ((|val|)) を返します。 --- self <=> other (({self})) と ((|other|)) を ASCII コード順で比較して、(({self})) が大きい時に正、等しい時に 0、小さい時に負の整数を返します。 変数 ((<組込み変数/$=>)) の値が真である時、比較は常にアルファベッ トの大文字小文字を無視して行われます。 ((({$=}))変数はいずれ廃止されることになっています (()) を参照) --- capitalize --- capitalize! 先頭の文字を(アルファベットであれば)大文字に、残りを小文字に変更します。 (({capitalize})) は変更後の文字列を生成して返します。 (({capitalize!})) は (({self})) を変更して返しますが、変更が起こら なかった場合は (({nil})) を返します。 p "foobar".capitalize # => "Foobar" (({$KCODE})) が適切に設定されていなければ、漢字コードの一部も変換 してしまいます(これは、ShiftJIS コードで起こり得ます)。 逆に、(({$KCODE})) を設定してもマルチバイト文字のアルファベット は処理しません。 # -*- Coding: shift_jis -*- $KCODE ='n' puts "帰".capitalize # => 蟻 (()), (()), (()) も参照してください。 --- casecmp(other) (()) ((|String/<=>>)) と同様に文字列の順序を比較しますが、アル ファベットの大文字小文字の違いを無視します。 このメソッドの動作は ((<組込み変数/$=>)) には影響されません。 p 'a' <=> 'A' #=> 1 p 'a'.casecmp('A') #=> 0 --- center(width) --- ljust(width) --- rjust(width) それぞれ中央寄せ、左詰め、右詰めした文字列を返します。 p "foo".center(10) # => " foo " p "foo".ljust(10) # => "foo " p "foo".rjust(10) # => " foo" 文字列の長さが ((|width|)) より長い時には元の文字列の複製を返しま す。 s = "foo" p s.center(1).id == s.id # => false --- chomp([rs]) --- chomp!([rs]) 文字列の末尾から ((|rs|)) で指定する行区切りを取り除きます。 ((|rs|))のデフォルト値は変数((<組込み変数/"$/">))の値です。 ((|rs|)) に (({nil})) を指定した場合、このメソッドは何もしません。 ((|rs|))が空文字列(パラグラフモード)の場合、末尾の連続する改行はす べて取り除かれます。 (({chomp})) は改行を取り除いた文字列を生成して返します。 (({chomp!})) は (({self})) を変更して返しますが、取り除く改行が なかった場合は (({nil})) を返します。 (()): ((|rs|)) が "\n"(デフォルト)のとき、システムによらず "\r", "\r\n", "\n" のいずれでも行区切りの文字とみなして取り除きます。 p "foo\r".chomp # => "foo" p "foo\r\n".chomp # => "foo" p "foo\n".chomp # => "foo" p "foo\n\r".chomp # => "foo\n" --- chop --- chop! 文字列の最後の文字を取り除きます(終端が"\r\n"であれば2文字取 り除きます)。 (({chop})) は最後の文字を取り除いた文字列を生成して返します。 (({chop!})) は (({self})) を変更して返しますが、取り除く文字がなかった 場合は (({nil})) を返します。 --- clone --- dup 文字列と同じ内容を持つ新しい文字列を返します。フリーズした文字列の (({clone})) はフリーズされた文字列を返しますが、(({dup})) は内容の 等しいフリーズされていない文字列を返します。 --- count(str[, str2[, ... ]]) 文字列中にある、((|str|)) に含まれる文字の数を返します。 ((|str|)) の形式は (()) と同じです。つまり、 `(({a-c}))' は (({a})) から (({c})) を意味し、(({"^0-9"})) のように 文字列の先頭が `(({^}))' の場合は指定文字以外を意味します。 `(({-}))' は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、`(({^}))' もその効果は文字列の先頭にあるときだけです。また、 `(({-}))', `(({^}))', `(({\}))' はバックスラッシュ(`(({\}))')によ りエスケープすることができます。 引数を複数指定した場合は、すべての引数の積集合を意味します。 p 'abcdefg'.count('c') # => 1 p '123456789'.count('2378') # => 4 p '123456789'.count('2-8', '^4-6') # => 4 以下はこのメソッドの典型的な使用例で、ファイルの行数を返します (ただしファイルの末尾に改行が必要です)。 n_lines = File.open("foo").read.count("\n") --- crypt(salt) (({self})) と ((|salt|)) から暗号化された文字列を生成して返します。 ((|salt|)) には英数字、ドット(.)、スラッシュ(/)から構成される、 2 バイト以上の文字列を指定します。 ((|salt|)) には、以下の様になるべくランダムな文字列を選ぶべきです。 ((-他にも(()) などがあります-)) salt = [rand(64),rand(64)].pack("C*").tr("\x00-\x3f","A-Za-z0-9./") passwd.crypt(salt) 暗号化された文字列から暗号化前の文字列 ((({self}))) を求めることは 一般に((*難しい*))とされ、(({self})) を知っている者のみが同じ暗号化 された文字列を生成できます。このことから (({self})) を知っているか どうかの認証に使うことが出来ます。 例えば UNIX パスワードの認証は以下のようにして行われます。 (この例は Etc.getpwnam で暗号化文字列が得られることを仮定しています)。 require 'etc' user = "foo" passwd = "bar" ent = Etc.getpwnam(user) p passwd.crypt(ent.passwd) == ent.passwd ((*注意*)): * crypt の処理は (()) の実装に依存しています。 従って、crypt で処理される内容の詳細や salt の与え方については、 利用環境の (()) 等を見て確認してください。 * crypt の結果は利用環境が異なると変わる場合があります。 crypt の結果を、異なる利用環境を通して使用する場合には注意 して下さい。 * 典型的な DES を使用した (()) の場合、 self の最初の 8 バイト、salt の最初の 2 バイトだけが使用されます。 --- delete(str[, str2[, ... ]]) --- delete!(str[, str2[, ... ]]) 文字列から ((|str|)) に含まれる文字を取り除きます。 ((|str|)) の形式は (()) と同じです。つまり、 `(({a-c}))' は (({a})) から (({c})) を意味し、(({"^0-9"})) のように 文字列の先頭が `(({^}))' の場合は指定文字以外を意味します。 `(({-}))' は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、`(({^}))' もその効果は文字列の先頭にあるときだけです。また、 `(({-}))', `(({^}))', `(({\}))' はバックスラッシュ(`(({\}))')によ りエスケープすることができます。 引数を複数指定した場合は、すべての引数の積集合を意味します。 p "123456789".delete("2-8", "^4-6") #=> "14569" p "123456789".delete("2378") #=> "14569" (({delete})) は変更後の文字列を生成して返します。 (({delete!})) は (({self})) を変更して返しますが、変更が起こら なかった場合は (({nil})) を返します。 --- downcase --- downcase! 文字列中のアルファベット大文字をすべて小文字に置き換えます。 (({downcase})) は変更後の文字列を生成して返します。 (({downcase!})) は (({self})) を変更して返しますが、置換が起こら なかった場合は (({nil})) を返します。 (({$KCODE})) が適切に設定されていなければ、漢字コードの一部も変換 してしまいます(これは、ShiftJIS コードで起こり得ます)。 逆に、(({$KCODE})) を設定してもマルチバイト文字のアルファベット は処理しません。 # -*- Coding: shift_jis -*- $KCODE ='n' puts "帰".downcase # => 蟻 (()), (()), (()) も参照してください。 --- dump 文字列中の非表示文字をバックスラッシュ記法に置き換えた文字列を 返します。(({str == eval(str.dump)})) となることが保証されています。 puts "abc\r\n\f\x00\b10\\\"".dump #=> "abc\r\n\f\000\01010\\\"" --- each([rs]) {|line| ... } --- each_line([rs]) {|line| ... } 文字列中の各行に対して繰り返します。行の区切りは ((|rs|)) に指定 した文字列で、そのデフォルトは変数 ((<組込み変数/"$/">)) の値です。 各 ((|line|)) には区切りの文字列も含みます。 ((|rs|)) に (({nil})) を指定すると行区切りなしとみなします。 空文字列 (({""})) を指定すると連続する改行を行の区切りとみなします (パラグラフモード)。 (({self})) を返します。 --- each_byte {|byte| ... } 文字列の各バイトに対して繰り返します。 (({self})) を返します。 --- empty? 文字列が空(つまり長さ 0)の時、真を返します。 --- gsub(pattern, replace) --- gsub!(pattern, replace) --- gsub(pattern) {|matched| .... } --- gsub!(pattern) {|matched| .... } 文字列中で ((|pattern|)) にマッチする部分((*全て*))を ((|replace|)) で 置き換えます。置換文字列 ((|replace|)) 中の (({\&})) と (({\0})) はマッチした部分文字列に、(({\1 ... \9})) は n 番 目の括弧の内容に置き換えられます。置換文字列内では (({\`}))、 (({\'}))、(({\+})) も使えます。これらは ((<組込み変数/$`>))、 ((<組込み変数/$'>))、((<組込み変数/$+>)) に対応します。 p 'abcabc'.gsub(/b/, '(\&)') #=> "a(b)ca(b)c" 引数 ((|replace|)) を省略した時にはイテレータとして動作し、 ブロックを評価した結果で置換を行います。ブロックには引数として マッチした部分文字列が渡されます。 またブロックなしの場合と違い、ブロックの中からは組込み変数 ((<$|組込み変数>)) を参照できます。 p 'abcabc'.gsub(/b/) {|s| s.upcase } #=> "aBcaBc" p 'abcabc'.gsub(/b/) { $&.upcase } #=> "aBcaBc" (({gsub})) は置換後の文字列を生成して返します。 (({gsub!})) は (({self})) を変更して返しますが、置換が起こらなかっ た場合は (({nil})) を返します。 p 'abcdefg'.gsub(/cd/, 'CD') #=> "abCDefg" str = 'abcdefg' str.gsub!(/cd/, 'CD') p str #=> "abCDefg" p 'abbbxabx'.gsub(/a(b+)/, '\1') #=> "bbbxbx" ((*注意*)): 引数 ((|replace|)) の中で ((<$|組込み変数/$1>)) を使うことはできません。この文字列が評価される時点ではまだマッチが 行われていないからです。また ((|replace|)) は (({\})) を 2 重にエ スケープしなければなりません((())参照)。 # 第二引数の指定でよくある間違い p 'abbbcd'.gsub(/a(b+)/, "#{$1}") # これは間違い p 'abbbcd'.gsub(/a(b+)/, "\1") # これも間違い p 'abbbcd'.gsub(/a(b+)/, "\\1") # これは正解 p 'abbbcd'.gsub(/a(b+)/, '\1') # これも正解 p 'abbbcd'.gsub(/a(b+)/, '\\1') # これも正解(より安全) p 'abbbcd'.gsub(/a(b+)/) { $1 } # これも正解(もっとも安全) (()) も参照してください。 (()): 1.6 以前は、((|pattern|)) が文字列の場合、 その文字列を正規表現にコンパイルしていました。1.7 以降は、その文字 列そのものがパターンになります。 --- hex 文字列を 16 進数表現と解釈して、整数に変換します。 p "10".hex # => 16 p "ff".hex # => 255 p "0x10".hex # => 16 p "-0x10".hex # => -16 接頭辞 "0x", "0X" は無視されます。(({[_0-9a-fA-F]})) 以外の 文字があればそこまでを変換対象とします。変換対象が空文字列であれば 0 を返します。 p "xyz".hex # => 0 p "10z".hex # => 16 p "1_0".hex # => 16 (()), (()), (()), ((<組込み関数/Integer>)), ((<組込み関数/Float>)) も参照してください。 逆に、数値を文字列に変換するには ((<組込み関数/sprintf>)), (()), (()) を使用します。 --- include?(substr) 文字列中に部分文字列 ((|substr|)) が含まれていれば真を返します。 ((|substr|)) が 0 から 255 の範囲の (()) の場合、文字コー ドとみなして、その文字が含まれていれば真を返します。 --- index(pattern[, pos]) 部分文字列の探索を左端から右端に向かって行います。見つかった部分文 字列の左端の位置を返します。見つからなければ (({nil})) を返します。 引数 ((|pattern|)) には探索する部分文字列の指定を文字列、文字コー ドを示す 0 から 255 の整数、正規表現のいずれかで指定します。 ((|pos|)) が与えられた時にはその位置から探索します。((|pos|)) の省 略時の値は 0 です。 p "astrochemistry".index("str") # => 1 p "character".index(?c) # => 0 p "regexpindex".index(/e.*x/, 2) # => 3 ((|pos|)) が負の場合、文字列の末尾から数えた位置から探索します。 p "foobarfoobar".index("bar", 6) # => 9 p "foobarfoobar".index("bar", -6) # => 9 (()) も参照してください。 --- insert(nth, other) (()) ((|nth|)) 番目の文字の直前に文字列 ((|other|)) を挿入します。 以下と(戻り値を除いて)同じです。 self[nth, 0] = other (({self})) を返します。 str = "foobaz" p str.insert(3, "bar") # => "foobarbaz" --- intern 文字列に対応するシンボル値((()))を返します。ナルキャラクタ ('\0')を含む文字列は (({intern})) できません(例外 (()) が発生します). シンボルに対応する文字列を得るには (()) (または(()))を使います。 p "foo".intern => :foo p "foo".intern.to_s == "foo" => true --- length --- size 文字列のバイト数を返します。 --- match(regexp) (()) ((|regexp|)).match(self) と同じです ((()) 参照)。 ((|regexp|)) が文字列の場合は、正規表現にコンパイルします。 --- next --- next! --- succ --- succ! 以下のような((*次*))の文字列を返します。 "aa".succ => "ab" "99".succ => "100" "a9".succ => "b0" "Az".succ => "Ba" "zz".succ => "aaa" (({succ!})), (({next!})) は文字列の内容を破壊的に修正します。 --- oct 文字列を 8 進文字列であると解釈して、整数に変換します。 p "10".oct # => 8 p "010".oct # => 8 p "8".oct # => 0 (({oct})) は文字列の接頭辞("0", "0b", "0B", "0x", "0X")に応じて 8 進以外の変換も行います。 p "0b10".oct # => 2 p "10".oct # => 8 p "010".oct # => 8 p "0x10".oct # => 16 整数とみなせない文字があればそこまでを変換対象とします。変換対象が 空文字列であれば 0 を返します。 ((-あらい 2002-01-14: 8 進だけは符号を許すのか。 p "-010".oct # => -8; p "-0x10".oct # => 0; p "-0b10".oct # => 0-)) p "1_0_1x".oct # => 65 (()), (()), (()), ((<組込み関数/Integer>)), ((<組込み関数/Float>)) も参照してください。 逆に、数値を文字列に変換するには ((<組込み関数/sprintf>)), (()), (()) を使用します。 --- replace(other) 文字列の内容を ((|other|)) の内容で置き換えます。 s = "foo" id = s.id s.replace "bar" p s # => "bar" p id == s.id # => true (({self})) を返します。 --- reverse --- reverse! 文字列をひっくり返します。 p "foobar".reverse # => "raboof" (({reverse})) は変更後の文字列を生成して返します。 (({reverse!})) は (({self})) を変更してそれを返します。 --- rindex(pattern[, pos]) 部分文字列の探索を右端から左端に向かって行います。見つかった部分文 字列の左端の位置を返します。見つからなければ (({nil})) を返します。 引数 ((|pattern|)) には探索する部分文字列の指定を文字列、文字コー ドを示す 0 から 255 の整数、正規表現のいずれかで指定します。 ((|pos|)) が与えられた時にはその位置から探索します。((|pos|)) の省 略時の値は (({self})).size (右端)です。 p "astrochemistry".rindex("str") # => 10 p "character".rindex(?c) # => 5 p "regexprindex".rindex(/e.*x/, 2) # => 1 ((|pos|)) が負の場合、文字列の末尾から数えた位置から探索します。 p "foobarfoobar".rindex("bar", 6) # => 3 p "foobarfoobar".rindex("bar", -6) # => 3 (()) と完全に左右が反転した動作をするわけではありま せん。探索はその開始位置を右から左にずらしながら行いますが、部分文 字列の照合は左から右に向かって行います。以下の例を参照してください。 ((-あらい 2002-01-14: ここまで書く必要あり？どうしても混乱した記述 になるなあ。必殺の例示で逃げ-)) # String#index の場合 p "foobar".index("bar", 2) # => 3 # bar <- ここから探索を行う # bar <- 右にずらしてここで見つかる # String#rindex の場合 p "foobar".rindex("bar", -2) # => 3 # bar <- ここ(右端が末尾から 2 番目)ではなく # bar <- ここから探索を行う(左端が末尾から2番目) # bar <- 左にずらしてここで見つかる --- scan(re) --- scan(re) {|s| ... } (({self})) に対して正規表現 ((|re|)) で繰り返しマッチを行い、マッ チした部分文字列の配列を返します。 p "foobar".scan(/./) # => ["f", "o", "o", "b", "a", "r"] p "foobarbazfoobarbaz".scan(/ba./) # => ["bar", "baz", "bar", "baz"] 正規表現が括弧を含む場合は、括弧で括られたパターンにマッチした部分 文字列の配列の配列を返します。 p "foobar".scan(/(.)/) # => [["f"], ["o"], ["o"], ["b"], ["a"], ["r"]] p "foobarbazfoobarbaz".scan(/(ba)(.)/) # => [["ba", "r"], ["ba", "z"], ["ba", "r"], ["ba", "z"]] ブロックを指定して呼び出した場合は、マッチした部分文字列(括弧を含 む場合は括弧で括られたパターンにマッチした文字列の配列)をブロック のパラメータとします。ブロックを指定した場合は (({self})) を返しま す。 "foobarbazfoobarbaz".scan(/ba./) {|s| p s} # => "bar" "baz" "bar" "baz" "foobarbazfoobarbaz".scan(/(ba)(.)/) {|s| p s} # => ["ba", "r"] ["ba", "z"] ["ba", "r"] ["ba", "z"] (()): 1.6 以前は、((|re|)) が文字列の場合、その 文字列を正規表現にコンパイルしていました。1.7 以降は、その文字列そ のものがパターンになります。 --- slice(nth[, len]) --- slice(substr) --- slice(first..last) --- slice(first...last) --- slice(regexp[, nth]) (()) と同じです。 (()): slice(regexp, nth) は、version 1.7 以降で 使用できます。 --- slice!(nth[, len]) --- slice!(substr) --- slice!(first..last) --- slice!(first...last) --- slice!(regexp[, nth]) 指定した範囲((()) 参照)を文字列から取り除いたう えで取り除いた部分文字列を返します。 引数が範囲外を指す場合は (({nil})) を返します。 (()): slice!(regexp, nth) は、version 1.7 以降で 使用できます。 --- split([sep[, limit]]) 文字列を ((|sep|)) で指定されたパターンによって分割して配列に格納 します。((|sep|)) が 1 バイトの文字列ならその文字を区切りとして分 割します。2 バイト以上の文字列なら正規表現にコンパイルされます。 ((|sep|)) が nil であるか、引数を省略した場合には変数 ((<組込み変数/$;>)) の値を区切り文字として使用します。 ((|sep|)) が 1 つの空白((({' '})))の時、または (({$;})) が使用され る場合でその値が (({nil})) の時には先頭の空白を除いて空白で分割を行 います。 p " a \t b \n c".split(/\s+/) # => ["", "a", "b", "c"] p " a \t b \n c".split # => ["a", "b", "c"] ($;のデフォルト値はnilです) p " a \t b \n c".split(' ') # => ["a", "b", "c"] ((|limit|)) が省略された時(または 0 の時)には配列末尾の空文字列は 取り除かれます。 ((|limit|)) が指定されて、その値が負でない時には最大 ((|limit|)) 個のフィールドに分割します。 ((|limit|)) の値が負の時には無限に大きい ((|limit|)) が指定された かのように分割します。 # limit 省略時は、0 を指定したのと同じ。配列末尾の空文字列は取り除かれる p "a,b,c,,,".split(/,/) # => ["a", "b", "c"] p "a,b,c,,,".split(/,/, 0) # => ["a", "b", "c"] # limit が 最大のフィールド数に満たない場合は最後の要素に残りすべてが入る p "a,b,c,,,".split(/,/, 3) # => ["a", "b", "c,,,"] # limit が -1 や最大のフィールド数以上の場合は最大のフィールド数を指定したのと同じ p "a,b,c,,,".split(/,/, 6) # => ["a", "b", "c", "", "", ""] p "a,b,c,,,".split(/,/, -1) # => ["a", "b", "c", "", "", ""] p "a,b,c,,,".split(/,/, 100) # => ["a", "b", "c", "", "", ""] ((|sep|)) で指定されたパターンが空文字列とマッチする場合は文字列が 1 文字ずつに分割されます(((<組込み変数/$KCODE>)) が適切に設定されて いれば漢字を認識して文字単位で分割します)。例えば: p 'hi there'.split(/ */).join(':') # => "h:i:t:h:e:r:e" ((|sep|)) で指定されたパターンに括弧が含まれている場合には、各括弧 のパターンにマッチした文字列も配列に含まれます。括弧が複数ある場合 は、マッチしたものだけが配列に含まれます。例えば: p '1-10,20'.split(/([-,])/) # => ["1", "-", "10", ",", "20"] p '1-10,20'.split(/(-)|(,)/) # => ["1", "-", "10", ",", "20"] (()): 1.6 以前は、((|sep|)) が 2 文字以上の文字 列の場合、その文字列を正規表現にコンパイルしていました。1.7 以降は、 その文字列そのものがパターンになります。 --- squeeze([str[,str2[, ... ]]]) --- squeeze!([str[,str2[, ... ]]]) ((|str|)) に含まれる同一の文字の並びをひとつにまとめます。 ((|str|)) の形式は (()) と同じです。つまり、 `(({a-c}))' は (({a})) から (({c})) を意味し、(({"^0-9"})) のように 文字列の先頭が `(({^}))' の場合は指定文字以外を意味します。 `(({-}))' は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、`(({^}))' もその効果は文字列の先頭にあるときだけです。また、 `(({-}))', `(({^}))', `(({\}))' はバックスラッシュ(`(({\}))')によ りエスケープすることができます。 引数を複数指定した場合は、すべての引数の積集合を意味します。 p "112233445566778899".squeeze =>"123456789" p "112233445566778899".squeeze("2-8") =>"11234567899" p "112233445566778899".squeeze("2-8", "^4-6") =>"11234455667899" p "112233445566778899".squeeze("2378") =>"11234455667899" (({squeeze})) は変更後の文字列を生成して返します。 (({squeeze!})) は (({self})) を変更して返しますが、変更が起こらな かった場合は (({nil})) を返します。 --- strip --- strip! --- lstrip (()) --- lstrip! (()) --- rstrip (()) --- rstrip! (()) 先頭と末尾の空白(whitespace)を取り除きます。 (({strip})) は変更後の文字列を生成して返します。 (({strip!})) は (({self})) を変更して返しますが、取り除く空白が なかった場合は (({nil})) を返します。 (()): (({lstrip})) は先頭部分だけ、(({rstrip})) は末尾部分だけの空白を取 り除きます。 --- sub(pattern, replace) --- sub!(pattern, replace) --- sub(pattern) {|matched| ... } --- sub!(pattern) {|matched| ... } 文字列中で ((|pattern|)) に((*最初に*))マッチする部分を ((|replace|)) で 置き換えます。 ブロックを指定して呼び出された時には、最初にマッチした部分をブロッ クを評価した値で置き換えます。 (({sub})) は置換後の文字列を生成して返します。 (({sub!})) は (({self})) を変更して返しますが、置換が起こら なかった場合は (({nil})) を返します。 マッチを一度しか行わない点を除けば (()) と同じです。 (()): 1.6 以前は、((|pattern|)) が文字列の場合、 その文字列を正規表現にコンパイルしていました。1.7 以降は、その文字 列そのものがパターンになります。 --- sum([bits=16]) 文字列の ((|bits|)) ビットのチェックサムを計算します。 以下と同じです。 sum = 0 str.each_byte {|c| sum += c} sum = sum & ((1 << bits) - 1) if bits != 0 例えば以下のコードで System V の (()) コマンドと 同じ値が得られます。 sum = 0 while gets sum += $_.sum end sum %= 65536 --- swapcase --- swapcase! 全ての大文字を小文字に、小文字を大文字に変更します。 (({swapcase})) は置換後の文字列を生成して返します。 (({swapcase!})) は (({self})) を変更して返しますが、置換が起こら なかった場合は (({nil})) を返します。 (({$KCODE})) が適切に設定されていなければ、漢字コードの一部も変換 してしまいます(これは、ShiftJIS コードで起こり得ます)。 逆に、(({$KCODE})) を設定してもマルチバイト文字のアルファベット は処理しません。 # -*- Coding: shift_jis -*- $KCODE ='n' puts "蟻".swapcase # => 帰 (()), (()), (()) も参照してください。 --- to_f 文字列を 10 進数表現と解釈して、浮動小数点数 (()) に変換します。 p "10".to_f # => 10.0 p "10e2".to_f # => 1000.0 p "1e-2".to_f # => 0.01 p ".1".to_f # => 0.1 p "nan".to_f # => NaN (ruby 1.7 feature: => 0.0) p "INF".to_f # => Infinity (ruby 1.7 feature: => 0.0) p "-Inf".to_f # => -Infinity (ruby 1.7 feature: => -0.0) p (("10" * 1000).to_f) # => Infinity (ruby 1.7 feature: => out of range (ArgumentError) p "0xa.a".to_f # => 10.625 # 16 進も許される(システム依存) # (ruby 1.7 feature: => 0.0) p " \n10".to_f # => 10.0 # 先頭の空白は無視される p "1_0_0".to_f # => 1.0 # `_' は数値要素とみなされない # (ruby 1.7 feature: => 100.0) p "".to_f # => 0.0 浮動小数点数とみなせなくなるところまでを変換対象とします。 変換対象が空文字列であれば 0.0 を返します。 ((-あらい 2002-01-14: String#to_f の現在の実装は (()) の呼び出しです。すべてのシステムで、ま た将来にわたって例のとおりの動作になるかどうかは確認してません-)) ((-(()): strtod(3) に依存しなくなりました-)) (()), (()), (()), ((<組込み関数/Integer>)), ((<組込み関数/Float>)) も参照してください。 逆に、数値を文字列に変換するには ((<組込み関数/sprintf>)), (()), (()) を使用します。 --- to_i --- to_i(base) (()) 文字列を 10 進数表現と解釈して、整数に変換します。 p " 10".to_i # => 10 p "010".to_i # => 10 p "-010".to_i # => -10 整数とみなせない文字があればそこまでを変換対象とします。変換対象が 空文字列であれば 0 を返します。 p "0x11".to_i # => 0 (()), (()), (()), ((<組込み関数/Integer>)), ((<組込み関数/Float>)) も参照してください。 逆に、数値を文字列に変換するには ((<組込み関数/sprintf>)), (()), (()) を使用します。 (()): 基数を指定することでデフォルトの 10 進以外に 2, 8, 16 進数への変換 を行うことができます。これら以外の引数を指定した場合、例外 (()) が発生します。 --- to_s --- to_str (({self})) を返します。 --- tr(search, replace) --- tr!(search, replace) 文字列の中に ((|search|)) 文字列に含まれる文字が存在したら、 それを ((|replace|)) 文字列の対応する文字に置き換えます。 ((|search|)) の形式は (()) と同じです。つまり、 `(({a-c}))' は (({a})) から (({c})) を意味し、(({"^0-9"})) のように 文字列の先頭が `(({^}))' の場合は指定文字以外が置換の対象になります。 ((|replace|)) に対しても `(({-}))' による範囲指定が可能です。 例えば、(()) を (({tr})) で書くと、 p "foo".tr('a-z', 'A-Z') => "FOO" となります。 `(({-}))' は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、`(({^}))' もその効果は文字列の先頭にあるときだけです。また、 `(({-}))', `(({^}))', `(({\}))' はバックスラッシュ(`(({\}))')によ りエスケープすることができます。 ((|replace|)) の範囲が ((|search|)) の範囲よりも小さい場合は、 ((|replace|)) の最後の文字が無限に続くものとして扱われます。 (({tr})) は置換後の文字列を生成して返します。 (({tr!})) は (({self})) を変更して返しますが、置換が起こら なかった場合は (({nil})) を返します。 --- tr_s(search, replace) --- tr_s!(search, replace) 文字列の中に ((|search|)) 文字列に含まれる文字が存在したら、 ((|replace|)) 文字列の対応する文字に置き換えます。さらに、 置換した部分内に同一の文字の並びがあったらそれを 1 文字に圧縮します。 ((|search|)) の形式は (()) と同じです。つまり、 `(({a-c}))' は (({a})) から (({c})) を意味し、(({"^0-9"})) のように 文字列の先頭が `(({^}))' の場合は指定文字以外が置換の対象になります。 ((|replace|)) に対しても `(({-}))' による範囲指定が可能です。 p "foo".tr_s('a-z', 'A-Z') => "FO" `(({-}))' は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、`(({^}))' もその効果は文字列の先頭にあるときだけです。また、 `(({-}))', `(({^}))', `(({\}))' はバックスラッシュ(`(({\}))')によ りエスケープすることができます。 ((|replace|)) の範囲が ((|search|)) の範囲よりも小さい場合、 ((|replace|)) の最後の文字が無限に続くものとして扱われます。 (({tr_s})) は置換後の文字列を生成して返します。 (({tr_s!})) は (({self})) を変更して返しますが、置換が起こら なかった場合は (({nil})) を返します。 ((*注意*)): このメソッドと (({tr(search, replace).squeeze(replace)})) とでは挙動が異なります。tr と squeeze の組みあわせが置換後の文字列全体を squeeze の対象にするのに対して、(({tr_s})) は((*置換された部分だけ*))を squeeze の対象とします。 p "foo".tr_s("o", "f") # => "ff" p "foo".tr("o", "f").squeeze("f") # => "f" --- unpack(template) パックされた (おそらくは (()) で生成された) 文字列を ((|template|)) 文字列にしたがってアンパックし、それらの要 素を含む配列を返します。((|template|)) 文字列のフォーマットについ ては(())を参照してください。 --- upcase --- upcase! ASCII 文字列の範囲内でアルファベットを全て大文字にします (({upcase})) は置換後の文字列を生成して返します。 (({upcase!})) は (({self})) を変更して返しますが、置換が起こら なかった場合は (({nil})) を返します。 (({$KCODE})) が適切に設定されていなければ、漢字コードの一部も変換 してしまいます(これは、ShiftJIS コードで起こり得ます)。 逆に、(({$KCODE})) を設定してもマルチバイト文字のアルファベット は処理しません。 # -*- Coding: shift_jis -*- $KCODE ='n' puts "蟻".upcase # => 帰 (()), (()), (()) も参照してください。 --- upto(max) {|s| ... } (({self})) から始めて ((|max|)) まで「次の文字列」を順番にブロックに 与えて繰り返します。「次」の定義については (()) を 参照してください。 このメソッドは文字列の (()) の内部で使用されます。 ((-あらい 2002-01-14: といっても、このメソッドを再定義しても、 Range#each の挙動は変わらない。あくまでも重要なのは (())の方-)) たとえば以下のコードは (({a, b, c, ... z,aa, ... az, ..., za})) を 出力します。((-あらい 2002-01-14: "c" > "ba" であることに注意-)) ("a" .. "za").each do |str| puts str end = Rubyの文法 * ((<字句構造>)) * ((<字句構造/識別子>)) * ((<字句構造/コメント>)) * ((<字句構造/埋め込みドキュメント>)) * ((<字句構造/予約語>)) * ((<プログラム>)) * ((<プログラム/式>)) * ((<プログラム/プログラムの終り>)) * ((<変数と定数>)) * ((<変数と定数/ローカル変数>)) * ((<変数と定数/インスタンス変数>)) * ((<変数と定数/クラス変数>)) * ((<変数と定数/グローバル変数>)) * ((<変数と定数/疑似変数>)) * ((<変数と定数/定数>)) * ((<変数と定数/定数参照の優先順位>)) * ((<リテラル>)) * ((<リテラル/数値リテラル>)) * ((<リテラル/文字列リテラル>)) * ((<リテラル/バックスラッシュ記法>)) * ((<リテラル/式展開>)) * ((<リテラル/コマンド出力>)) * ((<リテラル/ヒアドキュメント (行指向文字列リテラル)>)) * ((<リテラル/正規表現>)) * ((<リテラル/配列式>)) * ((<リテラル/ハッシュ式>)) * ((<リテラル/範囲オブジェクト>)) * ((<リテラル/シンボル>)) * ((<リテラル/%記法>)) * ((<演算子式>)) * ((<演算子式/代入>)) * ((<演算子式/自己代入>)) * ((<演算子式/多重代入>)) * ((<演算子式/範囲式>)) * ((<演算子式/and>)) * ((<演算子式/or>)) * ((<演算子式/not>)) * ((<演算子式/条件演算子>)) * ((<制御構造>)) * ((<制御構造/条件分岐>)) * ((<制御構造/if>)) * ((<制御構造/if 修飾子>)) * ((<制御構造/unless>)) * ((<制御構造/unless 修飾子>)) * ((<制御構造/case>)) * ((<制御構造/繰り返し>)) * ((<制御構造/while>)) * ((<制御構造/while 修飾子>)) * ((<制御構造/until>)) * ((<制御構造/until修飾子>)) * ((<制御構造/for>)) * ((<制御構造/break>)) * ((<制御構造/next>)) * ((<制御構造/redo>)) * ((<制御構造/retry>)) * ((<制御構造/例外処理>)) * ((<制御構造/raise>)) * ((<制御構造/begin>)) * ((<制御構造/rescue修飾子>)) * ((<制御構造/その他>)) * ((<制御構造/return>)) * ((<制御構造/BEGIN>)) * ((<制御構造/END>)) * ((<メソッド呼出し>)) * ((<メソッド呼出し/super>)) * ((<メソッド呼出し/イテレータ>)) * ((<メソッド呼出し/yield>)) * ((<クラス／メソッドの定義>)) * ((<クラス／メソッドの定義/クラス定義>)) * ((<クラス／メソッドの定義/特異クラス定義>)) * ((<クラス／メソッドの定義/モジュール定義>)) * ((<クラス／メソッドの定義/メソッド定義>)) * ((<クラス／メソッドの定義/メソッドの評価>)) * ((<クラス／メソッドの定義/特異メソッド定義>)) * ((<クラス／メソッドの定義/クラスメソッドの定義>)) * ((<クラス／メソッドの定義/呼び出し制限>)) * ((<クラス／メソッドの定義/定義に関する操作>)) * ((<クラス／メソッドの定義/alias>)) * ((<クラス／メソッドの定義/undef>)) * ((<クラス／メソッドの定義/defined?>)) = 字句構造 * ((<字句構造/識別子>)) * ((<字句構造/コメント>)) * ((<字句構造/埋め込みドキュメント>)) * ((<字句構造/予約語>)) Rubyの現在の実装はASCIIキャラクタセットを用いています。アル ファベットの大文字と小文字は区別されます。識別子と一部のリテ ラルの途中を除いては任意の場所に空白文字やコメントを置くこと ができます。空白文字とはスペース、タブ、垂直タブ、バックスペー ス、キャリッジリターン、改ページです。改行は行が明らかに次の 行に継続する時だけ、空白文字として、それ以外では文の区切りと して解釈されます。 == 識別子 例: foobar ruby_is_simple Rubyの識別子は英文字またはアンダースコア((({'_'})))か ら始まり、英文字、アンダースコア((({'_'})))または数字 からなります。識別子の長さに制限はありません。 == コメント 例: # this is a comment line スクリプト言語の習慣にならい、文字列中や数値リテラル `(({?#}))' 以外の (({#}))から行末までをコメントと見なします。 == 埋め込みドキュメント 例: =begin the everything between a line beginning with `=begin' and that with `=end' will be skipped by the interpreter. =end Rubyのソースコードにドキュメントを埋め込む事ができます。文が 始まる部分の行頭の(({=begin}))から、(({=end}))で始まる行までが 埋め込みドキュメントです。Rubyインタプリタとしては内容に縛りは かけませんが、通常は(())形式でドキュメントを埋め込むことを 期待しています。 == 予約語 予約語は以下のものです。 BEGIN class ensure nil self when END def false not super while alias defined for or then yield and do if redo true begin else in rescue undef break elsif module retry unless case end next return until 予約語はクラス名、変数名などに用いることはできません。ただし 接頭辞(({$})), (({@}))、(({@@}))が先頭についたものは予約語 とは見なされません。また、(({def})) のあとやメソッド呼び出しの ピリオドのあとなどメソッド名であるとはっきり分かる場所では メソッド名として用いることができます。 = プログラム * ((<プログラム/式>)) * ((<プログラム/プログラムの終り>)) プログラムは((<プログラム/式>))を並べたものです。式と式の間はセミコロ ン(;)または改行で区切ります。ただし、バックスラッシュに続く改行は文 の区切りにならず、次の行へ継続します。 例: print "hello world!\n" == 式 例: true (1+2)*3 foo() if test then ok else ng end 式は括弧によってグルーピングすることができます。 == プログラムの終り Rubyインタプリタはプログラムを読みこんでいる際に以下のものに出あうとそこ で読みこみを終了します。 * ファイルの終り(文字列をevalしている場合は文字列の終り) * (({^D}))(コントロールD) 、(({^Z}))(コントロールZ) * (({__END__}))のみの行(前後に空白があると認識されません) = 変数と定数 * ((<変数と定数/ローカル変数>)) * ((<変数と定数/インスタンス変数>)) * ((<変数と定数/クラス変数>)) * ((<変数と定数/グローバル変数>)) * ((<変数と定数/疑似変数>)) * ((<変数と定数/定数>)) * ((<変数と定数/定数参照の優先順位>)) Ruby の変数と定数の種別は変数名の最初の一文字によって、 ローカル変数、 インスタンス変数、 クラス変数、 グローバル変数、 定数 のいずれかに区別されます。 通常の変数の二文字目以降は英数字または (({_}))ですが、システム変数の一部には 「`(({$}))'+1文字の記号」という変数があります(((<組込み変数>))を参照)。変数名 の長さにはメモリのサイズ以外の制限はありません。 == ローカル変数 例: foobar 小文字または`(({_}))'で始まる識別子はローカル変数また はメソッド呼出しです。ローカル変数スコープ(クラス、モジュー ル、メソッド定義の本体)における小文字で始まる識別子への最初 の代入はそのスコープに属するローカル変数の宣言になります。宣 言されていない識別子の参照は引数の無いメソッド呼び出しとみな されます。 ローカル変数のスコープは、((*宣言した位置から*))その変数が宣 言されたブロック、メソッド定義、またはクラス/モジュール定義 の終りまでです。寿命もそのブロックの終りまで(トップレベルの ローカル変数はプログラムの終了まで)ですが、例外としてブロッ クが手続きオブジェクト化された場合は、そのオブジェクトが消滅 するまで存在します。同じスコープを参照する手続きオブジェクト 間ではローカル変数は共有されます。 # (A) の部分はスコープに入らない 2.times { p defined?(v) # (A) v = 1 # ここ(宣言開始)から p v # ここ(ブロックの終り)までが v のスコープ } # => nil 1 nil <- これが nil であることに注意 1 宣言は、例え実行されなくても宣言とみなされます。 v = 1 if false # 代入は行われないが宣言は有効 p defined?(v) # => "local-variable" p v # => nil またあまり推奨はされませんが ((<-K|Rubyの起動/-Kc>)) オプションを指定 すれば日本語文字の識別子も使用でき、それはローカル変数とみなされます。 == インスタンス変数 例: @foobar `(({@}))'で始まる変数はインスタンス変数であり、特定の オブジェクトに所属しています。インスタンス変数はそのクラスま たはサブクラスのメソッドから参照できます。初期化されていない インスタンス変数を参照した時の値は(({nil}))です。 == クラス変数 例: class Foo @@foo = 1 def bar puts @@foo end end (({@@}))で始まる変数はクラス変数です。クラス変数はクラス定義 の中で定義され、クラスの特異メソッド、インスタンスメソッドなどから参照／ 代入ができます。 クラス変数と((<変数と定数/定数>))の違いは以下の通りです。 * 再代入可能(定数は警告を出す) * クラスの外から直接参照できない(継承されたクラスからは参照／代入可能) クラス変数はクラス自身のインスタンス変数とは以下の点で異なります。 * サブクラスから参照／代入が可能 * インスタンスメソッドから参照／代入が可能 クラス変数は、そのクラスやサブクラス、それらのインスタンスで共有される グローバル変数であるとみなすことができます。 class Foo @@foo = 1 end class Bar < Foo p @@foo += 1 # => 2 end class Baz < Bar p @@foo += 1 # => 3 end モジュールで定義されたクラス変数(モジュール変数)は、そのモジュールをイ ンクルードしたクラス間でも共有されます。 module Foo @@foo = 1 end class Bar include Foo p @@foo += 1 # => 2 end class Baz include Foo p @@foo += 1 # => 3 end == グローバル変数 例: $foobar $/ `(({$}))'で始まる変数はグローバル変数で、プログラムの どこからでも参照できます(その分、利用には注意が必要です)。 グローバル変数には宣言は必要ありません。 初期化されていないグローバル変数を参照した時の値は (({nil}))です。 == 疑似変数 通常の変数以外に疑似変数と呼ばれる特殊な変数があります。 : (({self})) 現在のメソッドの実行主体 : (({nil})) (())クラスの唯一のインスタンス : (({true})) (())クラスの唯一のインスタンス。真の代表値 : (({false})) (())クラスの唯一のインスタンス。nilとfalseは偽を表します。 : (({__FILE__})) 現在のソースファイル名 : (({__LINE__})) 現在のソースファイル中の行番号 疑似変数の値を変更することはできません。 擬似変数へ代入すると文法エラーになります。 == 定数 例: FOOBAR アルファベット大文字 ((({[A-Z]}))) で始まる識別子は定数です。 定数の定義 (と初期化) は代入によって行われますが、メソッドの 中では定義できません。一度定義された定数に再び代入を行おうと すると警告メッセージが出ます。定義されていない定数にアクセス すると例外 (()) が発生します。 定数はその定数が定義されたクラス/モジュール定義の中(メソッド 本体やネストしたクラス/モジュール定義中を含みます)、クラスを 継承しているクラス、モジュールをインクルードしているクラスま たはモジュールから参照することができます。クラス定義の外で定 義された定数は (()) に所属することになります。 例: class Foo FOO = 'FOO' # クラス Foo の定数 FOO を定義(Foo::FOO) end class Bar < Foo BAR = 'BAR' # クラス Bar の定数 BAR を定義(Bar::BAR) # 親クラスの定数は直接参照できる p FOO # => "FOO" class Baz # ネストしたクラスはクラスの継承関係上は無関係であるがネス # トの外側の定数も直接参照できる p BAR # => "BAR" end end また((<クラス／メソッドの定義/クラス定義>))式はクラスオブジェクトの生 成を行うと同時に、名前がクラス名である定数にクラスオブジェクトを代入す る動作をします。クラス名を参照することは文法上は定数を参照していること になります。 class C end p C # => C あるクラスまたはモジュールで定義された定数を外部から参照する ためには`(({::}))'演算子を用います。また(({Object}))クラスで 定義されている定数(トップレベルの定数と言う)を確実に参照する ためには左辺無しの`(({::}))'演算子が使えます。 ただしこれらの `(({::}))' 演算子を用いて定数に代入すること はできません。 例: module M I = 35 class C end end p M::I #=> 35 p M::C #=> M::C p ::M #=> M M::NewConst = 777 # error--> parse error === 定数参照の優先順位 親クラスとネストの外側のクラスで同名の定数が定義されているとネストの外 側の定数の方を先に参照します。つまり、定数参照時の定数の探索順序は、最 初にネスト関係を外側に向かって探索し、次に継承関係を上位に向かって探索 します。 例: class Foo CONST = 'Foo' end class Bar CONST = 'Bar' class Baz < Foo p CONST # => "Bar" 外側の定数 # この場合、親クラスの定数は明示的に指定しなければ見えない p Foo::CONST # => "Foo" end end トップレベルの定数定義はネストの外側とはみなされません。したがってトッ プレベルの定数は、継承関係を探索した結果で参照されるので優先順位は低い と言えます。 例: class Foo CONST = 'Foo' end CONST = 'Object' class Bar < Foo p CONST # => "Foo" end # 以下のように明示的にネストしていれば規則通り Object の定数 # (ネストの外側)が先に探索される class Object class Bar < Foo p CONST # => "Object" end end 上位のクラス(クラスの継承関係上、およびネストの関係上の上位クラス)の定 数と同名の定数(下の例で CONST) に代入を行うと、上位の定数への代入では なく、そのクラスの定数の定義になります。 例: class Foo CONST = 'Foo' end class Bar < Foo p CONST # => "Foo" CONST = 'Bar' # Bar の定数 CONST を*定義* p CONST # => "Bar" (Foo::CONST は隠蔽される) p Foo::CONST # => "Foo" (:: 演算子で明示すれば見える) end = リテラル * ((<リテラル/数値リテラル>)) * ((<リテラル/文字列リテラル>)) * ((<リテラル/バックスラッシュ記法>)) * ((<リテラル/式展開>)) * ((<リテラル/コマンド出力>)) * ((<リテラル/ヒアドキュメント (行指向文字列リテラル)>)) * ((<リテラル/正規表現リテラル>)) * ((<リテラル/配列式>)) * ((<リテラル/ハッシュ式>)) * ((<リテラル/範囲オブジェクト>)) * ((<リテラル/シンボル>)) * ((<リテラル/%記法>)) 数字の1や文字列"hello world"のようにRubyのプログラムの中に直接 記述できる値の事をリテラルといいます。 == 数値リテラル : (({123})) : (({0d123})) (()) 整数 : (({-123})) 符号つき整数 (()) : (({123.45})) 浮動小数点数 : (({1.2e-3})) 浮動小数点数 : (({0xffff})) 16進整数 : (({0b1011})) 2進整数 : (({0377})) : (({0o377})) (()) 8進整数 : (({?a})) 文字(({a}))のコード(97) (()): 空白類を指定する場合は、?\s, ?\t などとする 必要があります。 : (({?\C-a})) コントロール a のコード(1) : (({?\M-a})) メタ a のコード(225) : (({?\M-\C-a})) メタ-コントロール a のコード(129) (({?})) 表現では全ての((<リテラル/バックスラッシュ記法>))が有効です。 文字コード以外の数値リテラルには、`(({_}))' を含めることができます。 ruby インタプリタは `(({_}))' を単に無視し、特別な解釈は何もしません。 これは、大きな数値の桁数がひと目でわかるように記述するのに便利です。 リテラルの最初と、最後には (({_})) を書くことはできません。(リテラルの 前(符号(+,-)の直後を含む)に (({_}))を置くとローカル変数やメソッド呼び 出しと解釈されます) ((-(()): 将来(1.6.7 から)、0x などの prefix の直後な どに指定することはできなくなります。また、(({_})) を連続して書いてもエ ラーになります。他、細かい部分でこのあたりの規則は見直され統一されまし た。たぶん-)) 1_000_000_000 => 1000000000 0xffff_ffff => 0xffffffff == 文字列リテラル 例: "this is a string expression\n" 'this is a string expression\n' %q!I said, "You said, 'She said it.'"! %!I said, "You said, 'She said it.'"! %Q('This is it.'\n) 文字列はダブルクォートまたはシングルクォートで囲まれています。 ダブルクォートで囲まれた文字列ではバックスラッシュによるエス ケープと((<リテラル/式展開>))(後述)が有効になります。シングルクォートで囲ま れた文字列では、(({\\}))(バックスラッシュそのもの)と (({\'}))(シングルクォート)、行末の(({\}))(改行を無視します) を除いて文字列の中身の解釈は行われません。 空白を間に挟んだ文字列リテラルは、コンパイル時に1つの文字列 リテラルと見倣されます。 p "foo" "bar" => "foobar" ((<リテラル/%記法>)) による別形式の文字列表現もあります。 === バックスラッシュ記法 : (({\t})) タブ(0x09) : (({\n})) 改行(0x0a) : (({\r})) キャリッジリターン(0x0d) : (({\f})) 改ページ(0x0c) : (({\b})) バックスペース (0x08) : (({\a})) ベル (0x07) : (({\e})) エスケープ (0x1b) : (({\s})) 空白 (0x20) : (({\nnn})) 8 進数表記 (n は 0-7) : (({\xnn})) 16 進数表記 (n は 0-9,a-f) : (({\cx})) : (({\C-x})) コントロール文字 (x は ASCII 文字) : (({\M-x})) メタ x (c | 0x80) : (({\M-\C-x})) メタ コントロール x : (({\x})) 文字 x そのもの 文字列式は評価されるたびに毎回新しい文字列オブジェクトを生成 します。 === 式展開 例: ($ruby = "RUBY"の場合) "my name is #{$ruby}" #=> "my name is RUBY" 'my name is #{$ruby}' #=> "my name is #{$ruby}" ダブルクォート((({"})))で囲まれた文字列式、コマンド文 字列および正規表現、の中では(({#{式}}))という形式で式 の内容(を文字列化したもの)を埋め込むことができます。式が変数 記号((({$})),(({@})))で始まる変数の場合には (({{}}))を省略して、(({#変数名}))という形式で も展開できます。文字(({#}))に続く文字が (({{})),(({$})),(({@}))でなければ、その まま文字(({#}))として解釈されます。明示的に式展開を止 めるには(({#}))の前にバックスラッシュを置きます。 式展開中の式は、ダブルクォートなども含めて Ruby の式をそのまま書くこと ができます。コメントも許されます。 p "#{ "string" # comment }" # => "string" (()): version 1.7 では、式展開中のコメントは、 (({#})) から (({}})) まででなく改行までです。上記の例は p "#{ "string" # comment }" # => "string" と書く必要があります。 == コマンド出力 例: `date` %x{ date } バッククォート((({`})))で囲まれた文字列は、ダブルクォー トで囲まれた文字列と同様に((<リテラル/バックスラッシュ記法>)) の解釈と((<リテラル/式展開>)) が行なわれた後、コマンドとして実行され、その標準出力が文字列 として与えられます。コマンドは評価されるたびに実行されます。 コマンドの終了ステータスを得るには、((<組込み変数/$?>)) を 参照します。 ((<リテラル/%記法>)) による別形式のコマンド出力もあります。 == ヒアドキュメント (行指向文字列リテラル) 文法: <<[-]["'`]識別子["'`] ... 識別子 普通の((<リテラル/文字列リテラル>))はデリミタ(", ', ` など)で囲まれた 文字列ですが、ヒアドキュメントは `<<識別子' を含む行の次の行から `識別 子' だけの行の直前までを文字列とする行指向のリテラルです。例えば、 print < "THE LOWER CASE STRING" 開始ラベルの次の行は常にヒアドキュメントとなります。例えば、以下のよう な記述は文法エラーになります printf('%s%d', <))、 ((<リテラル/式展開>))、 ((<リテラル/バックスラッシュ記法>))、 ((<リテラル/コマンド出力>)) を参照してください。 == 正規表現リテラル 例: /^Ruby the OOPL/ /Ruby/i /my name is #{myname}/o %r|Ruby| (({/}))で囲まれた文字列は正規表現です。正規表現として解釈される メタ文字については((<正規表現>))を参照してください。 終りの(({/}))の直後の文字は正規表現に対するオプションになります。 オプションの機能は以下の通りです。 : (({i})) 正規表現はマッチ時に大文字小文字の区別を行わない : (({o})) 一番最初に正規表現の評価が行われた時に 一度だけ((<リテラル/式展開>))を行う : (({x})) 正規表現中の空白(改行も含む)を無視する。また、バックスラッシュでエス ケープしない`(({#}))' から改行までをコメントとみなして無視する(ただ し、コメント中に (({/})) を含めると構文解析に失敗するので注意) /foo # コメント bar/x これは (({/foobar/})) と同じ。 空白を含めるには (({\ })) のようにエスケープします。 : (({m})) 複数行モード。正規表現 "." が改行にもマッチするようになる Ruby は日本語化されているので、((<組込み変数/$KCODE>)) の値に従って正 規表現中の日本語文字を正しく扱います。(({$KCODE = "n"})) の場合、日本 語文字を一切認識せずにバイト列として扱います。これはデフォルトの動作で す。 オプションとして (({n})), (({e})), (({s})), (({u})) のいずれかを指定す ることで正規表現の文字コードを ((<組込み変数/$KCODE>)) の値に関係なく 個々の正規表現リテラルに指定することもできます。 ((<リテラル/%記法>)) による別形式の正規表現も指定できます。 正規表現の中では文字列と同じ((<リテラル/バックスラッシュ記法>))や ((<リテラル/式展開>))も有効です。 == 配列式 例: [1, 2, 3] %w(a b c) %W(a b c) (()) 文法: `[' 式`,' ... `]' それぞれの式を評価した結果を含む配列を返します。 配列は(())クラスのインスタンスです。 要素が文字列リテラルの場合に限り、((<リテラル/%記法>)) による別形式の 配列表現も指定できます。 == ハッシュ式 例: {1=>2, 2=>4, 3=>6} 文法: `{' 式 `=>' 式 `,' ... `}' `{' 式 `,' 式 `,' ... `}' それぞれの式を評価した結果をキーと値とするハッシュオブジェク トを返します。ハッシュとは任意のオブジェクトをキー(添字)として持 つ配列で、(())クラスのインスタンスです。 メソッドの引数の末尾に要素が1つ以上のハッシュを渡す場合は、(({{})), (({}}))を省略することができます。ただし、(({obj[...]})) 形式のメソッ ド呼出しと((<リテラル/配列式>))では、要素全体がハッシュの場合に限り、 (({{})), (({}}))を省略することができます。 例: method(1,2,3=>4) # method(1,2,{3=>4}) obj[1=>2,3=>4] # obj[{1=>2,3=>4}] [1=>2,3=>4] # [{1=>2, 3=>4}] == 範囲オブジェクト ((<演算子式/範囲式>))を参照 == シンボル 例: (シンボルの例) :class :lvar :method! :andthisis? :$gvar :@ivar :@@cvar :+ 文法: `:' 識別子 `:' 変数名 `:' 演算子 (())クラスのインスタンス。 ある文字列と(({Symbol}))オブジェクトは一対一に対応します。 Symbol リテラルに指定できる演算子はメソッドとして再定義できる演算子だ けです。((<演算子式>)) を参照して下さい。 (()): 1.7では以下の記法も使えます。 p :'foo-bar' #=> :"foo-bar" p :"foo-bar" #=> :"foo-bar" p %s{foo-bar} #=> :"foo-bar" == %記法 ((<リテラル/文字列リテラル>))、 ((<リテラル/コマンド出力>))、 ((<リテラル/正規表現リテラル>))、 ((<リテラル/配列式>)) では、(({%}))で始まる形式の記法を用いることができます。 文字列や正規表現では、`"', `/' など(通常のリテラルの区切り文字)を要素 に含めたい場合にバックスラッシュの数をコードから減らす効果があります。 また配列式では文字列の配列を簡単に表現できます。それぞれ以下のように対 応します。 * (({%!STRING!})) : ダブルクォート文字列 * (({%Q!STRING!})) : 同上 * (({%q!STRING!})) : シングルクォート文字列 * (({%x!STRING!})) : コマンド出力 * (({%r!STRING!})) : 正規表現 * (({%w!STRING!})) : 要素が文字列の配列(空白区切り) * (({%W!STRING!})) : 要素が文字列の配列(空白区切り)。式展開、バックスラッシュ記法が有効((())) * (({%s!STRING!})) : シンボル。式展開、バックスラッシュ記法は無効((())) (({!}))の部分には改行を含めた任意の非英数字を使うことができます。始ま りの区切り文字が括弧(`(',`[',`{',`<')である時には、終りの区切り文字は 対応する括弧になります。括弧を区切り文字にした場合、対応が取れていれば 区切り文字と同じ括弧を要素に含めることができます。 %(()) => "()" 配列式の%記法はシングルクォートで囲んだ文字列を空白文字で分割したのと 同じです。たとえば、 %w(foo bar baz) は(({['foo', 'bar', 'baz']}))と等価です。 バックスラッシュを使って空白を要素に含むこともできます。 %w(foo\ bar baz) => ["foo bar", "baz"] (()): %W は、%w と同様ですが、ダブルクォートで囲んだ文字列のように、式展開、 バックスラッシュ記法が使用できます。空白による分割は式展開を評価する前 に行われます。 v = "c d" %W(a\ b #{v}e\sf #{}) => ["a b", "c de f", ""] = Numeric リテラルの符号は、単項演算子 `(({-}))', `(({+}))' のメソッド呼び出しでは ありません。 class Fixnum def -@ "negative #{self}" end end p -10 # => -10 n = 10 p -n # => "negative 10" この違いは結合強度にも影響します。 p -10.abs # => 10 n = 10 p -n.abs # => -10 = Array 配列クラス。配列の要素は任意の Ruby オブジェクトです。 一般的には配列は配列式を使って [1, 2, 3] のように生成します。 == スーパークラス: * (()) == インクルードしているモジュール: * (()) == クラスメソッド: --- Array[item,...] 引数を要素として持つ配列を生成します。 --- Array.new([size[, val]]) --- Array.new(ary) (()) --- Array.new(size) {|index| ... } (()) 配列を生成します。((|size|)) を指定したときにはその大きさの配列を 生成し (({nil})) で初期化します。第二引数 ((|val|)) も指定したとき には (({nil})) の代わりにそのオブジェクトを全要素にセットします。 (要素毎に ((|val|)) が複製されるわけではないことに注意してください。 全要素が同じオブジェクト ((|val|)) を参照します(()))。 (()): 二番目の形式では引数に指定した配列を複製し て返します。 p Array.new([1,2,3]) # => [1,2,3] 三番目の形式では、ブロックの評価結果で値を設定します。ブロックは要 素毎に実行されるので、全要素をあるオブジェクトの複製にすることがで きます。 p Array.new(5) {|i| i } # => [0, 1, 2, 3, 4] ary = Array.new(3, "foo") ary.each {|obj| p obj.id } # => 537774036 537774036 537774036 ary = Array.new(3) { "foo" } ary.each {|obj| p obj.id } # => 537770448 537770436 537770424 == メソッド: --- self[nth] ((|nth|)) 番目の要素を返します。先頭の要素が 0 番目になります。 ((|nth|)) の値が負の時には末尾からのインデックスと見倣します(末尾 の要素が -1 番目)。((|nth|)) 番目の要素が存在しない時には (({nil})) を返します。 --- self[start..end] ((|start|)) 番目の要素から ((|end|)) 番目の要素までの部分配列を返 します。((|start|)) の値が負の時には末尾からのインデックスと見倣し ます(末尾の要素が -1 番目)。((|start|)) の値が配列の範囲に収まらな い場合 (({nil})) を返します。((|end|)) の値が配列の長さを越える時 には、越えた分の長さは無視されます。また、範囲の始点が終点よりも大 きい時には (({nil})) を返します。 --- self[start, length] ((|start|)) 番目から ((|length|)) 個の要素を含む部分配列を返します。 ((|start|)) の値が負の時には末尾からのインデックスと見倣します(末 尾の要素が -1 番目)。((|length|)) が ((|start|)) 番目からの配列の 長さより長い時には、越えた分の長さは無視されます。((|length|)) が 負の時には (({nil})) を返します。 --- self[nth]=val ((|nth|)) 番目の要素を ((|val|)) に設定します。((|nth|)) が配列の 範囲を越える時には配列の長さを自動的に拡張し、拡張した領域を (({nil})) で初期化します。 ((|val|)) を返します。 --- self[start..end]=val ((|start|)) 番目の要素から ((|end|)) 番目の要素までを配列 ((|val|)) の内容に置換します。((|val|)) の値が配列でないときには ((|val|)) で置換します。((|val|)) の要素の数の方が多い時には、後ろ の要素がずれます。 ((|val|)) が (({nil})) か 空の配列 (({[]})) なら ((|start|)) から ((|end|)) までの要素が削除されます。 例: ary = [0, 1, 2, 3, 4, 5] ary[0..2] = ["a", "b"] p ary # => ["a", "b", 3, 4, 5] ary[2..4] = nil p ary # => ["a", "b"] ((|val|)) を返します。 --- self[start, length]=val インデックス ((|start|)) から ((|length|)) 個の要素を配列 ((|val|)) の内容で置き換えます。((|val|)) が配列でないときには (({val.to_ary})) もしくは (({[val]})) の内容で置換します。 ((|val|)) を返します。 例: ary = [0, 1, 2, 3] ary[1, 2] = ['a', 'b', 'c'] p ary # => [0, "a", "b", "c", 3] ary[2, 1] = 99 p ary # => [0, "a", 99, "c", 3] ary[1, 0] = ['inserted'] p ary # => [0, "inserted", "a", 99, "c", 3] --- self + other (({self})) と ((|other|)) の内容を繋げた新しい配列を返します。 ((|other|)) が配列でなければ (({other.to_ary})) の返り値を用います。 その返り値がまた配列でなかった場合は例外 (()) が発生し ます。 例: a = [1, 2] b = [8, 9] p a + b #=> [1, 2, 8, 9] p a #=> [1, 2] (変化なし) p b #=> [8, 9] (こちらも変化なし) --- self * times 配列の内容を繰り返した新しい配列を作成し返します。 値はコピーされないことに注意してください(())。 例: p [1, 2, 3] * 3 #=> [1, 2, 3, 1, 2, 3, 1, 2, 3] ((|times|)) が文字列なら、self.(())(times) と同じ 動作をします。 p [1,2,3] * "," # => "1,2,3" --- self - other 集合の差演算。(({self})) から ((|other|)) の要素を 取り除いた内容の新しい配列を返します。重複する要素は取り除かれ ます。 ((|other|)) が配列でなければ (({to_ary})) メソッドによる 暗黙の型変換を試みます。 --- self & other 集合の積演算。両方の配列に含まれる要素からなる新しい配列を返 します。重複する要素は取り除かれます。 ((|other|)) が配列でなければ (({to_ary})) メソッドによる 暗黙の型変換を試みます。 要素の重複判定は、(()) により行われます。 ((-処理の高速化のために内部で (()) を使用しているためです-)) --- self | other 集合の和演算。両方の配列にいずれかに含まれる要素を全て含む新し い配列を返します。重複する要素は取り除かれます。 ((|other|)) が配列でなければ (({to_ary})) メソッドによる 暗黙の型変換を試みます。 要素の重複判定は、(()) により行われます。 --- self << obj ((|obj|)) を配列の末尾に追加します。(({Array#push})) と同じ効果です。 ary = [1] ary << 2 p ary # [1, 2] またこのメソッドは (({self})) を返すので、以下のように連続して 書くことができます。 ary = [1] ary << 2 << 3 << 4 p ary #=> [1, 2, 3, 4] --- self <=> other (({self})) と (({other})) の各要素をそれぞれ順に (({<=>})) で比較 して、(({self})) が大きい時に正、等しい時に 0、小さい時に負の整数 を返します。各要素が等しいまま、一方だけ配列の末尾に達した時は、よ り短い配列の方が小さいとみなします。 --- self == other (({self})) と (({other})) の各要素をそれぞれ順に (({==})) で比較し て、全要素が等しければ真を返します。 --- assoc(key) 配列の配列を検索して、その 0 番目の要素が ((|key|)) に等しい最初の 要素を返します。比較は (({==})) 演算子を使って行われます。 該当する要素がなければ (({nil})) を返します。 例: ary = [[1,15], [2,25], [3,35]] p ary.assoc(2) # => [2, 25] p ary.assoc(100) # => nil p ary.assoc(15) # => nil (()) も参照してください。 --- at(pos) 配列の ((|pos|)) の位置にある要素を返します。 self[((|pos|))] と同じです。 --- clear 配列の要素をすべて削除して空にします。 (({self})) を返します。 例: ary = [1, 2] ary.clear p ary #=> [] --- clone --- dup レシーバと同じ内容を持つ新しい配列を返します。(({clone})) は frozen tainted singleton-class の情報も含めてコピーしますが、 (({dup})) は内容だけをコピーします。 またどちらのメソッドも要素それ自体のコピーはしません。 つまり「浅い(shallow)」コピーを行います。 例: ary = ['string'] p ary #=> ["string"] copy = ary.dup p copy #=> ["string"] ary[0][0...3] = '' p ary #=> ["ing"] p copy #=> ["ing"] --- collect! {|item| ..} --- map! {|item| ..} 各要素を順番にブロックに渡して評価し、その結果で要素を 置き換えます。(()) も参照。 (({self})) を返します。 例: ary = [1, 2, 3] ary.map! {|i| i * 3 } p ary #=> [3, 6, 9] --- compact --- compact! (({compact})) は (({self})) から (({nil})) である要素を取り除いた 新しい配列を返します。(({compact!})) は変更を破壊的に行い、変更が 行われた場合は (({self})) を、そうでなければ (({nil})) を返します。 例: ary = [1, nil, 2, nil, 3, nil] p ary.compact #=> [1, 2, 3] p ary #=> [1, nil, 2, nil, 3, nil] ary.compact! p ary #=> [1, 2, 3] p ary.compact! #=> nil --- concat(other) 配列 ((|other|)) を (({self})) の末尾に(破壊的に)連結します。 (({self})) を返します。 例: array = [1, 2] a = [3, 4] array.concat a p array # => [1, 2, 3, 4] p a # => [3, 4] # こちらは変わらない --- delete(val) --- delete(val) { ... } ((|val|)) と (({==})) で等しい要素をすべて取り除きます。 ((|val|)) と等しい要素が見つかった場合は、((*val*)) を返します。 ((|val|))と等しい要素がなければ (({nil})) を返しますが、ブロックが 指定されていればブロックを評価してその結果を返します。 例: array = [1, 2, 3, 2, 1] p array.delete(2) #=> 2 p array #=> [1, 3, 1] # ブロックなしの引数に nil を渡すとその戻り値から削除が # 行われたかどうかの判定をすることはできない ary = [nil,nil,nil] p ary.delete(nil) #=> nil p ary #=> [] p ary.delete(nil) #=> nil --- delete_at(pos) ((|pos|)) で指定された位置にある要素を取り除きそれを返します。 ((|pos|)) が範囲外であったら (({nil})) を返します。 (()) と同様に負のインデックスで末尾から位置を指定するこ とができます。 例: array = [0, 1, 2, 3, 4] array.delete_at 2 p array #=> [0, 1, 3, 4] --- delete_if {|x| ... } --- reject! {|x| ... } 要素を順番にブロックに渡して評価し、その結果が真になった要素を すべて削除します。 (({delete_if})) は常に (({self})) を返しますが、(({reject!})) は要 素が 1 つも削除されなければ (({nil})) を返します。 --- each {|item| .... } 各要素に対してブロックを評価します。(({self})) を返します。 例: # 1、2、3 が順番に表示される [1, 2, 3].each do |i| puts i end --- each_index {|index| .... } 各要素のインデックスに対してブロックを評価します。 以下と同じです。 (0 ... ary.size).each {|index| .... } (({self})) を返します。 --- empty? 配列の要素数が 0 の時真を返します。 --- eql?(other) (({self})) と (({other})) の各要素をそれぞれ順に (()) で比較して、全要素が等しければ真を返 します。 --- fetch(nth) (()) --- fetch(nth, ifnone) (()) --- fetch(nth) {|nth| ... } (()) (()) と同様 ((|nth|)) 番目の要素を返しますが、 Array#[nth] とは ((|nth|)) 番目の要素が存在しない場合の振舞いが異 なります。 最初の形式では、例外 (()) が発生します。 二番目の形式では、引数 ((|ifnone|)) を返します。 三番目の形式では、ブロックを評価した結果を返します。 Array#[nth] は、Array#fetch(nth, nil) と同じです。 --- fill(val) --- fill(val, start[, length]) --- fill(val, start..end) --- fill {|index| ... } (()) --- fill(start[, length]) {|index| ... } (()) --- fill(start..end) {|index| ... } (()) 配列の、指定された範囲すべてに ((|val|)) をセットします。二番目の 形式で ((|length|)) が省略された時は配列の終りまでの長さを意味しま す。指定された部分配列が元の配列の範囲を越える時は長さを自動的に拡 張し、拡張した部分を ((|val|)) で初期化します。 このメソッドが ((|val|)) のコピーでなく ((|val|)) 自身をセットする ことに注意してください((()))。 (()): ((|val|)) の代わりにブロックを指定するとブロックの評価結果を値とし ます。ブロックは要素毎に実行されるので、セットする値のそれぞれをあ るオブジェクトの複製にすることができます。 ary = [] p ary.fill(0,3) {|i| i} # => [0, 1, 2] p ary.fill { "foo" } # => ["foo", "foo", "foo"] p ary.collect {|v| v.id } # => [537770124, 537770112, 537770100] --- first 配列の先頭の要素を返します。要素がなければ (({nil})) を返します。 例: p [0, 1, 2].first #=> 0 p [].first #=> nil --- flatten --- flatten! ネストした配列を平滑化してそれを返します。(({flatten!})) は 配列それ自体を破壊的に平滑化し、配列がネストしていないとき には (({nil})) を返します。 例: p [1, [2, 3, [4], 5]].flatten #=> [1, 2, 3, 4, 5] array = [[[1, [2, 3]]]] array.flatten! p array #=> [1, 2, 3] --- include?(val) 配列が ((|val|)) と (({==})) において等しい要素を持つ時に真を返し ます。 --- index(val) ((|val|)) と (({==})) で等しい最初の要素の位置を返します。 等しい要素がひとつもなかった時には (({nil})) を返します。 --- indexes(index_1, ... , index_n) --- indices(index_1, ... , index_n) 各引数の値をインデックスとする要素の配列を返します。範囲外の インデックス指定に対しては (({nil})) が対応します。 例: ary = %w( a b c d e ) p ary.indexes( 0, 2, 4 ) #=> ["a", "c", "e"] p ary.indexes( 3, 4, 5, 6, 35 ) #=> ["d", "e", nil, nil] p ary.indexes( 0, -1, -2 ) #=> ["a", "e", "d"] p ary.indexes( -4, -5, -6, -35 ) #=> ["b", "a", nil, nil] (()): このメソッドは version 1.7 では、(()) です。 使用すると警告メッセージが表示されます。 代わりに (()) を使用します。 --- insert(nth, val[, val2 ...]) (()) インデックス ((|nth|)) の要素の直前に第 2 引数以降の値を挿入します。 (({self})) を返します。以下のように定義されます。 class Array def insert( n, *vals ) self[n, 0] = vals self end end 例: ary = %w( foo bar baz ) ary.insert 2, 'a', 'b' p ary # => ["foo", "bar", "a", "b", "baz"] --- join([sep]) 配列の要素を文字列 ((|sep|)) を間に挟んで連結した文字列を返します。 文字列でない配列要素に対しては (({to_s})) した結果を連結します。配 列要素が配列であれば再帰的に(同じ ((|sep|)) を利用して) join した 文字列を連結します。 ((|sep|)) が省略された場合には変数 ((<組込み変数/$,>)) の値が使われます。 注: 配列要素が自身を含むような無限にネストした配列に対しては、以下 のような結果になります。 ary = [1,2,3] ary.push ary p ary # => [1, 2, 3, [...]] p ary.join # => "123123[...]" --- last 配列の末尾の要素を返します。配列が空のときは (({nil})) を返します。 --- length --- size 配列の長さを返します。配列が空のときは 0 を返します。 --- nitems (({nil})) でない要素の数を返します。 --- pack(template) 配列の内容を ((|template|)) で指定された文字列にしたがって、 バイナリとしてパックした文字列を返します。テンプレートは 型指定文字列とその長さ(省略時は1)を並べたものです。長さと して (({*})) が指定された時は「残りのデータ全て」の長さを 表します。型指定文字は(())の通りです。 --- pop 末尾の要素を取り除いてそれを返します。空配列の時は (({nil})) を返します。 (()), (()), (()) も参照し てください。 例: array = [1, [2, 3], 4] p array.pop # => 4 p array.pop # => [2, 3] p array # => [1] p array.pop # => 1 p array.pop # => nil p array # => [] --- push(obj1[, obj2 ...]) ((|obj1|)), ((|obj2|)) ... を順番に配列の末尾に追加します。 (()), (()), (()) も参照して ください。 (({self})) を返します。 例: array = [1, 2, 3] array.push 4 array.push [5, 6] array.push 7, 8 p array # => [1, 2, 3, 4, [5, 6], 7, 8] --- rassoc(obj) (({self})) が配列の配列であると仮定して、要素の配列でインデックス 1 の要素が ((|obj|)) に等しいものを検索し見つかった最初の要素を返 します。比較は (({==})) 演算子を使って行われます。 該当する要素がなければ (({nil})) を返します。 例: a = [[15,1], [25,2], [35,3]] p a.rassoc(2) # => [25, 2] (()) も参照してください。 --- replace(another) 配列の内容を配列 ((|another|)) の内容で置き換えます。 (({self})) を返します。 例: a = [1, 2, 3] a.replace [4, 5, 6] p a #=> [4, 5, 6] --- reverse --- reverse! (({reverse})) は全ての要素を逆順に並べた新しい配列を返します。 (({reverse!})) は配列の要素を逆順に(破壊的に)並べ替えます。 (({reverse})) は、常に新しい配列を返しますが、(({reverse!})) は、 1 要素の配列に対して (({nil})) を返しそれ以外では (({self})) を返 します((- あらい 2002-01-06: このあたりの仕様はまだ流動的だと思い ます。String#reverse! は、1文字の文字列に対しても self を返してい ます-))。 --- reverse_each {|item| ... } 各要素に対して逆順にブロックを評価します。(({self})) を返します。 --- rindex(val) ((|val|)) と (({==})) において等しい最後の要素のインデックスを 返します。等しい要素がひとつもなかった時には (({nil})) を返します。 例: p [1, 0, 0, 1, 0].rindex(1) #=> 3 p [1, 0, 0, 0, 0].rindex(1) #=> 0 p [0, 0, 0, 0, 0].rindex(1) #=> nil --- select(index_1, ... , index_n) --- select {|item| ... } (()) 最初の形式では、引数で指定されたインデックスに対応する要素を配列で 返します。インデックスに対応する値がなければ nil が要素になります。 ((()), (()) と同じです) 例: ary = %w( a b c d e ) p ary.select( 0, 2, 4 ) #=> ["a", "c", "e"] p ary.select( 3, 4, 5, 6, 35 ) #=> ["d", "e", nil, nil, nil] p ary.select( 0, -1, -2 ) #=> ["a", "e", "d"] p ary.select( -4, -5, -6, -35 ) #=> ["b", "a", nil, nil] ブロック付きでイテレータとして呼び出した場合は (()) と同じです。つまり、ブロッ クに要素を順に渡し、ブロックが真を返した要素の配列を返します。 ary = %w(a b c d e) p ary.select {|v| v > "b"} # => ["c", "d", "e"] --- shift 配列の先頭の要素を取り除いてそれを返します。残りの要素はひとつずつ 前に詰められます。空配列に対しては(({nil})) を返します。 (()), (()), (()) も参照して ください。 --- slice(pos[, len]) --- slice(start..last) (()) と同じです。 --- slice!(pos[, len]) --- slice!(start..last) 指定した要素を取り除いて返します。取り除く要素がなければ (({nil})) を返します。 --- sort --- sort! --- sort {|a, b| ... } --- sort! {|a, b| ... } 配列の内容をソートします。ブロックとともに呼び出された時には ブロックに 2 引数を与えて評価し、その結果で比較します。 ブロックがない時には (({<=>})) 演算子を使って比較します。 (({sort})) はソートされた新しい配列を返し、(({sort!})) は (({self})) を破壊的に変更します。 (()): (({sort!})) は、バージョン 1.6 以前には要素の数が 2 より小さい場合には (({nil})) を返していました。一方バージョン 1.7 では常に (({self})) を 返します。 --- to_a --- to_ary (({self})) をそのまま返します。 --- to_s self.(())(((<組込み変数/$,>))) と同じです。 --- uniq --- uniq! (({uniq})) は配列から重複した要素を取り除いた新しい配列を返します。 取り除かれた要素の部分は前に詰められます。(({uniq!})) は削除を破壊 的に行い、削除が行われた場合は (({self})) を、そうでなければ (({nil})) を返します。 要素の重複判定は、(()) により行われます。 例: p [1, 1, 1].uniq #=> [1] p [1, 4, 1].uniq #=> [1, 4] p [1, 3, 2, 2, 3].uniq #=> [1, 3, 2] --- unshift(obj1[, obj2 ...]) ((|obj1|)), ((|obj2|)) ... を順番に配列の先頭に挿入します。(({self})) を返します。 (()), (()), (()) も参照してく ださい。 例: arr = [1,2,3] arr.unshift 0 p arr #=> [0, 1, 2, 3] arr.unshift [0] p arr #=> [[0], 0, 1, 2, 3] arr.unshift 1, 2 p arr #=> [1, 2, [0], 0, 1, 2, 3] = Hash ハッシュテーブル(連想配列とも呼ぶ)のクラス。ハッシュは任意の種類のオブ ジェクトから任意の種類のオブジェクトへの関連づけを行うことができます。 ハッシュ生成は以下のようなハッシュ式で行われます。 {a=>b, ... } ハッシュの格納に用いられるハッシュ値の計算には、 (()) メソッドが使われ、キーの同一性判定には、 (()) メソッドが使われます。 キーとして与えたオブジェクトの内容が変化し、メソッド (({hash})) の返す 値が変わるとハッシュから値が取り出せなくなりますから、(())、 (()) などのインスタンスはキーに向きません。文字列をキーとして与 えると、文字列をコピーし、コピーを更新不可に設定(freeze)してキーとして 使用します。キーとして使われている文字列を更新しようとすると例外 (()) が発生します。 == スーパークラス: * (()) == インクルードされているモジュール: * (()) == クラスメソッド: --- Hash[key,value,...] --- Hash[hash] 新しいハッシュを生成します。一番目の形式では、引数は必ず偶数個指定 しなければなりません。(奇数番目がキー、偶数番目が値)。 二番目の形式(1つのハッシュオブジェクトを引数に指定した場合)は、指 定したハッシュと同一のキーと値を持つ新たなハッシュを生成して返しま す。(生成されたハッシュのデフォルト値は nil です。) --- Hash.new([ifnone]) --- Hash.new {|hash, key| ...} (()) 空の新しいハッシュを生成します。((|ifnone|)) はキーに対 応する値が存在しない時のデフォルト値です。 デフォルト値の扱いには注意が必要です( (()) )。 (()): ブロックを指定した場合は、ブロックの評価結果がデフォルト値になりま す。値が設定されていないハッシュ要素を参照するとその都度ブロックを 実行し、その結果を返します。ブロックにはそのハッシュとハッシュを参 照したときのキーが渡されます。 # ブロックではない場合デフォルト値の変更により # 他の値も変更されたように見える h = Hash.new("foo") p h[1] # => "foo" p h[1] << "foo" # => "foobar" p h[1] # => "foobar" p h[2] # => "foobar" # ブロックを使うとうまく行く h = Hash.new {|hash, key| hash[key] = "foo"} p h[1] # => "foo" p h[1] << "bar" # => "foobar" p h[1] # => "foobar" p h[2] # => "foo" # 値が設定されたないときに(fetchのように)例外をあげるようにもできる h = Hash.new {|hash, key| raise(IndexError, "hash[#{key}] has no value") } h[1] # => hash[1] has no value (IndexError) == メソッド: --- self[key] ((|key|)) に関連づけられた値を返します。該当するキーが登 録されていない時には、デフォルト値(設定されていない時には (({nil}))) を返します。 値としての (({nil})) と区別する必要がある場合は (()) を使ってください。 --- self[key]=value --- store(key,value) ((|key|)) に対して ((|value|)) を関連づけます。((|value|)) を返し ます。 --- clear ハッシュの中身を空にします。(({self})) を返します。 --- clone --- dup レシーバと同じ内容を持つ新しいハッシュを返します。フリーズしたハッ シュの (({clone})) は同様にフリーズされたハッシュを返しますが、 (({dup})) は内容の等しいフリーズされていないハッシュを返します。 --- default --- default([key]) (()) ハッシュのデフォルト値を返します。 (()): 2 番目の形式はハッシュがデフォルト値としてブロックを持つ場合 ((())参照)に指定できます。(({self})) と 引数 ((|key|)) を引数にブロックを実行してその結果を返します。 ((|key|)) の省略値は (({nil})) です。 --- default=value ハッシュのデフォルト値を ((|value|)) に設定します。対応する値が存 在しないキーで検索した時にはこの値を返します。 ((|value|)) を返します。 --- default_proc (()) ハッシュのデフォルト値を返す (()) オブジェクトを返します。 デフォルトの (()) を持たない場合 nil を返します。 h = Hash.new {|h, k| } p h.default_proc # => # h = Hash.new(1) p h.default_proc # => nil --- delete(key) --- delete(key) {|key| ... } ((|key|)) に対する関連を取り除きます。取り除かれた値を返しますが、 ((|key|)) に対応する値が存在しない時には (({nil})) を返します。 ブロックが与えられた時には ((|key|)) にマッチするものがな かった時に評価し、その結果を返します。 --- reject {|key, value| ... } (({self})) を複製して、ブロックを評価した値が真になる要 素を削除したハッシュを返します。 ハッシュを返すことを除けば (()) と同じです。 --- delete_if {|key, value| ... } --- reject! {|key, value| ... } ((|key|)) と ((|value|)) を引数としてブロックを評価した値が真であ る時、その要素を (({self})) から削除します。 delete_if は常に (({self})) を返します。 reject! は、要素を削除しなかった場合には (({nil})) を返し、 そうでなければ (({self})) を返します。 --- each {|key, value| ... } --- each_pair {|key, value| ... } ((|key|)) と ((|value|)) を引数としてブロックを評価します。 (({self})) を返します。 --- each_key {|key| ... } ((|key|)) を引数としてブロックを評価します。 (({self})) を返します。 --- each_value {|value| ... } ((|value|))を引数としてブロックを評価します。 (({self})) を返します。 --- empty? ハッシュが空の時真を返します。 --- fetch(key[, default]) --- fetch(key) {|key| ... } ((|key|)) に関連づけられた値を返します。該当するキーが登録されてい ない時には、引数 ((|default|)) が与えられていればその値を、ブロッ クが与えられていればそのブロックを評価した値を返します。そのいずれ でもなければ例外 (()) が発生します。 --- has_key?(key) --- include?(key) --- key?(key) --- member?(key) ハッシュが ((|key|)) をキーとして持つ時真を返します。 --- has_value?(value) --- value?(value) ハッシュが ((|value|)) を値として持つ時真を返します。 値の一致判定は (({==})) で行われます。 --- index(val) ((|val|)) に対応するキーを返します。対応する要素が存在しない時には (({nil})) を返します。 該当するキーが複数存在する場合、どのキーを返すかは不定です。 --- indexes(key_1, ... , key_n) --- indices(key_1, ... , key_n) 引数で指定されたキーを持つ値の配列を返します。 (()): このメソッドは version 1.7 では、(()) です。 使用すると警告メッセージが表示されます。 代わりに (()) を使用します。 --- invert 値からキーへのハッシュを返します。 異なるキーに対して等しい値が登録されている場合の結果は不定であることに 注意してください、そのような場合にこのメソッドを利用することは意図され ていません。 h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 } h.invert #=> {200=>"d", 300=>"y", 0=>"a", 100=>"n"} --- keys 全キーの配列を返します。 --- length --- size ハッシュの要素の数を返します。 --- rehash キーのハッシュ値を再計算します。キーになっているオブジェクトのハッシュ 値が変わってしまった場合、このメソッドを使ってハッシュ値を再計算しない 限り、そのキーに対応する値を取り出すことができなくなります。 --- replace(other) ハッシュの内容を ((|other|)) の内容で置き換えます。 (({self})) を返します。 --- select(key_1, ... , key_n) --- select {|key, value| ... } (()): 最初の形式では、引数で指定されたキーを持つ値の配列を返します。 キーに対応する値がなければ (()) の戻り値が使用 されます。 (()) と (()) と同じです。 h = {1=>"a", 2=>"b", 3=>"c"} p h.select(1,3,4) => ["a", "c", nil] ブロック付きでイテレータとして呼び出した場合は (()) と同じです。つまり、ブロッ クにキーと値の組を順に渡し、ブロックが真を返した要素(キーと値の配 列)の配列を返します。 h = {1=>"a", 2=>"b", 3=>"c"} p h.select {|k,v| k % 2 == 1} => [[1, "a"], [3, "c"]] --- shift ハッシュから要素をひとつ取り除き、(({[key,value]})) という配列とし て返します。 ハッシュが空の場合、デフォルト値(())を持たなければ (({nil})) を、デフォルト値を持つならその値を返します(このとき、 (({[key,value]})) という形式の値を返す分けではないことに注意)。 h = Hash.new p h.empty? # => true p h[0] # => nil p h.shift # => nil p h.default # => nil h.each {|v| p v} # => p h.to_a # => [] h1 = Hash.new("default value") p h1.empty? # => true p h1[0] # => "default value" p h1.shift # => "default value" p h1.default # => "default value" h1.each {|v| p v} # => p h1.to_a # => [] # ruby 1.7 feature h2 = Hash.new {|arg| arg} p h2.empty? # => true p h2[0] # => [{}, 0] p h2.shift # => [{}, nil] p h2.default # => [{}, nil] h2.each {|v| p v} # => p h2.to_a # => [] --- to_a (({[key,value]})) からなる 2 要素の配列の配列を生成して返します。 --- to_hash (({self})) を返します。 --- update(other) --- update(other) {|key, self_val, other_val| ... } (()) ハッシュの内容をマージします。重複するキーに対応する値は ((|other|)) の内容で上書きされます。 (()): ブロックが与えられた場合は、重複するキーごとにブロックを評価してそ の結果をそのキーに対応する値にします。ブロックには引数としてキーと (({self[key]})) 、(({((|other|))[key]})) が渡されます。 foo = {1 => 'a', 2 => 'b', 3 => 'c'} bar = {1 => 'A', 2 => 'B', 3 => 'C'} p foo.dup.update(bar) # => {1=>"A", 2=>"B", 3=>"C"} p foo.dup.update(bar) {|k,v| v} # => {1=>"a", 2=>"b", 3=>"c"} (({self})) を返します。 --- values ハッシュの全値の配列を返します。 = Symbol シンボルを表すクラス。シンボルは任意の文字列と一対一に対応するオブジェ クトです。Ruby スクリプトからは * (({:symbol})) * (({'symbol'.intern})) のようにして得られます。リテラルでシンボルを表す場合、`(({:}))' の後に は識別子、メソッド名(`(({!}))',`(({?}))' などの接尾辞を含む)、変数名 (`(({$}))'などの接頭辞を含む)、再定義できる演算子のいずれかに適合する ものしか書くことはできません(そうでなければ文法エラーになります)。 == スーパークラス: * (()) == クラスメソッド: --- Symbol.all_symbols (()) 定義済みの全てのシンボルオブジェクトの配列を返します。 p Symbol.all_symbols # => [:RUBY_PLATFORM, :RUBY_VERSION, ...] シンボルの生成はコンパイル時に行われるので以下のようにしても結果に 差はありません。 a = Symbol.all_symbols :foo b = Symbol.all_symbols p b - a # => [] == メソッド: --- intern (()): (({self})) を返します。 --- id2name() --- to_s シンボルに対応する文字列を返します。 逆に、文字列に対応するシンボルを得るには (()) を使います。 p :foo.id2name.intern == :foo => true --- to_i シンボルに対応する整数を返します。 逆にこの整数から対応するシンボルを得るには (()) を使って一旦文字列を得る必要が あります。 id = :foo.to_i p id # => 8881 p id.id2name.intern # => :foo Rubyの実装では予約語、変数名、メソッド名などをこの整数で管理してい ます。オブジェクトに対応する整数((()) で得ら れます)と Symbol に対応する整数は別のものです。 = 演算子式 * ((<演算子式/代入>)) * ((<演算子式/自己代入>)) * ((<演算子式/多重代入>)) * ((<演算子式/範囲式>)) * ((<演算子式/and>)) * ((<演算子式/or>)) * ((<演算子式/not>)) * ((<演算子式/条件演算子>)) 例: 1+2*3/4 プログラミングの利便のために一部のメソッド呼び出しと制御構造は演算子形 式をとります。Rubyには以下にあげる演算子があります。 高い :: [] ** -(単項) +(単項) ! ~ * / % + - << >> & | ^ > >= < <= <=> == === != =~ !~ && || .. ... ?:(条件演算子) =(+=, -= ... ) not 低い and or 左の「高い」「低い」は演算子の優先順位です。 例えば「&&」は「||」より優先順位が高いので、以下のように 解釈されます。 a && b || c #=> (a && b) || c a || b && c #=> a || (b && c) ほとんどの演算子は特別な形式のメソッド呼び出しですが、一部の ものは言語に組み込みで、再定義できません。 * 再定義できる演算子(メソッド): (({+@})), (({-@})) は単項演算子 (({+})), (({-})) を表しメソッド定義 などではこの記法を利用します。 ((-このマニュアルの分類では ((<リテラル/コマンド出力>)) (({`...`})) は演算子ではありませんが説明の都合上再定義できる演算子の一覧にあげて います-)) | ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ +@ -@ [] []= ` * 再定義できない演算子(制御構造): 演算子の組合せである自己代入演算子と (({!=})), (({!~})) も再定義できません。 = ?: .. ... ! not && and || or :: == 代入 例: foo = bar foo[0] = bar foo.bar = baz 文法: 変数 '=' 式 定数 '=' 式 式`['expr..`]' '=' 式 式`.'識別子 '=' 式 代入式は変数などに値を設定するために用いられます。代入はロー カル変数や定数の宣言としても用いられます。代入式の左辺は以 下のいずれかでなければなりません。 * 変数 変数 `=' 式 左辺値が変数の場合、式を評価した値が変数に代入されます。 * 配列参照 式1`[' 式2 ... `]' `=' 式n 式1を評価して得られるオブジェクトに対しての、式 2 から式 n までを 引数とする (({[]=})) メソッド呼出しに変換されます。 例: class C def initialize @ary = [0,1,2,3,4,5,6,7] end def [](i) @ary[i * 2] end def []=( i, v ) @ary[i * 2] = v end end c = C.new p c[3] # c.[]( 3 ) に変換され、その結果は 6 p c[3] = 1 # c.[]=(3,1) に変換され、その結果は 1 * 属性参照 式1 `.' 識別子 `=' 式2 式 1 を評価して得られるオブジェクトに対して、 (({識別子=})) というメソッドを、式 2 を引数にして呼び出します。 例: class C def foo @foo end def foo=( v ) @foo = v end end c = C.new c.foo = 5 # c.foo=( 5 ) のように変換される p c.foo # => 5 属性は (()) を使って同じように定義できます。 例: class C attr :foo, true end c = C.new c.foo = 5 # c.foo=( 5 ) のように変換される p c.foo # => 5 === 自己代入 例: foo += 12 # foo = foo + 12 a ||= 1 # a が偽か未定義ならば1を代入。初期化時のイディオムの一種。 文法: 式1 op= 式2 # 式1は通常の代入の左辺のいずれか op は以下のいずれかです。演算子と(({=}))の間にスペースを 空けてはいけません。 +, -, *, /, %, **, &, |, ^, <<, >>, &&, || この形式の代入は (({op})) が &&, || の場合には、 式1 op (式1 = 式2) と評価され、それ以外では、 式1 = 式1 op 式2 と評価されます。 === 多重代入 例: foo, bar, baz = 1, 2, 3 foo, = list() foo, *rest = list2() 文法: 式 [`,' [式 `,' ... ] [`*' [式]]] = 式 [, 式 ... ][`*' 式] `*' [式] = 式 [, 式 ... ][`*' 式] 多重代入は複数の式または配列から同時に代入を行います。左辺の 各式はそれぞれ代入可能でなければなりません。右辺の式が一つし か与えられなかった場合、式を評価した値は配列に変換されて、各 要素が左辺のそれぞれの式に代入されます。左辺の要素の数よりも 配列の要素の数の方が多い場合には、余った要素は無視されます。 配列の要素が足りない場合には対応する要素の無い左辺には (({nil})) が代入されます。 左辺の最後の式の直前に (({*})) がついていると、対応する 左辺のない余った要素が配列として代入されます。余った要素が 無い時には空の配列が代入されます。 例: foo, bar = [1, 2] # foo = 1; bar = 2 foo, bar = 1, 2 # foo = 1; bar = 2 foo, bar = 1 # foo = 1; bar = nil foo, bar, baz = 1, 2 # foo = 1; bar = 2; baz = nil foo, bar = 1, 2, 3 # foo = 1; bar = 2 foo = 1, 2, 3 # foo = [1, 2, 3] *foo = 1, 2, 3 # foo = [1, 2, 3] foo,*bar = 1, 2, 3 # foo = 1; bar = [2, 3] ((- (({foo = 1, 2, 3})) という書き方は 1.6.2 あたりから可能なようです。 おそらくブロックパラメータの受渡しとの対象性からかと思います (({proc {|a| p a}.call(1,2,3) #=> [1,2,3]}))-)) 多重代入は括弧により、ネストした配列の要素を代入することもできます。 (foo, bar), baz = [1, 2], 3 # foo = 1; bar = 2; baz = 3 特殊な形式の代入式も多重代入にすることができます。 class C def foo=( v ) @foo = v end def []=(i,v) @bar = ["a", "b", "c"] @bar[i] = v end end obj = C.new obj.foo, obj[2] = 1, 2 # @foo = 1; @bar = ["a", "b", 2] 左辺が `(({,}))' で終る場合や、`(({*}))' の直後の式を省略した場合にも 余った要素は無視されます。 例: foo,* = 1, 2, 3 # foo = 1 foo, = 1, 2, 3 # foo = 1 * = 1, 2, 3 特に最後の単体の `(({*}))' はメソッド呼出しにおいて引数を完全に無視 したいときに使用できます。(((<メソッド呼出し>))の引数の受け渡しは 多重代入と((*ほぼ*))同じルールが適用されます) 例: def foo(*) end foo(1,2,3) 多重代入の値は配列に変換された右辺です。 == 範囲式 例: 1 .. 20 /first/ ... /second/ 文法: 式1 `..' 式2 式1 ` ... ' 式2 条件式以外の場所では式1から式2までの範囲オブジェクトを返しま す。範囲オブジェクトは(())クラス のインスタンスです。(({ ... }))で生成された範囲オブジェクトは 終端を含みません。 条件式として範囲指定式が用いられた場合には、式1が真になるま では偽を返し、その後は式2が真を返すまでは真を返します。式2が 真になれば状態は偽に戻ります。(({..}))は式1が真になっ た時にすぐに式2を評価し(awkのように)、(({ ... }))は次の 評価まで式2を評価しません(sedのように)。 == and 例: test && set test and set 文法: 式 `&&' 式 式 `and' 式 まず、左辺を評価して、結果が真であった場合には右辺も評価しま す。(({and})) は同じ働きをする優先順位の低い演算子です。 == or 例: demo || die demo or die 文法: 式 `||' 式 式 or 式 まず左辺を評価して、結果が偽であった場合には右辺も評価します。 (({or})) は同じ働きをする優先順位の低い演算子です。 == not 例: ! me not me i != you 文法: `!' 式 not 式 式の値が真である時偽を、偽である時真を返します。 式 `!=' 式 (({!(式 == 式)}))と同じ。 式 `!~' 式 (({!(式 =~ 式)}))と同じ。 == 条件演算子 例: obj == 1 ? foo : bar 文法: 式1 ? 式2 : 式3 式1の結果によって式2または式3を返します。 if 式1 then 式2 else 式3 end とまったく同じです。 = Module モジュールのクラス。 == スーパークラス: * (()) == クラスメソッド: --- Module.constants このメソッドを呼び出した時点で参照可能な定数名の配列を返します。 class Foo FOO = 1 end p Module.constants # 出力中に FOO は現われない => ["RUBY_PLATFORM", "STDIN", ..., "Foo", ... ] (()) や、 ((<組込み関数/local_variables>)), ((<組込み関数/global_variables>)), (()), (()) も参照してください。 --- Module.nesting このメソッドを呼び出した時点でのクラス/モジュールのネスト情 報を配列に入れて返します。 module Foo module Bar module Baz p Module.nesting end end end # => [Foo::Bar::Baz, Foo::Bar, Foo] --- Module.new --- Module.new {|mod| ... } (()) 新しく名前の付いていないモジュールを生成して返します。 名前のないモジュールは、最初に名前を求める際に代入されている定数名 を検索し、見つかった定数名をモジュール名とします。 p foo = Module.new # => # p foo.name # => "" Foo = foo # ここで p foo すれば "Foo" 固定 Bar = foo p foo.name # => "Bar" ("Foo" になるか "Bar" になるかは不定) (()): ブロックが与えられると生成したモジュールをブロックの引数に渡し、モ ジュールのコンテキストでブロックを実行します。この場合も生成したモ ジュールを返します。 mod = Module.new mod.module_eval {|m| ... } mod と同じです。ブロックの実行は Module#initialize が行います。 == メソッド: --- self <=> other (({self})) と (({other})) を比較して、 (({self})) が (({other})) の子孫であるとき -1、 同一のクラス／モジュールのとき 0、 (({self})) が (({other})) の先祖であるとき 1 を返します。 親子関係にないクラス同士の比較ではその動作は不定です ((-(()): version 1.7 では (({nil})) を返します-)) module Foo end class Bar include Foo end class Baz < Bar end class Qux end p Bar <=> Foo # => -1 p Baz <=> Bar # => -1 p Baz <=> Foo # => -1 p Baz <=> Qux # => 1 (version 1.7 では nil) p Qux <=> Baz # => 1 (version 1.7 では nil) --- self < other --- self <= other --- self > other --- self >= other 比較演算子。(({self})) が ((|other|)) の子孫である時、 (({self < other})) が成立します。 親子関係にないクラス同士の比較ではいずれの関係も false を返します。 module Foo end class Bar include Foo end class Baz < Bar end class Qux end p Bar < Foo # => true p Baz < Bar # => true p Baz < Foo # => true p Baz < Qux # => false p Baz > Qux # => false --- self === obj このメソッドは主に ((<制御構造/case>)) 文での比較に用いられます。 ((|obj|)) が (({self})) と (()) の関係がある時、真になります。つまり、((<制御構造/case>)) ではクラ ス、モジュールの所属関係をチェックすることになります。 str = String.new case str when String # String === str を評価する p true # => true end --- ancestors クラス、モジュールのスーパークラスとインクルードしているモジュール を優先順位順に配列に格納して返します。 module Foo end class Bar include Foo end class Baz < Bar p ancestors p included_modules p superclass end # => [Baz, Bar, Foo, Object, Kernel] # => [Foo, Kernel] # => Bar --- class_eval(src[,fname[,lineno]]) --- class_eval { ... } (()) の別名。 --- class_variables クラス／モジュールに定義されている((<変数と定数/クラス変数>))の配 列を返します。スーパークラスやインクルードしているモジュールのクラ ス変数も含みます。 ((<組込み関数/local_variables>)), ((<組込み関数/global_variables>)), (()), (()), (()) も参照してください。 --- const_defined?(name) モジュールに ((|name|)) で指定される名前の定数が定義されている時真 を返します。((|name|)) は (()) か文字列で指定します。 スーパークラスやインクルードしたモジュールで定義された定数は対象には なりません。(ただし、(()) だけは例外 ((-あらい 2002-04-10: バグ?制限?-))) module Kernel FOO = 1 end # Object は include したモジュールの定数に対しても # true を返す p Object.const_defined? :FOO # => true module Bar BAR = 1 end class Object include Bar end # ユーザ定義のモジュールに対しても同様 p Object.const_defined? :BAR # => true class Baz include Bar end # Object以外では自身の定数だけがチェック対象 p Baz.const_defined? :BAR # => false --- const_get(name) モジュールに定義されている ((|name|)) で指定される名前の定数の値を 取り出します。定数が定義されていない時には例外 (()) が 発生します。 ((|name|)) は (()) か文字列で指定します。 --- const_set(name, value) モジュールに ((|name|)) で指定された名前の定数を ((|value|)) とい う値として定義し、((|value|)) を返します。 そのモジュールにおいてすでにその名前の定数が定義されている場合、警 告メッセージが出力されます。((|name|)) は (()) か文字列で 指定します。 --- constants そのモジュール(またはクラス)で定義されている定数名の配列を返 します。 スーパークラスやインクルードしているモジュールの定数も含みます。 (()) や ((<組込み関数/local_variables>)), ((<組込み関数/global_variables>)), (()), (()) も参照してください。 例: Module.constnats と Module#constnats の違い # 出力の簡略化のため起動時の定数一覧を取得して後で差し引く $clist = Module.constants class Foo FOO = 1 end class Bar BAR = 1 # 出力に FOO は含まれない p constants - $clist # => ["BAR", "Bar", "Foo"] # Module.constants も同様 p Module.constants - $clist # => ["BAR", "Bar", "Foo"] class Baz p constants - $clist # => ["Bar", "Foo"] # ネストしたクラスでは、外側のクラスで定義した定数は # 参照可能なので、BAR は、Module.constants には含まれる # (クラス Baz も Bar の定数なので同様) p Module.constants - $clist # => ["BAR", "Baz", "Bar", "Foo"] end end --- include?(mod) (()) (({self})) が モジュール ((|mod|)) をインクルードしていれば 真を返します。 Foo = Module.new class Bar include Foo end class Baz < Bar end p Bar.include? Foo #=> true p Baz.include? Foo #=> true --- included_modules インクルードされているモジュールの配列を返します。 (()) の例も参照してください --- instance_method(name) (({self})) のインスタンスメソッドをオブジェクト化した (()) を返します。((|name|)) は (()) か文字 列です。 (()) も参照してください。 --- method_defined?(name) モジュールにインスタンスメソッド ((|name|)) が定義されているとき真 を返します。((|name|)) は (()) か文字列です。 --- module_eval(expr, [fname, [lineno=1]]) --- module_eval {|mod| .... } モジュールのコンテキストで文字列 ((|expr|)) を評価してその結果を返 します。 ((|fname|))、((|lineno|)) が与えられた場合は、ファイル ((|fname|))、 行番号 ((|lineno|)) にその文字列があるかのようにコンパイルされ、ス タックトレース表示などのファイル名／行番号を差し替えることができま す。 ブロックが与えられた場合にはそのブロックをモジュールのコンテキスト で評価してその結果を返します。ブロックの引数 ((|mod|)) には (({self})) が渡されます。 モジュールのコンテキストで評価するとは、実行中そのモジュールが (({self})) になるということです。つまり、そのモジュールの定義文の 中にあるかのように実行されます。 ただし、ローカル変数は (({module_eval})) の外側のスコープと共有し ます。(()): version 1.6.8 以降、定数、クラス変数 のスコープも外側のスコープになります。 ((*注*)): module_eval のブロック中でメソッドを定義する場合、 (()) と同様の制限があります。詳細はそちらの 説明を参照してください。 (()), (()) (()) も参照してください。 --- name クラス、モジュールの名前を返します。名前のないクラス、モジュール については空文字列を返します((()) の例を参照)。 --- public_instance_methods([inherited_too]) --- instance_methods([inherited_too]) そのモジュールで定義されているメソッド名の一覧を配列で返します。 ((|inherited_too|)) が真であれば(デフォルトは偽)、スーパー クラスのメソッドも探索します。 (()), (()), も参照してください。 --- private_instance_methods([inherited_too]) そのモジュールで定義されている private メソッド名の一覧を配列で返 します。 ((|inherited_too|)) が真であれば(デフォルトは偽)、スーパー クラスのメソッドも探索します。 (()), も参照してください。 --- protected_instance_methods([inherited_too]) そのモジュールで定義されている protected メソッド名の一覧を配列で 返します。 ((|inherited_too|)) が真であれば(デフォルトは偽)、スーパー クラスのメソッドも探索します。 (()), も参照してください。 --- private_class_method(name, ... ) --- public_class_method(name, ... ) ((|name|)) で指定したクラスメソッド(クラスの特異メソッド) の可視性 を変更します。 (({self})) を返します。 == プライベートメソッド: --- alias_method(new, old) メソッドの別名を定義します。 ((<クラス／メソッドの定義/alias>)) との違いは以下の通りです。 * メソッド名は文字列または (()) で指定する * グローバル変数の別名をつけることはできない * (({alias})) は構文なのでメソッドの中では使えない (({self})) を返します。 --- append_features(module_or_class) モジュール(あるいはクラス)に (({self})) の機能を追加します。 このメソッドは (({Module#include})) の実体であり、(({include})) を Ruby で書くと以下のように定義できます。 ((-あらい 2002-03-03: (()) では、include を実行する 順序が変わったので each の代わりに reverse_each を使う-)) def include(*modules) modules.each {|mod| # append_features はプライベートメソッドなので # 直接 mod.append_features(self) とは書けない mod.__send__ :append_features, self # 1.7 以降は以下の行も実行される # mod.__send__ :included, self } end (({self})) を返します。 --- attr(name[, assignable]) 属性読み込みのためのインスタンスメソッド ((|name|)) を定義します。 ((|name|)) は (()) か文字列で指定します。返り値は常に (({nil})) です。 このメソッドで定義されるアクセスメソッドの定義は次の通りです。 def name @name end 省略可能な第 2 引数 ((|assignable|)) が指定されその値が真である 場合には、属性の書きこみ用メソッド (({name=})) も同時に定義されます。 その定義は次の通りです。 def name=(val) @name = val end --- attr_accessor(name, ... ) 属性 ((|name|)) に対する読み込みメソッドと書きこみメソッドの両方を 定義します。((|name|)) は (()) か文字列で指定します。返り値 は常に (({nil})) です。 このメソッドで定義されるメソッドの定義は以下の通りです。 def name @name end def name=(val) @name = val end --- attr_reader(name, ... ) 属性 ((|name|)) の読み出しメソッドを定義します。 ((|name|)) は (()) か文字列で指定します。 返り値は常に (({nil})) です。 このメソッドで定義されるメソッドの定義は以下の通りです。 def name @name end --- attr_writer(name, ... ) 属性 ((|name|)) への書き込みメソッド ((({name=}))) を定義します。 ((|name|)) は (()) か文字列で指定します。返り値は常に (({nil})) です。 このメソッドで定義されるメソッドの定義は以下の通りです。 def name=(val) @name = val end --- define_method(name, method) --- define_method(name) { ... } インスタンスメソッド ((|name|)) を定義します。 ((|method|)) には (())、(()) あるいは (()) のいずれかのインスタンスを指定します。 引数 ((|method|)) を与えたときはそれを、ブロック付きで 呼びだしたときはブロックを (()) 化したオブジェクトを、 それぞれ返します。 例: class Foo def foo() p :foo end define_method(:bar, instance_method(:foo)) end Foo.new.bar # => :foo ブロックを与えた場合、Ruby 1.7 以降では、定義したメソッド の実行時にブロックがレシーバクラスのインスタンスの上で instance_eval されます。 一方 Ruby 1.6 ではブロックとメソッドの関連づけを行うだけで、 メソッドの実行時にはブロックは生成時のコンテキストのままで 実行されます。たとえば以下の例を参照してください。 class C end # インスタンスメソッド print_self を定義。 # ただし define_method はプライベートメソッド # なので直接は呼べない。__send__ を介して呼ぶ。 C.__send__(:define_method, :print_self) { p self } # 1.6 の場合 C.new.print_self #=> main # 1.7 の場合 C.new.print_self #=> # --- extend_object(object) (()) の実体です。オブジェクトに モジュールの機能を追加します。(({Object#extend})) は、Ruby で 書くと以下のように定義できます。 ((-あらい 2002-03-16: (()) では、extend を実行する 順序が変わったので each の代わりに reverse_each を使う-)) def extend(*modules) modules.each {|mod| mod.__send__ :extend_object, self } end extend_object のデフォルトの実装では、(({self})) に定義されて いるメソッドを ((|object|)) の特異メソッドとして追加します。 ((-あらい 2002-02-14: この文いらないんじゃない？ 特に「デフォルトの実装では」ってまるで再定義されることを意図した メソッドの説明みたい-)) ((|object|)) を返します((-あらい 2002-01-12: self じゃないんだ-))。 --- include(module ... ) 指定されたモジュールの性質(メソッドや定数、クラス変数)を追加します。 (({self})) を返します。 (({include})) は多重継承の代わりに用いられる Mix-in を実現するため に使われます。 class C include FileTest include Math end p C.ancestors # => [C, Math, FileTest, Object, Kernel] モジュールの機能追加は、クラスの継承関係の間にそのモジュールが挿入 されることで実現されています。従って、メソッドの探索などはスーパー クラスに優先されて追加したモジュールから探索されます(上の例の (()) の結果がメソッド探索の順序です)。 同じモジュールを二回以上 include すると二回目以降は無視されます。 module Foo; end class Bar; include Foo; end class Baz < Bar; include Foo; end # <- この include は無効 p Baz.ancestors # => [Baz, Bar, Foo, Object, Kernel] モジュールの継承関係が循環してしまうような include を行うと、例外 (()) が発生します。 module Foo; end module Bar; include Foo; end module Foo; include Bar; end => -:3:in `append_features': cyclic include detected (ArgumentError) from -:3:in `include' from -:3 (()): 引数に複数のモジュールを指定した場合、最後 の引数から逆順に include を行います。 --- included(class_or_module) (()) (({self})) が (({include})) されたときに対象のクラスまたはモジュー ルを引数にインタプリタから呼び出されます。 module Foo def self.included(mod) p "#{mod} include #{self}" end end class Bar include Foo end # => "Bar include Foo" --- method_added(name) メソッド ((|name|)) が追加された時にインタプリタから呼び出されます。 ((|name|)) には追加されたメソッドの名前が (()) で渡されます。 class Foo def Foo.method_added(name) puts "method \"#{name}\" was added" end def foo end define_method :bar, instance_method(:foo) end => method "foo" was added method "bar" was added 特異メソッドの追加に対するフックには (()) を使います。 --- method_removed(name) (()) メソッドが (()) により削 除された時にインタプリタから呼び出されます。 ((|name|)) には削除されたメソッド名が (()) で渡されます。 class Foo def Foo.method_removed(name) puts "method \"#{name}\" was removed" end def foo end remove_method :foo end => method "foo" was removed 特異メソッドの削除に対するフックには (()) を使います。 --- method_undefined(name) (()) メソッドが (()) または ((<クラス／メソッドの定義/undef>))により未定義にされた時にインタプリタ から呼び出されます。 ((|name|)) には未定義にされたメソッド名が (()) で渡されます。 class Foo def Foo.method_undefined(name) puts "method \"#{name}\" was undefined" end def foo end def bar end undef_method :foo undef bar end => method "foo" was undefined method "bar" was undefined 特異メソッドの未定義に対するフックには (()) を使います。 --- module_function([name ... ]) 引数なしのときは今後このモジュール定義内で新規に定義されるメソッド を(())にします。モジュール関数とはプラ イベートメソッドであると同時にモジュールの特異メソッドでもあるよう なメソッドです。例えば (()) モジュールで定義されているメソッ ドがモジュール関数です。 引数が与えられた時には引数によって指定されたメソッドをモジュール関 数にします。 module_function はメソッドに「モジュール関数」という属性をつけるメ ソッドではなく、プライベートメソッドとモジュールの特異メソッドの 2 つを同時に定義するメソッドです。そのため、モジュール関数を ((<クラス／メソッドの定義/alias>)) する場合は module Foo def foo p "foo" end module_function :foo alias :bar :foo end Foo.foo # => "foo" Foo.bar # => undefined method `bar' for Foo:Module (NoMethodError) としても、プライベートメソッド foo の別名ができるだけで、Foo の特 異メソッド Foo.foo の別名は定義されません。このようなことをしたい場合 は、先に別名を定義してからそれぞれをモジュール関数として定義するの が簡単です。 module Foo def foo p "foo" end alias :bar :foo module_function :foo, :bar end Foo.foo # => "foo" Foo.bar # => "foo" (({self})) を返します。 --- private([name ... ]) 引数なしのときは今後このクラスまたはモジュール定義内で新規に定義さ れるメソッドを関数形式でだけ呼び出せるように(private)設定します。 引数が与えられた時には引数によって指定されたメソッドを private に 設定します。 例: class Foo def foo1() 1 end # デフォルトでは public private # 可視性を private に変更 def foo2() 2 end # foo2 は private メソッド end foo = Foo.new p foo.foo1 # => 1 p foo.foo2 # => private method `foo2' called for # (NoMethodError) (({self})) を返します。 --- protected([name ... ]) 引数なしのときは今後このクラスまたはモジュール定義内で新規に定義さ れるメソッドを protected に設定します。protected とはそのメソッド が定義されているクラスまたはそのサブクラスからしか呼び出すことがで きないという意味です。 引数が与えられた時には引数によって指定されたメソッドを protected に設定します。 (({self})) を返します。 --- public([name ... ]) 引数なしのときは今後このクラスまたはモジュール定義内で新規に定義さ れるメソッドをどんな形式でも呼び出せるように(public)設定します。 引数が与えられた時には引数によって指定されたメソッドを public に設 定します。 例: def foo() 1 end p foo # => 1 # the toplevel default is private p self.foo # => private method `foo' called for # (NoMethodError) def bar() 2 end public :bar # visibility changed (all access allowed) p bar # => 2 p self.bar # => 2 (({self})) を返します。 --- remove_class_variable(name) ((|name|)) で指定したクラス変数を取り除き、そのクラス変数に設定さ れていた値を返します。もし指定したクラス変数がそのモジュール(また はクラス)で定義されていない場合は例外 (()) が発生します。 class Foo @@foo = 1 remove_class_variable(:@@foo) # => 1 p @@foo # => uninitialized class variable @@foo in Foo (NameError) end (()), (()) も参照してください。 --- remove_const(name) ((|name|)) で指定した定数を取り除き、その定数に設定されていた値を 返します。指定した定数がそのモジュール(またはクラス)で定義されてい ない場合は例外 (()) が発生します。 class Foo FOO = 1 p remove_const(:FOO) # => 1 p FOO # => uninitialized constant FOO at Foo (NameError) end 現在のところ組込みクラス/モジュールを設定している定数や ((<組込み関数/autoload>)) を指定した(まだロードしてない)定数を削除 できないという制約があります。 class Object remove_const :Array end => -:2:in `remove_const': cannot remove Object::Array (NameError) (()), (()) も参照してください。 --- remove_method(name) ((|name|)) で指定したインスタンスメソッドをモジュールから取り除き ます。もし指定したメソッドが定義されていないときには例外 (()) が発生します。 class Foo def foo() end remove_method(:foo) end (({self})) を返します。 (()) の例も参照してください。 --- undef_method(name) インスタンスに対して ((|name|)) というメソッドを呼び出すことを禁止 します。もし指定したメソッドが定義されていないときには例外 (()) が発生します。 ((<クラス／メソッドの定義/undef>)) との違いは、メソッド名を文字列または (()) で与える、メソッド内でも使用できる、の二点です。 また (()) とはスーパークラスの定義が継承され るかどうかで区別されます。以下の挙動を参照してください。 class A def ok() puts 'A' end end class B < A def ok() puts 'B' end end B.new.ok # => B # undef_method の場合はスーパークラスに同名のメソッドがあっても # その呼び出しはエラーになる class B undef_method :ok end B.new.ok # => NameError # remove_method の場合はスーパークラスに同名のメソッドがあると # それが呼ばれる class B remove_method :ok end B.new.ok # => A (({self})) を返します。 = Range 範囲オブジェクトのクラス。範囲オブジェクトは範囲演算子 (({..})) または (({...})) によって生成されます。(({..})) 演算子によって生成された範囲 オブジェクトは終端を含み、(({...})) 演算子によって生成された範囲オブジェ クトは終端を含みません。 例: for i in 1..5 ... end これは 1 から 5 までの範囲オブジェクトを生成して、それぞれの値に対して 繰り返すと言う意味です。 範囲演算子のオペランドは互いに (({<=>})) で比較できる必要があります。 さらに (()) を実行するためには (({succ})) メソッ ドを実行できるものでなければいけません。 ((-あらい 2002-01-13: 正確には、each できるためには繰り返される要素は 終端と (({<=})) あるいは、(({<})) メソッドで比較できる必要がある(なぜ か (({<=>})) ではない)。さらに、(()) のサブクラスであれば (({to_i})) メソッドにより(()) のサブクラスにならなくてはなら ず。これは、(({+ 1})) (なぜか (({succ})) ではない)を受け付けなくてはな らない。また、(({===})) で (({Range})) オブジェクトの範囲内かどうかを 調べられるためには両端のオブジェクトが (({<=})), (({>})), (({>=})) を 持たなくてはならない(なぜか (({<=>})) ではない)。このマニュアルの記述 内容に反して (({<=>})) メソッドを持つかどうかは (({Range})) オブジェク トを生成する際にチェックされるが直接は利用されない((()) 想 定しているのだろうか？)。この記述は、version 1.6.6 2002-01-11 のソース を元に書いている。勘違いがあれば突っ込んで欲しい-)) == スーパークラス: * (()) == インクルードしているモジュール: * (()) == クラスメソッド: --- Range.new(first,last[, exclude_end]) ((|first|)) から ((|last|)) までの範囲オブジェクトを生成して返しま す。((|exclude_end|)) が真ならば終端を含まない範囲オブジェクトを生 成します。((|exclude_end|)) 省略時には終端を含みます。 生成時に、引数の正当性チェックとして first <=> last を実行します。これが例外を返す場合、例外 (()) が発 生します。((()): ((|first|)) が (()) の インスタンスであればこのチェックは行われません) == メソッド: --- self === other このメソッドは主に ((<制御構造/case>)) 文での比較に用いられます。 ((|other|)) が範囲内に含まれている時に真を返します。 --- begin --- first 最初の要素を返します。 --- each {|item| ... } 範囲内の要素に対して繰り返します。 (()): Range#each は各要素の succ メソッドを使用 してイテレーションするようになりました。1.6 までは、Numeric オブ ジェクトは、特別に算術演算で行われていました。この変更により Float の Range の扱いが変わります(Float は、succ を持たない)。 (1.0 .. 2.0).each {|v| p v} => ruby 1.6.7 (2002-03-01) [i586-linux] 1 2 => -:1:in `each': cannot iterate from Float (TypeError) from -:1 ruby 1.7.3 (2002-09-02) [i586-linux] --- end --- last 終端を返します。範囲オブジェクトが終端を含むかどうかは関係ありませ ん。 p (1..5).end # => 5 p (1...5).end # => 5 --- exclude_end? 範囲オブジェクトが終端を含まないとき真を返します。 --- length --- size 範囲の長さを返します。 始点と終端が Integer のインスタンスなら (last - first + (exclude_end? ? 0 : 1)) です。それ以外では、each が実行され範囲の長さを数えます。 (()): length, size メソッドはなくなりました。 必要なら p ("a" .. "z").to_a.size => 26 などとする必要があります。 --- step([s]) {|item| ... } (()) 範囲内の要素を ((|s|)) おきに繰り返します。((|s|)) には正の整数を 指定します。デフォルトは 1 です。 ((-あらい 2002-01-13: もちろん (()) のサブクラスであれば ((|item|)) + ((|s|)) が動作しなければならない。それ以外では ((|succ|)) を ((|s|)) 回実行する。-)) ("a" .. "f").step(2) {|v| p v} # => "a" "c" "e" --- to_ary (()) (()) と同じです。範囲内の個々の値を要素とする配列 を返します。多重代入などで暗黙の型変換(配列化)が起こります。 a,b,c = (1..3) p [a,b,c] #=> [1, 2, 3] = 制御構造 * ((<制御構造/条件分岐>)) * ((<制御構造/if>)) * ((<制御構造/if 修飾子>)) * ((<制御構造/unless>)) * ((<制御構造/unless 修飾子>)) * ((<制御構造/case>)) * ((<制御構造/繰り返し>)) * ((<制御構造/while>)) * ((<制御構造/while 修飾子>)) * ((<制御構造/until>)) * ((<制御構造/until修飾子>)) * ((<制御構造/for>)) * ((<制御構造/break>)) * ((<制御構造/next>)) * ((<制御構造/redo>)) * ((<制御構造/retry>)) * ((<制御構造/例外処理>)) * ((<制御構造/raise>)) * ((<制御構造/begin>)) * ((<制御構造/rescue修飾子>)) * ((<制御構造/その他>)) * ((<制御構造/return>)) * ((<制御構造/BEGIN>)) * ((<制御構造/END>)) Rubyでは(Cなどとは異なり)制御構造は式であって、何らかの値を返すものが あります(返さないものもあります。値を返さない式を代入式の右辺に置くと parse error になります)。 RubyはC言語やPerlから引き継いだ制御構造を持ちますが、 その他に((<メソッド呼出し/イテレータ>))というループ抽象化の機 能があります。イテレータは繰り返しを始めとする制御構造をユー ザが定義する事が出来るものです. == 条件分岐 === if 例: if age >= 12 then print "adult fee\n" else print "child fee\n" end gender = if foo.gender == "male" then "male" else "female" end 文法: if 式 [then] 式 ... [elsif 式 [then] 式 ... ] ... [else 式 ... ] end 条件式を評価した結果が真である時、(({then})) 以下の式を実行します。 (({if})) の条件式が偽であれば (({elsif})) の条件を評価します。 (({elsif})) 節は複数指定できます。全ての (({if})) および (({elsif})) の条件式が偽であったときは (({else})) 節があればその式が実行されます。 (({if})) 式は、条件が成立した節(あるいは (({else})) 節)の最後に実行し た式の結果を返します。(({else})) 節がなくいずれの条件も成り立たなけれ ば (({nil})) を返します。 Ruby では (({false})) または (({nil})) だけが偽で、それ以外は 0 や空文 字列も含め全て真です。 Ruby では if を繋げるのは (({elsif})) であり、(({else if})) (C のように)でも (({elif}))(sh のように)でもないことに注意してください。 また (({if})) の条件式が正規表現のリテラルである時には $_ =~ リテラル であるかのように評価されます。 === if 修飾子 例: print "debug\n" if $DEBUG 文法: 式 if 式 右辺の条件が成立する時に、左辺の式を評価してその結果を返します。 条件が成立しなければ (({nil})) を返します。 === unless 例: unless baby? feed_meat else feed_milk end 文法: unless 式 [then] 式 ... [else 式 ... ] end (({unless})) は条件実行を行いますが、条件が (({if})) と反対で、条件が偽の時に実行を行います。(({unless})) 式に (({elsif})) を指定することはできません。 === unless 修飾子 例: print "stop\n" unless valid(passwd) 文法: 式 unless 式 右辺の条件が成立しない時に、左辺の式を評価してその結果を返します。 条件が成立しなければ (({nil})) を返します。 === case 例: case $age when 0 .. 2 "baby" when 3 .. 6 "little child" when 7 .. 12 "child" when 13 .. 18 "youth" else "adult" end 文法: case [式] [when 式 [, 式] ... [then] 式..].. [else 式..] end (({case})) は一つの式に対する一致判定による分岐を行います。(({when})) 節で指定された値と最初の式を評価した結果とを演算子 (({===})) を用いて 比較して、一致する場合には (({when})) 節の本体を実行します。 つまり、 case 式0 when 式1, 式2 stmt1 when 式3, 式4 stmt2 else stmt3 end は以下の (({if})) 式とほぼ等価です。 _tmp = 式0 if 式1 === _tmp or 式2 === _tmp stmt1 elsif 式3 === _tmp or 式4 === _tmp stmt2 else stmt3 end (({===})) がどのような条件で真になるかは、各クラスの (({===})) メソッ ドの動作についてのドキュメントを参照して下さい。 (({case})) の「式」を省略した場合、(({when})) の条件式が偽でない最初の 式を評価します。 foo = false bar = true quu = false case when foo then puts 'foo is true' when bar then puts 'bar is true' when quu then puts 'quu is true' end # "bar is true"と表示される (({case})) は、条件が成立した (({when})) 節、(あるいは (({else})) 節) の最後に実行した式の結果を返します。いずれの条件も成り立たなければ (({nil})) を返します。 == 繰り返し === while 例: arr = [0,2,4,8,16,32,64,128,256,512,1024] i = 0 while i < arr.length print arr[i] i += 1 end 文法: while 式 [do] ... end 式を評価した値が真の間、本体を繰り返して実行します。 (({while})) は値を返しません。 (()): (({while})) は (({nil})) を返します。また、引 数を伴った (({break})) により (({while})) 式の戻り値をその値にすること もできます。 === while 修飾子 例: sleep(60) while io_not_ready? 文法: 式 while 式 右辺の式を評価した値が真の間、左辺を繰り返して実行します。 左辺の式が (({rescue})) 節も (({ensure})) 節もない (({begin})) である場合には、 それを最初に一回評価してから繰り返します。 ((-(()): version 1.7 では、rescue/ensure 節があっても、 同様に解釈されます-)) 例: send_request(data) begin res = get_response() end while res == 'Continue' (({while})) 修飾した式は値を返しません。 (()): (({while})) 修飾した式は (({nil})) を返します。 また、引数を伴った (({break})) により (({while})) 修飾した式の戻り値を その値にすることもできます。 === until 例: until f.eof? print f.gets end 文法: until 式 [do] ... end 式を評価した値が真になるまで、本体を繰り返して実行します。 (({until})) は、値を返しません。 (()): (({until})) は (({nil})) を返します。また、引 数を伴った (({break})) により (({until})) 式の戻り値をその値にすること もできます。 === until修飾子 例: print(f.gets) until f.eof? 文法: 式 until 式 右辺の式を評価した値が真になるまで、左辺を繰り返して実行しま す。 左辺の式が (({rescue})) 節も (({ensure})) 節もない (({begin})) である場合には、 それを最初に一回評価してから繰り返します。 ((-(()): version 1.7 では、rescue/ensure 節があっても、 同様に解釈されます-)) 例: send_request(data) begin res = get_response() end until res == 'OK' (({until})) 修飾した式は値を返しません。 (()): (({until})) 修飾した式は (({nil})) を返します。 また、引数を伴った (({break})) により (({until})) 修飾した式の戻り値を その値にすることもできます。 === for 例: for i in [1, 2, 3] print i*2, "\n" end 文法: for lhs ... in 式 [do] 式.. end 式を評価した結果のオブジェクトの各要素に対して本体を繰り返し て実行します。これは以下の式とほぼ等価です。 (式).each `{' `|' lhs..`|' 式.. `}' 「ほぼ」というのは、(({do ... end}))または(({{ }}))による ブロックは新しいローカル変数の有効範囲を導入するのに対し、 (({for}))文はローカル変数のスコープに影響を及ぼさない点が 異なるからです。 (({for})) は、(({in})) に指定したオブジェクトの (({each})) メソッドの戻り値を返します。 === break 例: i = 0 while i < 3 print i, "\n" break end 文法: break break val ruby 1.7 feature (({break})) はもっとも内側のループを脱出します。ルー プとは * while * until * for * イテレータ のいずれかを指します。Cと違い、(({break}))はループを 脱出する作用だけを持ち、(({case})) を抜ける作用は持ち ません。 (({break})) によりループを抜けた (({for})) やイテレータは (({nil})) を返します。(()): ただし、引数を指定した場合はループ の戻り値はその引数になります。 === next 例: # 空行を捨てるcat ARGF.each_line do |line| next if line.strip.empty? print line end 文法: next next val ruby 1.7 feature (({next}))はもっとも内側のループの次の繰り返しにジャンプします。 ((<メソッド呼出し/イテレータ>))では、((<メソッド呼出し/yield>)) 呼出し の脱出になります。 (({next})) により抜けた (({yield})) 式は (({nil})) を返します。 (()): ただし、引数を指定した場合、(({yield})) 式の戻 り値はその引数になります。 === redo 例: redo 文法: redo ループ条件のチェックを行なわず、現在の繰り返しをやり直します。 === retry 例: retry 文法: retry イテレータ、ブロックまたはfor文の中で使われた場合には、そのイテレータ を起動しなおします。イテレータの引数も再評価されます。 for i in 1..5 retry if some_condition # i == 1 からやり直し end # ユーザ定義の "untilループ" def UNTIL(cond) yield retry unless cond end (({retry})) は、ループ以外に後述の (({rescue})) 節でも使えます。この場 合は、(({begin})) 式を始めからもう一度実行します。(({retry})) を使うこ とである処理が成功するまで処理を繰り返すようなループを作ることができます。 begin do_something # exception raised rescue # handles error retry # restart from beginning end (({rescue})) 節やイテレータ、ブロック for 文以外で (({retry})) が用い られた場合には例外 (()) が発生します。 ((-あるいは、突然エラーになってインタプリタが終了します。 retry #=> -:1: retry outside of rescue clause-)) イテレータ呼び出しにおける (({break})), (({next})), (({redo})), (({retry})) をまとめると以下のようになります。 def iter (a) : (b) yield (c) : (d) end iter { retry } -> (a) へ飛ぶ iter { redo } -> (b) へ飛ぶ iter { next } -> (c) へ飛ぶ iter { break } -> (d) へ飛ぶ (a) は、厳密には引数評価から始まります。(b) は yield 実行の直前を 指しています。(d) は、メソッドの終了です。 def iter(var = p("(a)")) p " : " # p "(b)" yield p "(c)" p " : " ensure p "(d)" end iter { p "(b)"; retry } # => (a) .. (b)(d)(a) .. (b)(d)(a) ... iter { p "(b)"; redo } # => (a) .. (b)(b)(b)(b) ... iter { p "(b)"; next } # => (a) .. (b)(c) .. (d) iter { p "(b)"; break } # => (a)..(b)(d) ((-あらい 2002-01-13: ensure は大域脱出を捕まえるので retry が (d) に飛んでいるあまり良い例じゃないか-)) == 例外処理 === raise 例: raise "you lose" # 例外 RuntimeError を発生させる # 以下の二つは SyntaxError を発生させる raise SyntaxError, "invalid syntax" raise SyntaxError.new("invalid syntax") raise # 最後の例外の再発生 文法: raise raise messageまたはexception raise error_type, message raise error_type, message, traceback 例外を発生させます。第一の形式では直前の例外を再発生させます。 第二の形式では、引数が文字列であった場合、その文字列をメッセー ジとする (()) 例外を発生させます。引数が例外 オブジェクトであった場合にはその例外を発生させます。第三の形式 では第一引数で指定された例外を、第二引数をメッセージとして発生さ せます。第四の形式の第三引数は ((<組込み変数/$@>))または ((<組込み関数/caller>))で得られる スタック情報で、例外が発生した場所を示します。 発生した例外は後述の (({begin})) 式の (({rescue})) 節で捕らえることができます。 その場合 (({rescue ((|error_type|)) => ((|var|))})) の形式を使えば 例外オブジェクトを得られます。このオブジェクトは組み込み 変数 ((<組込み変数/$!>)) でも得られます。また例外が 発生したソースコード上の位置は変数 ((<組込み変数/$@>)) に格納されます。 ((<組込み関数/raise>)) は Ruby の予約語ではなく、(()) モジュールで 定義されている関数的メソッドです。 === begin 例: begin do_something rescue recover ensure must_to_do end 文法: begin 式.. [rescue [error_type,..] [=> evar] [then] 式..].. [else 式..] [ensure 式..] end 本体の実行中に例外が発生した場合、(({rescue})) 節(複数指定できます)が 与えられていれば例外を捕捉できます。発生した例外と一致する (({rescue})) 節が存在する時には (({rescue})) 節の本体が実行されます。 発生した例外は ((<組込み変数/$!>)) を使って参照することができます。また、 指定されていれば変数 ((|evar|)) にも (({$!})) と同様に発生した例外が格 納されます。 begin raise "error message" rescue => evar p $! p evar end # => # # 例外の一致判定は例外のクラスが (({rescue})) 節で指定したクラスと同じか またはサブクラスであるかどうか (()) を用いて判 定されます((-(()): 1.7 での例外の一致判定は (()) を用いて行われます-))。 ((|error_type|)) が省略された時は (()) のサブクラスであ る全ての例外を捕捉します。Rubyの組み込み例外は((()) や (()) のような脱出を目的としたものを除いて) (()) のサブクラスです。 例外クラスのクラス階層については ((<組込みクラス／モジュール／例外クラス/例外クラス>)) を参照してください。 (({rescue})) では ((|error_type|)) は通常の引数と同じように評価され、 そのいずれかが一致すれば本体が実行されます。((|error_type|)) を評価し た値がクラスやモジュールでない場合には例外 (()) が発生しま す。 省略可能な (({else})) 節は、本体の実行によって例外が発生しなかった場合 に評価されます。 (({ensure})) 節が存在する時は (({begin})) 式を終了する直前に必ず (({ensure})) 節の本体を評価します。 (({begin}))式全体の評価値は、本体／(({rescue}))節／(({else}))節のうち 最後に評価された文の値です。また各節において文が存在しなかったときの値 は(({nil}))です。いずれにしても(({ensure}))節の値は無視されます。 === rescue修飾子 例: open("nonexistent file") rescue STDERR.puts "Warning: #$!" 文法: 式1 rescue 式2 式1で例外が発生したとき、式2を評価します。 以下と同じ意味です。捕捉する例外クラスを指定することはできません。 (つまり、(()) 例外クラスのサブクラスだけしか捕捉できません) begin 式1 rescue 式2 end rescue修飾子を伴う式の値は例外が発生しなければ式1、例外が発生すれば式2 です。ただし、大抵の場合、優先順位の都合により式全体を括弧で囲む必要が あります。 var = open("nonexistent file") rescue false p var => nil # 値を持たない変数 var が定義されただけ var = (open("nonexistent file") rescue false) p var => false 特にメソッドの引数に渡す場合は二重に括弧が必要となります。 p(open("nonexistent file") rescue false) => parse error p((open("nonexistent file") rescue false)) => false (()): 1.7 では、rescue の優先度が変更され、 この心配はなくなっています。 var = open("nonexistent file") rescue false p var => false p(open("nonexistent file") rescue false) => false == その他 === return 例: return return 12 return 1,2,3 文法: return [式[`,' 式 ... ]] 式の値を戻り値としてメソッドの実行を終了します。式が2つ以上 与えられた時には、それらを要素とする配列をメソッドの戻り値と します。式が省略された場合には (({nil})) を戻り値とします。 === BEGIN 例: BEGIN { ... } 文法: BEGIN '{' 文.. '}' 初期化ルーチンを登録します。(({BEGIN}))ブロックで指定した文は当該ファ イルのどの文が実行されるより前に実行されます。複数の(({BEGIN}))が指定 された場合には指定された順に実行されます。 (({BEGIN}))ブロックはコンパイル時に登録されます。即ち一つの記述につき ただ一回だけ登録が行われます。 (({BEGIN}))ブロックは独立したローカル変数のスコープを導入するため、ロー カル変数を外部と共有できません。ブロックの外と情報を伝達するには定数や グローバル変数などを介する必要があります。 (({BEGIN}))はトップレベルにしか置けません。 === END 例: END { ... } 文法: END '{' 文.. '}' 「後始末」ルーチンを登録します。(({END}))ブロックで指定した文はインタ プリタが終了する時に実行されます。複数の(({END}))ブロックを登録した場 合は、登録したときと逆の順序で実行されます。 (({END}))ブロックは一つの記述につき最初の一回のみ有効です。たとえば以 下のようにループの中で実行しても複数の(({END}))ブロックが登録されるわ けではありません。そのような目的には((<組込み関数/at_exit>))を使います。 5.times do |i| END { p i } end # => 0 また(({END}))で登録されたブロックを取り除く事はできません。 同様に((<組込み関数/at_exit>))のブロックも登録取り消しはできません。 (({END}))もトップレベルにしか置く事はできません。((-あらい 2001-10-06 本当？ あらい 2002-01-15: どうやら、(1) eval() による評価で (2) def の中で END す るとparse error のようです。よくわからない条件です-)) (({END}))ブロックは(({BEGIN}))ブロックとは異なり周囲とスコープを共有し ます。すなわちイテレータと同様のスコープを持ちます。 (({END}))ブロックの中で発生した例外はその(({END})) ブロックを中断しますが、すべての後始末ルーチンが実 行されるよう、インタプリタは終了せずにメッセージだ けを出力します。 例: END { p "FOO" } END { raise "bar"; p "BAR" } END { raise "baz"; p "BAZ" } => baz (RuntimeError) bar (RuntimeError) "FOO" = RuntimeError 実行時例外です。例外を指定しない ((<組込み関数/raise>)) の呼び出しはこ の例外を発生させます。 == スーパークラス: * (()) = Kernel 全てのクラスから参照できるメソッドを定義しているモジュール。 (({Object})) クラスはこのモジュールをインクルードしています。 ((<組込み関数>))の項で解説されているメソッドはこのモジュールで定義され ています。 (({Object})) クラスのメソッドは実際にはこのモジュールで定義されていま す。これはトップレベルでのメソッドの再定義に対応するためです。 = StandardError この例外クラスとそのサブクラスは、(())でクラ スを省略したときにも捕捉できます。 == スーパークラス: * (()) = Interrupt ((<組込み関数/trap>)) されていない (({SIGINT})) を受け取ると発生します。 (({SIGINT})) 以外のシグナル受信による例外は (()) を参 照してください。 == スーパークラス: * (()) ((())) * (()) ((())) = TypeError 不正な型を使用したときに発生します。 == スーパークラス: * (()) = メソッド呼出し * ((<メソッド呼出し/super>)) * ((<メソッド呼出し/イテレータ>)) * ((<メソッド呼出し/yield>)) 例: foo.bar() foo.bar bar() print "hello world\n" print Class::new 文法: [式 `.'] 識別子 [`(' 式 ... [`*' [式]],[`&' 式] `)'] [式 `::'] 識別子 [`(' 式 ... [`*' [式]],[`&' 式] `)'] メソッド呼出し式はレシーバ((({`.'}))の左側の式の値)の メソッドを呼び出します。レシーバが指定されない時は(({self})) のメソッドを呼び出します。 `(({::}))' を `(({.}))' の代わりに使えます。`(({::}))' は、クラスメソッ ド呼び出しに使うという流儀がありますが((-あらい 2002-04-21: このマニュ アルでは `::' の流儀を積極的には使いません。クラスメソッドとインスタン スメソッドの表記を使い分けるのは難しいと考えている(実際、同じスクリプ ト内で `::' を使ったり、`.' を使ったりと一貫しない例は良く見かける)の と、クラスが普通のオブジェクトと同様オブジェクトであることの理解を妨げ る。大文字のメソッドに関してここに書いた制限があるのが煩わしい。という 個人的な考えからです-))、大文字で始まるメソッド名を使うつもりで Klass::Foo とした場合定数と見なされるという制限があります。大文字で始まるメソッド 名を使用する場合は Klass.Foo と `(({.}))' を使うか、 Klass::Foo() と括弧でメソッド呼び出しであることを明示する必要があります。 メソッド名には通常の識別子の他、識別子に(({?}))または (({!}))の続いたものが許されます。慣習として、述語(真 偽値を返すメソッド)には(({?}))を、同名の ((({!}))の無い)メソッドに比べてより破壊的な作用をもつ メソッド(例:(({tr}))と(({tr!})))には (({!}))をつけるようになっています。 最後の引数の直前に(({*}))がついている場合、その引数の 値が展開されて渡されます。つまり: foo(*[1,2,3]) は foo(1,2,3) と同じです。 最後の引数の直前に (({&})) がついている場合、その引数で指定した手続き オブジェクト((()))やメソッドオブジェクト((()))がブロック としてメソッドに渡されます。詳細は((<メソッド呼出し/イテレータ>))を参 照してください。 メソッド呼び出しの際、((|private|))なメソッドは関数形式 (レシーバを省略した形式)でしか呼び出すことができません。 また((|protected|))なメソッドは(({self}))がそのメソッド が定義されたのと同じクラス、またはそのサブクラスでなければ 呼び出せません。(((<クラス／メソッドの定義/呼び出し制限>))を参照) == super 例: super super(1,2,3) 文法: super super(式, ... ) (({super}))は現在のメソッドがオーバーライドしているメ ソッドを呼び出します。括弧と引数が省略された場合には現在のメソッド の引数がそのまま引き渡されます。引数を渡さずにオーバーライドした メソッドを呼び出すには (({super()})) と括弧を明示します。 例: class Foo def foo(arg=nil) p arg end end class Bar < Foo def foo(arg) super(5) # 5 を引数にして呼び出す super(arg) # 5 を引数にして呼び出す super # 5 を引数にして呼び出す super(arg) の略記法 arg = 1 super # 1 を引数にして呼び出す super(arg) の略記法 super() # 引数なしで呼び出す end end Bar.new.foo 5 == イテレータ 例: [1,2,3].each do |i| print i*2, "\n" end [1,2,3].each {|i| print i*2, "\n" } 文法: method(arg1, arg2, ...) do [`|' 式 ... `|'] 式 ... end method(arg1, arg2, ...) `{' [`|' 式 ... `|'] 式 ... `}' method(arg1, arg2, ..., `&' proc_object) イテレータとは制御構造の抽象化のために用いられるメソッドです。 最初はループの抽象化のために用いられていましたが、最近では その他の用途も拡大しています。(({do ... end})) または (({{ ... } })) で 囲まれたコードの断片(ブロックと呼ばれる)を後ろに付けてメソッドを 呼び出すと、そのメソッドの内部からブロックを評価できます。 このようなブロックを呼び出すメソッドをイテレータと呼びます。 イテレータからのブロックの呼び出しは((<メソッド呼出し/yield>))式を 用います。yield に渡された値は (({|})) と (({|}))の間にはさまれた 変数に代入されます。 (({{ ... }}))の方が(({do ... end}))ブロックよりも結合強度が 強いです((-あらい:2001-04-02 version 1.6.0 から 1.6.2 までは この結合強度の違いがなくなっていましたが、これはバグです。version 1.6.3 で修正 されました-))。例えば: foobar a, b do .. end # foobar がイテレータとして呼び出されます foobar a, b { .. } # b がイテレータとして呼び出されます ブロックの中で初めて代入された(宣言された)ローカル変数はその ブロックの中でだけ有効です。例えば: foobar { i = 20 # ローカル変数 `i' が宣言された ... } print defined? i # `i' はここでは未定義なので false foobar a, b do i = 11 # まったく別の変数 i の宣言 ... end 以下は逆にブロック外でも有効な例です。 i = 10 [1,2,3].each do |m| p i * m # いきなり i を使える end ブロックの代わりに手続きオブジェクト((()))をブロックとして渡すに はイテレータの引数の最後に `(({&}))' で修飾した手続きオブジェクトを渡 します。(({Proc})) の代わりにメソッドオブジェクト((()))を渡す ことも出来ます。この場合、そのメソッドを呼ぶ手続きオブジェクトが生成さ れ渡されます。 pobj = proc {|v| p v } [1,2,3].each(&pobj) => 1 2 3 (()): version 1.7 では、to_proc メソッドを持つオブジェクトならば、`(({&}))' 修飾した引数として渡すことができます(デフォルトで Proc、Method オブジェ クトは共に to_proc メソッドを持ちます)。to_proc はメソッド呼出し時に実 行され、Proc オブジェクトを返すことが期待されます。 class Foo def to_proc Proc.new {|v| p v} end end [1,2,3].each(&Foo.new) => 1 2 3 イテレータの戻り値は、通常のメソッドと同様ですが、ブロックの中から ((<制御構造/break>)) により中断された場合は (({nil})) を返します。 (()): (({break})) に引数を指定した場合はその値がイテ レータの戻り値になります。 == yield 例: yield data 文法: yield `(' [式 [`,' 式 ... ]] `)' yield [式 [`,' 式 ... ]] 引数をブロックの引数として渡してブロックを評価します。(({yield})) は ((<メソッド呼出し/イテレータ>))を定義するために ((<クラス／メソッドの定義/メソッド定義>))内で使用します。 def foo yield(1,2) end foo {|a,b| p [a,b]} ブロック引数の代入は((<演算子式/多重代入>))と同じルールで行われます。 また (({yield})) を実行したメソッドにブロックが渡されていない (イテレータではない) 時は例外 (()) が発生します。 (({yield})) はブロック内で最後に評価した式の値を返します。また、 ((<制御構造/next>)) によりブロックの実行が中断された場合は (({nil})) を返します。 (()): (({next})) に引数を指定した場合はその値が (({yield})) の戻り値になりま す。 = Method (()) によりオブジェクト化され たメソッドオブジェクトのクラスです。メソッドの実体（名前でなく）とレシー バの組を封入します。(()) オブジェクトと違ってコンテキストを保持 しません。 (()) との差…(({Method})) は取り出しの対象であるメソッドが なければ作れませんが、(({Proc})) は準備なしに作れます。その点から (({Proc})) は使い捨てに向き、(({Method})) は何度も繰り返し生成する 場合に向くと言えます。また内包するコードの大きさという点では (({Proc})) は小規模、(({Method})) は大規模コードに向くと言えます。 例: * 既存のメソッドを Method オブジェクト化する ((()) を参照) class Foo def foo(arg) "foo called with arg #{arg}" end end m = Foo.new.method(:foo) p m # => # p m.call(1) # => "foo called with arg 1" * 名前のないメソッド(の代わり)が必要なら (()) を使うと良い pr = Proc.new {|arg| "proc called with arg #{arg}" } p pr # => # p pr.call(1) # => "proc called with arg 1" * Method オブジェクトが有用なのは以下のような場合 class Foo def foo() "foo" end def bar() "bar" end def baz() "baz" end end obj = Foo.new # 任意のキーとメソッドの関係をハッシュに保持しておく methods = {1 => obj.method(:foo), 2 => obj.method(:bar), 3 => obj.method(:baz)} # キーを使って関連するメソッドを呼び出す p methods[1].call # => "foo" p methods[2].call # => "bar" p methods[3].call # => "baz" * が、レシーバを固定させる(Method オブジェクトはレシーバを保持する)必 要がないなら (())を使う方法も有用。 class Foo def foo() "foo" end def bar() "bar" end def baz() "baz" end end # 任意のキーとメソッド(の名前)の関係をハッシュに保持しておく # レシーバの情報がここにはないことに注意 methods = {1 => :foo, 2 => :bar, 3 => :baz} # キーを使って関連するメソッドを呼び出す # レシーバは任意(Foo クラスのインスタンスである必要もない) p Foo.new.send(methods[1]) # => "foo" p Foo.new.send(methods[2]) # => "bar" p Foo.new.send(methods[3]) # => "baz" == スーパークラス: * (()) == メソッド: --- self[arg, ...] --- call(arg ... ) --- call(arg ... ) { ... } メソッドオブジェクトに封入されているメソッドを起動します。 引数やブロックはそのままメソッドに渡されます。 (({self[]})) の形の呼び出しは通常のメソッド呼び出しに見た目を 近付けるためだけに用意されたもので、((|Array#[]|))のような 他の ((|[]|)) メソッドとの意味的な関連性はありません。 メソッドオブジェクトが汚染されている場合、そのメソッドは、セーフレ ベル 4 で実行されます (((<セキュリティモデル/セーフレベルに関するその他の詳細>))を参照)。 --- arity メソッドオブジェクトの引数の数を返します。(({self})) が引数の数を 可変長で受け取れる場合 -(最低限必要な数 + 1) を返します。 --- inspect (()) 参照。以下の形式の文字列を返し ます。 # klass1 は、Method#inspect では、レシーバのクラス名、 (())#inspect では、UnboundMethod オブジェクトの生成 元となったクラス／モジュール名です。 klass2 は、実際にそのメソッドを定義しているクラス／モジュール名、 method は、メソッド名を表します。 module Foo def foo "foo" end end class Bar include Foo end p Bar.new.method(:foo) # => # (()): 特異メソッドに対しては、 # # という形式の文字列を返します。二番目の形式では klass1 はレシーバ、 klass2 は実際にそのメソッドを定義しているオブジェクトになります。 obj = "" class < # class Foo def Foo.foo end end p Foo.method(:foo) # => # class Bar < Foo end p Bar.method(:foo) # => # --- to_proc (({self})) を (({call})) する (()) オブジェクトを生成して返 します。 --- unbind (({self})) のレシーバとの関連を取り除いた (()) オブ ジェクトを生成して返します。 = クラス／メソッドの定義 * ((<クラス／メソッドの定義/クラス定義>)) * ((<クラス／メソッドの定義/特異クラス定義>)) * ((<クラス／メソッドの定義/モジュール定義>)) * ((<クラス／メソッドの定義/メソッド定義>)) * ((<クラス／メソッドの定義/メソッドの評価>)) * ((<クラス／メソッドの定義/特異メソッド定義>)) * ((<クラス／メソッドの定義/クラスメソッドの定義>)) * ((<クラス／メソッドの定義/呼び出し制限>)) * ((<クラス／メソッドの定義/定義に関する操作>)) * ((<クラス／メソッドの定義/alias>)) * ((<クラス／メソッドの定義/undef>)) * ((<クラス／メソッドの定義/defined?>)) == クラス定義 例: class Foo < Super def test : end : end 文法: class 識別子 [`<' superclass ] 式.. end クラスを定義します。クラス名はアルファベットの大文字で始まる識別子です。 ((-(()): version 1.7 では、rescue/ensure 節を指定で きます-)) クラス定義は、識別子で指定した定数へのクラスの代入になります (Ruby では、クラスもオブジェクトの一つで (())クラスの インスタンスです)。 クラスが既に定義されいるとき、さらに同じクラス名でクラス定義を書くとク ラスの定義の追加になります。ただし、元のクラスと異なるスーパークラスを 明示的に指定して定義すると、元のクラスとは異なる新たなクラスを同名で定 義することになります(このとき、クラス名の定数を上書きすることになるの で警告メッセージが出ます)。 class Foo < Array def foo end end # 定義を追加(スーパークラス Array を明示的に指定しても同じ) class Foo def bar end end # 別のクラスを定義(スーパークラスが異なるので) class Foo < String end # => warning: already initialized constant Foo クラス定義式の中は (({self})) がそのクラスであることと、 ((<クラス／メソッドの定義/呼び出し制限>))のデフォルトが異なること以外 にトップレベルとの違いはありません。クラス定義式中には任意の式を書くこ とができクラス定義の際に実行されます。 クラス定義はネスト(入れ子)にして定義できます。以下の例で入れ子の外側の クラス Foo と内側のクラス Bar の間には(定数 Bar が Foo の中の定数 Foo::Bar であること以外には)継承関係などの機能的な関連はまったくありま せん。 class Foo class Bar end end クラスのネストは、意味的に関連するクラスを外側のクラス／モジュールでひ とまとまりにしたり、包含関係を表すために使用されます。 # 関連するクラスを Net というカテゴリにまとめる # このような場合は外側は普通モジュールが利用される # (Net のインスタンスがない。Net を include できるなどのため) module Net class HTTP end class FTP end end obj = Net::HTTP.new # あるいは include Net obj = HTTP.new # 以下のような使い方は組込みのクラスにも見られる # 利用者は File::Constants を include することで、 # File::RDONLY などと書かずに直接 RDONLY と書くことができる。 class File module Constants RDONLY = 0 WRONLY = 1 end include Constants end File.open("foo", File::RDONLY) # あるいは include File::Constants File.open("foo", RDONLY) # 上記はあくまでも例である。実際の File.open ではより簡便な # File.open("foo", "r") という形式が使われる クラス定義式は値を返しません。 == 特異クラス定義 例: class << obj def test : end : end 文法: class `<<' expr 式.. end クラス定義と同じ構文で特定のオブジェクトの機能を定義します。 この構文の内部で定義したメソッドや定数は指定したオブジェクト に対してだけ有効になります。 特異クラス定義式は、最後に評価した式の結果を返します。 最後に評価した式が値を返さない場合は nil を返します。 == モジュール定義 例: module Foo def test : end : end 文法: module 識別子 式.. end モジュールを定義します。モジュール名はアルファベットの大文字 で始まる識別子です。 ((-(()): version 1.7 では、rescue/ensure 節を指定で きます-)) モジュール定義は、識別子で指定した定数へのモジュールの代入に なります(Ruby では、モジュールもオブジェクトの一つで (())クラスのインスタンスです)。 モジュールが既に定義されいるとき、さらに同じモジュール名でモ ジュール定義を書くとモジュールの定義の追加になります。 モジュール定義式は値を返しません。 == メソッド定義 例: def fact(n) if n == 1 then 1 else n * fact(n-1) end end 文法: def メソッド名 [`(' [arg ['=' default]] ... [`,' `*' arg] [',' '&' arg]`)'] 式.. [rescue [error_type,..] [=> evar] [then] 式..].. [else 式..] [ensure 式..] end この定義のある場所にメソッドを定義します。すなわち、 クラス/モジュール定義中ならばそのクラス/モジュールのメソッドを 定義します。トップレベルならばどこからでも呼べるメソッドを 定義します。このようなメソッドは結果として他の言語における 「関数」のように使えます。 メソッド名としては通常の識別子の他に、再定義可能な演算子 (例: ==, +, -など ((<演算子式>)) を参照)も指定できます。 仮引数にデフォルト式が与えられた場合、メソッド呼び出しで実 引数を省略したときのデフォルト値になります(デフォルト式の 評価は呼び出し時にメソッド定義内のコンテキストで行われます)。 最後の仮引数の直前に (({*})) がある場合には残りの実引数は みな配列としてこの引数に格納されます。 例: # 引数のないメソッド。以下 end は省略 def foo end # 引数のあるメソッド def foo(arg, arg2) # デフォルト引数のあるメソッド def foo(arg = nil) # ブロックをとる def foo(arg, &block) # すべて持つ def foo(arg, arg2, arg3 = nil, *rest, &block) # 演算子形式 def ==(other) def +(other) def *(other) 最後の仮引数の直前に (({&})) があるとこのメソッドに与えられているブロッ クが手続きオブジェクト((()))としてこの引数に格納されます。これは、 ((<メソッド呼出し/イテレータ>))を定義する方法の一つです。(イテレータを 定義する代表的な方法は ((<メソッド呼出し/yield>)) を呼び出すことです。 他に (())/((<組込み関数/proc>)) を使う方法などもありま す。) ブロックが与えられなかった場合のブロック引数の値は(({nil}))です。 (({*}))と(({&}))が同時に指定される場合には(({&}))が後ろに来ます。 例: イテレータの定義 # yield を使う def foo # block_given? は、メソッドがブロックを渡されて # 呼ばれたかどうかを判定する組込み関数 if block_given? yield(1,2) end end # Proc.new を使う def bar if block_given? Proc.new.call(1,2) # proc.call(1,2) でも同じ(proc は組込み関数) end end # 応用: 引数として Proc オブジェクトとブロックの # 両方を受け付けるイテレータを定義する例 def foo(block = Proc.new) block.call(1,2) end foo(proc {|a,b| p [a,b]}) foo {|a,b| p [a,b]} # ブロック引数を使う def baz(&block) if block block.call(1,2) end end そのほか特殊な形式をとるメソッド定義を以下に挙げます。 # 単項プラス/マイナス def +@ def -@ # 要素代入 def foo=(value) # obj.foo = value # [] と []= def [](key) # obj[key] def []=(key, value) # obj[key] = value def []=(key, key2, value) # obj[key, key2] = value # バッククォート記法 def `(arg) # `arg` または %x(arg) バッククォート記法の実装はメソッドなのでこのように再定義が可能です。普 通はこのメソッドを再定義するべきではありませんが、まれにOS(シェル)のコ マンド実行の挙動に不具合がある場合などに利用できます((- 実際の応用例が (()),(())にあります-))。 通常のメソッド定義はネストできません((-(()): 1.7 以 降ネスト可能になりました-))。またメソッド実行時の例外を捕捉するために ((<制御構造/begin>)) 式と同様の(({rescue})), (({else})), (({ensure})) 節を指定できます。 メソッド定義式は値を返しません。 === メソッドの評価 メソッドが呼び出されると、以下の順で式が評価されます。 * 指定されていれば引数のデフォルト式 * メソッドの本体 * 指定されていれば例外の発生の有無によりメソッド定義式の (({rescue})) 節または (({else})) 節 * 指定されていれば (({ensure})) 節 引数のデフォルト式も含め、すべてそのメソッドのコンテキストで評価されま す。 メソッドの戻り値は ((<制御構造/return>)) に渡した値です。(({return})) が呼び出されなかった場合は、メソッドの本体から (({ensure})) 節実行直前 までの最後に評価した式の値を返します。 最後に評価した式が(((<制御構造/while>))など)値を返さない式の場合は (({nil})) を返します。 またメソッドは定義する前に呼び出すことはできません。例えば foo def foo print "foo\n" end は未定義メソッドの呼び出しで例外 (()) を発生させます。 == 特異メソッド定義 例: def foo.test print "this is foo\n" end 文法: def 式 `.' 識別子 [`(' [引数 [`=' default]] ... [`,' `*' 引数 ]`)'] 式.. [rescue [error_type,..] [=> evar] [then] 式..].. [else 式..] [ensure 式..] end 特異メソッドとはクラスではなくある特定のオブジェクトに固有の メソッドです。特異メソッドの定義はネストできます。 クラスの特異メソッドはそのサブクラスにも継承されます。言い替 えればクラスの特異メソッドは他のオブジェクト指向システムにお けるクラスメソッドの働きをすることになります。 特異メソッド定義式は値を返しません。 == クラスメソッドの定義 Ruby におけるクラスメソッドとはクラスの特異メソッドのことです。Ruby で は、クラスもオブジェクトなので、普通のオブジェクトと同様に特異メソッド を定義できます。 したがって、何らかの方法でクラスオブジェクトにメソッドを定義すれば、そ れがクラスメソッドとなります。具体的には以下のようにして定義することが 出来ます(モジュールも同様です)。 # 特異メソッド方式。 class Hoge def Hoge.foo end end # クラス定義の外でも良い def Hoge.bar end # 以下のようにすればクラス名が変わってもメソッド部の変更が不要 class Hoge def self.baz 'To infinity and beyond!' end end # 特異クラス方式。複数のメソッドを一度に定義するとき向き class << Hoge def bar 'bar' end end # モジュールをクラスに extend すれば、モジュールのインスタンス # メソッドがクラスメソッドになる module Foo def foo end end class Hoge extend Foo end (({extend})) については、(()) を参照して ください。 == 呼び出し制限 メソッドは (({public}))、(({private}))、(({protected})) の三通りの 呼び出し制限を持ちます。 (({public})) に設定されたメソッドは制限なしに呼び出せます。 (({private})) に設定されたメソッドは関数形式でしか呼び出せません。 (({protected})) に設定されたメソッドは、そのメソッドが定義された クラスおよびその下位クラスのインスタンスからしか呼び出せません。 デフォルトでは (({def})) 式がクラス定義の外にあれば (({private}))、 クラス定義の中にあれば (({public})) に定義します。これは (())、(())、 (()) を用いて変更できます。ただし (())という名前のメソッドは定義する場所に関係なく常に (({private}))になります。 例: def foo # デフォルトは private end class C def bar # デフォルトは public end def ok # デフォルトは public end private :ok # …だが、ここで private に変わる def initialize # initialize は private end end == 定義に関する操作 === alias 例: alias foo bar alias :foo :bar alias $MATCH $& 文法: alias 新メソッド名 旧メソッド名 alias 新グローバル変数名 旧グローバル変数名 メソッドあるいはグローバル変数に別名をつけます。メソッド名に は識別子そのものか (()) を指定します(obj.method のよ うな式を書くことはできません)。(({alias})) の引数はメソッド 呼び出し等の一切の評価は行われません。 メソッドの定義内で別名を付けるには(())クラスのメソッド (()) を利用して下さい。 別名を付けられたメソッドは、その時点でのメソッド定義を引き継 ぎ、元のメソッドが再定義されても、再定義前の古いメソッドと同 じ働きをします。あるメソッドの動作を変え、再定義するメソッド で元のメソッドの結果を利用したいときなどに利用されます。 # メソッド foo を定義 def foo "foo" end # 別名を設定(メソッド定義の待避) alias :_orig_foo :foo # foo を再定義(元の定義を利用) def foo _orig_foo * 2 end p foo # => "foofoo" グローバル変数の alias は一方の変更が他方に反映され、まった く同じ変数であるかのようになります。添付ライブラリの (()) はこのことを利用して((<組込み変数>)) に英 語名をつけます。 ((-あらい 2001-11-04: 実際には特定の組込み変数だけが ここに書いた通りの挙動になる。version 1.7 ではこの制 限は取り除かれている-)) # 特殊な変数のエイリアスは一方の変更が他方に反映される $_ = 1 alias $foo $_ $_ = 2 p [$foo, $_] # => [2, 2] # こちらは通常の変数のエイリアスで本当の意味での # エイリアスにはならない。これは、version 1.6 ま # での制限 $bar = 3 alias $foo $bar $bar = 4 p [$foo, $bar] # => [3, 4] ただし、正規表現の部分文字列に対応する変数 (({$1})),(({$2})), ... には別名を付けることができません。ま た、インタプリタに対して重要な意味のあるグローバル変数 (((<組込み変数>))を参照)を再定義すると動作に支障を来す場合が あります。 (({alias})) 式は nil を返します。 === undef 例: undef bar 文法: undef メソッド名[, メソッド名[, ...]] メソッドの定義を取り消します。メソッド名には識別子そのもの か (()) を指定します(obj.method のような式を書くことはできません)。 (({undef})) の引数はメソッド呼び出し等の一切の評価は行われません。 メソッドの定義内で定義を取り消すには(())クラスのメソッ ド (()) を利用して下 さい。 (({undef})) のより正確な動作は、メソッド名とメソッド定義との 関係を取り除き、そのメソッド名を特殊な定義と関連づけます。この状態の メソッドの呼び出しは例えスーパークラスに同名のメソッドがあっても例外 (()) を発生させます。 (一方、メソッド (()) は、関係を取 り除くだけです。この違いは重要です)。 (({alias}))による別名定義と (({undef}))による定義取り消しによってクラスのインタフェー スをスーパークラスと独立に変更することができます。ただし、メ ソッドがselfにメッセージを送っている場合もあるので、よく注意 しないと既存のメソッドが動作しなくなる可能性があります。 (({undef})) 式は nil を返します。 === defined? 例: defined? print defined? File.print defined?(foobar) defined?($foobar) defined?(@foobar) defined?(Foobar) 文法: defined? 式 式が定義されていなければ、偽を返します。定義されていれば式の種別 を表す文字列を返します。 定義されていないメソッド、undef されたメソッド、 (()) により削除さ れたメソッドのいずれに対しても (({defined?})) は偽を返します。 特別な用法として以下があります。 defined? yield yield の呼び出しが可能なら真(文字列 "yield")を返します。 ((<組込み関数/block_given?>)) と同様にメソッドがブロック付きで呼ばれたか を判断する方法になります。 defined? super ((<メソッド呼出し/super>)) の実行が可能なら真(文字列 "super")を返します。 defined? a = 1 p a # => nil "assignment" を返します。実際に代入は行いませんがローカル変数は定義されます。 /(.)/ =~ "foo" p defined? $& # => "$&" p defined? $1 # => "$1" p defined? $2 # => nil 大文字で始まるメソッド名に対しては (({()})) を明示しなければ定数の判定 を行ってしまいます。 def Foo(a,b) end p defined? Foo # => nil p defined? Foo() # => "method" Foo = 1 p defined? Foo # => "constant" 以下は、defined? が返す値の一覧です。 * "super" * "method" * "yield" * "self" * "nil" * "true" * "false" * "assignment" * "local-variable" * "local-variable(in-block)" * "global-variable" * "instance-variable" * "constant" * "class variable" * "$&", "$`", "$1", "$2", ... * "expression" = Class クラスのクラス。より正確に言えば、個々のクラスはそれぞれメタクラスと呼 ばれる名前のないクラスをクラスとして持っていて、(({Class})) はそのメタ クラスのクラスです。この関係は少し複雑ですが、Ruby を利用するにあたっ ては特に重要ではありません。 クラスは、モジュールとは * インスタンスを作成できる * (()) による Mix-in ができない という違いがありますが、それ以外のほとんどの機能は (()) から継 承されています。(({Module})) のメソッドのうち * (()) * (()) * (()) は (({Class})) では未定義にされています。 == スーパークラス: * (()) == クラスメソッド: --- Class.new([superclass]) --- Class.new([superclass]) {|klass| ... } 新しく名前の付いていない ((|superclass|)) のサブクラスを生成します。 ((|superclass|)) が省略された時には(({Object})) のサブクラスを生成 します。 名前のないクラスは、最初に名前を求める際に代入されている定数名を検 索し、見つかった定数名をクラス名とします。 p foo = Class.new # => # p foo.name # => "" Foo = foo # ここで p foo すれば "Foo" 固定 Bar = foo p foo.name # => "Bar" ("Foo" になるか "Bar" になるかは不定) (()): ブロックが与えられると生成したクラスをブロックの引数に渡し、クラス のコンテキストでブロックを実行します。この場合も生成したクラスを返 します。 klass = Class.new(super) klass.module_eval {|m| ... } klass と同じです。ブロックの実行は Module#initialize が行います。 == メソッド: --- allocate (()) クラスのインスタンスを生成して返します。生成したオブジェクトは (通常)クラスのインスタンスであること以外には何も特性を持ちません。 --- new( ... ) クラスのインスタンスを生成して返します。このメソッドの引数はブロック引数も 含め (()) に渡されます。 (()): version 1.7 では、new は、allocate でイン スタンスを生成し、initialize で初期化を行うメソッドです。 --- superclass クラスのスーパークラスを返します。 == プライベートメソッド: --- inherited(subclass) クラスのサブクラスが定義された時、新しく生成されたサブクラスを引数 にインタプリタから呼び出されます。 class Foo def Foo.inherited(subclass) puts "class \"#{self}\" was inherited by \"#{subclass}\"" end end class Bar < Foo end # => class "Foo" was inherited by "Bar" = importenv.rb (({require 'importenv'}))を加えるだけで環境変数をグローバル変数としてアクセスすることができるようになる。 == 使用例 require 'importenv' p $USER # => "rubikitch" (自分のユーザ名) $USER = "matz" p ENV["USER"] # => "matz" p $USER # => "matz" (*) === 注意 Ruby 1.6.2までは(*)の出力が自分のユーザ名になってしまうバグがあったが、それは1.6.3で修正されている。 = 組込み関数 Ruby には厳密な意味では関数はありませんが、(()) モジュールで 定義されているメソッドは (どこからでも関数形式で呼び出せるので) 他言語における関数のように使えます。これらのメソッドを再定義する 場合は他の場所への影響を考えて行なう必要があります。 --- ` str 文字列 ((|str|)) を外部コマンドとして実行し、その出力を文字列として 返します。このメソッドは (({`str`})) の形式で呼ばれます (((<%x(...)|リテラル/%記法>)) という表記によっても呼び出せます。 詳細は ((<リテラル/コマンド出力>)) を参照してください)。 実行したコマンドの終了ステータスは ((<組込み変数/$?>)) で参照できます。 コマンドの出力を得る必要がなく、単にコマンドを実行したいだけなら ((<組込み関数/system>)) を使います。特に端末を制御するコマンドでは (({`command`})) は失敗するかもしれません。 --- Array(arg) ((|arg|)).to_ary か ((|arg|)).to_a を呼び出して引数を配 列に変換した結果を返します。 変換した結果が配列でなければ例外 (()) が発生 します。 (()): 引数が (({nil})) の場合、例外 (()) が発生します。 --- Float(arg) 引数を浮動小数点数((()))に変換した結果を返します。 整数や浮動小数点数と見なせない文字列を引数に指定した場合、例外 (()) が発生します。 (()) も参照してください。 p Float("10") # => 10.0 p Float("10e2") # => 1000.0 p Float("1e-2") # => 0.01 p Float(".1") # => 0.1 p Float("nan") # => NaN (ruby 1.7 feature: => invalid value (ArgumentError)) p Float("INF") # => Infinity (ruby 1.7 feature: => invalid value (ArgumentError)) p Float("-Inf") # => -Infinity (ruby 1.7 feature: => invalid value (ArgumentError)) p Float(("10" * 1000).to_f) # => Infinity (ruby 1.7 feature: => out of range (ArgumentError) p Float("0xa.a") # => 10.625 # (ruby 1.7 feature: => invalid value (ArgumentError)) p Float(" \n10") # => 10.0 # 先頭の空白は無視される p Float("1_0_0") # => 100.0 # `_' も数値要素とみなす p Float("") # => invalid value (ArgumentError) p Float(nil) # => 0.0 # ruby 1.7 feature: cannot convert nil into Float --- Integer(arg) 引数を整数((()),(()))に変換した結果を返します。 数値、文字列以外のオブジェクトに対しては (({to_i})) メソッドを 使用します((()): 1.7 では、(({to_int})))。 変換した結果が整数((())のサブクラス)でなければ 例外 (()) が発生します。 引数が文字列であった場合には、0x, 0b, 0 などの接頭辞に応じて それぞれ 16 進、2 進、8 進数として変換します。 整数と見なせない文字列を引数に指定した場合、例外 (()) が発生します。 ((-あらい 2002-02-22: 渡せる引数について詳細に触れること-)) (()), (()), (()) も参照してください。 --- String(arg) ((|arg|)).(({to_s})) を呼び出して引数を文字列に変換した 結果を返します。 変換した結果が文字列でなければ例外 (()) が発 生します。 ((|arg|)) が文字列の場合、何もせず ((|arg|)) を返します。 --- abort --- abort(message) (()) Ruby プログラムを異常終了します。((<組込み関数/exit>)) との違いは、 呼び出し時に ((<組込み変数/$!>)) が (({nil})) でなければその例外の メッセージを標準エラー出力に出力することと、プログラムの終了ステー タスが 1 固定であることです。 (()): 引数 ((|message|)) を指定すると (())#(()) に ((|message|)) を設定し て標準エラー出力に出力します。 --- at_exit { .... } 与えられたブロックをインタプリタ終了時に実行します。(({at_exit})) がメソッドである点を除けば、((<制御構造/END>)) ブロックによる終了 処理の登録と同等です。登録した処理を取り消すことはできません。 ((<終了処理>))も参照してください。 登録した処理を (()) オブジェクトで返します。 --- autoload(const_name, feature) 定数 ((|const_name|)) を最初に参照した時に ((|feature|)) を ((<組込み関数/require>)) するように設定します。((|const_name|)) は文字列または (()) で指定します。 なお、((|const_name|)) には、"::" 演算子を含めることはできません (つまり、トップレベルの定数しか指定できません)。 (({nil})) を返します。 --- binding 変数・メソッドなどの環境情報を含んだ (()) オブジェクトを 生成して返します。通常、((<組込み関数/eval>)) の第二引数として使います。 --- caller([level]) ((|level|)) 段上(引数省略時は、1)の呼出し元の情報を ((<組込み変数/$@>)) の形式のバックトレース(文字列の配列)として返します。トップレベルで は空の配列を返します。caller の戻り値を (({$@})) に代入することで 例外の発生位置を設定できます。以下のようなコードで caller 呼出し時 のスタックトレースを表示できます。 puts caller(0) --- callcc {|cont| .... } (()) を参照してください。 --- catch(tag) {|tag| .... } ブロックを実行してその値を返します。ブロックの実行中に ((|tag|)) と同じ名前の ((<組込み関数/throw>)) が行われた 場合は、その (({throw})) の第二引数を戻り値とします。 例えば以下のコードを実行すると ((|some_process|)) は 呼び出されず、また catch の戻り値は 10 ではなく 25 に なります。 ret = catch(:exit) { throw :exit, 25 some_process() 10 } p ret #=> 25 ネストしたループは ((<制御構造/break>)) によって一気に抜 けることはできません。 このような場合、catch や ((<例外|制御構造/begin>)) を使用します。 catch(:loop1) { for i in 1..2 for j in 1..2 throw :loop1, j end end } --- chop --- chop! システム変数 ((<組込み変数/$_>)) を最後の文字を取り除いたものにし ます(終端が"\r\n"であれば2文字取り除きます)。 (({chop!})) は文字列そのものを変更しその結果を返しますが、 取り除く文字列がなければ (({nil})) を返します。 詳細は (()) を参照してください。 (({$_.chop})) と関数 (({chop})) では以下の点で違いがあります。 * (({chop})) は (({$_})) の値をコピーして、コピーの方を更新し、 (({$_})) に((*再代入*))します。 --- chomp([rs]) --- chomp!([rs]) システム変数 ((<組込み変数/$_>)) を ((|rs|)) で指定される末尾 の文字列を取り除いたものにします。 (({chomp!})) は文字列そのものを変更しその結果を返しますが、 取り除く文字列がなければ (({nil})) を返します。 ((|rs|)) のデフォルト値は ((<組込み変数/"$/">)) です。 詳細は (()) を参照してください。 (({$_.chomp})) と関数 (({chomp})) では以下の点で違いがあります。 * (({chomp})) は (({$_})) の値をコピーして、コピーの方を更新し、 (({$_})) に((*再代入*))します。 --- eval(expr[, binding[, fname[, lineno=1]]]) 文字列 ((|expr|)) を Ruby プログラムとして評価してその結果を返しま す。第2引数に (()) オブジェクトまたは (()) オブジェ クトを与えた場合、そのオブジェクトを生成したコンテキストで文字列を 評価します。((<組込み関数/binding>)) も参照してください。 def foo a = 1 binding end eval("p a", foo) # => 1 ((|fname|)) と ((|lineno|)) が与えられた場合には、ファイル ((|fname|)) 行番号 ((|lineno|)) に文字列があるかのように コンパイルされ、スタックトレースの表示などを差し替えることが できます。 --- exec(command) --- exec(program[, arg1[, arg2[, ...]]]) ((|command|)) で指定されたコマンドを実行します。プロセスの実行コー ドはそのコマンド(あるいは shell。後述)になるので、起動に成功した場 合、この関数からは戻りません。起動に失敗し、ruby インタプリタに制 御が戻った場合は、例外 (()) が発生します。 一番目の形式では ((|command|)) が shell のメタ文字 ((({* ? {} [] <> () ~ & | \ $ ; ' ` " \n})))を含む場合、 shell 経由で実行されます。そうでなければインタプリタから直接 実行されます。 二番目の形式では、常に shell を経由せずに実行されます。 この場合には空白や shell のメタキャラクタもそのまま ((|program|)) の引数に渡されます。 先頭の引数が2要素の配列であった場合、第1要素の文字列が実際に 起動するプログラムのパスであり、第2要素が「みせかけ」のプロ グラム名になります。 --- exit([status]) Rubyプログラムの実行を終了します。((|status|)) として整 数が与えられた場合、その値を Ruby コマンドの終了ステータスとし ます。デフォルトの終了ステータスは 0 です。 (({exit})) は例外 (()) を発生させ ることによってプログラムの実行を終了させますので、 必要に応じて (()) 節で捕捉することができます。 --- exit!([status]) 整数 ((|status|)) を終了ステータスとして、Ruby プログラム の実行を終了します。(({exit!})) は (({exit})) と は違って、例外処理などは一切行ないません。 ((<組込み関数/fork>))の後、 子プロセスを終了させる時などに用いられます。 --- fork --- fork { ... } (()) システムコールを使ってプロセスの複製を作 ります。親プロセスでは子プロセスのプロセスIDを、子プロセスでは (({nil})) を返します。ブロックを指定して呼び出した場合には、生成し た子プロセスでブロックを評価します。 --- gets([rs]) --- readline([rs]) Ruby インタプリタ実行時に引数として与えられたファイル(なければ標準 入力)をつなげた仮想的なファイル(システム変数 ((<組込み変数/$<>)) や (()) でアクセスできる) から一行読み込んで、文字列を返しま す。ファイルの終りに到達した時には (({nil})) を返します。 行の区切りは引数 ((|rs|)) で指定した文字列になります。((|rs|)) の デフォルト値はシステム変数 ((<組込み変数/"$/">)) の値です。読み込 んだ文字列はシステム変数 ((<組込み変数/$_>)) にもセットされます。 ((|rs|)) に (({nil})) を指定すると行区切りなしとみなしてファイルの内容を すべて読み込みます。 空文字列 (({""})) を指定すると連続する改行を行の区切りとみなします (パラグラフモード)。 (({readline})) は (({gets})) と同じ働きをしますが、 ファイルの最後まで読むと例外 (()) を発生させます。 --- global_variables プログラム中で定義されているグローバル変数(`$'で始まる変数)名の 配列を返します。 ((<組込み関数/local_variables>)), (()), (()), (()), (()) も参照してください。 --- gsub(pattern[, replace]) --- gsub!(pattern[, replace]) --- gsub(pattern) {|matched| ... } --- gsub!(pattern) {|matched| ... } システム変数 ((<組込み変数/$_>)) の指す文字列内で ((|pattern|)) に マッチする部分を全て ((|replace|)) に置き換えた文字列を返します。 引数 ((|replace|)) が省略された時にはイテレータとして動作し、ブロッ クを評価した結果で置換を行います。ブロックには引数としてマッチした 文字列が渡されます。 $_ = "foobar" p gsub(/o+/) {|m| m.upcase } # => "fOObar" (({gsub!})) は (({$_})) の指している文字列そのものを書き換えます。 詳細は、(()) を参照してください。 (({String#gsub})) と関数 (({gsub})) では以下の点で違いがあります。 * (({gsub}))メソッドは (({$_})) の値をコピーして、コピーの方を更新し、 (({$_})) に((*再代入*))します。 --- iterator? --- block_given? メソッドにブロックが与えられている時には真、そうでない時に偽 を返します。 --- load(file[, priv]) ((|file|)) から Ruby プログラムをロード・実行します。 ((|file|)) をロードするパスはシステム変数 ((<組込み変数/$:>)) で決定されます。パス先頭の `(({~}))'(チルダ)はユーザのホームディ レクトリに展開されます。 省略可能な引数 ((|priv|)) が真のとき、 ロード・実行は内部的に生成される無名モジュールを トップレベルとして行われ、グローバルな名前空間を汚染しません。 ロードに成功した場合は、(({true})) を返します。 失敗した場合は、例外 (()) が発生します。 --- local_variables 現在のスコープで定義されているローカル変数名の配列を返します。 ((<組込み関数/global_variables>)), (()), (()), (()), (()) も参照してください。 --- loop { ... } (中断されない限り)永遠にブロックの評価を繰り返します。 --- open(file[, mode[, perm]]) --- open(file[, mode[, perm]]) {|io| ... } ((|file|)) をオープンして、(()) オブジェクトを返します。 ((|mode|)) は、以下の文字列か整数((()) モジュール の定数の論理和)を指定します。省略時は (({"r"})) が指定されたもの とみなします。 * "r", RDONLY: ファイルを読み込みモードでオープンします。 * "w", WRONLY|CREAT|TRUNC: ファイルを書き込みモードでオー プンします。オープン時にファイルがすでに存在していれば その内容を空にします。 * "a", WRONLY|CREAT|APPEND: ファイルを書き込みモードでオー プンします。出力は((*常に*))ファイルの末尾に追加されま す ((-例えば、ファイルオープン中にファイルのサイズが小さ くなってもその末尾に出力されます。このことはログ出力な どでプログラムを実行したままそのログを小さくしたい場合 に利用されます-)) "+" があれば、ファイルは読み書き両用モード(RDWR)でオープ ンされます。 * "r+": ファイルの読み書き位置は先頭にセットされます。 * "w+": "r+" と同じですが、オープン時にファイルがすでに 存在していればその内容を空にします。 * "a+": "r+" と同じですが、オープン時にファイルがすでに 存在していれば読み書き位置がファイルの末尾にセットされ ます。 これらのいずれに対しても "b" フラグを("r+b"のように)つけることがで きます(整数なら File::BINARY)。この場合、バイナリモードでオープン します(ただし、システムがテキスト／バイナリでファイルを区別する場 合に限ります) 第 3 引数 ((|perm|)) は (()) の第 3 引数と同 じく、(({CREAT})) 時のファイルのアクセス権を整数で指定します。 この引数は、第 2 引数が数値形式でなければ無視されます((-version 1.7 では第 2 引数によらず指定されれば有効になります-))。 デフォルトは 0666 です。 ファイル名が `(({|}))' で始まる時には続く文字列をコマンドとして起 動し、コマンドの標準入出力に対してパイプラインを生成します ファイル名が (({"|-"})) である時、(({open})) は Ruby の子プロセス を生成し、その子プロセスとの間のパイプ((())オブジェクト)を返し ます。(このときの動作は、(()) と同じです。 (()) にはパイプラインを生成する機能はありません)。 ((*注意*)): Perlと異なりコマンドは常に `(({|}))' で始まります。 (({open})) がブロックとともに呼び出された時、(({open})) はファイル をオープンしてブロックを実行し、ブロックの実行が終了するとファイル をクローズします。この場合はブロックを評価した結果を返します。つま り、以下のようになります。 open(path, mode) do |f| ... end # 上記とほぼ同じコード f = open(path, mode) begin ... ensure f.close end --- p(obj, [obj2, ...]) ((|obj|)) を人間に読みやすい形で出力します。以下のコードと同じです。 ((())参照) print obj.inspect, "\n", obj2.inspect, "\n", ... (({nil})) を返します。 --- print([arg1[, arg2, ...]]) 引数を順に出力します。引数が与えられない時には変数 ((<組込み変数/$_>)) の値を出力します。 文字列以外のオブジェクトが引数として与えられた場合には、 当該オブジェクトを (({to_s})) メソッドにより文字列に変換 してから出力します。 ただし、(({nil})) に対しては文字列 (({"nil"})) を出力します 変数 ((<組込み変数/$;>)) (出力フィールドセパレータ)に (({nil})) で ない値がセットされている時には、各引数の間にその文字列を出力します。 変数 ((<組込み変数/$\>)) (出力レコードセパレータ)に (({nil})) でな い値がセットされている時には、最後にそれを出力します。 (({nil})) を返します。 --- printf([port, ]format[, arg[, ...]]) C 言語の printf と同じように、((|format|)) に従い引数を文字列に変 換して ((<$>|組込み変数>)) に出力します。第一引数が (()) のサ ブクラスのインスタンスであった場合はそのオブジェクトに対して出力を 行ないます((-第一引数に IO を渡すインタフェースは obsolete と明言 されています(あらい 2002-01-07 どこで言ってたっけ？確か「デスクトッ プリファレンスにはこのことは載ってなかったという話だったはず)-))。 引数を 1 つも指定しなければ何もしません ((-あらい 2002-01-07: IO#printfとは違う-))。 Ruby における format 文字列の拡張については(()) の項を参照してください。 (({nil})) を返します。 --- proc { ... } --- lambda { ... } --- proc --- lambda 与えられたブロックから手続きオブジェクト ((()) のインスタンス) を生成して返します((())と同じです)。 ブロックが指定されなければ、呼び出し元のメソッドで指定されたブロック を手続きオブジェクトとして返します。呼び出し元のメソッドがブロックなし で呼ばれると (()) 例外が発生します。 --- putc(ch) 文字 ((|ch|)) を ((<$>|組込み変数>)) に出力します。 ((|ch|)) が数字なら 0 〜 255 の範囲の対応する文字を出力 します。((|ch|)) が文字列なら、その先頭の文字を出力します。 ((|ch|)) を返します。 putc("ch") putc(?c) putc(99) # => ccc --- puts([obj[, obj2[, ....]]] ) ((|obj|)) と改行を順番に ((<$>|組込み変数>)) に出力します。 引数がなければ改行のみを出力します。 引数が配列の場合、その要素と改行を順に出力します。 配列や文字列以外のオブジェクトが引数として与えられた場合には、 当該オブジェクトを最初に (({to_ary})) により配列へ、 次に (({to_s})) メソッドにより文字列へ変換を試みます。 ただし、(({nil})) に対しては文字列 (({"nil"})) を出力します 末尾が改行で終っている引数に対しては (({puts})) 自身 は改行を出力しません。 puts "foo", "bar\n", "baz" puts "" # 改行のみ出力 puts # 改行のみ出力 puts "foo" => foo bar baz foo (({nil})) を返します。 --- raise --- raise(exception) --- raise(message) --- raise(error_type, message [, backtrace]) --- fail(error_type, message [, backtrace]) 例外を発生させます。 引数が無い場合は、同スレッドの同じブロック内で最後に rescue された 例外オブジェクト (((<組込み変数/$!>))) を再発生させます。そのような 例外が存在しないときは例外 (()) を発生させます。 begin open("nonexist") rescue raise # => `open': No such file or directory - "nonexist" (Errno::ENOENT) end 引数が一つの場合、引数が文字列であれば、その文字列をメッ セージとする (({RuntimeError})) 例外を発生させます。引数 が例外クラスまたは例外オブジェクトであった場合にはその例 外を発生させます。 raise "error message" # => -:1: error message (RuntimeError) raise ArgumentError # => -:1: ArgumentError (ArgumentError) raise ArgumentError.new # => -:1: ArgumentError (ArgumentError) 引数が二つまたは三つの場合、第一引数で指定された例外を、第二引数に 与えたメッセージとともに発生させます。この場合、例外は例外クラスまたは 例外オブジェクトで指定します。第三引数は例外発生時のスタックトレース で、((<組込み関数/caller>)) の戻り値と同じ形式でなければいけません。 raise ArgumentError, "error message" # => -:1: error message (ArgumentError) raise ArgumentError, "error message", ["file1:99", "file2:999:in `method'"] # => file1:99: error message (ArgumentError) from file2:999:in `method' 例外ではないクラスやオブジェクトを第一引数に指定した場合、実際に 発生する例外はそのオブジェクトの (({exception})) メソッドが 返す値になります。 class MyException def exception ArgumentError.new end end raise MyException.new # => -:7: ArgumentError (ArgumentError) 第二の形式で引数を指定した場合は、(({exception})) メソッ ドにその引数が渡されます。 class MyException def exception(mesg) ArgumentError.new(mesg) end end raise MyException.new, "error message" # => -:7: error message (ArgumentError) (({exception})) メソッドは必ず例外オブジェクトを返さなければいけ ません。そうでない場合は (()) が発生します。 発生した例外は変数 ((<組込み変数/$!>)) に格納されます。また例外が 発生した時のスタックトーレスが変数 ((<組込み変数/$@>)) に格納され ます。 --- rand([max=0]) 0 以上 ((|max|)) 未満の範囲の整数の乱数を発生します。ま だ((<組込み関数/srand>)) が呼ばれていなければ自動的に (({srand})) を呼び出します。 ((|max|)) に (({nil})) または 0 を指定すると 0 以上 1 未 満の実数値 (()) で乱数を与えます。 --- readlines([rs]) コマンドライン引数として与えられたファイル(なければ標準入力) をつ なげた仮想的なファイル(((<組込み変数/ARGF>))を全て読み込んで、その 各行を要素としてもつ配列を返します。 行の区切りは引数 ((|rs|)) で指定した文字列になります。((|rs|)) の デフォルト値はシステム変数 ((<組込み変数/"$/">)) の値です。 ((|rs|)) に (({nil})) を指定すると行区切りなしとみなします。 空文字列 (({""})) を指定すると連続する改行を行の区切りとみなします (パラグラフモード)。 --- require(feature) Ruby ライブラリ ((|feature|)) をロードパス ((<組込み変数/$:>)) 上 から探し、同じライブラリがまだロードされていなかった時だけロードし ます。 Ruby ライブラリとは Ruby スクリプト ((({*.rb}))) か拡張ライブラリ ((({*.so}))) であり、((|feature|)) の拡張子が省略された場合はその 両方から探します(検索順序に関しては ((<組込み変数/$:>)) を参照して ください)。省略されなかった場合は指定された種別のみを探します。ま た拡張ライブラリの拡張子にはアーキテクチャで実際に使われる拡張子に 関らず常に (({.so})) を用います。 実際にライブラリをロードした時には (({true}))、既にロードされてい る時には (({false})) を返します。ロードに失敗した場合は、例外 (()) が発生します。ロードした ((|feature|)) の名前を(拡 張子も含めて)、変数 ((<組込み変数/$">)) に追加します。 --- scan(re) --- scan(re) {|matched| ... } ((<組込み変数/$_>)).(()) と同じです。 --- select(reads[, writes[, excepts[, timeout]]]) (()) と同じです。 --- set_trace_func(trace_proc) Ruby インタプリタがプログラムを実行する過程で、メソッドの呼び出しや 式の評価などのイベントが発生する度に手続きオブジェクト ((|trace_proc|)) を実行します。標準添付の((<デバッガ|debug.rb>))、((<トレーサ|tracer.rb>))、 ((<プロファイラ|profile.rb>))はこの組み込み関数を利用して実現されています。 例: set_trace_func lambda {|event, file, line, id, binding, klass| # .... } ブロック引数の意味は以下の通りです。 : event 実行のタイプを表す、以下のいずれかの文字列。 * "line" ... 式の評価。 * "call" ... メソッドの呼び出し。 * "return" ... メソッド呼び出しからのリターン。 * "c-call" ... Cで記述されたメソッドの呼び出し。 * "c-return" ... Cで記述されたメソッド呼び出しからのリターン。 * "class" ... クラス定義、特異クラス定義、モジュール定義への突入。 * "end" ... クラス定義、特異クラス定義、モジュール定義の終了。 * "raise" ... 例外の発生。 : file 実行中のプログラムのソースファイル名 (文字列)。 : line 実行中のプログラムのソースファイル上の行番号 (整数)。 : id ((|event|)) に応じ、以下のものが渡されます。 第六ブロック引数の ((|klass|)) と対応しています。 : line 最後に呼び出されたメソッドを表す (()) オブジェクト。 トップレベルでは (({nil}))。 : call/return/c-call/c-return 呼び出された/リターンするメソッドを表す (()) オブジェクト。 : class/end (({nil}))。 : raise 最後に呼び出されたメソッドを表す (()) オブジェクト。 トップレベルでは (({nil}))。 : binding 実行中のプログラムのコンテキストを表す (()) オブジェクト。 : klass ((|event|)) に応じ、以下のものが渡されます。 第四ブロック引数の ((|id|)) と対応しています。 : line 最後に呼び出されたメソッドが属するクラスを表す (()) オブジェクト。トップレベルでは (({false}))。 : call/return/c-call/c-return 呼び出された/リターンするメソッドが属するクラス を表す (()) オブジェクト。 : class/end (({false}))。 : raise 最後に呼び出されたメソッドが属するクラスを表す (())オブジェクト。トップレベルでは (({false}))。 --- sleep([sec]) ((|sec|)) 秒だけプログラムの実行を停止します。((|sec|)) には浮動小数点数も指定できます。((|sec|)) が省略された場 合、((({SIGALRM})) または他スレッドからの (())) などで明示的に起こさない限り永 久にスリープします。戻り値は実際に停止していた秒数(整数)です。 --- split([sep[, limit]]) ((|$_|)) の示す文字列をパターン ((|sep|)) によって ((|limit|)) 個の文字列に分割し、その配列を返します。詳細 は (()) を参照してください。 --- sprintf(format ... ) --- format(format ... ) ((|format|)) 文字列を C 言語の (({sprintf})) と同じよう に解釈し、引数をフォーマットした文字列を返します。 ((|format|)) 指定子は C 言語の (({sprintf})) が受け付け るものとほとんど同じです。 Ruby には整数の大きさに上限がないので、(({%b, %o, %x})) に負の数を与えると(左側に無限に1が続くとみなせるので) (({..f})) のような表示をします。絶対値に符号を付けた形式 で出力するためには(({%+x}))、(({% x}))のように指定します。 詳細は(())を参照してください。 --- srand([seed]) ((<組込み関数/rand>)) の乱数の種を設定し、古い初期値を返 します。初期値が省略された時には現在の時間などを種にしま す。 --- sub(pattern[, replace]) --- sub!(pattern[, replace]) --- sub(pattern) {|matched| ... } --- sub!(pattern) {|matched| ... } システム変数 ((<組込み変数/$_>)) の指す文字列内で ((|pattern|)) に マッチする最初の部分を ((|replace|)) に置き換えた文字列を返します。 引数 ((|replace|)) が省略された時にはイテレータとして動作し、ブロッ クを評価した結果で置換を行います。ブロックには引数としてマッチした 文字列が渡されます。 (({sub!})) は (({$_})) の指している文字列そのものを書き換えます。 詳細は、(()) を参照してください。 (({String#sub})) と関数 (({sub})) では以下の点で違いがあります。 * (({sub}))メソッドは (({$_})) の値をコピーして、コピーの方を更新し、 (({$_})) に((*再代入*))します。 --- syscall(num, arg ... ) ((|num|))で指定された番号のシステムコールを実行します。 第2引数以降をシステムコールの引数として渡します。引数は文字 列または整数でなければなりません。 どの数値がどのシステムコールに対応するかは、 (()) や (({/usr/include/sys/syscall.h})) を参照してください。 システムコールの慣習に従い、(()) が -1 を返す場合には例外 (()) が発生します。 それ以外では、返した値をそのまま数値で返します。 --- system(command) --- system(program[, arg1[, arg2[, ...]]]) ((|command|)) を実行して、成功した時(子プロセスが終了ステータス 0 で終了した時)には真を、失敗した時(コマンドが実行できなかった場合も 含む)には偽を返します。終了ステータスは変数 ((<組込み変数/$?>)) で 参照できます。 コマンドを実行することができなかった場合、多くのシェルはステータス 127 を返します。(したがって (({$?})) の数値は、0x7f00)、シェルを介 さない場合は Ruby の子プロセスがステータス 127 で終了します。コマ ンドが実行できなかったのか、コマンドが失敗したのかは、普通 (({$?})) を参照することで判別可能です。 その他の挙動に関しては ((<組込み関数/exec>)) を参照して ください。 ((<`command`|組込み関数/"`">)), ((<組込み関数/open>)) も参照してくだ さい。 --- test(cmd, file1 [, file2]) ファイルテストを行います。((|cmd|)) は以下に示す ((<リテラル/数値リテラル>))か文字列です(文字列の場合はそ の先頭の文字だけをコマンドとみなします)。 * 1つの引数を取るもの * (({?r})) ファイルを実効 uid で読むことができる * (({?w})) ファイルに実効 uid で書くことができる * (({?x})) ファイルを実効 uid で実行することができる * (({?o})) ファイルの所有者が実効 uid である * (({?G})) ファイルのグループ所有者が実効 gid である * (({?R})) ファイルを実 uid で読むことができる * (({?W})) ファイルに実 uid で書くことができる * (({?X})) ファイルを実 uid で実行することができる * (({?O})) ファイルの所有者が実 uid である * (({?e})) ファイルが存在する * (({?z})) ファイルサイズが 0 である * (({?s})) ファイルサイズが 0 でない(ファイルサイズを返す) * (({?f})) ファイルはプレーンファイルである * (({?d})) ファイルはディレクトリである * (({?l})) ファイルはシンボリックリンクである * (({?p})) ファイルは名前つきパイプ(FIFO)である * (({?S})) ファイルはソケットである * (({?b})) ファイルはブロック特殊ファイルである * (({?c})) ファイルはキャラクター特殊ファイルである * (({?u})) ファイルに setuid ビットがセットされている * (({?g})) ファイルに setgid ビットがセットされている * (({?k})) ファイルに sticky ビットがセットされている * (({?M})) ファイルの最終更新時刻を返す * (({?A})) ファイルの最終アクセス時刻を返す * (({?C})) ファイルの inode 変更時刻を返す * 2つの引数を取るもの * (({?=})) ファイル1とファイル2の最終更新時刻が等しい * (({?>})) ファイル1の方がファイル2より最終更新時刻が新しい * (({?<})) ファイル1の方がファイル2より最終更新時刻が古い * (({?-})) ファイル1がファイル2にハードリンクされている --- throw(tag[, value=nil]) 同じ ((|tag|)) を指定した ((<組込み関数/catch>)) のブロックの 終わりまで(メソッドを越えて)脱出します。もし同じ ((|tag|)) で 待っている (({catch})) が存在しない場合は (()) で スレッドが終了します。((|tag|)) は文字列またはシンボルです。 ((|value|)) は (({catch})) の戻り値になります。 例: ret = catch(:exit) { throw :exit, 25 some_process() # 絶対に実行されない 10 } p ret #=> 25 --- trace_var(varname, hook) --- trace_var(varname) {|newval| .... } グローバル変数 ((|varname|)) への代入のフックを登録します。 ((|varname|)) は文字列か (()) で指定します。 ここでの「グローバル変数」は、((<特殊変数|組込み変数>))も含めた`$' で始まる変数のことです。 この呼び出し以降、((|varname|)) で指定したグローバル変数に 代入が起こると文字列または (()) オブジェクト ((|hook|)) が評価されます。フックが (({Proc})) オブジェクトなら ブロック引数に代入された値が渡されます。またフックは複数 登録できます。 トレースを解除するには、((|hook|)) に (({nil})) を 指定するか、((<組込み関数/untrace_var>)) を用います。 例: trace_var(:$v) {|val| puts "$v=#{val.inspect}" } $v = "foo" #=> $v="foo" $v = 1 #=> $v=1 ((|hook|)) が (({nil})) ならば、設定されていた ((|hook|)) の配列を返します(ブロックで登録されていれば (()) オブジェクトで返されます) それ以外は、(({nil})) を返します。 --- trap(signal, command) --- trap(signal) { ... } ((|signal|)) で指定された割り込みにたいするハンドラとして ((|command|)) を登録します。((|signal|)) はシグナル名の 文字列か (())、またはシグナル番号で指定します。 ((|command|)) は文字列またはブロックで指定します。 (({nil}))、空文字列(({""}))、(({"SIG_IGN"})) または (({"IGNORE"})) を指定した時は、そのシグナルを無視します (可能ならば)。 (({"SIG_DFL"})) または (({"DEFAULT"})) を指定した時は、 デフォルトの動作を行なうようになります。 (({"EXIT"}))を指定した時は、シグナルを受け取ると((<終了処理>))を 行ったあとステータス 0 で終了します。 また ((|signal|)) の特別な値として 0 または (({"EXIT"})) を指定できます。これは「プログラムの終了時」を表します。 いくつかのシグナルに対して、Ruby インタプリタは例外 (()) や (()) を発生させます。このようなシグナルは例外処理によっ て捕捉することもできます。 begin Process.kill :QUIT, $$ # 自身にSIGQUITを送信 rescue SignalException puts "rescue #$!" end # => rescue SIGQUIT trap() により捕捉されたシグナルは例外を発生させません。 trap は既にシグナルに対応する ((|command|)) が登録されて いれば、それを返します(ブロックは (()) オブジェク トとして返されます。"IGNORE" や "DEFAULT" に対しては (({nil})) を返します)。何も登録されていなければ (({nil})) を返します。 p trap(:INT, "p true") # => nil p trap(:INT) { } # => "p true" p trap(:INT, "SIG_IGN") # => # p trap(:INT, "DEFAULT") # => nil p trap(:INT, "EXIT") # => nil p trap(:INT, nil) # => "EXIT" 存在しないシグナルを指定した場合は、例外 (()) が発 生します((-なお、Windows ((()), (()))では、INT ILL FPE SEGV TERM BREAK ABRT そして EXIT しか指定できません。-)) --- untrace_var(varname[, hook]) グローバル変数 ((|varname|)) に関連付けられたフックを 解除します。((|hook|)) が指定された場合にはそのフックだけを 解除します。((|hook|)) が省略されるかまたは (({nil})) を 与えた場合は ((|varname|)) のフックを全て解除します。 解除されたフックの配列を返します。 例: $v = nil trace_var(:$v) {|val| puts "$v=#{val.inspect}" } $v = 'str' #=> $v="str" untrace_var :$v $v = 'str' # なにも出力されない = Float 浮動小数点数のクラス。Float の実装は C 言語の double で、その精度は環 境に依存します。((-一般にはせいぜい16桁です。詳しくは多くのシステムで 採用されている浮動小数点標準規格、IEEE (Institute of Electrical and Electronics Engineers: 米国電気電子技術者協会) 754 を参照してください-)) # あるシステムでの 1/3(=0.333...) の結果 printf("%.50f\n", 1.0/3) => 0.33333333333333331482961625624739099293947219848633 == スーパークラス: * (()) == インクルードしているモジュール: * (()) == クラスメソッド: --- Float.induced_from(num) ((|num|)) を (({Float})) に変換した結果を返します。 == メソッド: --- self + other --- self - other --- self * other --- self / other --- self % other --- self ** other 算術演算子。それぞれ和、差、積、商、剰余、冪を計算します。 --- self <=> other (({self})) と (({other})) を比較して、(({self})) が大きい時に正、 等しい時に 0、小さい時に負の整数を返します。 --- self == other --- self < other --- self <= other --- self > other --- self >= other 比較演算子。 --- finite? 数値が ∞ でも、NaN でもなければ真を返します --- infinite? 数値が +∞ のとき 1、-∞のとき -1 を返します。それ以外は nil を返 します。浮動小数点数の 0 による除算は ∞ です。 inf = 1.0/0 p inf p inf.infinite? => Infinity 1 inf = -1.0/0 p inf p inf.infinite? => -Infinity -1 --- nan? 数値が NaN(Not a number)のとき真を返します。浮動小数点数 0 の 0 に よる除算は NaN です。 nan = 0.0/0.0 p nan p nan.nan? => NaN true --- to_f (({self})) を返します。 --- to_i --- truncate 小数点以下を切り捨てて値を整数に変換します。 (()), (()), (()) も参照。 = ArgumentError 引数の数があっていないときや、値が正しくないときに発生します。 Time.at # => wrong number of arguments (0 for 1) (ArgumentError) Array.new(-1) # => negative array size (ArgumentError) など == スーパークラス: * (()) = Fixnum マシンのポインタのサイズに収まる長さの固定長整数。ほとんどのマシンでは 31 ビット幅です。演算の結果が (({Fixnum})) の範囲を越えた時には自動的 に (()) に拡張されます。 == スーパークラス: * (()) == メソッド: --- id2name (()) オブジェクトの整数値 ((()) で得られます)に対応する文字列を返します。整数に対応するシンボルが 存在しない時には (({nil})) を返します。 = Bignum 多倍長整数のクラス。(({Bignum})) が扱うことのできる大きさはメモリサイ ズだけによって制限されます。演算の結果が (()) の範囲内である場 合には (({Fixnum})) に変換され、逆に (({Fixnum})) の範囲を越える時には (({Bignum})) に拡張されます。ビット演算については 2 の補数表現の無限長 のビットストリングとみなすことができます。特に負の数は左側に無限に 1 のビットが立っているように操作できます。(()) との混合に関しては、 変換時に桁落ちが生じる可能性があります。 == スーパークラス: * (()) = Integer 整数の抽象クラス。サブクラスとして (()) と (()) があり ます。この 2 種類の整数は値の大きさに応じてお互いに自動的に変換されま す。ビット操作において整数は無限の長さのビットストリングとみなすことが できます。 == スーパークラス: * (()) == インクルードしているモジュール: * (()) == クラスメソッド: --- Integer.induced_from(num) ((|num|)) を (({Integer})) に変換した結果を返します。 == メソッド: --- self[nth] ((|nth|)) 番目のビット(最下位ビット(LSB)が 0 番目)が立っている時 1 を、そうでなければ 0 を返します。 (({self[nth]=bit})) が Integer にないのは、Numeric 関連クラスが immutable であるためです。 == メソッド: --- self + other --- self - other --- self * other --- self / other --- self % other --- self ** other 算術演算子。それぞれ和、差、積、商、剰余、冪を計算します。 --- self <=> other (({self})) と (({other})) を比較して、(({self})) が大きい時に正、 等しい時に 0、小さい時に負の整数を返します。 --- self == other --- self < other --- self <= other --- self > other --- self >= other 比較演算子。 --- ~ self --- self | other --- self & other --- self ^ other ビット演算子。それぞれ否定、論理和、論理積、排他的論理和を計算しま す。 --- self << bits --- self >> bits シフト演算子。(({bits})) だけビットを右(左)にシフトします。 右シフトは、符号ビット(最上位ビット(MSB))が保持されます。 printf("%#b\n", 0b0101 << 1) printf("%#b\n", 0b0101 >> 1) => 0b1010 0b10 p -1 >> 1 => -1 --- chr 文字コードに対応する 1 バイトの文字列を返します。例えば (({65.chr})) は "A" を返します。 逆に文字列から文字コードを得るには (({"A"[0]})) とします ((()) を参照してください)。 整数は 0 から 255 の範囲内でなければなりません。範囲外の整数に対す る呼び出しは例外 (()) を発生させます。 --- downto(min) {|n| ... } (({self})) から ((|min|)) まで 1 ずつ減らしながら繰り返します。 (({self})) < (({min})) であれば何もしません。 (()), (()), (()) も参照。 --- next --- succ ((*次*))の整数を返します。 --- step(limit, step) {|n| ... } (({self})) からはじめ ((|step|)) を足しながら ((|limit|)) を越える 前までブロックを繰り返します。((|step|)) は負の数も指定できます。 また、((|limit|)) や ((|step|)) には (()) なども指定できます。 ((|step|)) に 0 を指定した場合は例外 (()) が発生します。 (({self})) を返します。 (()), (()), (()) も参照。 (()): Numeric#(()) も参照。 --- times {|n| ... } (({self})) 回だけ(0 から (({self-1})) まで)繰り返します。 (({self})) が負であれば何もしません。 (({self})) を返します。 (()), (()), (()) も参照。 --- to_i --- to_int (({self})) を返します。 --- size 整数の実装上のサイズをバイト数で返します。 現在の実装では (()) は、(({sizeof(long)})) 固定(多くの 32 bit マシンで 4 バイト)、(())は、システム依存です。 p 1.size p 0x1_0000_0000.size # => 4 8 --- to_f 値を浮動小数点数((()))に変換します。 --- to_s --- to_s(base) (()) 整数を 10 進文字列表現に変換します。 (()): 引数を指定すれば、それを基数とした文字列表 現に変換します。基数として 2, 8, 10, 16 以外を指定した場合は例外 (()) が発生します。 p 10.to_s(2) # => "1010" p 10.to_s(8) # => "12" p 10.to_s(16) # => "a" --- upto(max) {|n| ... } (({self})) から ((|max|)) まで 1 ずつ増やしながら繰り返します。 (({self})) > (({max})) であれば何もしません。 (({self})) を返します。 (()), (()), (()) も参照。 = Exception 全ての例外の祖先のクラスです。 == スーパークラス: * (()) == クラスメソッド: --- Exception.new([error_message]) --- Exception.exception([error_message]) 例外オブジェクトを生成して返します。引数としてエラーメッセージを表 す文字列を与えることができます。このメッセージは属性 (()) の値になり、デフォルトの例外ハンドラで表示 されます。 == メソッド: --- exception([error_message]) 引数を指定しない場合は self を返します。そうでなければ、自身のコピー を生成し、(()) 属性を ((|error_message|)) にし て返します。 ((<組込み関数/raise>)) は、実質的に、例外オブジェクトの (({exception})) メソッドの呼び出しです。 --- backtrace バックトレース情報を返します。 * (({"#{sourcefile}:#{sourceline}:in `#{method}'"})) (メソッド内の場合) * (({"#{sourcefile}:#{sourceline}"})) (トップレベルの場合) という形式(デフォルトでは)の (()) の配列です。 --- message --- to_s --- to_str エラーメッセージをあらわす文字列を返します。 --- set_backtrace(errinfo) バックトレース情報に ((|errinfo|)) を設定し、設定されたバックトレース 情報を返します。((|errinfo|)) は (({nil}))、(()) あるいは (()) の配列のいずれかでな くてはなりません。 = Continuation ((<組込み関数>)) (({((<組込み関数/callcc>)) { |cont| ... }})) の呼出し は、直前の状態(ローカル変数の値、スタックフレーム)を ((|cont|)) に記憶 してブロックを実行します。((|cont|)) は、Continuation クラスのインスタ ンスで、(()) メソッドを実行するこ とでいつでも記憶した状態を継続することができます。 C 言語の setjmp()/longjmp() がわかる人は setjmp() == callcc {|c| } longjmp() == c.call と考えれば、わかりやすいかも知れません(ただし、callcc はスタックが深く なる方向にもジャンプ出来るという違いがあります) callcc() は、ブロックの戻り値を返しますが、Continuation#call(((|args|))) が呼び出されたときは ((|args|)) を返します。 : 例： 以下は、Continuationによる無限ループの例 def LOOP c = nil yield callcc {|c| true} c.call(false) end LOOP {|v| p v} => true false false false : : callcc とは、call-with-current-continuation の略です。 == スーパークラス: * (()) == メソッド: --- call(ret[,ret2[,...]]) (({self})) が記憶した状態を継続します。引数は そのまま ((<組込み関数/callcc>)) の戻り値になります。 = Errno::EXXX 各 (({errno})) に対応する例外クラスです。実際のクラス名については (()) モジュールとシステムのマニュアル (()) を参照してください。 == スーパークラス: * (()) == 定数: --- Errno 各クラスに対応する (({errno})) の値です。 (({Errno::EXXX::Errno})) 定数は、対応する値が常に設定されています が、(()) メソッドは実際にエ ラーが発生してなければ (({nil})) を返します。 : 例: (({Errno::EAGAIN})) と (({Errno::EWOULDBLOCK})) はシステムによっ ては同じ (({errno})) 値を持つ例外クラスです。以下は (({Errno})) 定数によりこのことを調べています。 p Errno::EAGAIN::Errno # => 11 p Errno::EWOULDBLOCK::Errno # => 11 p Errno::EAGAIN.new.errno # => nil p Errno::EWOULDBLOCK.new.errno # => nil = ARGF スクリプトに指定した引数 (((<組込み定数/ARGV>)) を参照) をファイル名と みなして、それらのファイルを連結した 1 つの仮想ファイルを表すオブジェ クトです。(({ARGV})) が空なら標準入力を対象とします。(({ARGV})) を変更 すればこのオブジェクトの動作に影響します。 while line = ARGF.gets .. end は、 while argv = ARGV.shift File.open(argv) {|file| while line = file.gets .. end } end のように動作します。 (({ARGF})) を処理するごとに (({ARGV})) の要素は一つずつ取り除かれます。 最後まで (({ARGF})) を読み込んだ後、再度 (({ARGF})) から内容を読むと ((({ARGV})) が空なので)標準入力からの読み込みとなります。 ARGV.replace %w(/tmp/foo /tmp/bar) ARGF.each {|line| # 処理中の ARGV の内容を表示 p [ARGF.filename, ARGV]; ARGF.skip } # 最後まで読んだ後(ARGVが空)の動作 p ARGF.gets p ARGF.filename # => ["/tmp/foo", ["/tmp/bar"]] ["/tmp/bar", []] nil "-" ((<組込み関数/gets>)) など一部の((<組込み関数>))は (({ARGF.gets})) な どこのオブジェクトをレシーバとしたメソッドの省略形です。 == メソッド: (()) オブジェクトのメソッドに加えて、以下のメソッドを持ちます。 --- ARGF.to_s --- ARGF.filename 処理対象のファイル名を返します。標準入力に対しては (({-})) を返し ます。組込み変数 ((<組込み変数/$FILENAME>)) と同じです。 --- ARGF.file 処理対象の (()) オブジェクト(または (()) オブジェクト)を 返します。 --- ARGF.lineno 全引数ファイルを一つのファイルとみなしたときの現在の行番号を返しま す。個々の引数ファイル毎の行番号を得るには (({ARGF.file.lineno})) とします。 --- ARGF.skip 処理対象のファイルをクローズします。次回の読み込みは次の引数が処理 対象になります。(({self})) を返します。 = EOFError EOF(End Of File)に達したときに発生します。 == スーパークラス: * (()) = LoadError ((<組込み関数/require>)) や ((<組込み関数/load>)) が失敗したときに発生します。 == スーパークラス: * (()) = File ファイルアクセスのためのクラス。通常 ((<組込み関数/open>)) を 使ってオープンされます。このクラスには (()) モジュールに 定義されているのと同じ特異メソッドが定義されています。 == スーパークラス: * (()) == インクルードしているモジュール: * (()) == クラスメソッド: --- File.atime(filename) --- File.ctime(filename) --- File.mtime(filename) それぞれ、ファイルの最終アクセス時刻/状態が最後に変更された 時刻／最終更新時刻(((