Ruby-quick-guide

提供：Dev Guides
移動先:案内、検索

Ruby-概要

Rubyは純粋なオブジェクト指向プログラミング言語です。 1993年に日本の松本幸宏によって作成されました。

www.ruby-lang.orgのRubyメーリングリストで、Yukihiro Matsumotoという名前を見つけることができます。 松本は、RubyコミュニティではMatzとしても知られています。

  • Rubyは「プログラマの親友」です。*

Rubyには、Smalltalk、Perl、およびPythonの機能と同様の機能があります。 Perl、Python、およびSmalltalkはスクリプト言語です。 Smalltalkは真のオブジェクト指向言語です。 Rubyは、Smalltalkと同様、完璧なオブジェクト指向言語です。 Ruby構文の使用は、Smalltalk構文の使用よりもはるかに簡単です。

Rubyの機能

  • Rubyはオープンソースであり、Webで自由に利用できますが、ライセンスが必要です。
  • Rubyは、汎用のインタープリター型プログラミング言語です。
  • Rubyは真のオブジェクト指向プログラミング言語です。
  • Rubyは、PythonやPERLに似たサーバー側のスクリプト言語です。
  • Rubyを使用して、Common Gateway Interface（CGI）スクリプトを作成できます。
  • RubyはHTML（Hypertext Markup Language）に埋め込むことができます。
  • Rubyには、新しい開発者が非常に迅速かつ簡単に学習できる、簡潔で簡単な構文があります。
  • Rubyの構文は、C ++やPerlなどの多くのプログラミング言語の構文と似ています。
  • Rubyは非常にスケーラブルであり、Rubyで書かれた大きなプログラムは簡単に保守できます。
  • Rubyは、インターネットおよびイントラネットアプリケーションの開発に使用できます。
  • RubyはWindowsおよびPOSIX環境にインストールできます。
  • Rubyは、Tcl/Tk、GTK、OpenGLなどの多くのGUIツールをサポートしています。
  • Rubyは、DB2、MySQL、Oracle、Sybaseに簡単に接続できます。
  • Rubyには豊富な組み込み関数セットがあり、Rubyスクリプトに直接使用できます。

必要なツール

このチュートリアルで説明する例を実行するには、Intel Core i3またはi5などの最新のコンピューターで、最低2GBのRAM（4GBのRAMを推奨）が必要です。 また、次のソフトウェアが必要になります-

  • LinuxまたはWindows 95/98/2000/NTまたはWindows 7オペレーティングシステム。
  • Apache 1.3.19-5 Webサーバー。
  • Internet Explorer 5.0以上のWebブラウザー。
  • Ruby 1.8.5

このチュートリアルでは、Rubyを使用してGUI、ネットワーク、およびWebアプリケーションを作成するために必要なスキルを提供します。 また、Rubyアプリケーションの拡張と埋め込みについても説明します。

次は何ですか？

次の章では、Rubyとそのドキュメントを入手できる場所について説明します。 最後に、Rubyをインストールし、Rubyアプリケーションを開発するための環境を準備する方法について説明します。

Ruby-環境設定

ローカル環境のセットアップ

Rubyプログラミング言語用に環境をセットアップする意思がある場合は、先に進みましょう。 このチュートリアルでは、環境のセットアップに関連するすべての重要なトピックについて説明します。 最初に次のトピックを確認してから、さらに進むことをお勧めします-

  • link：/ruby​​/ruby​​_installation_unix [Linux/UnixでのRubyのインストール]-Linux/Unixマシンで開発環境を計画している場合は、この章に進んでください。
  • link：/ruby​​/ruby​​_installation_windows [WindowsでのRubyのインストール]-Windowsマシンで開発環境を計画している場合は、この章に進んでください。
  • link：/ruby​​/ruby​​_command_line_options [Rubyコマンドラインオプション]-この章では、Rubyインタープリターと一緒に使用できるすべてのコマンドラインオプションの一覧を示します。
  • link：/ruby​​/ruby​​_environment_variables [Ruby環境変数]-この章には、Rubyインタープリターを機能させるために設定する必要のあるすべての重要な環境変数のリストがあります。

人気のRubyエディター

Rubyプログラムを作成するには、エディターが必要です-

  • Windowsマシンで作業している場合は、メモ帳や編集プラスなどのシンプルなテキストエディターを使用できます。
  • VIM（Vi IMproved）は非常にシンプルなテキストエディターです。 これは、ほぼすべてのUnixマシンで使用でき、現在はWindowsでも使用できます。 それ以外の場合は、お気に入りのviエディターを使用してRubyプログラムを作成できます。
  • RubyWinは、Windows用のRuby統合開発環境（IDE）です。
  • Ruby開発環境https://homepage2.nifty.com/sakazuki/rde_en/[(RDE）]は、Windowsユーザーにとっても非常に優れたIDEです。

インタラクティブルビー（IRb）

Interactive Ruby（IRb）は、実験用のシェルを提供します。 IRbシェル内で、式の結果を行ごとにすぐに表示できます。

このツールはRubyのインストールに付属しているため、IRbを機能させるために余分な作業は必要ありません。

コマンドプロンプトで irb と入力するだけで、Interactive Rubyセッションが次のように開始されます- 

$irb
irb 0.6.1(99/09/16)
irb(main):001:0> def hello
irb(main):002:1> out = "Hello World"
irb(main):003:1> puts out
irb(main):004:1> end
nil
irb(main):005:0> hello
Hello World
nil
irb(main):006:0>

ここで何をしたか心配する必要はありません。 これらすべての手順は、以降の章で学習します。

次は何ですか？

動作するRuby環境があり、最初のRubyプログラムを作成する準備ができていると仮定します。 次の章では、Rubyプログラムの作成方法について説明します。

Ruby-構​​文

ルビで簡単なプログラムを書きましょう。 すべてのrubyファイルの拡張子は .rb になります。 そのため、次のソースコードをtest.rbファイルに配置します。 

#!/usr/bin/ruby -w

puts "Hello, Ruby!";

ここでは、Rubyインタープリターが/usr/binディレクトリーで使用可能であると想定しています。 今、次のようにこのプログラムを実行してみてください- 

$ ruby test.rb

これは、次の結果を生成します- 

Hello, Ruby!

単純なRubyプログラムを見てきました。次に、Ruby構文に関連するいくつかの基本概念を見てみましょう。

Rubyプログラムの空白

スペースやタブなどの空白文字は、文字列に表示される場合を除き、通常Rubyコードでは無視されます。 ただし、あいまいなステートメントの解釈に使用されることもあります。 この種の解釈では、-wオプションが有効な場合に警告が生成されます。

例

a + b is interpreted as a+b ( Here a is a local variable)
a  +b is interpreted as a(+b) ( Here a is a method call)

Rubyプログラムの行末

Rubyは、セミコロンと改行文字をステートメントの終わりとして解釈します。 ただし、Rubyが行末に＆plus;、-、またはバックスラッシュなどの演算子を検出した場合、ステートメントの継続を示します。

Ruby識別子

識別子は、変数、定数、およびメソッドの名前です。 Ruby識別子は大文字と小文字が区別されます。 これは、RamとRAMがRubyの2つの異なる識別子であることを意味します。

Rubyの識別子名は、英数字とアンダースコア文字（_）で構成されます。

予約語

次のリストは、Rubyの予約語を示しています。 これらの予約語は、定数名または変数名として使用できません。 ただし、メソッド名として使用できます。

BEGIN do next then
END else nil true
alias elsif not undef
and end or unless
begin ensure redo until
break false rescue when
case for retry while
class if return while
def in self FILE
defined? module super LINE

Rubyのヒアドキュメント

「ヒアドキュメント」とは、複数の行から文字列を構築することを指します。 <<に続いて、文字列リテラルを終了する文字列または識別子を指定できます。現在の行から終端文字までのすべての行は、文字列の値です。

ターミネータが引用符で囲まれている場合、引用符の種類によって行指向の文字列リテラルの種類が決まります。 <<とターミネータの間にスペースがあってはならないことに注意してください。

ここに異なる例があります- 

#!/usr/bin/ruby -w

print <<EOF
   This is the first way of creating
   here document ie. multiple line string.
EOF

print <<"EOF";                # same as above
   This is the second way of creating
   here document ie. multiple line string.
EOF

print <<`EOC`                 # execute commands
    echo hi there
    echo lo there
EOC

print <<"foo", <<"bar"  # you can stack them
    I said foo.
foo
    I said bar.
bar

これは、次の結果を生成します- 

   This is the first way of creating
   her document ie. multiple line string.
   This is the second way of creating
   her document ie. multiple line string.
hi there
lo there
      I said foo.
      I said bar.

Ruby BEGINステートメント

構文

BEGIN {
   code
}

プログラムの実行前に呼び出される_code_を宣言します。

例

#!/usr/bin/ruby

puts "This is main Ruby Program"

BEGIN {
   puts "Initializing Ruby Program"
}

これは、次の結果を生成します- 

Initializing Ruby Program
This is main Ruby Program

Ruby ENDステートメント

構文

END {
   code
}

プログラムの最後に呼び出される_code_を宣言します。

例

#!/usr/bin/ruby

puts "This is main Ruby Program"

END {
   puts "Terminating Ruby Program"
}
BEGIN {
   puts "Initializing Ruby Program"
}

これは、次の結果を生成します- 

Initializing Ruby Program
This is main Ruby Program
Terminating Ruby Program

ルビーのコメント

コメントは、1行、1行の一部、または複数行をRubyインタープリターから隠します。 あなたは、行の先頭にハッシュ文字（＃）を使用することができます- 

# I am a comment. Just ignore me.

または、コメントはステートメントまたは式の後の同じ行にある場合があります- 

name = "Madisetti" # This is again comment

次のように複数の行をコメントすることができます- 

# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.

別のフォームがあります。 このブロックコメントは、= begin/= endでインタープリターからの数行を隠します- 

=begin
This is a comment.
This is a comment, too.
This is a comment, too.
I said that already.
=end

Ruby-クラスとオブジェクト

Rubyは完璧なオブジェクト指向プログラミング言語です。 オブジェクト指向プログラミング言語の機能が含まれます-

  • データカプセル化
  • データ抽象化
  • 多型
  • 継承

これらの機能については、章のリンク：/ruby​​/ruby​​_object_oriented [オブジェクト指向Ruby]で説明しています。

オブジェクト指向プログラムには、クラスとオブジェクトが含まれます。 クラスは、個々のオブジェクトが作成される青写真です。 オブジェクト指向の用語では、「自転車」は「自転車」として知られる「オブジェクトのクラス」のインスタンスであると言います。

任意の車両の例を見てください。 車輪、馬力、燃料またはガスのタンク容量で構成されています。 これらの特性は、クラスVehicleのデータメンバーを形成します。 これらの特性を利用して、ある車両を他の車両と区別できます。

車両には、停止、運転、スピードなどの特定の機能もあります。 これらの関数でさえ、クラスVehicleのデータメンバーを形成します。 したがって、クラスを特性と機能の組み合わせとして定義できます。

クラスVehicleは次のように定義できます- 

Class Vehicle {

   Number no_of_wheels
   Number horsepower
   Characters type_of_tank
   Number Capacity
   Function speeding {
   }

   Function driving {
   }

   Function halting {
   }
}

これらのデータメンバーに異なる値を割り当てることにより、Vehicleクラスの複数のインスタンスを形成できます。 たとえば、飛行機には3つの車輪、1,000馬力、タンクの種類としての燃料、および100リットルの容量があります。 同様に、自動車には4つの車輪、200馬力、タンクの種類としてのガス、および25リットルの容量があります。

Rubyでクラスを定義する

Rubyを使用してオブジェクト指向プログラミングを実装するには、まずRubyでオブジェクトとクラスを作成する方法を学ぶ必要があります。

Rubyのクラスは常にキーワード_class_で始まり、その後にクラスの名前が続きます。 名前は常に最初の大文字である必要があります。 クラス_Customer_は次のように表示できます- 

class Customer
end

キーワード_end_を使用して、クラスを終了します。 _class_のすべてのデータメンバーは、クラス定義と_end_キーワードの間にあります。

Rubyクラスの変数

Rubyは4種類の変数を提供します-

  • ローカル変数-ローカル変数はメソッドで定義される変数です。 ローカル変数はメソッド外では使用できません。 メソッドの詳細については、後続の章で説明します。 ローカル変数は、小文字または_で始まります。
  • インスタンス変数-インスタンス変数は、特定のインスタンスまたはオブジェクトのメソッド全体で使用できます。 つまり、インスタンス変数はオブジェクトごとに変化します。 インスタンス変数の前には、アットマーク（＆commat;）があり、その後に変数名が続きます。
  • クラス変数-クラス変数は異なるオブジェクト間で利用可能です。 クラス変数はクラスに属し、クラスの特性です。 それらの前には記号＆commat;＆commat;が付いています。そして、変数名が続きます。
  • グローバル変数-クラス変数はクラス間で使用できません。 クラス全体で使用できる単一の変数が必要な場合は、グローバル変数を定義する必要があります。 グローバル変数の前には常にドル記号（＆dollar;）が付きます。

例

クラス変数＆commat;＆commat; no_of_customersを使用して、作成されているオブジェクトの数を判別できます。 これにより、顧客の数を導き出すことができます。 

class Customer
   &commat;&commat;no_of_customers = 0
end

新しいメソッドを使用してRubyでオブジェクトを作成する

オブジェクトはクラスのインスタンスです。 Rubyでクラスのオブジェクトを作成する方法を学びます。 クラスのメソッド_new_を使用して、Rubyでオブジェクトを作成できます。

メソッド_new_はメソッドのユニークなタイプであり、Rubyライブラリで事前定義されています。 新しいメソッドは_class_メソッドに属します。

これは、クラスCustomerの2つのオブジェクトcust1およびcust2を作成する例です- 

cust1 = Customer. new
cust2 = Customer. new

ここで、cust1とcust2は2つのオブジェクトの名前です。 オブジェクト名に続けて等号（=）を記述し、その後にクラス名が続きます。 次に、ドット演算子とキーワード_new_が続きます。

Rubyオブジェクトを作成するカスタムメソッド

メソッド_new_にパラメーターを渡すことができ、それらのパラメーターを使用してクラス変数を初期化できます。

パラメーターを使用して_new_メソッドを宣言する場合、クラスの作成時にメソッド_initialize_を宣言する必要があります。

_initialize_メソッドは、クラスの_new_メソッドがパラメーターで呼び出されたときに実行される特別なタイプのメソッドです。

ここに初期化メソッドを作成する例があります- 

class Customer
   &commat;&commat;no_of_customers = 0
   def initialize(id, name, addr)
      &commat;cust_id = id
      &commat;cust_name = name
      &commat;cust_addr = addr
   end
end

この例では、ローカル変数として id、name 、および addr を使用して_initialize_メソッドを宣言します。 ここでは、_def_と_end_を使用して、Rubyのメソッド_initialize_を定義しています。 メソッドの詳細については、後続の章で説明します。

_initialize_メソッドでは、これらのローカル変数の値をインスタンス変数＆commat; cust_id、＆commat; cust_name、および＆commat; cust_addrに渡します。 ここで、ローカル変数は、新しいメソッドとともに渡される値を保持します。

今、次のようにオブジェクトを作成できます- 

cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

Rubyクラスのメンバー関数

Rubyでは、関数はメソッドと呼ばれます。 _class_の各メソッドは、キーワード_def_で始まり、その後にメソッド名が続きます。

メソッド名は常に*小文字*で優先されます。 キーワード_end_を使用して、Rubyでメソッドを終了します。

ここにRubyメソッドを定義する例があります- 

class Sample
   def function
      statement 1
      statement 2
   end
end

ここで、_statement 1_と_statement 2_は、クラスSample内のメソッド_function_の本体の一部です。 これらの文は、任意の有効なRubyステートメントです。 たとえば、次のように_Hello Ruby_を印刷するメソッド_puts_を置くことができます- 

class Sample
   def hello
      puts "Hello Ruby!"
   end
end

今、次の例では、Sampleクラスの1つのオブジェクトを作成し、_hello_メソッドを呼び出して結果を確認します- 

#!/usr/bin/ruby

class Sample
   def hello
      puts "Hello Ruby!"
   end
end

# Now using above class to create objects
object = Sample. new
object.hello

これは、次の結果を生成します- 

Hello Ruby!

シンプルなケーススタディ

クラスとオブジェクトをさらに練習したい場合のケーススタディを以下に示します。

リンク：/ruby​​/ruby​​_class_case_study [Rubyクラスのケーススタディ]

Ruby-変数、定数、リテラル

変数は、任意のプログラムで使用されるデータを保持するメモリの場所です。

Rubyでサポートされる変数には5つのタイプがあります。 前の章でも、これらの変数について簡単に説明しました。 この5つのタイプの変数については、この章で説明します。

Rubyグローバル変数

グローバル変数は＆dollar;で始まります。 初期化されていないグローバル変数の値はnilで、-wオプションで警告を生成します。

グローバル変数への割り当ては、グローバルステータスを変更します。 グローバル変数を使用することは推奨されません。 彼らはプログラムを不可解にします。

グローバル変数の使用方法を示す例を次に示します。 

#!/usr/bin/ruby

$global_variable = 10
class Class1
   def print_global
      puts "Global variable in Class1 is #$global_variable"
   end
end
class Class2
   def print_global
      puts "Global variable in Class2 is #$global_variable"
   end
end

class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global

ここで、$ global_variableはグローバル変数です。 これは、次の結果を生成します-

注-Rubyでは、変数または定数の直前にハッシュ（＃）文字を置くことにより、変数または定数の値にアクセスできます。 

Global variable in Class1 is 10
Global variable in Class2 is 10

Rubyインスタンス変数

インスタンス変数は＆commat;で始まります。 初期化されていないインスタンス変数の値は_nil_であり、-wオプションで警告を生成します。

インスタンス変数の使用法を示す例を次に示します。 

#!/usr/bin/ruby

class Customer
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
   end
end

# Create Objects
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# Call Methods
cust1.display_details()
cust2.display_details()

ここで、＆commat; cust_id、＆commat; cust_name、＆commat; cust_addrはインスタンス変数です。 これは、次の結果を生成します- 

Customer id 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala

Rubyクラス変数

クラス変数は＆commat;＆commat;で始まりますメソッド定義で使用する前に初期化する必要があります。

初期化されていないクラス変数を参照すると、エラーが発生します。 クラス変数は、クラス変数が定義されているクラスまたはモジュールの子孫の間で共有されます。

クラス変数をオーバーライドすると、-wオプションで警告が生成されます。

これはクラス変数の使用法を示す例です- 

#!/usr/bin/ruby

class Customer
   @@no_of_customers = 0
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
   end
   def total_no_of_customers()
      @@no_of_customers += 1
      puts "Total number of customers: #@@no_of_customers"
   end
end

# Create Objects
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# Call Methods
cust1.total_no_of_customers()
cust2.total_no_of_customers()

ここで＆commat;＆commat; no_of_customersはクラス変数です。 これは、次の結果を生成します- 

Total number of customers: 1
Total number of customers: 2

Rubyローカル変数

ローカル変数は、小文字または_で始まります。 ローカル変数のスコープは、クラス、モジュール、def、doから対応する終わりまで、またはブロックの開き中括弧から閉じ中括弧\ {}までの範囲です。

初期化されていないローカル変数が参照されると、引数のないメソッドの呼び出しとして解釈されます。

初期化されていないローカル変数への割り当ては、変数宣言としても機能します。 変数は、現在のスコープの終わりに達するまで存在し始めます。 ローカル変数の有効期間は、Rubyがプログラムを解析するときに決定されます。

上記の例では、ローカル変数はid、name、およびaddrです。

ルビー定数

定数は大文字で始まります。 クラスまたはモジュール内で定義された定数はそのクラスまたはモジュール内からアクセスでき、クラスまたはモジュール外で定義された定数はグローバルにアクセスできます。

メソッド内で定数を定義することはできません。 初期化されていない定数を参照すると、エラーが発生します。 すでに初期化されている定数に割り当てを行うと、警告が生成されます。 

#!/usr/bin/ruby

class Example
   VAR1 = 100
   VAR2 = 200
   def show
      puts "Value of first Constant is #{VAR1}"
      puts "Value of second Constant is #{VAR2}"
   end
end

# Create Objects
object = Example.new()
object.show

ここで、VAR1とVAR2は定数です。 これは、次の結果を生成します- 

Value of first Constant is 100
Value of second Constant is 200

ルビーの擬似変数

これらはローカル変数のように見えますが、定数のように動作する特別な変数です。 これらの変数に値を割り当てることはできません。

  • self -現在のメソッドの受信者オブジェクト。
  • true -trueを表す値。
  • false -falseを表す値。
  • nil -未定義を表す値。
  • FILE -現在のソースファイルの名前。
  • LINE -ソースファイルの現在の行番号。

Rubyの基本的なリテラル

Rubyがリテラルに使用するルールはシンプルで直感的です。 このセクションでは、すべての基本的なRubyリテラルについて説明します。

整数

Rubyは整数をサポートしています。 整数の範囲は-2 ^ 30 ^〜2 ^ 30-1 ^または-2 ^ 62 ^〜2 ^ 62-1 ^です。 この範囲内の整数はクラス_Fixnum_のオブジェクトであり、この範囲外の整数はクラス_Bignum_のオブジェクトに格納されます。

オプションの先行符号、オプションのベースインジケータ（8進数の場合は0、16進数の場合は0x、2進数の場合は0b）を使用して整数を書き込み、その後に適切なベースの数字列を続けます。 数字文字列ではアンダースコア文字は無視されます。

ASCII文字に対応する整数値を取得したり、疑問符を前に付けてシーケンスをエスケープすることもできます。

例

123                  # Fixnum decimal
1_234                # Fixnum decimal with underline
-500                 # Negative Fixnum
0377                 # octal
0xff                 # hexadecimal
0b1011               # binary
?a                   # character code for 'a'
?\n                  # code for a newline (0x0a)
12345678901234567890 # Bignum

注-クラスとオブジェクトについては、このチュートリアルの別の章で説明しています。

浮動小数点数

Rubyは浮動小数点数をサポートしています。 これらも数字ですが、小数部があります。 浮動小数点数は_Float_クラスのオブジェクトであり、次のいずれかです-

例

123.4                # floating point value
1.0e6                # scientific notation
4E20                 # dot not required
4e+20                # sign before exponential

文字列リテラル

Ruby文字列は、単に8ビットバイトのシーケンスであり、クラスStringのオブジェクトです。 二重引用符で囲まれた文字列では置換とバックスラッシュ表記が許可されますが、単一引用符で囲まれた文字列では置換が許可されず、\\と\ 'のみにバックスラッシュ表記が許可されます

例

#!/usr/bin/ruby -w

puts 'escape using "\\"';
puts 'That\'s right';

これは、次の結果を生成します- 

escape using "\"
That's right

シーケンス*＃\ {expr} *を使用して、任意のRuby式の値を文字列に置き換えることができます。 ここで、exprは任意のルビー式です。 

#!/usr/bin/ruby -w

puts "Multiplication Value : #{24*60*60}";

これは、次の結果を生成します- 

Multiplication Value : 86400

バックスラッシュ表記

以下は、Rubyがサポートするバックスラッシュ表記法のリストです-

Notation Character represented
\n Newline (0x0a)
\r Carriage return (0x0d)
\f Formfeed (0x0c)
\b Backspace (0x08)
\a Bell (0x07)
\e Escape (0x1b)
\s Space (0x20)
\nnn Octal notation (n being 0-7)
\xnn Hexadecimal notation (n being 0-9, a-f, or A-F)
\cx, \C-x Control-x
\M-x Meta-x (c
0x80) \M-\C-x
Meta-Control-x \x

Ruby文字列の詳細については、link：/ruby​​/ruby​​_strings [Ruby Strings]をご覧ください。

Rubyの配列

Ruby配列のリテラルは、角括弧の間にオブジェクト参照のコンマ区切りのシリーズを配置することによって作成されます。 末尾のコンマは無視されます。

例

#!/usr/bin/ruby

ary = [  "fred", 10, 3.14, "This is a string", "last element", ]
ary.each do |i|
   puts i
end

これは、次の結果を生成します- 

fred
10
3.14
This is a string
last element

Ruby配列の詳細については、link：/ruby​​/ruby​​_arrays [Ruby Arrays]を参照してください。

ルビーハッシュ

リテラルRuby Hashは、キーと値の間にカンマまたはシーケンス⇒のいずれかを使用して、キーと値のペアのリストを中括弧の間に配置することによって作成されます。 末尾のコンマは無視されます。

例

#!/usr/bin/ruby

hsh = colors = { "red" => 0xf00, "green" => 0x0f0, "blue" => 0x00f }
hsh.each do |key, value|
   print key, " is ", value, "\n"
end

これは、次の結果を生成します- 

red is 3840
green is 240
blue is 15

Rubyハッシュの詳細については、リンク：/ruby​​/ruby​​_hashes [Rubyハッシュ]を参照してください。

ルビーレンジ

範囲は、開始と終了のある値のセットである間隔を表します。 範囲は、s..eおよびs …​ eリテラルを使用して、またはRange.newを使用して構築できます。

.を使用して構築された範囲 開始から終了まで包括的に実行します。 を使用して作成されたもの…​ 終了値を除外します。 イテレータとして使用する場合、範囲はシーケンス内の各値を返します。.

範囲（1..5）は1、2、3、4、5の値を含むことを意味し、範囲（1 …​ 5）は1、2、3、4の値を含むことを意味します。

例

#!/usr/bin/ruby

(10..15).each do |n|
   print n, ' '
end

これは、次の結果を生成します- 

10 11 12 13 14 15

Rubyの範囲の詳細については、link：/ruby​​/ruby​​_ranges [Ruby Ranges]をご覧ください。

Ruby-演算子

Rubyは現代の言語に期待されるように、豊富な演算子セットをサポートしています。 ほとんどの演算子は、実際にはメソッド呼び出しです。 たとえば、＆plus; bはa。＆plus;（b）として解釈されます。ここで＆plus;変数_a_によって参照されるオブジェクト内のメソッドは、_b_を引数として呼び出されます。

各演算子（＆plus;-/％*＆| ^ << >> && ||）には、対応する形式の省略された代入演算子（＆plus; =-=など）があります。

Rubyの算術演算子

変数aが10を保持し、変数bが20を保持すると仮定します-

Operator Description Example
PLUS Addition − Adds values on either side of the operator. a PLUS b will give 30
− Subtraction − Subtracts right hand operand from left hand operand. a - b will give -10
* Multiplication − Multiplies values on either side of the operator. a* b will give 200
/ Division − Divides left hand operand by right hand operand. b/a will give 2
% Modulus − Divides left hand operand by right hand operand and returns remainder. b % a will give 0
** Exponent − Performs exponential (power) calculation on operators. a**b will give 10 to the power 20

Ruby比較演算子

変数aが10を保持し、変数bが20を保持すると仮定します-

Operator Description Example
== Checks if the value of two operands are equal or not, if yes then condition becomes true. (a == b) is not true.
!= Checks if the value of two operands are equal or not, if values are not equal then condition becomes true. (a != b) is true.
> Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true. (a > b) is not true.
< Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true. (a < b) is true.
>= Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true. (a >= b) is not true.
⇐ Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true. (a ⇐ b) is true.
<⇒ Combined comparison operator. Returns 0 if first operand equals second, 1 if first operand is greater than the second and -1 if first operand is less than the second. (a <⇒ b) returns -1.
=== Used to test equality within a when clause of a case statement. (1…​10) === 5 returns true.
.eql? True if the receiver and argument have both the same type and equal values. 1 == 1.0 returns true, but 1.eql?(1.0) is false.
equal? True if the receiver and argument have the same object id. if aObj is duplicate of bObj then aObj == bObj is true, a.equal?bObj is false but a.equal?aObj is true.

Rubyの代入演算子

変数aが10を保持し、変数bが20を保持すると仮定します-

Operator Description Example
= Simple assignment operator, assigns values from right side operands to left side operand. c = a PLUS b will assign the value of a PLUS b into c
PLUS= Add AND assignment operator, adds right operand to the left operand and assign the result to left operand. c PLUS= a is equivalent to c = c PLUS a
-= Subtract AND assignment operator, subtracts right operand from the left operand and assign the result to left operand. c -= a is equivalent to c = c - a
*= Multiply AND assignment operator, multiplies right operand with the left operand and assign the result to left operand. c *= a is equivalent to c = c * a
/= Divide AND assignment operator, divides left operand with the right operand and assign the result to left operand. c/= a is equivalent to c = c/a
%= Modulus AND assignment operator, takes modulus using two operands and assign the result to left operand. c %= a is equivalent to c = c % a
**= Exponent AND assignment operator, performs exponential (power) calculation on operators and assign value to the left operand. c = a is equivalent to c = c a

Rubyの並列割り当て

Rubyは、変数の並列割り当てもサポートしています。 これにより、Rubyコードの1行で複数の変数を初期化できます。 たとえば- 

a = 10
b = 20
c = 30

これは、並列割り当てを使用してより迅速に宣言することができます- 

a, b, c = 10, 20, 30

並列割り当てはまた、2つの変数に保持されている値を交換するのに便利です- 

a, b = b, c

Rubyのビット演算子

ビット単位演算子はビットに対して機能し、ビットごとの演算を実行します。

a = 60の場合;およびb = 13;今バイナリ形式では、次のようになります- 

 a    =  0011 1100
 b    =  0000 1101
 ------------------
 a&b  =  0000 1100
 a|b  =  0011 1101
 a^b  =  0011 0001
 ~a   =  1100 0011

次のビット演算子は、Ruby言語でサポートされています。

Operator Description Example
& Binary AND Operator copies a bit to the result if it exists in both operands. (a & b) will give 12, which is 0000 1100
Binary OR Operator copies a bit if it exists in either operand.
(a b) will give 61, which is 0011 1101 ^
Binary XOR Operator copies the bit if it is set in one operand but not both. (a ^ b) will give 49, which is 0011 0001 ~
Binary Ones Complement Operator is unary and has the effect of 'flipping' bits. (~a ) will give -61, which is 1100 0011 in 2’s complement form due to a signed binary number. <<
Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand. a << 2 will give 240, which is 1111 0000 >>

Rubyの論理演算子

以下の論理演算子がRuby言語でサポートされています

変数_a_が10を保持し、変数_b_が20を保持すると仮定します-

Operator Description Example
and Called Logical AND operator. If both the operands are true, then the condition becomes true. (a and b) is true.
or Called Logical OR Operator. If any of the two operands are non zero, then the condition becomes true. (a or b) is true.
&& Called Logical AND operator. If both the operands are non zero, then the condition becomes true. (a && b) is true.
Called Logical OR Operator. If any of the two operands are non zero, then the condition becomes true. (a
b) is true. ! Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then Logical NOT operator will make false.
!(a && b) is false. not Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then Logical NOT operator will make false.

ルビー三項演算子

Ternary Operatorと呼ばれるもう1つの演算子があります。 最初に式の真または偽の値を評価し、評価の結果に応じて2つの指定されたステートメントのいずれかを実行します。 条件演算子はこの構文を持っています-

Operator Description Example
? : Conditional Expression If Condition is true ? Then value X : Otherwise value Y

Rubyの範囲演算子

Rubyのシーケンス範囲は、連続する値の範囲を作成するために使用されます-開始値、終了値、およびその間の値の範囲で構成されます。

Rubyでは、これらのシーケンスは「..」および「…​」範囲演算子を使用して作成されます。 2ドット形式は包括的範囲を作成し、3ドット形式は指定された高い値を除外する範囲を作成します。

Operator Description Example
.. Creates a range from start point to end point inclusive. 1..10 Creates a range from 1 to 10 inclusive.
…​ Creates a range from start point to end point exclusive. 1…​10 Creates a range from 1 to 9.

ルビ定義？ オペレータ

定義済み？ は、渡された式が定義されているかどうかを判断するメソッド呼び出しの形式をとる特別な演算子です。 式の説明文字列、または式が定義されていない場合は_nil_を返します。

定義のさまざまな使用法がありますか？ オペレーター

使い方1

defined? variable # True if variable is initialized

例えば 

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil (undefined)

使い方2

defined? method_call # True if a method is defined

例えば 

defined? puts        # => "method"
defined? puts(bar)   # => nil (bar is not defined here)
defined? unpack      # => nil (not defined here)

使い方3

# True if a method exists that can be called with super user
defined? super

例えば 

defined? super     # => "super" (if it can be called)
defined? super     # => nil (if it cannot be)

使い方4

defined? yield   # True if a code block has been passed

例えば 

defined? yield    # => "yield" (if there is a block passed)
defined? yield    # => nil (if there is no block)

ルビードット「。」および二重コロン「::」演算子

モジュールの名前とピリオドを名前の前に付けてモジュールメソッドを呼び出し、モジュール名と2つのコロンを使用して定数を参照します。 

*::* は単項演算子であり、クラスまたはモジュール内で定義された定数、インスタンスメソッド、およびクラスメソッドに、クラスまたはモジュール外のどこからでもアクセスできます。
*Remember* では、クラスとメソッドも定数と見なされる場合があります。
*::* Const_nameの前に、適切なクラスまたはモジュールオブジェクトを返す式を付ける必要があります。

プレフィックス式が使用されていない場合、デフォルトでメインのObjectクラスが使用されます。

ここに2つの例があります- 

MR_COUNT = 0         # constant defined on main Object class
module Foo
   MR_COUNT = 0
   ::MR_COUNT = 1    # set global count to 1
   MR_COUNT = 2      # set local count to 2
end
puts MR_COUNT        # this is the global constant
puts Foo::MR_COUNT   # this is the local "Foo" constant

第二の例 

CONST = ' out there'
class Inside_one
   CONST = proc {' in there'}
   def where_is_my_CONST
      ::CONST + ' inside one'
   end
end
class Inside_two
   CONST = ' inside two'
   def where_is_my_CONST
      CONST
   end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST + Inside_two::CONST
puts Inside_two::CONST + CONST
puts Inside_one::CONST
puts Inside_one::CONST.call + Inside_two::CONST

Ruby演算子の優先順位

次の表に、優先順位の高いものから低いものまで、すべての演算子を示します。

Method Operator Description
Yes :: Constant resolution operator
Yes [ ] [ ]= Element reference, element set
Yes ** Exponentiation (raise to the power)
Yes ! ~ PLUS - Not, complement, unary plus and minus (method names for the last two are PLUSCOMMAT and -COMMAT)
Yes */% Multiply, divide, and modulo
Yes PLUS - Addition and subtraction
Yes >> << Right and left bitwise shift
Yes & Bitwise 'AND'
Yes ^
Bitwise exclusive `OR' and regular `OR' Yes ⇐ < > >=
Comparison operators Yes <⇒ == === != =~ !~
Equality and pattern match operators (!= and !~ may not be defined as methods)   &&
Logical 'AND'  
Logical 'OR'
  .. …​ Range (inclusive and exclusive)
  ? : Ternary if-then-else
  = %= \{/= -= PLUS= = &= >>= <⇐* = &&=
= **= Assignment
  defined? Check if specified symbol defined
  not Logical negation
  or and Logical composition

注-メソッド列に_Yes_が含まれる演算子は、実際にはメソッドであるため、オーバーライドされる場合があります。

Ruby-コメント

コメントは、実行時に無視されるRubyコード内の注釈行です。 単一行のコメントは、＃文字で始まり、次のように＃から行末まで続きます- 

#!/usr/bin/ruby -w
# This is a single line comment.

puts "Hello, Ruby!"

実行すると、上記のプログラムは次の結果を生成します- 

Hello, Ruby!

Rubyマルチラインコメント

次のように = begin および = end 構文を使用して複数の行をコメントできます- 

#!/usr/bin/ruby -w

puts "Hello, Ruby!"

=begin
This is a multiline comment and con spwan as many lines as you
like. But =begin and =end should come in the first line only.
=end

実行すると、上記のプログラムは次の結果を生成します- 

Hello, Ruby!

末尾のコメントがコードから十分に離れており、簡単に区別できることを確認してください。 ブロックに複数の末尾コメントが存在する場合、それらを揃えます。 たとえば- 

@counter      # keeps track times page has been hit
@siteCounter  # keeps track of times all pages have been hit

Ruby-if …​ else、case、unless

Rubyは、現代の言語によくある条件付き構造を提供します。 ここでは、Rubyで使用可能なすべての条件ステートメントと修飾子について説明します。

Ruby if …​ elseステートメント

構文

if conditional [then]
   code...
[elsif conditional [then]
   code...]...
[else
   code...]
end

_if_式は、条件付き実行に使用されます。 _false_および_nil_の値はfalseであり、他のすべてはtrueです。 Rubyはelsifを使用しますが、ifやelifは使用しません。

_conditional_がtrueの場合、_code_を実行します。 _conditional_が真でない場合、else節で指定された_code_が実行されます。

if式の_conditional_は、予約語_then_、改行、またはセミコロンによってコードから分離されています。

例

#!/usr/bin/ruby

x = 1
if x > 2
   puts "x is greater than 2"
elsif x <= 2 and x!=0
   puts "x is 1"
else
   puts "I can't guess the number"
end
x is 1

ルビif修飾子

構文

code if condition

_conditional_がtrueの場合、_code_を実行します。

例

#!/usr/bin/ruby

$debug = 1
print "debug\n" if $debug

これは、次の結果を生成します- 

debug

ステートメント以外のRuby

構文

unless conditional [then]
   code
[else
   code ]
end

_conditional_がfalseの場合、_code_を実行します。 _conditional_がtrueの場合、else句で指定されたコードが実行されます。

例

#!/usr/bin/ruby

x = 1
unless x>=2
   puts "x is less than 2"
 else
   puts "x is greater than 2"
end

これは、次の結果を生成します- 

x is less than 2

修飾子を除いてRuby

構文

code unless conditional

_conditional_がfalseの場合、_code_を実行します。

例

#!/usr/bin/ruby

$var =  1
print "1 -- Value is set\n" if $var
print "2 -- Value is set\n" unless $var

$var = false
print "3 -- Value is set\n" unless $var

これは、次の結果を生成します- 

1 -- Value is set
3 -- Value is set

Rubyのcaseステートメント

構文

case expression
[when expression [, expression ...] [then]
   code ]...
[else
   code ]
end

caseで指定された_expression_と===演算子を使用するときに指定された_expression_を比較し、一致するwhen節の_code_を実行します。

when句で指定された_expression_は、左のオペランドとして評価されます。 一致するwhen節がない場合、_case_は_else_節のコードを実行します。

_when_ステートメントの式は、予約語then、改行、またはセミコロンによってコードから分離されます。 したがって- 

case expr0
when expr1, expr2
   stmt1
when expr3, expr4
   stmt2
else
   stmt3
end

基本的に次のようなものです- 

_tmp = expr0
if expr1 === _tmp || expr2 === _tmp
   stmt1
elsif expr3 === _tmp || expr4 === _tmp
   stmt2
else
   stmt3
end

例

#!/usr/bin/ruby

$age =  5
case $age
when 0 .. 2
   puts "baby"
when 3 .. 6
   puts "little child"
when 7 .. 12
   puts "child"
when 13 .. 18
   puts "youth"
else
   puts "adult"
end

これは、次の結果を生成します- 

little child

Ruby-ループ

Rubyのループは、同じコードブロックを指定された回数実行するために使用されます。 この章では、Rubyがサポートするすべてのループステートメントについて詳しく説明します。

Ruby whileステートメント

構文

while conditional [do]
   code
end

_conditional_がtrueのときに_code_を実行します。 _while_ループの_conditional_は、予約語do、改行、バックスラッシュ\、またはセミコロン;によって_code_から分離されています。

例

#!/usr/bin/ruby

&dollar;i = 0
&dollar;num = 5

while &dollar;i < &dollar;num  do
   puts("Inside the loop i = #&dollar;i" )
   &dollar;i &plus;=1
end

これは、次の結果を生成します- 

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4

Ruby while修飾子

構文

code while condition

OR

begin
  code
end while conditional

_conditional_がtrueのときに_code_を実行します。

_rescue_またはensure句のない_begin_ステートメントの後に_while_修飾子が続く場合、_code_は条件が評価される前に1回実行されます。

例

#!/usr/bin/ruby

&dollar;i = 0
&dollar;num = 5
begin
   puts("Inside the loop i = #&dollar;i" )
   &dollar;i &plus;=1
end while &dollar;i < &dollar;num

これは、次の結果を生成します- 

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4

Ruby until Statement

until conditional [do]
   code
end

conditional_がfalseのときに_code_を実行します。 _until_ステートメントの条件は、予約語_do、改行、またはセミコロンによって_code_から分離されます。

例

#!/usr/bin/ruby

&dollar;i = 0
&dollar;num = 5

until &dollar;i > &dollar;num  do
   puts("Inside the loop i = #&dollar;i" )
   &dollar;i &plus;=1;
end

これは、次の結果を生成します- 

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Inside the loop i = 5

修飾子までルビー

構文

code until conditional

OR

begin
   code
end until conditional

_conditional_がfalseのときに_code_を実行します。

_until_修飾子が_rescue_またはensure句のない_begin_ステートメントの後に続く場合、_condition_が評価される前に_code_が1回実行されます。

例

#!/usr/bin/ruby

&dollar;i = 0
&dollar;num = 5
begin
   puts("Inside the loop i = #&dollar;i" )
   &dollar;i &plus;=1;
end until &dollar;i > &dollar;num

これは、次の結果を生成します- 

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Inside the loop i = 5

ステートメントのルビー

構文

for variable [, variable ...] in expression [do]
   code
end

_expression_の各要素に対して_code_を1回実行します。

例

#!/usr/bin/ruby

for i in 0..5
   puts "Value of local variable is #{i}"
end

ここで、範囲0..5を定義しました。 0..5の_i_のステートメントにより、_i_は0から5（5を含む）の範囲の値を取ることができます。 これは、次の結果を生成します- 

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

_for …​ in_ループは、次とほぼ正確に同等です- 

(expression).each do |variable[, variable...]| code end

ただし、_for_ループはローカル変数の新しいスコープを作成しません。 _for_ループの_expression_は、予約語do、改行、またはセミコロンによって_code_から分離されます。

例

#!/usr/bin/ruby

(0..5).each do |i|
   puts "Value of local variable is #{i}"
end

これは、次の結果を生成します- 

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

Ruby breakステートメント

構文

break

最も内部的なループを終了します。 ブロック内で呼び出された場合（nilを返すメソッドで）、関連付けられたブロックでメソッドを終了します。

例

#!/usr/bin/ruby

for i in 0..5
   if i > 2 then
      break
   end
   puts "Value of local variable is #{i}"
end

これは、次の結果を生成します- 

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2

Rubyの次のステートメント

構文

next

最も内部的なループの次の反復にジャンプします。 （_yield_またはnilを返す呼び出しで）ブロック内で呼び出された場合、ブロックの実行を終了します。

例

#!/usr/bin/ruby

for i in 0..5
   if i < 2 then
      next
   end
   puts "Value of local variable is #{i}"
end

これは、次の結果を生成します- 

Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

Ruby REDOステートメント

構文

redo

ループ条件をチェックせずに、最も内部的なループのこの反復を再開します。 ブロック内で呼び出された場合、_yield_または_call_を再起動します。

例

#!/usr/bin/ruby

for i in 0..5
   if i < 2 then
      puts "Value of local variable is #{i}"
      redo
   end
end

これは、次の結果を生成し、無限ループに入ります- 

Value of local variable is 0
Value of local variable is 0
............................

Ruby再試行ステートメント

構文

retry

_retry_がbegin expressionのrescue句に表示される場合、begin bodyの先頭から再開します。 

begin
   do_something # exception raised
rescue
   # handles error
   retry  # restart from beginning
end

イテレータ、ブロック、または_for_式の本体に再試行が表示される場合、イテレータ呼び出しの呼び出しを再開します。 反復子の引数が再評価されます。 

for i in 1..5
   retry if some_condition # restart from i == 1
end

例

#!/usr/bin/ruby
for i in 0..5
   retry if i > 2
puts "Value of local variable is #{i}"
end

これは、次の結果を生成し、無限ループに入ります- 

Value of local variable is 1
Value of local variable is 2
Value of local variable is 1
Value of local variable is 2
Value of local variable is 1
Value of local variable is 2
............................

Ruby-メソッド

Rubyのメソッドは、他のプログラミング言語の関数と非常によく似ています。 Rubyメソッドは、1つ以上の繰り返し可能なステートメントを単一のユニットにバンドルするために使用されます。

メソッド名は小文字で始める必要があります。 メソッド名を大文字で始めると、Rubyはそれが定数であると見なし、呼び出しを誤って解析する可能性があります。

メソッドは呼び出す前に定義する必要があります。そうしないと、Rubyは未定義のメソッド呼び出しに対して例外を発生させます。

構文

def method_name [( [arg [= default]]...[, * arg [, &expr ]])]
   expr..
end

したがって、次のように簡単なメソッドを定義できます- 

def method_name
   expr..
end

あなたはこのようなパラメータを受け入れるメソッドを表すことができます- 

def method_name (var1, var2)
   expr..
end

あなたは、必要なパラメータを渡さずにメソッドが呼び出された場合に使用されるパラメータのデフォルト値を設定することができます- 

def method_name (var1 = value1, var2 = value2)
   expr..
end

あなたは単純なメソッドを呼び出すたびに、次のようにメソッド名のみを書きます- 

method_name

ただし、パラメータを使用してメソッドを呼び出す場合、次のようなパラメータとともにメソッド名を記述します- 

method_name 25, 30

パラメーター付きのメソッドを使用する場合の最も重要な欠点は、そのようなメソッドを呼び出すときは常にパラメーターの数を覚えておく必要があることです。 たとえば、メソッドが3つのパラメーターを受け入れ、2つだけを渡すと、Rubyはエラーを表示します。

例

#!/usr/bin/ruby

def test(a1 = "Ruby", a2 = "Perl")
   puts "The programming language is #{a1}"
   puts "The programming language is #{a2}"
end
test "C", "C++"
test

これは、次の結果を生成します- 

The programming language is C
The programming language is C++
The programming language is Ruby
The programming language is Perl

メソッドからの戻り値

Rubyのすべてのメソッドはデフォルトで値を返します。 この戻り値は、最後のステートメントの値になります。 たとえば- 

def test
   i = 100
   j = 10
   k = 0
end

このメソッドを呼び出すと、最後に宣言された変数_k_が返されます。

Rubyのreturnステートメント

rubyの_return_ステートメントは、Rubyメソッドから1つ以上の値を返すために使用されます。

構文

return [expr[`,' expr...]]

3つ以上の式が指定されている場合、これらの値を含む配列が戻り値になります。 式が指定されていない場合、nilが戻り値になります。

例

return

OR

return 12

OR

return 1,2,3

この例を見てください- 

#!/usr/bin/ruby

def test
   i = 100
   j = 200
   k = 300
return i, j, k
end
var = test
puts var

これは、次の結果を生成します- 

100
200
300

可変数のパラメーター

2つのパラメーターをとるメソッドを宣言するとします。このメソッドを呼び出すときは常に、2つのパラメーターを渡す必要があります。

ただし、Rubyでは、可変数のパラメーターで機能するメソッドを宣言できます。 このサンプルを調べてみましょう- 

#!/usr/bin/ruby

def sample (*test)
   puts "The number of parameters is #{test.length}"
   for i in 0...test.length
      puts "The parameters are #{test[i]}"
   end
end
sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"

このコードでは、1つのパラメーターテストを受け入れるメソッドサンプルを宣言しています。 ただし、このパラメーターは可変パラメーターです。 これは、このパラメーターが任意の数の変数を受け取ることができることを意味します。 したがって、上記のコードは次の結果を生成します- 

The number of parameters is 3
The parameters are Zara
The parameters are 6
The parameters are F
The number of parameters is 4
The parameters are Mac
The parameters are 36
The parameters are M
The parameters are MCA

クラスメソッド

メソッドがクラス定義の外部で定義されている場合、そのメソッドはデフォルトで_private_としてマークされます。 一方、クラス定義で定義されたメソッドは、デフォルトでパブリックとしてマークされます。 メソッドのデフォルトの可視性と_private_マークは、モジュールの_public_または_private_によって変更できます。

クラスのメソッドにアクセスするたびに、最初にクラスをインスタンス化する必要があります。 次に、オブジェクトを使用して、クラスの任意のメンバーにアクセスできます。

Rubyを使用すると、クラスをインスタンス化せずにメソッドにアクセスできます。 クラスメソッドがどのように宣言されアクセスされるかを見てみましょう- 

class Accounts
   def reading_charge
   end
   def Accounts.return_date
   end
end

メソッドreturn_dateの宣言方法を参照してください。 クラス名の後にピリオドが続き、その後にメソッドの名前が続いて宣言されます。 次のように、このクラスメソッドに直接アクセスできます- 

Accounts.return_date

このメソッドにアクセスするには、Accountsクラスのオブジェクトを作成する必要はありません。

Rubyエイリアスステートメント

これにより、メソッドまたはグローバル変数にエイリアスが与えられます。 エイリアスはメソッド本体内で定義できません。 メソッドのエイリアスは、メソッドがオーバーライドされた場合でも、メソッドの現在の定義を保持します。

番号付きグローバル変数（＆dollar; 1、＆dollar; 2、…​）のエイリアスを作成することは禁止されています。 組み込みのグローバル変数をオーバーライドすると、深刻な問題が発生する可能性があります。

構文

alias method-name method-name
alias global-variable-name global-variable-name

例

alias foo bar
alias &dollar;MATCH &dollar;&

ここで、barのfooエイリアスを定義しました。＆dollar; MATCHは＆dollar;＆のエイリアスです。

Ruby undefステートメント

これにより、メソッド定義がキャンセルされます。 _undef_はメソッド本体に表示できません。

_undef_および_alias_を使用することにより、クラスのインターフェイスをスーパークラスとは独立して変更できますが、selfの内部メソッド呼び出しによってプログラムが破損する可能性があることに注意してください。

構文

undef method-name

例

_bar_と呼ばれるメソッドの定義を解除するには、次のようにします- 

undef bar

ルビー-ブロック

Rubyがメソッドを定義する方法を見てきました。ここでは、多数のステートメントを配置し、そのメソッドを呼び出すことができます。 同様に、Rubyにはブロックという概念があります。

  • ブロックはコードのチャンクで構成されます。
  • ブロックに名前を割り当てます。
  • ブロック内のコードは常に中括弧（\ {}）で囲まれています。
  • ブロックは、ブロックの名前と同じ名前の関数から常に呼び出されます。 これは、_test_という名前のブロックがある場合、_test_関数を使用してこのブロックを呼び出すことを意味します。
  • _yield_ステートメントを使用してブロックを呼び出します。

構文

block_name {
   statement1
   statement2
   ..........
}

ここでは、簡単な_yield_ステートメントを使用してブロックを呼び出す方法を学習します。 また、ブロックを呼び出すためのパラメーターで_yield_ステートメントを使用する方法も学習します。 両方のタイプの_yield_ステートメントでサンプルコードを確認します。

yieldステートメント

yieldステートメントの例を見てみましょう- 

#!/usr/bin/ruby

def test
   puts "You are in the method"
   yield
   puts "You are again back to the method"
   yield
end
test {puts "You are in the block"}

これは、次の結果を生成します- 

You are in the method
You are in the block
You are again back to the method
You are in the block

yieldステートメントでパラメーターを渡すこともできます。 ここに例があります- 

#!/usr/bin/ruby

def test
   yield 5
   puts "You are in the method test"
   yield 100
end
test {|i| puts "You are in the block #{i}"}

これは、次の結果を生成します- 

You are in the block 5
You are in the method test
You are in the block 100

ここでは、_yield_ステートメントが記述され、その後にパラメーターが続きます。 複数のパラメーターを渡すこともできます。 ブロックでは、2つの垂直線（||）の間に変数を配置して、パラメーターを受け入れます。 したがって、上記のコードでは、yield 5ステートメントは値5をパラメーターとしてテストブロックに渡します。

さて、次の文を見てください- 

test {|i| puts "You are in the block #{i}"}

ここでは、変数_i_で値5を受け取ります。 さて、次の_puts_ステートメントを観察してください- 

puts "You are in the block #{i}"

この_puts_ステートメントの出力は次のとおりです- 

You are in the block 5

あなたが複数のパラメータを渡したい場合、_yield_ステートメントは次のようになります- 

yield a, b

そして、ブロックは- 

test {|a, b| statement}

パラメーターはコンマで区切られます。

ブロックとメソッド

ブロックとメソッドを相互に関連付ける方法を見てきました。 通常、ブロックと同じ名前のメソッドからyieldステートメントを使用してブロックを呼び出します。 したがって、あなたは書く- 

#!/usr/bin/ruby

def test
   yield
end
test{ puts "Hello world"}

この例は、ブロックを実装する最も簡単な方法です。 _yield_ステートメントを使用して、テストブロックを呼び出します。

しかし、メソッドの最後の引数の前に＆が付いている場合、このメソッドにブロックを渡すことができ、このブロックは最後のパラメーターに割り当てられます。 引数リストに*と＆の両方が存在する場合、＆は後で来るはずです。 

#!/usr/bin/ruby

def test(&block)
   block.call
end
test { puts "Hello World!"}

これは、次の結果を生成します- 

Hello World!

BEGINブロックとENDブロック

すべてのRubyソースファイルは、ファイルのロード中（BEGINブロック）およびプログラムの実行終了後（ENDブロック）に実行するコードブロックを宣言できます。 

#!/usr/bin/ruby

BEGIN {
   # BEGIN block code
   puts "BEGIN code block"
}

END {
   # END block code
   puts "END code block"
}
   # MAIN block code
puts "MAIN code block"

プログラムには、複数のBEGINブロックとENDブロックを含めることができます。 BEGINブロックは、検出された順に実行されます。 ENDブロックは逆の順序で実行されます。 実行すると、上記のプログラムは次の結果を生成します- 

BEGIN code block
MAIN code block
END code block

Ruby-モジュールとミックスイン

モジュールは、メソッド、クラス、および定数をまとめる方法です。 モジュールには、2つの大きな利点があります。

  • モジュールは_namespace_を提供し、名前の衝突を防ぎます。
  • モジュールは_mixin_機能を実装します。

モジュールは名前空間を定義します。名前空間は、他のメソッドや定数が踏まれることを心配せずにメソッドや定数を再生できるサンドボックスです。

構文

module Identifier
   statement1
   statement2
   ...........
end

モジュール定数は、クラス定数と同じように、最初の大文字が名前になります。 メソッド定義も同様に見えます。モジュールメソッドはクラスメソッドのように定義されます。

クラスメソッドと同様に、モジュール名とピリオドを名前の前に付けてモジュールメソッドを呼び出し、モジュール名と2つのコロンを使用して定数を参照します。

例

#!/usr/bin/ruby

# Module defined in trig.rb file

module Trig
   PI = 3.141592654
   def Trig.sin(x)
   # ..
   end
   def Trig.cos(x)
   # ..
   end
end

同じ機能名で異なる機能を持つモジュールをもう1つ定義できます- 

#!/usr/bin/ruby

# Module defined in moral.rb file

module Moral
   VERY_BAD = 0
   BAD = 1
   def Moral.sin(badness)
   # ...
   end
end

クラスメソッドのように、モジュールでメソッドを定義するときは常に、モジュール名の後にドットとメソッド名を続けて指定します。

Rubyのrequireステートメント

requireステートメントは、CおよびC ++のincludeステートメントおよびJavaのimportステートメントに似ています。 3番目のプログラムが定義済みのモジュールを使用する場合、Ruby _require_ステートメントを使用してモジュールファイルを単純にロードできます-

構文

require filename

ここでは、*。rb *拡張子とファイル名を指定する必要はありません。

例

$LOAD_PATH << '.'

require 'trig.rb'
require 'moral'

y = Trig.sin(Trig::PI/4)
wrongdoing = Moral.sin(Moral::VERY_BAD)

ここでは、 $ LOAD_PATH << '。' を使用して、現在のディレクトリでインクルードファイルを検索する必要があることをRubyに認識させています。 $ LOAD_PATHを使用したくない場合は、 require_relative を使用して相対ディレクトリのファイルを含めることができます。

重要-ここでは、両方のファイルに同じ関数名が含まれています。 したがって、これにより、プログラムの呼び出しに含まれるときにコードがあいまいになりますが、モジュールはこのコードのあいまいさを回避し、モジュール名を使用して適切な関数を呼び出すことができます。

Rubyのincludeステートメント

モジュールをクラスに埋め込むことができます。 クラスにモジュールを埋め込むには、クラスで_include_ステートメントを使用します-

構文

include modulename

モジュールが別のファイルで定義されている場合、クラスにモジュールを埋め込む前に_require_ステートメントを使用してそのファイルを含める必要があります。

例

_support.rb_ファイルに記述された次のモジュールを検討してください。 

module Week
   FIRST_DAY = "Sunday"
   def Week.weeks_in_month
      puts "You have four weeks in a month"
   end
   def Week.weeks_in_year
      puts "You have 52 weeks in a year"
   end
end

今、次のようにクラスにこのモジュールを含めることができます- 

#!/usr/bin/ruby
$LOAD_PATH << '.'
require "support"

class Decade
include Week
   no_of_yrs = 10
   def no_of_months
      puts Week::FIRST_DAY
      number = 10*12
      puts number
   end
end
d1 = Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month
Week.weeks_in_year
d1.no_of_months

これは、次の結果を生成します- 

Sunday
You have four weeks in a month
You have 52 weeks in a year
Sunday
120

Rubyのミックスイン

このセクションを読む前に、オブジェクト指向の概念の知識があることを前提としています。

クラスが複数の親クラスから機能を継承できる場合、そのクラスは複数の継承を示すことになっています。

Rubyは複数の継承を直接サポートしていませんが、Rubyモジュールには別の素晴らしい用途があります。 一気に、それらは多重継承の必要性をほとんどなくし、_mixin_と呼ばれる機能を提供します。

ミックスインを使用すると、クラスに機能を追加するための素晴らしい制御方法が提供されます。 ただし、mixinのコードがそれを使用するクラスのコードとやり取りし始めると、その真の力が発揮されます。

mixinの理解を得るために次のサンプルコードを調べてみましょう- 

module A
   def a1
   end
   def a2
   end
end
module B
   def b1
   end
   def b2
   end
end

class Sample
include A
include B
   def s1
   end
end

samp = Sample.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1

モジュールAは、メソッドa1とa2で構成されています。 モジュールBは、メソッドb1とb2で構成されています。 クラスSampleには、モジュールAとBの両方が含まれています。 クラスSampleは、4つのメソッドすべて、つまりa1、a2、b1、およびb2にアクセスできます。 したがって、クラスSampleが両方のモジュールから継承していることがわかります。 したがって、クラスSampleは多重継承または_mixin_を示していると言えます。

ルビー-文字列

RubyのStringオブジェクトは、通常は人間の言語を表す文字を表す1つ以上のバイトの任意のシーケンスを保持および操作します。

最も単純な文字列リテラルは、一重引用符（アポストロフィ文字）で囲まれています。 引用符内のテキストは、文字列の値です- 

'This is a simple Ruby string literal'

あなたが一重引用符で囲まれた文字列リテラル内にアポストロフィを配置する必要がある場合は、Rubyインタープリターが文字列を終了するとは思わないように、バックスラッシュをその前に付けます- 

'Won\'t you read O\'Reilly\'s book?'

バックスラッシュは別のバックスラッシュをエスケープするためにも機能するため、2番目のバックスラッシュ自体はエスケープ文字として解釈されません。

以下は、Rubyの文字列関連の機能です。

式の置換

式の置換は、＃\ {および}を使用してRuby式の値を文字列に埋め込む手段です- 

#!/usr/bin/ruby

x, y, z = 12, 36, 72
puts "The value of x is #{ x }."
puts "The sum of x and y is #{ x + y }."
puts "The average was #{ (x + y + z)/3 }."

これは、次の結果を生成します- 

The value of x is 12.
The sum of x and y is 48.
The average was 40.

一般的な区切り文字列

一般的な区切り文字列を使用すると、任意の区切り文字（たとえば、！、（、\ {、<など）の前にパーセント文字（％）を付けて一致するペア内に文字列を作成できます。 Q、q、およびxには特別な意味があります。 一般的な区切り文字列は- 

%{Ruby is fun.}  equivalent to "Ruby is fun."
%Q{ Ruby is fun. } equivalent to " Ruby is fun. "
%q[Ruby is fun.]  equivalent to a single-quoted string
%x!ls! equivalent to back tick command output `ls`

エスケープ文字

____次の表は、バックスラッシュ表記で表すことができるエスケープ文字または印刷できない文字のリストです。

注-二重引用符で囲まれた文字列では、エスケープ文字が解釈されます。単一引用符で囲まれた文字列では、エスケープ文字が保持されます。

Backslash notation Hexadecimal character Description
\a 0x07 Bell or alert
\b 0x08 Backspace
\cx   Control-x
\C-x   Control-x
\e 0x1b Escape
\f 0x0c Formfeed
\M-\C-x   Meta-Control-x
\n 0x0a Newline
\nnn   Octal notation, where n is in the range 0.7
\r 0x0d Carriage return
\s 0x20 Space
\t 0x09 Tab
\v 0x0b Vertical tab
\x   Character x
\xnn   Hexadecimal notation, where n is in the range 0.9, a.f, or A.F

文字コード

Rubyのデフォルトの文字セットはASCIIで、その文字は1バイトで表されます。 UTF-8または別の最新の文字セットを使用する場合、文字は1〜4バイトで表される場合があります。

次のように、プログラムの開始時に$ KCODEを使用して文字セットを変更できます- 

$KCODE = 'u'

____次は、$ KCODEの可能な値です。

Sr.No. Code & Description
1

a

ASCII（なしと同じ）。 これがデフォルトです。

2

e

EUC.

3

n

なし（ASCIIと同じ）。

4

u

UTF-8

文字列組み込みメソッド

Stringメソッドを呼び出すには、Stringオブジェクトのインスタンスが必要です。 以下は、文字列オブジェクトのインスタンスを作成する方法です- 

new [String.new(str = "")]

これは、_str_のコピーを含む新しい文字列オブジェクトを返します。 これで、_str_オブジェクトを使用して、すべての使用可能なインスタンスメソッドを使用できます。 たとえば- 

#!/usr/bin/ruby

myStr = String.new("THIS IS TEST")
foo = myStr.downcase

puts "#{foo}"

これは、次の結果を生成します- 

this is test

____Followingは、パブリックStringメソッドです（strがStringオブジェクトであると仮定）-

Sr.No. Methods & Description
1

str % arg

フォーマット仕様を使用して文字列をフォーマットします。 argが複数の置換を含む場合、配列でなければなりません。 形式の仕様については、「カーネルモジュール」のsprintfを参照してください。

2

str * integer

整数倍のstrを含む新しい文字列を返します。 言い換えると、strは整数imesを繰り返したものです。

3

str PLUS other_str

other_strをstrに連結します。

4

str << obj

オブジェクトをstrに連結します。 オブジェクトが0.255の範囲のFixnumである場合、オブジェクトは文字に変換されます。 concatと比較してください。

5

str <⇒ other_str

strをother_strと比較し、-1（より小さい）、0（等しい）、または1（より大きい）を返します。 比較では大文字と小文字が区別されます。

6

str == obj

strとobjが等しいかどうかをテストします。 objがStringでない場合、falseを返します。 str <⇒ objが0を返す場合、trueを返します。

7

str =~ obj

strを正規表現パターンobjと照合します。 試合が始まる位置を返します。それ以外の場合はfalse。

8

str.capitalize

文字列を大文字にします。

9

str.capitalize!

大文字と同じですが、変更は適切に行われます。

10

str.casecmp

文字列の大文字と小文字を区別しない比較を行います。

11

str.center

文字列を中央揃えにします。

12

str.chomp

文字列の末尾からレコード区切り文字（$/）（通常は\ n）を削除します。 レコード区切り文字が存在しない場合、何もしません。

13

str.chomp!

chompと同じですが、変更はその場で行われます。

14

str.chop

strの最後の文字を削除します。

15

str.chop!

chopと同じですが、変更はその場で行われます。

16

str.concat(other_str)

other_strをstrに連結します。

17

str.count(str, …​)

1つ以上の文字セットをカウントします。 複数の文字セットがある場合、それらのセットの共通部分をカウントします

18

str.crypt(other_str)

一方向暗号化ハッシュをstrに適用します。 引数はソルト文字列で、2文字の長さで、各文字はa.z、A.Z、0.9、…​の範囲にあります。 または/。

19

str.delete(other_str, …​)

引数の共通部分のすべての文字が削除されたstrのコピーを返します。

20

str.delete!(other_str, …​)

削除と同じですが、変更はその場で行われます。

21

str.downcase

すべての大文字を小文字に置き換えてstrのコピーを返します。

22

str.downcase!

ダウンケースと同じですが、変更はその場で行われます。

23

str.dump

すべての非印刷文字を\ nnn表記で置き換え、すべての特殊文字をエスケープしたバージョンのstrを返します。

24 *str.each(separator = DOLLAR/) \{
substr

block }*

引数をレコード区切り文字（デフォルトでは$/）として使用してstrを分割し、指定されたブロックに各部分文字列を渡します。

25 *str.each_byte \{
fixnum

block }*

strからブロックに各バイトを渡し、各バイトをバイトの10進表現として返します。

26 *str.each_line(separator=$/) \{
substr

block }*

引数をレコード区切り文字（デフォルトでは$/）として使用してstrを分割し、指定されたブロックに各部分文字列を渡します。

27

str.empty?

strが空（長さがゼロ）の場合、trueを返します。

28

str.eql?(other)

2つの文字列は、長さと内容が同じ場合に等しくなります。

29

str.gsub(pattern, replacement) [or]

  • str.gsub（pattern）\ {
match

ブロック}*

パターンのすべての出現を置換またはブロックの値で置き換えてstrのコピーを返します。 パターンは通常、正規表現になります。文字列の場合、正規表現のメタ文字は解釈されません（つまり、/\ d/は数字と一致しますが、「\ d」はバックスラッシュと「d」が一致します）

30

str[fixnum] [or] str[fixnum,fixnum] [or] str[range] [or] str[regexp] [or] str[regexp, fixnum] [or] str[other_str]

次の引数を使用してstrを参照します。1つのFixnumは、fixnumで文字コードを返します。 2つのFixnum。オフセット（最初のfixnum）から長さ（2番目のfixnum）までの部分文字列を返します。範囲、範囲内の部分文字列を返します。 regexpは、一致した文字列の一部を返します。 fixnumを含む正規表現。fixnumで一致したデータを返します。 other_strは、other_strに一致するサブストリングを返します。 負のFixnumは、文字列の終わりから-1で始まります。

31

str[fixnum] = fixnum [or] str[fixnum] = new_str [or] str[fixnum, fixnum] = new_str [or] str[range] = aString [or] str[regexp] = new_str [or] str[regexp, fixnum] = new_str [or] str[other_str] = new_str ]

文字列のすべてまたは一部を置換（割り当て）します。 スライスの同義語！

32 *str.gsub!(pattern, replacement) [or] str.gsub!(pattern) \{
match

block }*

String＃gsubの置換を実行し、strを返すか、置換が実行されなかった場合はnilを返します。

33

str.hash

文字列の長さと内容に基づいてハッシュを返します。

34

str.hex

strの先頭の文字を16進数の文字列（オプションの符号とオプションの0xを含む）として扱い、対応する数値を返します。 エラー時にはゼロが返されます。

35

str.include? other_str [or] str.include? fixnum

strが指定された文字列または文字を含む場合、trueを返します。

36

str.index(substring [, offset]) [or]

  • str.index（fixnum [、offset]）[または]*
  • str.index（regexp [、offset]） *

str内の指定された部分文字列、文字（fixnum）、またはパターン（regexp）の最初の出現のインデックスを返します。 見つからない場合はnilを返します。 2番目のパラメーターが存在する場合は、検索を開始する文字列内の位置を指定します。

37
  • str.insert(index, other_str)*

指定されたインデックスの文字の前にother_strを挿入し、strを変更します。 負のインデックスは文字列の末尾からカウントされ、指定された文字の後に挿入されます。 意図は、指定されたインデックスから始まるように文字列を挿入することです。

38

str.inspect

印刷可能なバージョンのstrを、特殊文字をエスケープして返します。

39

str.intern [or] str.to_sym

strに対応するSymbolを返し、以前に存在しなかった場合はシンボルを作成します。

40

str.length

strの長さを返します。 サイズを比較します。

41

str.ljust(integer, padstr = ' ')

integerがstrの長さよりも大きい場合、strが左寄せされ、padstrが埋め込まれた、長さintegerの新しい文字列を返します。それ以外の場合、strを返します。

42

str.lstrip

先頭の空白を削除したstrのコピーを返します。

43

str.lstrip!

strから先頭の空白を削除し、変更が行われなかった場合はnilを返します。

44

str.match(pattern)

パターンをRegexpに変換し（まだない場合）、strでmatchメソッドを呼び出します。

45

str.oct

strの先頭の文字を8進数の文字列（オプションの符号付き）として扱い、対応する数値を返します。 変換が失敗した場合、0を返します。

46

str.replace(other_str)

strの内容と汚染度をother_strの対応する値に置き換えます。

47

str.reverse

strの文字を逆順にした新しい文字列を返します。

48

str.reverse!

strを所定の位置に反転します。

49

str.rindex(substring [, fixnum]) [or]

  • str.rindex（fixnum [、fixnum]）[または]*
  • str.rindex（regexp [、fixnum]） *

str内の指定された部分文字列、文字（fixnum）、またはパターン（regexp）の最後の出現のインデックスを返します。 見つからない場合はnilを返します。 2番目のパラメーターが存在する場合、文字列内でsearchを終了する位置を指定します。このポイントを超える文字は考慮されません。

50.
  • str.rjust(integer, padstr = ' ')*

integerがstrの長さよりも大きい場合、strを右寄せしてpadstrで埋めた長さintegerの新しいストリングを返します。それ以外の場合、strを返します。

51

str.rstrip

末尾の空白を削除したstrのコピーを返します。

52

str.rstrip!

strから末尾の空白を削除し、変更が行われなかった場合はnilを返します。

53

str.scan(pattern) [or]

  • str.scan（pattern）\ {
match、…​

ブロック}*

どちらの形式もstrを反復処理し、パターン（RegexpまたはString）に一致します。 一致するたびに結果が生成され、結果配列に追加されるかブロックに渡されます。 パターンにグループが含まれていない場合、個々の結果はそれぞれ、一致した文字列$で構成されます。 パターンにグループが含まれている場合、個々の結果はそれ自体グループごとに1つのエントリを含む配列です。

54

str.slice(fixnum) [or] str.slice(fixnum, fixnum) [or]

  • str.slice（range）[or] str.slice（regexp）[or]*

  • str.slice（regexp、fixnum）[または] str.slice（other_str）*

  • str [fixnum]などを参照してください*

    *str.slice！（fixnum）[または] str.slice！（fixnum、fixnum）[または]*
    *str.slice！（範囲）[または] str.slice！（正規表現）[または]*

  • str.slice！（other_str） *

指定された部分をstrから削除し、削除された部分を返します。 Fixnumを使用するフォームは、値が範囲外の場合、IndexErrorを発生させます。 RangeフォームはRangeErrorを送出し、RegexpとStringフォームは静かに割り当てを無視します。

55
  • str.split(pattern = DOLLAR, [limit])*

区切り文字に基づいてstrを部分文字列に分割し、これらの部分文字列の配列を返します。

_pattern_が文字列の場合、その内容はstrを分割するときの区切り文字として使用されます。 patternが単一のスペースの場合、strは先頭の空白と連続した空白文字の連続を無視して空白で分割されます。

_pattern_が正規表現の場合、strはパターンが一致する場所で分割されます。 パターンが長さ0の文字列と一致するときはいつでも、strは個々の文字に分割されます。

_pattern_を省略すると、$の値。使用されている。 もし$; nil（デフォルト）の場合、strは、 ``が指定されているかのように空白で分割されます。

_limit_パラメーターを省略すると、末尾のヌルフィールドは抑制されます。 limitが正の数の場合、最大でその数のフィールドが返されます（limitが1の場合、文字列全体が配列内の唯一のエントリとして返されます）。 負の場合、返されるフィールドの数に制限はなく、末尾のNULLフィールドは抑制されません。

56

str.squeeze([other_str])*

String＃countで説明した手順を使用して、other_strパラメーターから文字セットを作成します。 このセットで発生する同じ文字の実行が単一の文字に置き換えられた新しい文字列を返します。 引数が指定されていない場合、同一の文字のすべての実行は単一の文字に置き換えられます。

57

str.squeeze!([other_str])*

strを所定の位置に絞り込み、strを返すか、変更が行われなかった場合はnilを返します。

58

str.strip

前後の空白を削除したstrのコピーを返します。

59

str.strip!

strから先頭および末尾の空白を削除します。 strが変更されなかった場合、nilを返します。

60

str.sub(pattern, replacement) [or]

  • str.sub（pattern）\ {
match

ブロック}*

パターンの最初の出現を、置換またはブロックの値で置き換えたstrのコピーを返します。 パターンは通常、正規表現になります。文字列の場合、正規表現のメタ文字は解釈されません。

61

str.sub!(pattern, replacement) [or]

  • str.sub！（パターン）\ {
match

ブロック}*

String＃subの置換を実行し、strを返すか、置換が実行されなかった場合はnilを返します。

62

str.succ [or] str.next

strの後継を返します。

63

str.succ! [or] str.next!

String＃succと同等ですが、レシーバーを変更します。

64

str.sum(n = 16)

str内の文字の基本的なnビットチェックサムを返します。nはオプションのFixnumパラメーターで、デフォルトは16です。 結果は、2n-1を法とするstrの各文字のバイナリ値の合計です。 これは特に良いチェックサムではありません。

65

str.swapcase

大文字のアルファベット文字を小文字に、小文字を大文字に変換してstrのコピーを返します。

66

str.swapcase!

String＃swapcaseと同等ですが、レシーバーをその場で変更し、strを返します。変更が行われなかった場合はnilを返します。

67

str.to_f

strの先頭の文字を浮動小数点数として解釈した結果を返します。 有効な数字の末尾を超える余分な文字は無視されます。 strの先頭に有効な数値がない場合、0.0が返されます。 このメソッドは例外を発生させません。

68

str.to_i(base = 10)

strの先頭文字を整数ベース（ベース2、8、10、または16）として解釈した結果を返します。 有効な数字の末尾を超える余分な文字は無視されます。 strの先頭に有効な番号がない場合、0が返されます。 このメソッドは例外を発生させません。

69

str.to_s [or] str.to_str

受信者を返します。

70

str.tr(from_str, to_str)

from_strの文字をto_strの対応する文字に置き換えてstrのコピーを返します。 to_strがfrom_strより短い場合、最後の文字が埋め込まれます。 どちらの文字列もc1.c2表記を使用して文字の範囲を示し、from_strは^で始まる場合があります。これは、リストされている文字を除くすべての文字を示します。

71

str.tr!(from_str, to_str)

String＃trと同じルールを使用して、strを所定の位置に変換します。 strを返します。変更が行われなかった場合はnilを返します。

72

str.tr_s(from_str, to_str)

String＃trで説明されているようにstrのコピーを処理し、翻訳の影響を受けた領域の重複文字を削除します。

73

str.tr_s!(from_str, to_str)

strを所定の場所でString＃tr_s処理し、strを返すか、変更が行われなかった場合はnilを返します。

74

str.unpack(format)

>フォーマット文字列に従ってstr（バイナリデータを含む場合があります）をデコードし、抽出された各値の配列を返します。 フォーマット文字列は、単一文字のディレクティブのシーケンスで構成され、表18にまとめられています。 各指令の後には、この指令で繰り返す回数を示す数字を続けることができます。 アスタリスク（*）は、残りのすべての要素を使い果たします。 ディレクティブsSiIlLの後には、アンダースコア（_）を続けて、指定された型の基になるプラットフォームのネイティブサイズを使用できます。それ以外の場合は、プラットフォームに依存しない一貫したサイズを使用します。 フォーマット文字列ではスペースは無視されます。

75

str.upcase

すべての小文字を対応する大文字に置き換えてstrのコピーを返します。 操作はロケールに依存しません。 aからzの文字のみが影響を受けます。

76

str.upcase!

strの内容を大文字に変更し、変更がない場合はnilを返します。

77 *str.upto(other_str) \{
s

block }*

strで始まりother_strで終わる連続した値を反復処理し、各値を順番にブロックに渡します。 String＃succメソッドは、各値を生成するために使用されます。

文字列アンパックディレクティブ

____次の表に、メソッドString＃unpackのアンパックディレクティブを示します。

Directive Returns Description
A String With trailing nulls and spaces removed.
a String String.
B String Extracts bits from each character (most significant bit first).
b String Extracts bits from each character (least significant bit first).
C Fixnum Extracts a character as an unsigned integer.
c Fixnum Extracts a character as an integer.
D, d Float Treats sizeof(double) characters as a native double.
E Float Treats sizeof(double) characters as a double in littleendian byte order.
e Float Treats sizeof(float) characters as a float in littleendian byte order.
F, f Float Treats sizeof(float) characters as a native float.
G Float Treats sizeof(double) characters as a double in network byte order.
g String Treats sizeof(float) characters as a float in network byte order.
H String Extracts hex nibbles from each character (most significant bit first)
h String Extracts hex nibbles from each character (least significant bit first).
I Integer Treats sizeof(int) (modified by _) successive characters as an unsigned native integer.
i Integer Treats sizeof(int) (modified by _) successive characters as a signed native integer.
L Integer Treats four (modified by _) successive characters as an unsigned native long integer.
l Integer Treats four (modified by _) successive characters as a signed native long integer.
M String Quoted-printable.
m String Base64-encoded.
N Integer Treats four characters as an unsigned long in network byte order.
n Fixnum Treats two characters as an unsigned short in network byte order.
P String Treats sizeof(char *) characters as a pointer, and return \emph{len} characters from the referenced location.
p String Treats sizeof(char *) characters as a pointer to a null-terminated string.
Q Integer Treats eight characters as an unsigned quad word (64 bits).
q Integer Treats eight characters as a signed quad word (64 bits).
S Fixnum Treats two (different if _ used) successive characters as an unsigned short in native byte order.
s Fixnum Treats two (different if _ used) successive characters as a signed short in native byte order.
U Integer UTF-8 characters as unsigned integers.
u String UU-encoded.
V Fixnum Treats four characters as an unsigned long in little-endian byte order.
v Fixnum Treats two characters as an unsigned short in little-endian byte order.
w Integer BER-compressed integer.
X   Skips backward one character.
x   Skips forward one character.
Z String With trailing nulls removed up to first null with *.
COMMAT   Skips to the offset given by the length argument.

例

次の例を試して、さまざまなデータを解凍します。 

"abc \0\0abc \0\0".unpack('A6Z6')   #=> ["abc", "abc "]
"abc \0\0".unpack('a3a3')           #=> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*')       #=> ["abc ", "abc "]
"aa".unpack('b8B8')                 #=> ["10000110", "01100001"]
"aaa".unpack('h2H2c')               #=> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS')     #=> [-2, 65534]
"now = 20is".unpack('M*')           #=> ["now is"]
"whole".unpack('xax2aX2aX1aX2a')    #=> ["h", "e", "l", "l", "o"]

Ruby-arrays

Ruby-ハッシュ

ハッシュは、次のようなキーと値のペアのコレクションです： "employee" ⇒ "salary"。 整数インデックスではなく、オブジェクトタイプの任意のキーを介してインデックス付けが行われることを除いて、配列に似ています。

キーまたは値のいずれかでハッシュをトラバースする順序は任意のように見える場合があり、通常は挿入順序にはなりません。 存在しないキーでハッシュにアクセスしようとすると、メソッドは_nil_を返します。

ハッシュを作成する

配列と同様に、ハッシュを作成するさまざまな方法があります。 あなたは_new_クラスメソッドで空のハッシュを作成することができます- 

months = Hash.new

_new_を使用して、デフォルト値でハッシュを作成することもできます。それ以外の場合は単に_nil_です- 

months = Hash.new( "month" )

or

months = Hash.new "month"

デフォルト値を持つハッシュのキーにアクセスすると、キーまたは値が存在しない場合、ハッシュにアクセスするとデフォルト値が返されます- 

#!/usr/bin/ruby

months = Hash.new( "month" )

puts "#{months[0]}"
puts "#{months[72]}"

これは、次の結果を生成します- 

month
month
#!/usr/bin/ruby

H = Hash["a" => 100, "b" => 200]

puts "#{H['a']}"
puts "#{H['b']}"

これは、次の結果を生成します- 

100
200

あなたは任意のRubyオブジェクトをキーまたは値、さらには配列として使用できるので、次の例は有効なものです- 

[1,"jan"] => "January"

ハッシュ組み込みメソッド

Hashメソッドを呼び出すには、Hashオブジェクトのインスタンスが必要です。 私たちが見てきたように、以下はハッシュオブジェクトのインスタンスを作成する方法です- 

Hash[[key =>|, value] *] or

Hash.new [or] Hash.new(obj) [or]
Hash.new { |hash, key| block }

これは、指定されたオブジェクトが入力された新しいハッシュを返します。 作成されたオブジェクトを使用して、使用可能なインスタンスメソッドを呼び出すことができます。 たとえば- 

#!/usr/bin/ruby

$, = ", "
months = Hash.new( "month" )
months = {"1" => "January", "2" => "February"}

keys = months.keys
puts "#{keys}"

これは、次の結果を生成します- 

["1", "2"]

以下は、パブリックハッシュメソッドです（_hash_が配列オブジェクトであると仮定）-

Sr.No. Methods & Description
1
  • hash == other_hash*

キーと値のペアの数が同じかどうか、およびキーと値のペアが各ハッシュの対応するペアと一致するかどうかに基づいて、2つのハッシュが等しいかどうかをテストします。

2

hash.[key]

キーを使用して、ハッシュから値を参照します。 キーが見つからない場合、デフォルト値を返します。

3

hash.[key] = value

_value_で指定された値を_key_で指定されたキーに関連付けます。

4

hash.clear

ハッシュからすべてのキーと値のペアを削除します。

5

hash.default(key = nil)

_hash_のデフォルト値を返します。default=で設定されていない場合はnilを返します。 （キーが_hash_に存在しない場合、[]はデフォルト値を返します。）

6

hash.default = obj

_hash_のデフォルト値を設定します。

7

hash.default_proc

_hash_がブロックによって作成された場合、ブロックを返します。

8

hash.delete(key) [or]

  • array.delete（key）\ {
key

ブロック}*

_key_で_hash_からキーと値のペアを削除します。 ブロックが使用されている場合、ペアが見つからない場合はブロックの結果を返します。 _delete_if_を比較します。

9 *hash.delete_if \{
key,value

block }*

ブロックが_true_と評価するすべてのペアについて、_hash_からキーと値のペアを削除します。

10 *hash.each \{
key,value

block }*

_hash_を反復処理し、キーごとにブロックを1回呼び出して、キー値を2要素配列として渡します。

11 *hash.each_key \{
key

block }*

_hash_を反復処理し、キーごとにブロックを呼び出して、_key_をパラメーターとして渡します。

12 *hash.each_key \{
key_value_array

block }*

_hash_を反復処理し、_key_ごとに1回ブロックを呼び出し、_key_と_value_をパラメーターとして渡します。

13 *hash.each_key \{
value

block }*

_hash_を反復処理し、_key_ごとに1回ブロックを呼び出し、_value_をパラメーターとして渡します。

14

hash.empty?

ハッシュが空（キーと値のペアを含まない）かどうかをテストし、_true_または_false_を返します。

15

hash.fetch(key [, default] ) [or]

  • hash.fetch（key）\ {
キー

ブロック}*

指定された_key_の_hash_から値を返します。 _key_が見つからず、他の引数がない場合、_IndexError_例外が発生します。 _default_が指定されている場合、それが返されます。オプションのブロックが指定されている場合、その結果が返されます。

16

hash.has_key?(key) [or] hash.include?(key) [or]

  • hash.key？（key）[または] hash.member？（key） *

特定の_key_がハッシュに存在するかどうかをテストし、_true_または_false_を返します。

17
  • hash.has_value?(value)*

ハッシュに指定の_value_が含まれているかどうかをテストします。

18

hash.index(value)

指定された_value_の_key_をハッシュで返し、一致する値が見つからない場合は_nil_を返します。

19

hash.indexes(keys)

指定されたキーの値で構成される新しい配列を返します。 見つからないキーのデフォルト値を挿入します。 このメソッドは非推奨です。 選択を使用します。

20

hash.indices(keys)

指定されたキーの値で構成される新しい配列を返します。 見つからないキーのデフォルト値を挿入します。 このメソッドは非推奨です。 選択を使用します。

21

hash.inspect

ハッシュのプリティプリント文字列バージョンを返します。

22

hash.invert

新しい_hash_を作成し、_hash_から_keys_と_values_を反転します。つまり、新しいハッシュでは、_hash_のキーが値になり、値がキーになります。

23

hash.keys

_hash_のキーを持つ新しい配列を作成します。

24

hash.length

_hash_のサイズまたは長さを整数として返します。

25

hash.merge(other_hash) [or]

  • hash.merge（other_hash）\ {
key、oldval、newval

ブロック}*

_hash_および_other_hash_の内容を含む新しいハッシュを返します。ハッシュ内のペアを、_other_hash_のキーで重複キーで上書きします。

26

hash.merge!(other_hash) [or]

  • hash.merge！（other_hash）\ {
key、oldval、newval

ブロック}*

マージと同じですが、変更はその場で行われます。

27

hash.rehash

各_key_の現在の値に基づいて_hash_を再構築します。 値が挿入されてから値が変更されている場合、このメソッドは_hash_のインデックスを再作成します。

28 *hash.reject \{
key, value

block }*

_block_が_true_と評価するペアごとに新しい_hash_を作成します

29 *hash.reject! \{
key, value

block }*

_reject_と同じですが、変更はその場で行われます。

30

hash.replace(other_hash)

_hash_の内容を_other_hash_の内容に置き換えます。

31 *hash.select \{
key, value

block }*

_block_が_true_を返す_hash_のキーと値のペアで構成される新しい配列を返します。

32

hash.shift

_hash_からキーと値のペアを削除し、2要素配列として返します。

33

hash.size

_size_または_hash_の長さを整数として返します。

34

hash.sort

_hash_をキーと値のペアの配列を含む2次元配列に変換してから、配列としてソートします。

35

hash.store(key, value)

_hash_にキーと値のペアを格納します。

36

hash.to_a

ハッシュから2次元配列を作成します。 各キー/値ペアは配列に変換され、これらの配列はすべて包含配列に格納されます。

37

hash.to_hash

hash（自己）を返します。

38

hash.to_s

_hash_を配列に変換してから、その配列を文字列に変換します。

39

hash.update(other_hash) [or]

  • hash.update（other_hash）\ {
key、oldval、newval

ブロック} *

_hash_と_other_hash_の内容を含む新しいハッシュを返し、_hash_のペアを_other_hash_のキーで重複キーで上書きします。

40
  • hash.value?(value)*

_hash_に指定された_value_が含まれているかどうかをテストします。

41

hash.values

_hash_のすべての値を含む新しい配列を返します。

42

hash.values_at(obj, …​)

指定されたキーに関連付けられている_hash_の値を含む新しい配列を返します。

Ruby-日付と時刻

*Time* クラスは、Rubyの日付と時刻を表します。 これは、オペレーティングシステムによって提供されるシステムの日付と時刻の機能上の薄い層です。 このクラスは、システムで1970年以前または2038年以降の日付を表すことができない場合があります。

この章では、日付と時刻の最も必要なすべての概念について理解します。

現在の日付と時刻を取得する

以下は、現在の日付と時刻を取得する簡単な例です- 

#!/usr/bin/ruby -w

time1 = Time.new
puts "Current Time : " &plus; time1.inspect

# Time.now is a synonym:
time2 = Time.now
puts "Current Time : " &plus; time2.inspect

これは、次の結果を生成します- 

Current Time : Mon Jun 02 12:02:39 -0700 2008
Current Time : Mon Jun 02 12:02:39 -0700 2008

日付と時刻のコンポーネントの取得

_Time_オブジェクトを使用して、日付と時刻のさまざまなコンポーネントを取得できます。 以下は同じことを示す例です- 

#!/usr/bin/ruby -w

time = Time.new

# Components of a Time
puts "Current Time : " + time.inspect
puts time.year    # => Year of the date
puts time.month   # => Month of the date (1 to 12)
puts time.day     # => Day of the date (1 to 31 )
puts time.wday    # => 0: Day of week: 0 is Sunday
puts time.yday    # => 365: Day of year
puts time.hour    # => 23: 24-hour clock
puts time.min     # => 59
puts time.sec     # => 59
puts time.usec    # => 999999: microseconds
puts time.zone    # => "UTC": timezone name

これは、次の結果を生成します- 

Current Time : Mon Jun 02 12:03:08 -0700 2008
2008
6
2
1
154
12
3
8
247476
UTC

Time.utc、Time.gm、およびTime.local関数

これらの2つの関数は、次のように標準形式で日付をフォーマットするために使用することができます- 

# July 8, 2008
Time.local(2008, 7, 8)
# July 8, 2008, 09:10am, local time
Time.local(2008, 7, 8, 9, 10)
# July 8, 2008, 09:10 UTC
Time.utc(2008, 7, 8, 9, 10)
# July 8, 2008, 09:10:11 GMT (same as UTC)
Time.gm(2008, 7, 8, 9, 10, 11)

次は、次の形式で配列内のすべてのコンポーネントを取得する例です- 

[sec,min,hour,day,month,year,wday,yday,isdst,zone]

次を試してください- 

#!/usr/bin/ruby -w

time = Time.new
values = time.to_a
p values

これは、次の結果を生成します- 

[26, 10, 12, 2, 6, 2008, 1, 154, false, "MST"]

この配列は、次のように日付の異なる形式を取得するために_Time.utc_または_Time.local_関数に渡すことができます- 

#!/usr/bin/ruby -w

time = Time.new
values = time.to_a
puts Time.utc(*values)

これは、次の結果を生成します- 

Mon Jun 02 12:15:36 UTC 2008

以下は、（プラットフォームに依存する）エポック以降の秒として内部的に表される時間を取得する方法です- 

# Returns number of seconds since epoch
time = Time.now.to_i

# Convert number of seconds into Time object.
Time.at(time)

# Returns second since epoch which includes microseconds
time = Time.now.to_f

タイムゾーンと夏時間

あなたは次のようにタイムゾーンと夏時間に関連するすべての情報を取得するために_Time_オブジェクトを使用することができます- 

time = Time.new

# Here is the interpretation
time.zone       # => "UTC": return the timezone
time.utc_offset # => 0: UTC is 0 seconds offset from UTC
time.zone       # => "PST" (or whatever your timezone is)
time.isdst      # => false: If UTC does not have DST.
time.utc?       # => true: if t is in UTC time zone
time.localtime  # Convert to local timezone.
time.gmtime     # Convert back to UTC.
time.getlocal   # Return a new Time object in local zone
time.getutc     # Return a new Time object in UTC

時間と日付のフォーマット

日付と時刻をフォーマットするには、さまざまな方法があります。 ここにいくつかの例を示します- 

#!/usr/bin/ruby -w

time = Time.new
puts time.to_s
puts time.ctime
puts time.localtime
puts time.strftime("%Y-%m-%d %H:%M:%S")

これは、次の結果を生成します- 

Mon Jun 02 12:35:19 -0700 2008
Mon Jun  2 12:35:19 2008
Mon Jun 02 12:35:19 -0700 2008
2008-06-02 12:35:19

時間フォーマット指令

次の表のこれらのディレクティブは、_Time.strftime_メソッドで使用されます。

Sr.No. Directive & Description
1

%a

曜日の短縮名（日）。

2

%A

完全な曜日名（日曜日）。

3

%b

短縮された月名（Jan）。

4

%B

完全な月名（1月）。

5

%c

優先されるローカルの日付と時刻の表現。

6

%d

月の日（01〜31）。

7

%H

24時間制（00〜23）。

8

%I

時刻、12時間制（01から12）。

9

%j

年の日（001から366）。

10

%m

月（01〜12）。

11

%M

分（00から59）。

12

%p

子午線インジケータ（AMまたはPM）。

13

%S

秒（00から60）。

14

%U

最初の日曜日を最初の週の最初の日として開始する、現在の年の週番号（00〜53）。

15

%W

最初の週の最初の日として最初の月曜日から始まる、現在の年の週番号（00〜53）。

16

%w

曜日（日曜日は0、0〜6）。

17

%x

日付のみ、時間なしの優先表現。

18

%X

日付なしの時刻のみの優先表現。

19

%y

世紀のない年（00から99）。

20

%Y

世紀のある年。

21

%Z

タイムゾーン名。

22

%%

リテラル％文字。

時間演算

次のように時間を使用して簡単な算術演算を実行できます- 

now = Time.now          # Current time
puts now

past = now - 10         # 10 seconds ago. Time - number => Time
puts past

future = now + 10  # 10 seconds from now Time + number => Time
puts future

diff = future - past     # => 10  Time - Time => number of seconds
puts diff

これは、次の結果を生成します- 

Thu Aug 01 20:57:05 -0700 2013
Thu Aug 01 20:56:55 -0700 2013
Thu Aug 01 20:57:15 -0700 2013
20.0

ルビー-範囲

範囲はどこでも発生します：1月から12月、0から9行、50から67行など。 Rubyは範囲をサポートしており、さまざまな方法で範囲を使用できます-

  • シーケンスとしての範囲
  • 条件としての範囲
  • 間隔としての範囲

シーケンスとしての範囲

範囲の最初で、おそらく最も自然な使用法は、シーケンスを表現することです。 シーケンスには、開始点、終了点、およびシーケンス内の連続した値を生成する方法があります。

Rubyは、 .. および …​ 範囲演算子を使用してこれらのシーケンスを作成します。 2ドット形式は包括的範囲を作成し、3ドット形式は指定された高い値を除外する範囲を作成します。 

(1..5)        #==> 1, 2, 3, 4, 5
(1...5)       #==> 1, 2, 3, 4
('a'..'d')    #==> 'a', 'b', 'c', 'd'

シーケンス1..100は、2つの_Fixnum_オブジェクトへの参照を含むRange _object_として保持されます。 必要な場合は、_to_a_メソッドを使用して範囲をリストに変換できます。 次の例を試してください- 

#!/usr/bin/ruby

$, =", "   # Array value separator
range1 = (1..10).to_a
range2 = ('bar'..'bat').to_a

puts "#{range1}"
puts "#{range2}"

これは、次の結果を生成します- 

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
["bar", "bas", "bat"]

範囲は、それらを反復処理し、さまざまな方法でその内容をテストできるメソッドを実装します- 

#!/usr/bin/ruby

# Assume a range
digits = 0..9

puts digits.include?(5)
ret = digits.min
puts "Min value is #{ret}"

ret = digits.max
puts "Max value is #{ret}"

ret = digits.reject {|i| i < 5 }
puts "Rejected values are #{ret}"

digits.each do |digit|
   puts "In Loop #{digit}"
end

これは、次の結果を生成します- 

true
Min value is 0
Max value is 9
Rejected values are 5, 6, 7, 8, 9
In Loop 0
In Loop 1
In Loop 2
In Loop 3
In Loop 4
In Loop 5
In Loop 6
In Loop 7
In Loop 8
In Loop 9

条件としての範囲

範囲は条件式としても使用できます。 たとえば、次のコードフラグメントは標準入力から行のセットを印刷します。各セットの最初の行には単語_start_が含まれ、最後の行には単語_ends_が含まれます- 

while gets
   print if/start/../end/
end

範囲は、caseステートメントで使用できます- 

#!/usr/bin/ruby

score = 70

result = case score
   when 0..40 then "Fail"
   when 41..60 then "Pass"
   when 61..70 then "Pass with Merit"
   when 71..100 then "Pass with Distinction"
   else "Invalid Score"
end

puts result

これは、次の結果を生成します- 

Pass with Merit

間隔としての範囲

汎用範囲の最後の使用法は、間隔テストとしてです。ある値が範囲で表される間隔内に収まるかどうかを確認します。 これは、ケース等価演算子===を使用して行われます。 

#!/usr/bin/ruby

if ((1..10) === 5)
   puts "5 lies in (1..10)"
end

if (('a'..'j') === 'c')
   puts "c lies in ('a'..'j')"
end

if (('a'..'j') === 'z')
   puts "z lies in ('a'..'j')"
end

これは、次の結果を生成します- 

5 lies in (1..10)
c lies in ('a'..'j')

Ruby-イテレーター

イテレータは、_collections_がサポートするメソッドに他なりません。 データメンバーのグループを格納するオブジェクトは、コレクションと呼ばれます。 Rubyでは、配列とハッシュをコレクションと呼ぶことができます。

イテレータは、コレクションのすべての要素を順番に返します。 ここでは、_each_と_collect_の2つのイテレータについて説明します。 これらを詳しく見てみましょう。

Ruby各イテレーター

各反復子は、配列またはハッシュのすべての要素を返します。

構文

collection.each do |variable|
   code
end

_collection_の各要素に対して_code_を実行します。 ここで、_collection_は配列またはルビーハッシュにすることができます。

例

#!/usr/bin/ruby

ary = [1,2,3,4,5]
ary.each do |i|
   puts i
end

これは、次の結果を生成します- 

1
2
3
4
5

常に_each_イテレータをブロックに関連付けます。 配列の各値を1つずつブロックに返します。 値は変数 i に保存され、画面に表示されます。

Rubyはイテレーターを収集します

_collect_イテレータは、コレクションのすべての要素を返します。

構文

collection = collection.collect

_collect_メソッドは、必ずしもブロックに関連付けられる必要はありません。 _collect_メソッドは、配列かハッシュかに関係なく、コレクション全体を返します。

例

#!/usr/bin/ruby

a = [1,2,3,4,5]
b = Array.new
b = a.collect
puts b

これは、次の結果を生成します- 

1
2
3
4
5

注-_collect_メソッドは、配列間でコピーを行う正しい方法ではありません。 _clone_と呼ばれる別のメソッドがあります。これは、ある配列を別の配列にコピーするために使用する必要があります。

通常、各値を使用して新しい配列を取得する場合は、collectメソッドを使用します。 たとえば、このコードは、_a_の各値を10回含む配列_b_を生成します。 

#!/usr/bin/ruby

a = [1,2,3,4,5]
b = a.collect{|x| 10*x}
puts b

これは、次の結果を生成します- 

10
20
30
40
50

Ruby-ファイルI/O

Rubyは、Kernelモジュールに実装されたI/O関連のメソッドのセット全体を提供します。 すべてのI/Oメソッドは、クラスIOから派生しています。

クラス_IO_は、read、write、gets、puts、readline、getc、、_ printf_などのすべての基本メソッドを提供します。

この章では、Rubyで利用可能なすべての基本的なI/O関数について説明します。 その他の機能については、Ruby Class _IO_を参照してください。

putsステートメント

前の章では、変数に値を割り当て、_puts_ステートメントを使用して出力を印刷しました。

_puts_ステートメントは、変数に格納されている値を表示するようにプログラムに指示します。 これにより、書き込む各行の最後に新しい行が追加されます。

例

#!/usr/bin/ruby

val1 = "This is variable one"
val2 = "This is variable two"
puts val1
puts val2

これは、次の結果を生成します- 

This is variable one
This is variable two

getsステートメント

_gets_ステートメントを使用して、STDINと呼ばれる標準画面からユーザーからの入力を取得できます。

例

次のコードは、getsステートメントの使用方法を示しています。 このコードは、ユーザーに値を入力するように促します。値は変数valに格納され、最終的にSTDOUTに出力されます。 

#!/usr/bin/ruby

puts "Enter a value :"
val = gets
puts val

これは、次の結果を生成します- 

Enter a value :
This is entered value
This is entered value

putcステートメント

文字列全体を画面に出力する_puts_ステートメントとは異なり、_putc_ステートメントは一度に1文字を出力するために使用できます。

例

次のコードの出力は、文字Hです- 

#!/usr/bin/ruby

str = "Hello Ruby!"
putc str

これは、次の結果を生成します- 

H

印刷ステートメント

_print_ステートメントは_puts_ステートメントに似ています。 唯一の違いは、_puts_ステートメントは内容を印刷した後に次の行に移動するのに対して、_print_ステートメントではカーソルが同じ行に配置されることです。

例

#!/usr/bin/ruby

print "Hello World"
print "Good Morning"

これは、次の結果を生成します- 

Hello WorldGood Morning

ファイルの開閉

これまで、標準入出力の読み取りと書き込みを行ってきました。 ここで、実際のデータファイルを再生する方法を見ていきます。

File.newメソッド

モード文字列に応じて、_File.new_メソッドを使用して読み取り、書き込み、またはその両方を行う_File_オブジェクトを作成できます。 最後に、_File.close_メソッドを使用してそのファイルを閉じることができます。

構文

aFile = File.new("filename", "mode")
   # ... process the file
aFile.close

File.openメソッド

_File.open_メソッドを使用して、新しいファイルオブジェクトを作成し、そのファイルオブジェクトをファイルに割り当てることができます。 ただし、_File.open_メソッドと_File.new_メソッドには1つの違いがあります。 違いは、_File.open_メソッドをブロックに関連付けることができますが、_File.new_メソッドを使用して同じことを実行できないことです。 

File.open("filename", "mode") do |aFile|
   # ... process the file
end

____これは、ファイルを開くさまざまなモードのリストです-

Sr.No. Modes & Description
1

r

読み取り専用モード。 ファイルポインタはファイルの先頭に置かれます。 これがデフォルトのモードです。

2

r+

読み書きモード。 ファイルポインタはファイルの先頭にあります。

3

w

書き込み専用モード。 ファイルが存在する場合はファイルを上書きします。 ファイルが存在しない場合は、書き込み用の新しいファイルを作成します。

4

w+

読み書きモード。 ファイルが存在する場合、既存のファイルを上書きします。 ファイルが存在しない場合、読み取りおよび書き込み用の新しいファイルを作成します。

5

a

書き込み専用モード。 ファイルが存在する場合、ファイルポインタはファイルの末尾にあります。 つまり、ファイルは追加モードになっています。 ファイルが存在しない場合は、書き込み用の新しいファイルを作成します。

6

a+

読み取りおよび書き込みモード。 ファイルが存在する場合、ファイルポインタはファイルの末尾にあります。 ファイルが追加モードで開きます。 ファイルが存在しない場合、読み取りおよび書き込み用の新しいファイルが作成されます。

ファイルの読み書き

「単純な」I/Oに使用してきたのと同じメソッドが、すべてのファイルオブジェクトに使用できます。 したがって、getsは標準入力から行を読み取り、_aFile.gets_はファイルオブジェクトaFileから行を読み取ります。

ただし、I/Oオブジェクトは、生活を楽にするアクセス方法の追加セットを提供します。

sysreadメソッド

メソッド_sysread_を使用して、ファイルの内容を読み取ることができます。 sysreadメソッドを使用する場合、どのモードでもファイルを開くことができます。 たとえば-

以下は入力テキストファイルです- 

This is a simple text file for testing purpose.

今、このファイルを読んでみましょう- 

#!/usr/bin/ruby

aFile = File.new("input.txt", "r")
if aFile
   content = aFile.sysread(20)
   puts content
else
   puts "Unable to open file!"
end

このステートメントは、ファイルの最初の20文字を出力します。 これで、ファイルポインターはファイルの21番目の文字に配置されます。

syswriteメソッド

メソッドsyswriteを使用して、コンテンツをファイルに書き込むことができます。 syswriteメソッドを使用するときは、ファイルを書き込みモードで開く必要があります。 たとえば- 

#!/usr/bin/ruby

aFile = File.new("input.txt", "r+")
if aFile
   aFile.syswrite("ABCDEF")
else
   puts "Unable to open file!"
end

このステートメントは、「ABCDEF」をファイルに書き込みます。

each_byteメソッド

このメソッドは_File_クラスに属します。 メソッド_each_byte_は常にブロックに関連付けられています。 次のコードサンプルを検討してください- 

#!/usr/bin/ruby

aFile = File.new("input.txt", "r+")
if aFile
   aFile.syswrite("ABCDEF")
   aFile.each_byte {|ch| putc ch; putc ?. }
else
   puts "Unable to open file!"
end

文字は変数chに1つずつ渡され、次のように画面に表示されます- 

s. .a. .s.i.m.p.l.e. .t.e.x.t. .f.i.l.e. .f.o.r. .t.e.s.t.i.n.g. .p.u.r.p.o.s.e...
.
.

IO.readlinesメソッド

クラス_File_は、クラスIOのサブクラスです。 クラスIOには、ファイルを操作するために使用できるいくつかのメソッドもあります。

IOクラスメソッドの1つは_IO.readlines_です。 このメソッドは、ファイルの内容を1行ずつ返します。 次のコードは、メソッド_IO.readlines_の使用を表示します- 

#!/usr/bin/ruby

arr = IO.readlines("input.txt")
puts arr[0]
puts arr[1]

このコードでは、変数arrは配列です。 ファイル_input.txt_の各行は、配列arrの要素になります。 したがって、arr [0]には最初の行が含まれ、arr [1]にはファイルの2行目が含まれます。

IO.foreachメソッド

このメソッドは、行ごとに出力も返します。 メソッド_foreach_とメソッド_readlines_の違いは、メソッド_foreach_がブロックに関連付けられていることです。 ただし、メソッド_readlines_とは異なり、メソッド_foreach_は配列を返しません。 たとえば- 

#!/usr/bin/ruby

IO.foreach("input.txt"){|block| puts block}

このコードは、ファイル_test_の内容を1行ずつ変数ブロックに渡し、出力が画面に表示されます。

ファイルの名前変更と削除

_rename_および_delete_メソッドを使用して、Rubyを使用してプログラムでファイルの名前を変更したり削除したりできます。

以下は、既存のファイル_test1.txt_の名前を変更する例です- 

#!/usr/bin/ruby

# Rename a file from test1.txt to test2.txt
File.rename( "test1.txt", "test2.txt" )

以下は、既存のファイル_test2.txt_を削除する例です- 

#!/usr/bin/ruby

# Delete file test2.txt
File.delete("test2.txt")

ファイルモードと所有権

マスクを使用して_chmod_メソッドを使用して、ファイルのモードまたは権限/アクセスリストを変更します-

以下は、既存のファイル_test.txt_のモードをマスク値に変更する例です- 

#!/usr/bin/ruby

file = File.new( "test.txt", "w" )
file.chmod( 0755 )

____次は、_chmod_メソッドに異なるマスクを選択するのに役立つテーブルです-

Sr.No. Mask & Description
1

0700

所有者のrwxマスク

2

0400

所有者のr

3

0200

所有者のw

4

0100

所有者のx

5

0070

グループのrwxマスク

6

0040

グループのr

7

0020

グループのw

8

0010

グループのx

9

0007

その他のrwxマスク

10

0004

他のr

11

0002

他のw

12

0001

xはその他

13

4000

実行時にユーザーIDを設定する

14

2000

実行時にグループIDを設定

15

1000

使用後でも、交換したテキストを保存する

ファイル問い合わせ

次のコマンドは、ファイルを開く前に存在するかどうかをテストします- 

#!/usr/bin/ruby

File.open("file.rb") if File::exists?( "file.rb" )

次のコマンドは、ファイルが実際にファイルであるかどうかを照会します- 

#!/usr/bin/ruby

# This returns either true or false
File.file?( "text.txt" )

次のコマンドは、指定されたファイル名がディレクトリであるかどうかを調べます- 

#!/usr/bin/ruby

# a directory
File::directory?( "/usr/local/bin" ) # => true

# a file
File::directory?( "file.rb" ) # => false

次のコマンドは、ファイルが読み取り可能、書き込み可能または実行可能かどうかを見つけます- 

#!/usr/bin/ruby

File.readable?( "test.txt" )   # => true
File.writable?( "test.txt" )   # => true
File.executable?( "test.txt" ) # => false

次のコマンドは、ファイルのサイズがゼロかどうかを調べます- 

#!/usr/bin/ruby

File.zero?( "test.txt" )      # => true

次のコマンドは、ファイルのサイズを返します- 

#!/usr/bin/ruby

File.size?( "text.txt" )     # => 1002

次のコマンドは、ファイルの種類を見つけるために使用することができます- 

#!/usr/bin/ruby

File::ftype( "test.txt" )     # => file

ftypeメソッドは、次のいずれかを返すことにより、ファイルのタイプを識別します-file、directory、characterSpecial、blockSpecial、fifo、link、socket、またはunknown.

次のコマンドを使用して、ファイルが作成、変更、または最後にアクセスされたときを見つけることができます- 

#!/usr/bin/ruby

File::ctime( "test.txt" ) # => Fri May 09 10:06:37 -0700 2008
File::mtime( "text.txt" ) # => Fri May 09 10:44:44 -0700 2008
File::atime( "text.txt" ) # => Fri May 09 10:45:01 -0700 2008

Rubyのディレクトリ

すべてのファイルはさまざまなディレクトリに含まれており、Rubyでもこれらの処理に問題はありません。 _File_クラスはファイルを処理しますが、ディレクトリは_Dir_クラスで処理されます。

ディレクトリをナビゲートする

Rubyプログラム内のディレクトリを変更するには、次のように_Dir.chdir_を使用します。 この例では、現在のディレクトリを_/usr/bin_に変更します。 

Dir.chdir("/usr/bin")

_Dir.pwd_を使用して、現在のディレクトリが何であるかを確認できます- 

puts Dir.pwd # This will return something like/usr/bin

_Dir.entries_を使用して、特定のディレクトリ内のファイルとディレクトリのリストを取得できます- 

puts Dir.entries("/usr/bin").join(' ')

_Dir.entries_は、指定されたディレクトリ内のすべてのエントリを含む配列を返します。 _Dir.foreach_は同じ機能を提供します- 

Dir.foreach("/usr/bin") do |entry|
   puts entry
end

ディレクトリリストを取得するさらに簡潔な方法は、Dirのクラス配列メソッドを使用することです- 

Dir["/usr/bin/*"]

ディレクトリを作成する

_Dir.mkdir_を使用してディレクトリを作成できます- 

Dir.mkdir("mynewdir")

また、mkdirを使用して、新しいディレクトリ（既存のディレクトリではない）にアクセス許可を設定することもできます-

注-マスク755は、パーミッションの所有者、グループ、ワールド[誰でも]をrwxr-xr-xに設定します（r =読み取り、w =書き込み、x =実行）。 

Dir.mkdir( "mynewdir", 755 )

ディレクトリを削除する

_Dir.delete_を使用して、ディレクトリを削除できます。 _Dir.unlink_と_Dir.rmdir_はまったく同じ機能を実行し、便宜上提供されています。 

Dir.delete("testdir")

ファイルと一時ディレクトリの作成

一時ファイルとは、プログラムの実行中に短時間作成される可能性のあるファイルですが、情報の永続的な保存場所ではありません。

_Dir.tmpdir_は、現在のシステム上の一時ディレクトリへのパスを提供しますが、このメソッドはデフォルトでは使用できません。 _Dir.tmpdir_を使用可能にするには、require 'tmpdir’を使用する必要があります。

_File.join_で_Dir.tmpdir_を使用して、プラットフォームに依存しない一時ファイルを作成できます- 

require 'tmpdir'
   tempfilename = File.join(Dir.tmpdir, "tingtong")
   tempfile = File.new(tempfilename, "w")
   tempfile.puts "This is a temporary file"
   tempfile.close
   File.delete(tempfilename)

このコードは、一時ファイルを作成し、データを書き込み、削除します。 Rubyの標準ライブラリには、一時ファイルを作成できる_Tempfile_というライブラリも含まれています- 

require 'tempfile'
   f = Tempfile.new('tingtong')
   f.puts "Hello"
   puts f.path
   f.close

組み込み関数

ここにファイルとディレクトリを処理するためのルビー組み込み関数があります-

  • リンク：/ruby​​/ruby​​_file_methods [ファイルクラスとメソッド]。
  • リンク：/ruby​​/ruby​​_dir_methods [Dirクラスとメソッド]。

Ruby-例外

実行と例外は常に一緒に行きます。 存在しないファイルを開いている場合、この状況を適切に処理しなかった場合、プログラムは品質が悪いと見なされます。

例外が発生すると、プログラムは停止します。 したがって、例外は、プログラムの実行中に発生し、プログラムを完全に停止する代わりに適切なアクションを実行するさまざまなタイプのエラーを処理するために使用されます。

Rubyは、例外を処理する優れたメカニズムを提供します。 例外を発生させる可能性のあるコードを_begin/end_ブロックで囲み、_rescue_句を使用して、処理する例外のタイプをRubyに伝えます。

構文

begin
# -
rescue OneTypeOfException
# -
rescue AnotherTypeOfException
# -
else
# Other exceptions
ensure
# Always will be executed
end

_begin_から_rescue_までのすべてが保護されています。 このコードブロックの実行中に例外が発生した場合、_rescue_と_end_の間のブロックに制御が渡されます。

_begin_ブロック内の各_rescue_句について、Rubyは発生した例外を各パラメーターと順番に比較します。 rescue句で指定された例外が現在スローされている例外のタイプと同じか、その例外のスーパークラスである場合、マッチは成功します。

例外が指定されたエラータイプのいずれにも一致しない場合、すべての_rescue_句の後に_else_句を使用できます。

例

#!/usr/bin/ruby

begin
   file = open("/unexistant_file")
   if file
      puts "File opened successfully"
   end
rescue
      file = STDIN
end
print file, "==", STDIN, "\n"

これにより、次の結果が生成されます。 _open_が失敗したため、_STDIN_が_file_に置き換えられていることがわかります。 

#<IO:0xb7d16f84>==#<IO:0xb7d16f84>

再試行ステートメントの使用

_rescue_ブロックを使用して例外をキャプチャし、_retry_ステートメントを使用して最初から_begin_ブロックを実行できます。

構文

begin
   # Exceptions raised by this code will
   # be caught by the following rescue clause
rescue
   # This block will capture all types of exceptions
   retry  # This will move control to the beginning of begin
end

例

#!/usr/bin/ruby

begin
   file = open("/unexistant_file")
   if file
      puts "File opened successfully"
   end
rescue
   fname = "existant_file"
   retry
end

以下は、プロセスの流れです-

  • オープン時に例外が発生しました。
  • 救助に行きました。 fnameが再割り当てされました。
  • 再試行することにより、開始の最初に行きました。
  • 今回はファイルが正常に開きます。
  • 本質的なプロセスを継続しました。

注-再置換された名前のファイルが存在しない場合、このサンプルコードは無限に再試行することに注意してください。 例外プロセスに_retry_を使用する場合は注意してください。

raiseステートメントの使用

_raise_ステートメントを使用して、例外を発生させることができます。 次のメソッドは、呼び出されるたびに例外を発生させます。 2番目のメッセージが出力されます。

構文

raise

OR

raise "Error Message"

OR

raise ExceptionType, "Error Message"

OR

raise ExceptionType, "Error Message" condition

最初の形式は、現在の例外（または、現在の例外がない場合はRuntimeError）を再発生させるだけです。 これは、例外を渡す前にインターセプトする必要がある例外ハンドラで使用されます。

2番目の形式は、新しい_RuntimeError_例外を作成し、そのメッセージを指定された文字列に設定します。 この例外は、コールスタックで発生します。

3番目の形式では、最初の引数を使用して例外を作成し、関連するメッセージを2番目の引数に設定します。

4番目の形式は3番目の形式に似ていますが、_unless_などの条件ステートメントを追加して例外を発生させることができます。

例

#!/usr/bin/ruby

begin
   puts 'I am before the raise.'
   raise 'An error has occurred.'
   puts 'I am after the raise.'
rescue
   puts 'I am rescued.'
end
puts 'I am after the begin block.'

これは、次の結果を生成します- 

I am before the raise.
I am rescued.
I am after the begin block.

_raise_の使用法を示すもう1つの例- 

#!/usr/bin/ruby

begin
   raise 'A test exception.'
rescue Exception => e
   puts e.message
   puts e.backtrace.inspect
end

これは、次の結果を生成します- 

A test exception.
["main.rb:4"]

ensureステートメントの使用

場合によっては、例外が発生したかどうかに関係なく、コードブロックの最後で何らかの処理が行われることを保証する必要があります。 たとえば、ブロックへの入り口でファイルを開いている場合があり、ブロックが終了するときにファイルが閉じていることを確認する必要があります。

_ensure_句はこれを行います。 _ensure_は、最後のレスキュー句の後に続き、ブロックの終了時に常に実行されるコードのチャンクを含みます。 ブロックが正常に終了するか、例外を発生させてレスキューするか、またはキャッチされなかった例外で終了した場合、_ensure_ブロックが実行されます。

構文

begin
   #.. process
   #..raise exception
rescue
   #.. handle error
ensure
   #.. finally ensure execution
   #.. This will always execute.
end

例

begin
   raise 'A test exception.'
rescue Exception => e
   puts e.message
   puts e.backtrace.inspect
ensure
   puts "Ensuring execution"
end

これは、次の結果を生成します- 

A test exception.
["main.rb:4"]
Ensuring execution

elseステートメントの使用

_else_句が存在する場合、_rescue_句の後、_ensure_の前に配置されます。

_else_句の本体は、コード本体によって例外が発生しない場合にのみ実行されます。

構文

begin
   #.. process
   #..raise exception
rescue
   # .. handle error
else
   #.. executes if there is no exception
ensure
   #.. finally ensure execution
   #.. This will always execute.
end

例

begin
   # raise 'A test exception.'
   puts "I'm not raising exception"
rescue Exception => e
   puts e.message
   puts e.backtrace.inspect
else
   puts "Congratulations-- no errors!"
ensure
   puts "Ensuring execution"
end

これは、次の結果を生成します- 

I'm not raising exception
Congratulations-- no errors!
Ensuring execution

発生したエラーメッセージは、＆dollar;を使用してキャプチャできます！ 変数。

キャッチアンドスロー

レイズアンドレスキューの例外メカニズムは、問題が発生したときに実行を放棄するのに最適ですが、通常の処理中に深くネストされた構造から飛び出すことができると便利な場合があります。 これがキャッチとスローが便利になるところです。

_catch_は、指定された名前（SymbolまたはString）でラベル付けされたブロックを定義します。 ブロックは、スローが発生するまで通常実行されます。

構文

throw :lablename
#.. this will not be executed
catch :lablename do
#.. matching catch will be executed after a throw is encountered.
end

OR

throw :lablename condition
#.. this will not be executed
catch :lablename do
#.. matching catch will be executed after a throw is encountered.
end

例

次の例では、「！」の場合、スローを使用してユーザーとの対話を終了します。プロンプトに応じて入力されます。 

def promptAndGet(prompt)
   print prompt
   res = readline.chomp
   throw :quitRequested if res == "!"
   return res
end

catch :quitRequested do
   name = promptAndGet("Name: ")
   age = promptAndGet("Age: ")
   sex = promptAndGet("Sex: ")
   # ..
   # process information
end
promptAndGet("Name:")

手動操作が必要なため、上記のプログラムをマシンで試してください。 これは、次の結果を生成します- 

Name: Ruby on Rails
Age: 3
Sex: !
Name:Just Ruby

クラスの例外

Rubyの標準クラスとモジュールは例外を発生させます。 すべての例外クラスは階層を形成し、最上位に例外クラスがあります。 次のレベルには7つの異なるタイプが含まれています-

  • 割り込み
  • NoMemoryError
  • SignalException
  • ScriptError
  • StandardError
  • SystemExit

このレベルには Fatal の例外が1つありますが、Rubyインタープリターはこれを内部でのみ使用します。

ScriptErrorとStandardErrorには多くのサブクラスがありますが、ここで詳細を説明する必要はありません。 重要なことは、独自の例外クラスを作成する場合、それらは例外クラスまたはその子孫のいずれかのサブクラスである必要があるということです。

例を見てみましょう- 

class FileSaveError < StandardError
   attr_reader :reason
   def initialize(reason)
      &commat;reason = reason
   end
end

さて、この例外を使用する次の例を見てください- 

File.open(path, "w") do |file|
begin
   # Write out the data ...
rescue
   # Something went wrong!
   raise FileSaveError.new(&dollar;!)
end
end

ここで重要な行はraise _FileSaveError.new（＆dollar;！）_です。 raiseを呼び出して例外が発生したことを通知し、FileSaveErrorの新しいインスタンスを渡します。その理由は、特定の例外が原因でデータの書き込みが失敗したためです。

Ruby-オブジェクト指向

Rubyは純粋なオブジェクト指向言語であり、Rubyにはすべてがオブジェクトとして見えます。 Rubyのすべての値はオブジェクトであり、文字列、数値、さらにはtrueとfalseでさえ、最も原始的なものですらあります。 クラス自体も、_Class_クラスのインスタンスである_object_です。 この章では、オブジェクト指向Rubyに関連するすべての主要な機能について説明します。

クラスはオブジェクトの形式を指定するために使用され、データ表現とそのデータを1つのきれいなパッケージに操作するためのメソッドを組み合わせます。 クラス内のデータとメソッドは、クラスのメンバーと呼ばれます。

Rubyクラス定義

クラスを定義するときには、データ型の設計図を定義します。 これは実際にはデータを定義しませんが、クラス名が何を意味するのか、つまりクラスのオブジェクトが何を構成するのか、そしてそのようなオブジェクトに対して実行できる操作は定義します。

クラス定義は、キーワード class で始まり、その後に class name が続き、 end で区切られます。 たとえば、次のようにキーワードクラスを使用してBoxクラスを定義しました- 

class Box
   code
end

名前は大文字で開始する必要があり、慣例により、複数の単語を含む名前は、各単語を大文字で区切り文字なしで実行します（CamelCase）。

Rubyオブジェクトを定義する

クラスはオブジェクトの設計図を提供するため、基本的にオブジェクトはクラスから作成されます。 new キーワードを使用して、クラスのオブジェクトを宣言します。 次のステートメントは、クラスBoxの2つのオブジェクトを宣言します- 

box1 = Box.new
box2 = Box.new

初期化メソッド

  • initializeメソッド*は標準のRubyクラスメソッドであり、 constructor が他のオブジェクト指向プログラミング言語で機能するのとほぼ同じように機能します。 initializeメソッドは、オブジェクトの作成時にいくつかのクラス変数を初期化する場合に役立ちます。 このメソッドは、パラメータのリストを取ることができ、他のルビーメソッドと同様に、以下に示すように def キーワードが先行します-
class Box
   def initialize(w,h)
      &commat;width, &commat;height = w, h
   end
end

インスタンス変数

インスタンス変数*はクラス属性の一種であり、クラスを使用してオブジェクトが作成されると、オブジェクトのプロパティになります。 すべてのオブジェクトの属性は個別に割り当てられ、他のオブジェクトと値を共有しません。 これらには＆commat;を使用してアクセスします。クラス内の演算子ですが、クラス外からアクセスするには、 accessorメソッド*と呼ばれる public メソッドを使用します。 上記で定義したクラス Box を使用する場合、＆commat; widthと＆commat; heightはクラスBoxのインスタンス変数です。 

class Box
   def initialize(w,h)
      # assign instance variables
      &commat;width, &commat;height = w, h
   end
end

アクセサおよびセッターメソッド

クラスの外部から変数を使用可能にするには、変数を* accessorメソッド*内で定義する必要があります。これらのaccessorメソッドはgetterメソッドとも呼ばれます。 次の例は、アクセサメソッドの使用法を示しています- 

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      &commat;width, &commat;height = w, h
   end

   # accessor methods
   def printWidth
      &commat;width
   end

   def printHeight
      &commat;height
   end
end

# create an object
box = Box.new(10, 20)

# use accessor methods
x = box.printWidth()
y = box.printHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

上記のコードが実行されると、次の結果が生成されます- 

Width of the box is : 10
Height of the box is : 20

変数の値にアクセスするために使用されるアクセサメソッドと同様に、Rubyは、以下のように定義される* setterメソッド*を使用して、クラスの外部からこれらの変数の値を設定する方法を提供します- 

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # accessor methods
   def getWidth
      @width
   end
   def getHeight
      @height
   end

   # setter methods
   def setWidth=(value)
      @width = value
   end
   def setHeight=(value)
      @height = value
   end
end

# create an object
box = Box.new(10, 20)

# use setter methods
box.setWidth = 30
box.setHeight = 50

# use accessor methods
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

上記のコードが実行されると、次の結果が生成されます- 

Width of the box is : 30
Height of the box is : 50

インスタンスメソッド

インスタンスメソッド*も、 *def キーワードを使用して他のメソッドを定義するのと同じ方法で定義され、以下に示すようにクラスインスタンスを使用してのみ使用できます。 それらの機能は、インスタンス変数へのアクセスに限定されるものではありませんが、要件に応じてさらに多くのことができます。 

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      &commat;width, &commat;height = w, h
   end
   # instance method
   def getArea
      &commat;width * &commat;height
   end
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"

上記のコードが実行されると、次の結果が生成されます- 

Area of the box is : 200

クラスのメソッドと変数

  • クラス変数*は変数であり、クラスのすべてのインスタンス間で共有されます。 つまり、変数のインスタンスが1つあり、オブジェクトインスタンスによってアクセスされます。 クラス変数には、2つの＆commat;というプレフィックスが付きます。文字（＆commat;＆commat;）。 クラス変数は、以下に示すようにクラス定義内で初期化する必要があります。

クラスメソッドは、* def self.methodname（）を使用して定義されます。これは、終了デリミタで終了し、次の例に示すようにクラス名を *classname.methodname として使用して呼び出されます- 

#!/usr/bin/ruby -w

class Box
   # Initialize our class variables
   &commat;&commat;count = 0
   def initialize(w,h)
      # assign instance avriables
      &commat;width, &commat;height = w, h

      &commat;&commat;count += 1
   end

   def self.printCount()
      puts "Box count is : #&commat;&commat;count"
   end
end

# create two object
box1 = Box.new(10, 20)
box2 = Box.new(30, 100)

# call class method to print box count
Box.printCount()

上記のコードが実行されると、次の結果が生成されます- 

Box count is : 2

to_sメソッド

定義するクラスには、オブジェクトの文字列表現を返す to_s インスタンスメソッドが必要です。 以下は、幅と高さの点でBoxオブジェクトを表すための簡単な例です- 

#!/usr/bin/ruby -w

class Box
   # constructor method
   def initialize(w,h)
      &commat;width, &commat;height = w, h
   end
   # define to_s method
   def to_s
      "(w:#&commat;width,h:#&commat;height)"  # string formatting of the object.
   end
end

# create an object
box = Box.new(10, 20)

# to_s method will be called in reference of string automatically.
puts "String representation of box is : #{box}"

上記のコードが実行されると、次の結果が生成されます- 

String representation of box is : (w:10,h:20)

アクセス制御

Rubyでは、インスタンスメソッドレベルで、 public、private、またはprotected の3つのレベルの保護が提供されます。 Rubyは、インスタンス変数とクラス変数にアクセス制御を適用しません。

  • パブリックメソッド-パブリックメソッドは誰でも呼び出すことができます。 メソッドは、常にプライベートである初期化を除き、デフォルトでパブリックです。
  • プライベートメソッド-プライベートメソッドにはアクセスできず、クラス外からも見ることができません。 クラスメソッドのみがプライベートメンバーにアクセスできます。
  • 保護されたメソッド-保護されたメソッドは、定義クラスとそのサブクラスのオブジェクトによってのみ呼び出すことができます。 アクセスは家族内で行われます。

以下は、3つのアクセス修飾子すべての構文を示す簡単な例です- 

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      &commat;width, &commat;height = w, h
   end

   # instance method by default it is public
   def getArea
      getWidth() *getHeight
   end

   # define private accessor methods
   def getWidth
      &commat;width
   end
   def getHeight
      &commat;height
   end
   # make them private
   private :getWidth, :getHeight

   # instance method to print area
   def printArea
      &commat;area = getWidth()* getHeight
      puts "Big box area is : #&commat;area"
   end
   # make it protected
   protected :printArea
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"

# try to call protected or methods
box.printArea()

上記のコードが実行されると、次の結果が生成されます。 ここでは、最初のメソッドは正常に呼び出されますが、2番目のメソッドには問題があります。 

Area of the box is : 200
test.rb:42: protected method `printArea' called for #
<Box:0xb7f11280 @height = 20, @width = 10> (NoMethodError)

クラスの継承

オブジェクト指向プログラミングで最も重要な概念の1つは、継承の概念です。 継承を使用すると、クラスを別のクラスの観点から定義でき、アプリケーションの作成と保守が簡単になります。

継承は、コード機能と高速な実装時間を再利用する機会も提供しますが、残念ながら、Rubyは複数レベルの継承をサポートしませんが、Rubyは mixins をサポートします。 ミックスインは、インターフェイス部分のみが継承される多重継承の特殊な実装のようなものです。

クラスを作成するとき、プログラマは完全に新しいデータメンバーとメンバー関数を記述する代わりに、新しいクラスが既存のクラスのメンバーを継承するように指定できます。 この既存のクラスは、*ベースクラスまたはスーパークラス*と呼ばれ、新しいクラスは*派生クラスまたはサブクラス*と呼ばれます。

Rubyはサブクラス化、つまり継承の概念もサポートしており、次の例で概念を説明します。 クラスを拡張するための構文は簡単です。 クラス文字列に<文字とスーパークラスの名前を追加するだけです。 たとえば、次のクラス_BigBox_を_Box_のサブクラスとして定義します- 

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      &commat;width, &commat;height = w, h
   end
   # instance method
   def getArea
      &commat;width *&commat;height
   end
end

# define a subclass
class BigBox < Box

   # add a new instance method
   def printArea
      &commat;area = &commat;width* &commat;height
      puts "Big box area is : #&commat;area"
   end
end

# create an object
box = BigBox.new(10, 20)

# print the area
box.printArea()

上記のコードが実行されると、次の結果が生成されます- 

Big box area is : 200

メソッドのオーバーライド

派生クラスに新しい機能を追加することはできますが、親クラスで既に定義されているメソッドの動作を変更したい場合があります。 次の例に示すように、メソッド名を同じに保ち、メソッドの機能をオーバーライドするだけで簡単にできます- 

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      &commat;width, &commat;height = w, h
   end
   # instance method
   def getArea
      &commat;width *&commat;height
   end
end

# define a subclass
class BigBox < Box

   # change existing getArea method as follows
   def getArea
      &commat;area = &commat;width* &commat;height
      puts "Big box area is : #&commat;area"
   end
end

# create an object
box = BigBox.new(10, 20)

# print the area using overriden method.
box.getArea()

オペレータの過負荷

＆plus;が欲しい＆plus;を使用して2つのBoxオブジェクトのベクトル加算を実行する演算子、Boxの幅と高さをスカラーで乗算する*演算子、およびBoxの幅と高さを無効にする単項-演算子。 これは、数学演算子が定義されたBoxクラスのバージョンです- 

class Box
   def initialize(w,h)     # Initialize the width and height
      &commat;width,&commat;height = w, h
   end

   def &plus;(other)       # Define &plus; to do vector addition
      Box.new(&commat;width &plus; other.width, &commat;height &plus; other.height)
   end

   def -&commat;           # Define unary minus to negate width and height
      Box.new(-&commat;width, -&commat;height)
   end

   def *(scalar)           # To perform scalar multiplication
      Box.new(&commat;width*scalar, &commat;height*scalar)
   end
end

オブジェクトの凍結

オブジェクトが変更されないようにしたい場合があります。 Objectのfreezeメソッドを使用すると、オブジェクトを定数に効果的に変換することができます。 Object.freeze を呼び出すと、すべてのオブジェクトを凍結できます。 凍結されたオブジェクトは変更できません。そのインスタンス変数は変更できません。

特定のオブジェクトが既に凍結されているかどうか、またはオブジェクトが凍結されている場合はtrueを返し、そうでない場合はfalseを返す* Object.frozen？*メソッドを使用してチェックできます。 次の例では、概念をクリアします- 

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # accessor methods
   def getWidth
      @width
   end
   def getHeight
      @height
   end

   # setter methods
   def setWidth=(value)
      @width = value
   end
   def setHeight=(value)
      @height = value
   end
end

# create an object
box = Box.new(10, 20)

# let us freez this object
box.freeze
if( box.frozen? )
   puts "Box object is frozen object"
else
   puts "Box object is normal object"
end

# now try using setter methods
box.setWidth = 30
box.setHeight = 50

# use accessor methods
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

上記のコードが実行されると、次の結果が生成されます- 

Box object is frozen object
test.rb:20:in `setWidth=': can't modify frozen object (TypeError)
   from test.rb:39

クラス定数

クラス内で定数を定義するには、＆commat;を使用せずに定義された変数に直接数値または文字列値を割り当てます。または＆commat;＆commat;。 慣例により、定数名は大文字のままにします。

定数が定義されると、その値を変更することはできませんが、変数のようにクラス内で定数に直接アクセスできますが、クラス外の定数にアクセスする場合は、 *classname
constant* を使用する必要があります以下の例に示します。
#!/usr/bin/ruby -w

# define a class
class Box
   BOX_COMPANY = "TATA Inc"
   BOXWEIGHT = 10
   # constructor method
   def initialize(w,h)
      &commat;width, &commat;height = w, h
   end
   # instance method
   def getArea
      &commat;width * &commat;height
   end
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"
puts Box::BOX_COMPANY
puts "Box weight is: #{Box::BOXWEIGHT}"

上記のコードが実行されると、次の結果が生成されます- 

Area of the box is : 200
TATA Inc
Box weight is: 10

クラス定数は継承され、インスタンスメソッドのようにオーバーライドできます。

割り当てを使用してオブジェクトを作成

コンストラクター initialize を呼び出さずにオブジェクトを作成したい場合があります。 新しいメソッドを使用して、そのような場合は、_allocate_を呼び出すことができます。これにより、次の例のように初期化されていないオブジェクトが作成されます- 

#!/usr/bin/ruby -w

# define a class
class Box
   attr_accessor :width, :height

   # constructor method
   def initialize(w,h)
      &commat;width, &commat;height = w, h
   end

   # instance method
   def getArea
      &commat;width * &commat;height
   end
end

# create an object using new
box1 = Box.new(10, 20)

# create another object using allocate
box2 = Box.allocate

# call instance method using box1
a = box1.getArea()
puts "Area of the box is : #{a}"

# call instance method using box2
a = box2.getArea()
puts "Area of the box is : #{a}"

上記のコードが実行されると、次の結果が生成されます- 

Area of the box is : 200
test.rb:14: warning: instance variable @width not initialized
test.rb:14: warning: instance variable @height not initialized
test.rb:14:in `getArea': undefined method `*'
   for nil:NilClass (NoMethodError) from test.rb:29

クラス情報

クラス定義が実行可能なコードである場合、これはそれらが何らかのオブジェクトのコンテキストで実行されることを意味します：selfは何かを参照する必要があります。 それが何であるかを調べましょう。 

#!/usr/bin/ruby -w

class Box
   # print class information
   puts "Type of self = #{self.type}"
   puts "Name of self = #{self.name}"
end

上記のコードが実行されると、次の結果が生成されます- 

Type of self = Class
Name of self = Box

これは、そのクラスを現在のオブジェクトとしてクラス定義が実行されることを意味します。 これは、メソッド定義の実行中にメタクラスとそのスーパークラスのメソッドが利用できることを意味します。

Ruby-正規表現

_正規表現_は、パターンに保持されている特殊な構文を使用して、他の文字列または文字列セットを一致または検索するのに役立つ特殊な文字シーケンスです。

_正規表現literal_は、スラッシュの間、または次のように％rが続く任意の区切り文字の間のパターンです-

構文

/pattern/
/pattern/im    # option can be specified
%r!/usr/local! # general delimited regular expression

例

#!/usr/bin/ruby

line1 = "Cats are smarter than dogs";
line2 = "Dogs also like meat";

if ( line1 =~/Cats(.*)/)
   puts "Line1 contains Cats"
end
if ( line2 =~/Cats(.*)/)
   puts "Line2 contains  Dogs"
end

これは、次の結果を生成します- 

Line1 contains Cats

正規表現修飾子

正規表現リテラルには、マッチングのさまざまな側面を制御するオプションの修飾子が含まれる場合があります。 修飾子は、前述のように、2番目のスラッシュ文字の後に指定され、これらの文字のいずれかで表すことができます-

Sr.No. Modifier & Description
1

i

テキストの一致時に大文字と小文字を区別しません。

2

o

＃\ {}補間を一度だけ実行します（正規表現リテラルが最初に評価されるとき）。

3

x

空白を無視し、正規表現でコメントを許可します。

4

m

複数行に一致し、改行を通常の文字として認識します。

5

u,e,s,n

正規表現をUnicode（UTF-8）、EUC、SJIS、またはASCIIとして解釈します。 これらの修飾子のいずれも指定されていない場合、正規表現はソースエンコーディングを使用すると見なされます。

％Qで区切られた文字列リテラルのように、Rubyでは、正規表現を％rで開始し、その後に選択した区切り文字を続けることができます。 これは、説明するパターンに、エスケープしたくないスラッシュ文字が多く含まれている場合に便利です- 

# Following matches a single slash character, no escape required
%r|/|

# Flag characters are allowed with this syntax, too
%r[</(.*)>]i

正規表現パターン

制御文字を除き、（＆plus;？ 。 * ^＆dollar; （）[] \ {} | \）、すべての文字が一致します。 制御文字の前にバックスラッシュを付けることにより、制御文字をエスケープできます。

____次の表に、Rubyで使用できる正規表現の構文を示します。

Sr.No. Pattern & Description
1

^

行頭に一致します。

2

$

行末に一致します。

3

.

改行を除く任意の1文字に一致します。 mオプションを使用すると、改行も一致させることができます。

4

[…​]

大括弧内の任意の1文字に一致します。

5

[^…​]

括弧内にない任意の1文字と一致します

6

re*

前の表現の0回以上の出現に一致します。

7

re+

先行表現の1回以上の出現に一致します。

8

re?

前の表現の0または1回の出現に一致します。

9

re\{ n}

直前の表現の正確にn個の出現に一致します。

10

re\{ n,}

前の表現のn回以上の出現に一致します。

11

re\{ n, m}

先行表現の少なくともn回、最大m回の出現に一致します。

12 *a

b*

aまたはbのいずれかに一致します。

13

(re)

正規表現をグループ化し、一致したテキストを記憶します。

14

(?imx)

正規表現内でi、m、またはxオプションを一時的に切り替えます。 括弧内にある場合、その領域のみが影響を受けます。

15

(?-imx)

正規表現内でi、m、またはxオプションを一時的にオフにします。 括弧内にある場合、その領域のみが影響を受けます。

16

(?: re)

一致したテキストを記憶せずに正規表現をグループ化します。

17

(?imx: re)

括弧内のi、m、またはxオプションを一時的に切り替えます。

18

(?-imx: re)

括弧内のi、m、またはxオプションを一時的にオフにします。

19

(?#…​)

コメント。

20

(?= re)

パターンを使用して位置を指定します。 範囲がありません。

21

(?! re)

パターン否定を使用して位置を指定します。 範囲がありません。

22

(?> re)

バックトラックせずに独立したパターンに一致します。

23

\w

単語の文字に一致します。

24

\W

単語以外の文字に一致します。

25

\s

空白に一致します。 [\ t \ n \ r \ f]と同等です。

26

\S

空白以外に一致します。

27

\d

数字と一致します。 [0-9]と同等です。

28

\D

数字以外に一致します。

29

\A

文字列の先頭に一致します。

30

\Z

文字列の末尾に一致します。 改行が存在する場合、改行の直前に一致します。

31

\z

文字列の末尾に一致します。

32

\G

最後の一致が終了したポイントに一致します。

33

\b

大括弧の外にある場合、単語の境界に一致します。 括弧内にある場合、バックスペース（0x08）に一致します。

34

\B

単語の境界以外に一致します。

35

\n, \t, etc.

改行、キャリッジリターン、タブなどに一致します。

36

\1…​\9

n番目のグループ化された部分式に一致します。

37

正規表現の例

__ *リテラル文字 *

Sr.No. Example & Description
1

/ruby/

「ルビー」に一致します。

2

¥

円記号に一致します。 マルチバイト文字は、Ruby 1.9およびRuby 1.8でサポートされています。

__ *文字クラス *

Sr.No. Example & Description
1

/[Rr]uby/

「Ruby」または「ruby」に一致します。

2

/rub[ye]/

「ruby」または「rube」に一致します。

3

/[aeiou]/

任意の1つの小文字の母音に一致します。

4

/[0-9]/

任意の数字と一致します。/[0123456789]/と同じです。

5

/[a-z]/

小文字のASCII文字に一致します。

6

/[A-Z]/

大文字のASCII文字に一致します。

7

/[a-zA-Z0-9]/

上記のいずれかに一致します。

8

/[^aeiou]/

小文字の母音以外のものに一致します。

9

/[^0-9]/

数字以外に一致します。

__ *特殊文字クラス *

Sr.No. Example & Description
1

/./

改行を除くすべての文字に一致します。

2

/./m

複数行モードでは、改行にも一致します。

3

/\d/

数字と一致：/[0-9]/。

4

/\D/

数字以外に一致します：/[^ 0-9]/。

5

/\s/

空白文字に一致します：/[\ t \ r \ n \ f]/。

6

/\S/

空白以外と一致：/[^ \ t \ r \ n \ f]/。

7

/\w/

単一の単語文字/[A-Za-z0-9 _]/に一致します。

8

/\W/

単語以外の文字/[^ A-Za-z0-9 _]/に一致します。

__ *繰り返しのケース *

Sr.No. Example & Description
1

/ruby?/

「rub」または「ruby」に一致します。yはオプションです。

2

/ruby/*

「rub」と0個以上のysに一致します。

3

/ruby+/

「rub」と1つ以上のysに一致します。

4

/\d{3}/

正確に3桁に一致します。

5

/\d\{3,}/

3桁以上に一致します。

6

/\d\{3,5}/

3、4、または5桁に一致します。

__ *貪欲でない繰り返し *

これは繰り返しの最小数に一致します-

Sr.No. Example & Description
1

/<.>/*

貪欲な繰り返し：「<ruby> perl>」に一致します。

2

/<.?>/*

貪欲でない：「<ruby> perl>」の「<ruby>」に一致します。

__ *括弧でグループ化 *

Sr.No. Example & Description
1

/\D\d+/

グループなし：+ \ dを繰り返す

2

/(\D\d)+/

グループ化：+ \ D \ dペアを繰り返します

3

/([Rr]uby(, )?)+/

「ルビー」、「ルビー、ルビー、ルビー」などに一致

__ *後方参照 *

これは以前に一致したグループに再び一致します-

Sr.No. Example & Description
1

/([Rr])uby&\1ails/

ruby＆railsまたはRuby＆Railsに一致します。

2

/(['"])(?:(?!\1).)\1/*

一重引用符または二重引用符で囲まれた文字列。 \ 1は、最初のグループが一致したものに一致します。 \ 2は、2番目のグループが一致したものに一致します。

__ *代替案 *

Sr.No. Example & Description
1 */ruby

rube/*

「ruby」または「rube」に一致します。

2
*/rub(y

le))/*

「ルビー」または「ルーブル」に一致します。

3 */ruby(!+

__ *アンカー *

一致位置を指定する必要があります。

Sr.No. Example & Description
1

/^Ruby/

文字列または内部行の先頭の「Ruby」に一致します。

2

/RubyDOLLAR/

文字列または行の末尾の「ルビー」に一致します。

3

/\ARuby/

文字列の先頭の「Ruby」に一致します。

4

/Ruby\Z/

文字列の末尾の「ルビー」に一致します。

5

/\bRuby\b/

単語の境界で「ルビー」に一致します。

6

/\brub\B/

\ Bは非単語境界です。「rube」および「ruby」の「rub」に一致しますが、単独ではありません。

7

/Ruby(?=!)/

感嘆符が後に続く場合、「Ruby」に一致します。

8

/Ruby(?!!)/

感嘆符が後に続かない場合、「Ruby」に一致します。

__ *括弧付きの特別な構文 *

Sr.No. Example & Description
1

/R(?#comment)/

「R」に一致します。 残りはすべてコメントです。

2

/R(?i)uby/

「uby」の照合中は大文字と小文字が区別されません。

3

/R(?i:uby)/

同上。

4 */rub(?:y

検索と置換

正規表現を使用する最も重要なStringメソッドには、 sub と gsub 、およびそれらのインプレースバリアント* sub！と gsub！*があります。

これらのメソッドはすべて、Regexpパターンを使用して検索および置換操作を実行します。 sub ＆* sub！はパターンの最初の出現を置き換え、 *gsub ＆* gsub！*はすべての出現を置き換えます。 

*sub* と *gsub* は新しい文字列を返し、元の文字列を変更せずに、* sub！*と* gsub！*が呼び出された文字列を変更します。

以下は例です- 

#!/usr/bin/ruby

phone = "2004-959-559 #This is Phone Number"

# Delete Ruby-style comments
phone = phone.sub!(/#.*&dollar;/, "")
puts "Phone Num : #{phone}"

# Remove anything other than digits
phone = phone.gsub!(/\D/, "")
puts "Phone Num : #{phone}"

これは、次の結果を生成します- 

Phone Num : 2004-959-559
Phone Num : 2004959559

以下は別の例です- 

#!/usr/bin/ruby

text = "rails are rails, really good Ruby on Rails"

# Change "rails" to "Rails" throughout
text.gsub!("rails", "Rails")

# Capitalize the word "Rails" throughout
text.gsub!(/\brails\b/, "Rails")
puts "#{text}"

これは、次の結果を生成します- 

Rails are Rails, really good Ruby on Rails

Ruby/DBIチュートリアル

この章では、Rubyを使用してデータベースにアクセスする方法を説明します。 _Ruby DBI_モジュールは、Perl DBIモジュールと同様のRubyスクリプト用のデータベースに依存しないインターフェースを提供します。

DBIはRubyのDatabase Independent Interfaceの略です。つまり、DBIはRubyコードと基になるデータベースとの間に抽象化レイヤーを提供し、データベース実装を非常に簡単に切り替えることができることを意味します。 使用されている実際のデータベースに関係なく、一貫したデータベースインターフェイスを提供する一連のメソッド、変数、および規則を定義します。

DBIは、次とインターフェースすることができます-

  • ADO（ActiveXデータオブジェクト）
  • DB2
  • フロントベース
  • mSQL
  • MySQL
  • ODBC
  • オラクル
  • OCI8（Oracle）
  • PostgreSQL
  • プロキシ/サーバー
  • SQLite
  • SQLRelay

DBIアプリケーションのアーキテクチャ

DBIは、バックエンドで利用可能なデータベースから独立しています。 Oracle、MySQL、Informixなどのいずれで作業していても、DBIを使用できます。 これは、次のアーキテクチャ図から明らかです。

Ruby DBI Architecture

Ruby DBIの一般的なアーキテクチャは2つの層を使用します-

  • データベースインターフェイス（DBI）層。 このレイヤーはデータベースに依存せず、通信するデータベースサーバーの種類に関係なく同じ方法で使用される一連の一般的なアクセス方法を提供します。
  • データベースドライバー（DBD）レイヤー。 この層はデータベースに依存しています。異なるドライバーは、異なるデータベースエンジンへのアクセスを提供します。 MySQL用のドライバー、PostgreSQL用のドライバー、InterBase用のドライバー、Oracle用のドライバーなどがあります。 各ドライバーは、DBI層からの要求を解釈し、特定の種類のデータベースサーバーに適した要求にマッピングします。

前提条件

MySQLデータベースにアクセスするためのRubyスクリプトを作成する場合は、Ruby MySQLモジュールをインストールする必要があります。

このモジュールは、上記で説明したようにDBDとして機能し、https://www.tmtm.org/en/mysql/ruby/からダウンロードできます。

Ruby/DBIの入手とインストール

次の場所からRuby DBIモジュールをダウンロードしてインストールできます-

https://imgur.com/NFEuWe4/embed

このインストールを開始する前に、root権限を持っていることを確認してください。 さて、以下の手順に従ってください-

ステップ1

$ tar zxf dbi-0.2.0.tar.gz

ステップ2

配布ディレクトリ_dbi-0.2.0_に移動し、そのディレクトリの_setup.rb_スクリプトを使用して構成します。 最も一般的な設定コマンドは次のようになり、config引数の後に引数はありません。 このコマンドは、デフォルトですべてのドライバーをインストールするようにディストリビューションを構成します。 

$ ruby setup.rb config

より具体的には、使用するディストリビューションの特定の部分をリストする—​withオプションを指定します。 たとえば、メインのDBIモジュールとMySQL DBDレベルのドライバーのみを構成するには、次のコマンドを発行します- 

$ ruby setup.rb config --with = dbi,dbd_mysql

ステップ3

最後のステップは、次のコマンドを使用してドライバーをビルドし、インストールすることです- 

$ ruby setup.rb setup
$ ruby setup.rb install

データベース接続

データベースに接続する前に、次のことを確認して、MySQLデータベースで作業することを想定しています-

  • データベースTESTDBを作成しました。
  • TESTDBにEMPLOYEEを作成しました。
  • このテーブルには、フィールドFIRST_NAME、LAST_NAME、AGE、SEX、およびINCOMEがあります。
  • ユーザーID「testuser」とパスワード「test123」は、TESTDBにアクセスするように設定されています。
  • Ruby Module DBIがマシンに適切にインストールされます。
  • MySQLの基本を理解するために、MySQLチュートリアルを完了しました。

以下は、MySQLデータベース「TESTDB」と接続する例です 

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   # get server version string and display it
   row = dbh.select_one("SELECT VERSION()")
   puts "Server version: " + row[0]
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

このスクリプトを実行すると、Linuxマシンで次の結果が生成されます。 

Server version: 5.0.45

データソースとの接続が確立された場合、データベースハンドルが返され、さらに使用するために dbh に保存されます。それぞれ。

最後に、公開する前に、データベース接続が閉じられ、リソースが解放されていることを確認してください。

INSERT操作

レコードをデータベーステーブルに作成する場合は、INSERT操作が必要です。

データベース接続が確立されると、 do メソッドまたは prepare および execute メソッドを使用して、データベーステーブルにテーブルまたはレコードを作成する準備が整います。

doステートメントの使用

行を返さないステートメントは、 do データベースハンドルメソッドを呼び出すことで発行できます。 このメソッドはステートメント文字列引数を取り、ステートメントの影響を受ける行数のカウントを返します。 

dbh.do("DROP TABLE IF EXISTS EMPLOYEE")
dbh.do("CREATE TABLE EMPLOYEE (
   FIRST_NAME  CHAR(20) NOT NULL,
   LAST_NAME  CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT )" );

同様に、SQL _INSERT_ステートメントを実行して、EMPLOYEEテーブルにレコードを作成できます。 

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   dbh.do( "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
      VALUES ('Mac', 'Mohan', 20, 'M', 2000)" )
   puts "Record has been created"
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

準備と実行の使用

DBIクラスの_prepare_および_execute_メソッドを使用して、Rubyコードを介してSQLステートメントを実行できます。

レコードの作成は次の手順を実行します-

  • INSERTステートメントでSQLステートメントを準備しています。 これは、 prepare メソッドを使用して行われます。
  • SQLクエリを実行して、データベースからすべての結果を選択します。 これは、 execute メソッドを使用して行われます。
  • ステートメントハンドルを解放します。 これは finish APIを使用して行われます
  • すべてがうまくいったら、この操作を*コミット*します。

これらの2つの方法を使用するための構文は次のとおりです- 

sth = dbh.prepare(statement)
sth.execute
   ... zero or more SQL operations ...
sth.finish

これらの2つのメソッドを使用して、 bind 値をSQLステートメントに渡すことができます。 入力する値が事前に指定されていない場合があります。 そのような場合、バインディング値が使用されます。 実際の値の代わりに疑問符（？）が使用され、実際の値はexecute（）APIを介して渡されます。

以下は、EMPLOYEEテーブルに2つのレコードを作成する例です- 

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare( "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
      VALUES (?, ?, ?, ?, ?)" )
   sth.execute('John', 'Poul', 25, 'M', 2300)
   sth.execute('Zara', 'Ali', 17, 'F', 1000)
   sth.finish
   dbh.commit
   puts "Record has been created"
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

一度に複数のINSERTがある場合、最初にステートメントを準備し、ループ内で複数回実行する方が、ループを毎回実行するよりも効率的です。

読み取り操作

任意のデータベースに対するREAD操作は、データベースからいくつかの有用な情報を取得することを意味します。

データベース接続が確立されると、このデータベースに対してクエリを実行する準備が整います。 do メソッドまたは prepare および execute メソッドを使用して、データベーステーブルから値をフェッチできます。

レコードの取得には次の手順が必要です-

  • 必要な条件に基づいてSQLクエリを準備します。 これは、 prepare メソッドを使用して行われます。
  • SQLクエリを実行して、データベースからすべての結果を選択します。 これは、 execute メソッドを使用して行われます。
  • すべての結果を1つずつ取得し、それらの結果を印刷します。 これは fetch メソッドを使用して行われます。
  • ステートメントハンドルを解放します。 これは finish メソッドを使用して行われます。

以下は、給与が1000を超えるEMPLOYEEテーブルからすべてのレコードを照会する手順です。 

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("SELECT * FROM EMPLOYEE WHERE INCOME > ?")
   sth.execute(1000)

   sth.fetch do |row|
   printf "First Name: %s, Last Name : %s\n", row[0], row[1]
   printf "Age: %d, Sex : %s\n", row[2], row[3]
   printf "Salary :%d \n\n", row[4]
end
   sth.finish
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

これは、次の結果を生成します- 

First Name: Mac, Last Name : Mohan
Age: 20, Sex : M
Salary :2000

First Name: John, Last Name : Poul
Age: 25, Sex : M
Salary :2300

データベースからレコードを取得するためのショートカットメソッドは他にもあります。 興味がある場合は、リンクをたどってください：/ruby​​/ruby​​_dbi_fetching_results [Fetching the Result]そうでなければ、次のセクションに進んでください。

更新操作

データベースでのUPDATE操作とは、データベースですでに使用可能な1つ以上のレコードを更新することです。 以下は、SEXが「M」であるすべてのレコードを更新する手順です。 ここでは、すべての男性の年齢を1年ずつ増やします。 これには3つのステップがかかります-

  • 必要な条件に基づいてSQLクエリを準備します。 これは、 prepare メソッドを使用して行われます。
  • SQLクエリを実行して、データベースからすべての結果を選択します。 これは、 execute メソッドを使用して行われます。
  • ステートメントハンドルを解放します。 これは finish メソッドを使用して行われます。
  • すべてが正常に完了したら、この操作を*コミット*します。
#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = ?")
   sth.execute('M')
   sth.finish
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

削除操作

データベースから一部のレコードを削除する場合は、DELETE操作が必要です。 以下は、AGEが20を超えるEMPLOYEEからすべてのレコードを削除する手順です。 この操作では、次の手順を実行します。

  • 必要な条件に基づいてSQLクエリを準備します。 これは、 prepare メソッドを使用して行われます。
  • SQLクエリを実行して、データベースから必要なレコードを削除します。 これは、 execute メソッドを使用して行われます。
  • ステートメントハンドルを解放します。 これは finish メソッドを使用して行われます。
  • すべてが正常に完了したら、この操作を*コミット*します。
#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("DELETE FROM EMPLOYEE WHERE AGE > ?")
   sth.execute(20)
   sth.finish
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

トランザクションの実行

トランザクションは、データの一貫性を保証するメカニズムです。 トランザクションには、次の4つのプロパティが必要です-

  • Atomicity -トランザクションが完了するか、まったく何も起こりません。
  • 一貫性-トランザクションは一貫した状態で開始し、システムを一貫した状態にしておく必要があります。
  • 分離-トランザクションの中間結果は、現在のトランザクションの外部では見えません。
  • 耐久性-トランザクションがコミットされると、システム障害が発生した後でも効果は持続します。

DBIは、トランザクションを_commit_または_rollback_するための2つのメソッドを提供します。 トランザクションを実装するために使用できる_transaction_と呼ばれるもう1つのメソッドがあります。 トランザクションを実装するには、2つの簡単なアプローチがあります-

アプローチI

最初のアプローチは、DBIの_commit_および_rollback_メソッドを使用して、トランザクションを明示的にコミットまたはキャンセルします- 

dbh['AutoCommit'] = false # Set auto commit to false.
begin
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'John'")
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'Zara'")
   dbh.commit
rescue
   puts "transaction failed"
   dbh.rollback
end
dbh['AutoCommit'] = true

アプローチII

2番目のアプローチでは、_transaction_メソッドを使用します。 これは、トランザクションを構成するステートメントを含むコードブロックを取得するため、より簡単です。 _transaction_メソッドはブロックを実行し、ブロックが成功するか失敗するかに応じて、_commit_または_rollback_を自動的に呼び出します- 

dbh['AutoCommit'] = false # Set auto commit to false.
dbh.transaction do |dbh|
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'John'")
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'Zara'")
end
dbh['AutoCommit'] = true

コミット操作

コミットとは、変更をファイナライズするためにデータベースに緑の信号を与える操作です。この操作の後、変更を元に戻すことはできません。 

*commit* メソッドを呼び出す簡単な例を次に示します。
dbh.commit

ロールバック操作

1つ以上の変更に満足せず、それらの変更を完全に元に戻したい場合は、 rollback メソッドを使用します。 

*rollback* メソッドを呼び出す簡単な例を次に示します。
dbh.rollback

データベースの切断

データベース接続を切断するには、切断APIを使用します。 

dbh.disconnect

データベースへの接続が切断メソッドを使用してユーザーによって閉じられた場合、未処理のトランザクションはすべてDBIによってロールバックされます。 ただし、DBIの実装の詳細に依存する代わりに、アプリケーションで明示的にコミットまたはロールバックを呼び出す方が適切です。

エラー処理

エラーには多くの原因があります。 いくつかの例は、実行されたSQLステートメントの構文エラー、接続障害、または既にキャンセルまたは終了したステートメントハンドルのフェッチメソッドの呼び出しです。

DBIメソッドが失敗すると、DBIは例外を発生させます。 DBIメソッドはいくつかのタイプの例外を発生させる可能性がありますが、2つの最も重要な例外クラスは_DBI
InterfaceError_と_DBI :: DatabaseError_です。

これらのクラスの例外オブジェクトには、err _、 errstr_、および_state_という名前の3つの属性があり、エラー番号、説明的なエラー文字列、および標準エラーコードを表します。 属性は以下に説明されています-

  • err -発生したエラーの整数表現、またはDBDでサポートされていない場合は_nil_を返します。たとえば、Oracle DBDは_ORA-XXXX_エラーメッセージの数値部分を返します。
  • errstr -発生したエラーの文字列表現を返します。
  • state -発生したエラーのSQLSTATEコードを返します。SQLSTATEは5文字の文字列です。 ほとんどのDBDはこれをサポートせず、代わりにnilを返します。

あなたはほとんどの例で上記のコードを見てきました- 

rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

スクリプトの実行中に実行していることに関するデバッグ情報を取得するには、トレースを有効にします。 これを行うには、最初にdbi/traceモジュールをロードしてから、トレースモードと出力先を制御する_trace_メソッドを呼び出す必要があります- 

require "dbi/trace"
..............

trace(mode, destination)

モード値は0（オフ）、1、2、または3であり、宛先はIOオブジェクトでなければなりません。 デフォルト値は、それぞれ2およびSTDERRです。

メソッドを含むコードブロック

ハンドルを作成するメソッドがいくつかあります。 これらのメソッドは、コードブロックで呼び出すことができます。 メソッドと共にコードブロックを使用する利点は、コードブロックにパラメーターとしてハンドルを提供し、ブロックの終了時にハンドルを自動的にクリーンアップすることです。 概念を理解するための例はほとんどありません。

  • DBI.connect -このメソッドはデータベースハンドルを生成し、ブロックの最後で_disconnect_を呼び出してデータベースを切断することをお勧めします。
  • dbh.prepare -このメソッドはステートメントハンドルを生成し、ブロックの最後で_finish_することをお勧めします。 ブロック内で、_execute_メソッドを呼び出してステートメントを実行する必要があります。
  • dbh.execute -このメソッドは、ブロック内でexecuteを呼び出す必要がないことを除いて似ています。 文ハンドルは自動的に実行されます。

例1

*DBI.connect* はコードブロックを取得し、それにデータベースハンドルを渡し、次のようにブロックの最後でハンドルを自動的に切断します。
dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123") do |dbh|

例2

*dbh.prepare* は、コードブロックを受け取り、ステートメントハンドルをそれに渡すことができ、次のようにブロックの最後で自動的にfinishを呼び出します。
dbh.prepare("SHOW DATABASES") do |sth|
   sth.execute
   puts "Databases: " + sth.fetch_all.join(", ")
end

実施例３

*dbh.execute* は、コードブロックを取得し、それにステートメントハンドルを渡し、次のようにブロックの終わりに自動的に終了を呼び出します-
dbh.execute("SHOW DATABASES") do |sth|
   puts "Databases: " + sth.fetch_all.join(", ")
end

DBI _transaction_メソッドは、上記で説明したコードブロックも使用します。

ドライバー固有の機能と属性

DBIを使用すると、データベースドライバーは、データベース固有の追加機能を提供できます。これは、任意のHandleオブジェクトの_func_メソッドを介してユーザーが呼び出すことができます。

ドライバー固有の属性がサポートされており、 [] = または [] メソッドを使用して設定または取得できます。

__ DBD
Mysqlは、次のドライバー固有の機能を実装します-
Sr.No. Functions & Description
1

dbh.func(:createdb, db_name)

新しいデータベースを作成します。

2

dbh.func(:dropdb, db_name)

データベースを削除します。

3

dbh.func(:reload)

リロード操作を実行します。

4

dbh.func(:shutdown)

サーバーをシャットダウンします。

5

dbh.func(:insert_id) ⇒ Fixnum

接続の最新のAUTO_INCREMENT値を返します。

6

dbh.func(:client_info) ⇒ String

バージョンに関するMySQLクライアント情報を返します。

7

dbh.func(:client_version) ⇒ Fixnum

バージョンに関するクライアント情報を返します。 ：client_infoに似ていますが、刺す代わりにfixnumを返します。

8

dbh.func(:host_info) ⇒ String

ホスト情報を返します。

9

dbh.func(:proto_info) ⇒ Fixnum

通信に使用されているプロトコルを返します。

10

dbh.func(:server_info) ⇒ String

バージョンに関するMySQLサーバー情報を返します。

11

dbh.func(:stat) ⇒ String

データベースの現在の状態を返します。

12

dbh.func(:thread_id) ⇒ Fixnum

現在のスレッドIDを返します。

例

#!/usr/bin/ruby

require "dbi"
begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   puts dbh.func(:client_info)
   puts dbh.func(:client_version)
   puts dbh.func(:host_info)
   puts dbh.func(:proto_info)
   puts dbh.func(:server_info)
   puts dbh.func(:thread_id)
   puts dbh.func(:stat)
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   dbh.disconnect if dbh
end

これは、次の結果を生成します- 

5.0.45
50045
Localhost via UNIX socket
10
5.0.45
150621
Uptime: 384981  Threads: 1  Questions: 1101078  Slow queries: 4 \
Opens: 324  Flush tables: 1  Open tables: 64  \
Queries per second avg: 2.860

Ruby Webアプリケーション-CGIプログラミング

Rubyは汎用言語です。 _web言語_とはまったく呼ばれません。 それでも、一般的なWebアプリケーションとWebツールは、Rubyの最も一般的な用途の1つです。

Rubyで独自のSMTPサーバー、FTPデーモン、またはWebサーバーを作成できるだけでなく、CGIプログラミングなどのより一般的なタスクや、PHPの代替としてRubyを使用することもできます。

CGIプログラミングの詳細については、リンク：/perl/perl_cgi [CGIプログラミング]チュートリアルで数分お過ごしください。

CGIスクリプトの作成

最も基本的なRuby CGIスクリプトは次のようになります- 

#!/usr/bin/ruby

puts "HTTP/1.0 200 OK"
puts "Content-type: text/html\n\n"
puts "<html><body>This is a test</body></html>"

このスクリプト_test.cgi_を呼び出して、適切な権限を持つUnixベースのWebホスティングプロバイダーにアップロードすると、CGIスクリプトとして使用できます。

たとえば、Linux WebホスティングプロバイダーでホストされているWebサイトhttps://www.example.com/があり、test.cgi_をメインディレクトリにアップロードして実行権限を付与し、https://wwwにアクセスした場合。 example.com/[https://www.example.com/test.cgi]は、 ' This is a test_ というHTMLページを返す必要があります。

ここで、Webブラウザから_test.cgi_が要求されると、WebサーバーはWebサイトで_test.cgi_を探し、Rubyインタープリターを使用して実行します。 Rubyスクリプトは、基本的なHTTPヘッダーを返し、次に基本的なHTMLドキュメントを返します。

cgi.rbを使用する

Rubyには、 cgi という特別なライブラリが付属しており、前述のCGIスクリプトとの対話よりも高度な対話が可能です。

CGIを使用する基本的なCGIスクリプトを作成しましょう- 

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new

puts cgi.header
puts "<html><body>This is a test</body></html>"

ここでは、CGIオブジェクトを作成し、それを使用してヘッダー行を印刷しました。

フォーム処理

クラスCGIを使用すると、2つの方法でHTMLクエリパラメータにアクセスできます。/cgi-bin/test.cgi?FirstName = Zara＆LastName = AliというURLが与えられているとします。

次のように直接CGI＃[]を使用して、パラメータ_FirstName_および_LastName_にアクセスできます- 

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
cgi['FirstName'] # =>  ["Zara"]
cgi['LastName']  # =>  ["Ali"]

これらのフォーム変数にアクセスする別の方法があります。 このコードは、すべてのキーと値のハッシュを提供します- 

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
h = cgi.params  # =>  {"FirstName"=>["Zara"],"LastName"=>["Ali"]}
h['FirstName']  # =>  ["Zara"]
h['LastName']   # =>  ["Ali"]

以下は、すべてのキーを取得するコードです- 

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
cgi.keys         # =>  ["FirstName", "LastName"]

フォームに同じ名前の複数のフィールドが含まれる場合、対応する値が配列としてスクリプトに返されます。 []アクセサーは、これらのすべてを取得するために、paramsメソッドの結果であるthese.indexの最初の1つだけを返します。

この例では、フォームに「name」という3つのフィールドがあり、「Zara」、「Huma」、「Nuha」という3つの名前を入力したとします- 

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
cgi['name']        # => "Zara"
cgi.params['name'] # => ["Zara", "Huma", "Nuha"]
cgi.keys           # => ["name"]
cgi.params         # => {"name"=>["Zara", "Huma", "Nuha"]}

注意-RubyはGETおよびPOSTメソッドを自動的に処理します。 これら2つの異なる方法に個別の処理はありません。

正しいデータを送信できる、関連付けられているが基本的なフォームには、次のようなHTMLコードがあります- 

<html>
   <body>
      <form method = "POST" action = "http://www.example.com/test.cgi">
         First Name :<input type = "text" name = "FirstName" value = ""/>
         <br/>
         Last Name :<input type = "text" name = "LastName" value = ""/>
         <input type = "submit" value = "Submit Data"/>
      </form>
   </body>
</html>

フォームとHTMLの作成

CGIには、HTMLの作成に使用される膨大な数のメソッドが含まれています。 タグごとに1つのメソッドがあります。 これらのメソッドを有効にするには、CGI.newを呼び出してCGIオブジェクトを作成する必要があります。

タグのネストを簡単にするために、これらのメソッドはコンテンツをコードブロックとして取得します。 コードブロックは、タグのコンテンツとして使用される_String_を返す必要があります。 たとえば- 

#!/usr/bin/ruby

require "cgi"
cgi = CGI.new("html4")
cgi.out {
   cgil {
      cgi.head { "\n"&plus;cgi.title{"This Is a Test"} } &plus;
      cgi.body { "\n"&plus;
         cgi.form {"\n"&plus;
            cgi.hr &plus;
            cgi.h1 { "A Form: " } &plus; "\n"&plus;
            cgi.textarea("get_text") &plus;"\n"+
            cgi.br +
            cgi.submit
         }
      }
   }
}

注-CGIクラスの_form_メソッドは、フォーム送信で使用されるHTTPメソッド（GET、POSTなど）を設定するメソッドパラメーターを受け入れることができます。 この例で使用されるデフォルトはPOSTです。

これは、次の結果を生成します- 

Content-Type: text/html
Content-Length: 302

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Final//EN">

<HTML>
   <HEAD>
      <TITLE>This Is a Test</TITLE>
   </HEAD>
   <BODY>
      <FORM METHOD = "post" ENCTYPE = "application/x-www-form-urlencoded">
         <HR>
         <H1>A Form: </H1>
         <TEXTAREA COLS = "70" NAME = "get_text" ROWS = "10"></TEXTAREA>
         <BR>
         <INPUT TYPE = "submit">
      </FORM>
   </BODY>
</HTML>

文字列の引用

URLとHTMLコードを扱うときは、特定の文字を引用符で囲むように注意する必要があります。 たとえば、スラッシュ文字（/）はURLで特別な意味を持つため、パス名の一部でない場合は*エスケープする必要があります。

たとえば、URLのクエリ部分の/は文字列％2Fに変換され、使用するには/に変換して戻す必要があります。 スペースとアンパサンドも特殊文字です。 これを処理するために、CGIはルーチン CGI.escape および CGI.unescape を提供します。 

#!/usr/bin/ruby

require 'cgi'
puts CGI.escape(Zara Ali/A Sweet & Sour Girl")

これは、次の結果を生成します- 

Zara+Ali%2FA Sweet+%26+Sour+Girl")
#!/usr/bin/ruby

require 'cgi'
puts CGI.escapeHTML('<h1>Zara Ali/A Sweet & Sour Girl</h1>')

これは、次の結果を生成します- 

&lt;h1&gt;Zara Ali/A Sweet & Sour Girl&lt;/h1&gt;'

CGIクラスの便利なメソッド

ここにCGIクラスに関連するメソッドのリストがあります-

  • リンク：/ruby​​/ruby​​_cgi_methods [Ruby CGI]-標準CGIライブラリに関連するメソッド。

クッキーとセッション

これら2つの概念については、異なるセクションで説明しました。 セクションに従ってください-

  • リンク：/ruby​​/ruby​​_cgi_cookies [Ruby CGI Cookies]-CGI Cookieの処理方法。
  • リンク：/ruby​​/ruby​​_cgi_sessions [Ruby CGI Sessions]-CGIセッションを管理する方法。

ウェブホスティングサーバー

あなたは、Unixベースのサーバー上であなたのウェブサイトをホストするためにインターネット上の次のトピックをチェックすることができます-

Rubyを使用した電子メールの送信-SMTP

SMTP（Simple Mail Transfer Protocol）は、メールサーバー間の電子メールの送信と電子メールのルーティングを処理するプロトコルです。

Rubyは、SMTP（Simple Mail Transfer Protocol）クライアント側接続用のNet
SMTPクラスを提供し、2つのクラスメソッド_new_および_start_を提供します。
  • *新しい*は2つのパラメータを取ります-
  • _server name_のデフォルトはlocalhostです。
  • _ポート番号_のデフォルトは、既知のポート25です。
  • *開始*メソッドはこれらのパラメータを取ります-
  • server-SMTPサーバーのIP名。デフォルトはlocalhostです。
  • port-ポート番号、デフォルトは25。
  • domain-メール送信者のドメイン。デフォルトはENV ["HOSTNAME"]です。
  • account-ユーザー名、デフォルトはnilです。
  • password-ユーザーパスワード、デフォルトはnil。
  • authtype-許可タイプ、デフォルトは_cram_md5_。

SMTPオブジェクトには、sendmailと呼ばれるインスタンスメソッドがあります。これは通常、メッセージのメール送信作業を行うために使用されます。 それは3つのパラメータを取ります-

  • source-文字列または配列、または一度に1つの文字列を返す_each_イテレータを持つもの。
  • sender-電子メールの_from_フィールドに表示される文字列。
  • recipients-受信者のアドレスを表す文字列または文字列の配列。

例

Rubyスクリプトを使用して1つのメールを送信する簡単な方法を次に示します。 一度試してください- 

require 'net/smtp'

message = <<MESSAGE_END
From: Private Person <me&commat;fromdomain.com>
To: A Test User <test&commat;todomain.com>
Subject: SMTP e-mail test

This is a test e-mail message.
MESSAGE_END

Net::SMTP.start('localhost') do |smtp|
  smtp.send_message message, 'me&commat;fromdomain.com', 'test&commat;todomain.com'
end

ここでは、ドキュメントを使用して、ヘッダーを正しくフォーマットするように注意しながら、基本的な電子メールをメッセージに配置しました。 電子メールには、 From 、 To 、および Subject ヘッダーが必要です。これらのヘッダーは、電子メールの本文から空白行で区切られています。

メールを送信するには、Net
SMTPを使用してローカルマシン上のSMTPサーバーに接続し、send_messageメソッドをメッセージ、送信元アドレス、および宛先アドレスとともにパラメーターとして使用します（送信元アドレスと送信先アドレスは電子メール自体の中では、これらは常にメールのルーティングに使用されるわけではありません）。
マシンでSMTPサーバーを実行していない場合は、Net
SMTPを使用してリモートSMTPサーバーと通信できます。 Webメールサービス（HotmailやYahoo!など）を使用していない場合 メール）、あなたの電子メールプロバイダーは、次のようにNet :: SMTPに提供できる送信メールサーバーの詳細を提供します-
Net::SMTP.start('mail.your-domain.com')

このコード行は、ユーザー名やパスワードを使用せずにmail.your-domain.comのポート25でSMTPサーバーに接続します。 ただし、必要な場合は、ポート番号などの詳細を指定できます。 たとえば- 

Net::SMTP.start('mail.your-domain.com',
                25,
                'localhost',
                'username', 'password' :plain)

この例では、プレーンテキスト形式のユーザー名とパスワードを使用して、mail.your-domain.comのSMTPサーバーに接続します。 クライアントのホスト名をローカルホストとして識別します。

Rubyを使用してHTML電子メールを送信する

Rubyを使用してテキストメッセージを送信すると、すべてのコンテンツが単純なテキストとして扱われます。 テキストメッセージにHTMLタグを含める場合でも、単純なテキストとして表示され、HTMLタグはHTML構文に従ってフォーマットされません。 ただし、Ruby Net
SMTPは、HTMLメッセージを実際のHTMLメッセージとして送信するオプションを提供します。

電子メールメッセージを送信するときに、MIMEバージョン、コンテンツタイプ、および文字セットを指定して、HTML電子メールを送信できます。

例

以下は、HTMLコンテンツを電子メールとして送信する例です。 一度試してください- 

require 'net/smtp'

message = <<MESSAGE_END
From: Private Person <me&commat;fromdomain.com>
To: A Test User <test&commat;todomain.com>
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP e-mail test

This is an e-mail message to be sent in HTML format

<b>This is HTML message.</b>
<h1>This is headline.</h1>
MESSAGE_END

Net::SMTP.start('localhost') do |smtp|
   smtp.send_message message, 'me&commat;fromdomain.com', 'test&commat;todomain.com'
end

添付ファイルを電子メールとして送信する

混合コンテンツを含むメールを送信するには、 Content-type ヘッダーを multipart/mixed に設定する必要があります。 次に、 boundaries 内でテキストと添付セクションを指定できます。

境界は、2つのハイフンで始まり、その後に一意の番号が続きます。この番号は、電子メールのメッセージ部分には表示できません。 電子メールの最終セクションを示す最終境界も、2つのハイフンで終わる必要があります。

添付ファイルは、* pack（ "m"）*関数でエンコードしてから、送信前にbase64エンコードする必要があります。

例

以下は、ファイル /tmp/test.txt を添付ファイルとして送信する例です。 

require 'net/smtp'

filename = "/tmp/test.txt"
# Read a file and encode it into base64 format
filecontent = File.read(filename)
encodedcontent = [filecontent].pack("m")   # base64

marker = "AUNIQUEMARKER"
body = <<EOF
This is a test email to send an attachement.
EOF

# Define the main headers.
part1 = <<EOF
From: Private Person <me&commat;fromdomain.net>
To: A Test User <test&commat;todmain.com>
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary = #{marker}
--#{marker}
EOF

# Define the message action
part2 = <<EOF
Content-Type: text/plain
Content-Transfer-Encoding:8bit

#{body}
--#{marker}
EOF

# Define the attachment section
part3 = <<EOF
Content-Type: multipart/mixed; name = \"#{filename}\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename = "#{filename}"

#{encodedcontent}
--#{marker}--
EOF

mailtext = part1 &plus; part2 &plus; part3

# Let's put our code in safe area
begin
   Net::SMTP.start('localhost') do |smtp|
      smtp.sendmail(mailtext, 'me&commat;fromdomain.net', ['test&commat;todmain.com'])
   end
rescue Exception => e
   print "Exception occured: " &plus; e
end

注-配列内で複数の宛先を指定できますが、コンマで区切る必要があります。

Ruby-ソケットプログラミング

Rubyは、ネットワークサービスへの2つのレベルのアクセスを提供します。 低レベルでは、基盤となるオペレーティングシステムの基本的なソケットサポートにアクセスできます。これにより、接続指向プロトコルとコネクションレスプロトコルの両方のクライアントとサーバーを実装できます。

Rubyには、FTP、HTTPなど、特定のアプリケーションレベルのネットワークプロトコルへの高レベルのアクセスを提供するライブラリもあります。

この章では、ネットワーク-ソケットプログラミングの最も有名な概念を理解します。

ソケットとは何ですか？

ソケットは、双方向通信チャネルのエンドポイントです。 ソケットは、プロセス内、同じマシン上のプロセス間、または異なる大陸のプロセス間で通信できます。

ソケットは、Unixドメインソケット、TCP、UDPなど、さまざまなチャネルタイプで実装できます。 _socket_は、一般的なトランスポートを処理するための特定のクラスと、残りを処理するための汎用インターフェイスを提供します。

ソケットには独自の語彙があります-

Sr.No. Term & Description
1

domain

トランスポートメカニズムとして使用されるプロトコルファミリ。 これらの値は、PF_INET、PF_UNIX、PF_X25などの定数です。

2

type

2つのエンドポイント間の通信のタイプ。通常、接続指向プロトコルの場合はSOCK_STREAM、コネクションレスプロトコルの場合はSOCK_DGRAM。

3

protocol

通常、これはドメインおよびタイプ内のプロトコルのバリアントを識別するために使用できます。

4

hostname

ネットワークインターフェイスの識別子-

文字列。ホスト名、ドット区切りのアドレス、またはコロン（および場合によってはドット）表記のIPV6アドレスを指定できます

INADDR_BROADCASTアドレスを指定する文字列「<broadcast>」。

INADDR_ANYを指定する長さゼロの文字列、または

ホストバイト順のバイナリアドレスとして解釈される整数。

5

port

各サーバーは、1つ以上のポートで呼び出しているクライアントをリッスンします。 ポートは、Fixnumポート番号、ポート番号を含む文字列、またはサービスの名前です。

シンプルなクライアント

ここでは、特定のポートとホストへの接続を開く非常に単純なクライアントプログラムを作成します。 Rubyクラス TCPSocket は、そのようなソケットを開く_open_関数を提供します。

  • TCPSocket.open（hosname、port）*は、_port_上の_hostname_へのTCP接続を開きます。

ソケットを開いたら、IOオブジェクトのようにソケットから読み取ることができます。 完了したら、ファイルを閉じるのと同じように忘れずに閉じてください。

次のコードは、特定のホストとポートに接続し、ソケットから利用可能なデータを読み取り、終了する非常に単純なクライアントです- 

require 'socket'        # Sockets are in standard library

hostname = 'localhost'
port = 2000

s = TCPSocket.open(hostname, port)

while line = s.gets     # Read lines from the socket
   puts line.chop       # And print with platform line terminator
end
s.close                 # Close the socket when done

シンプルなサーバー

インターネットサーバーを作成するには、 TCPServer クラスを使用します。 TCPServerオブジェクトは、TCPSocketオブジェクトのファクトリです。 

*TCPServer.open（hostname、port* 関数を呼び出して、サービスの_port_を指定し、 *TCPServer* オブジェクトを作成します。

次に、返されたTCPServerオブジェクトの_accept_メソッドを呼び出します。 このメソッドは、クライアントが指定したポートに接続するまで待機し、そのクライアントへの接続を表す_TCPSocket_オブジェクトを返します。 

require 'socket'                 # Get sockets from stdlib

server = TCPServer.open(2000)    # Socket to listen on port 2000
loop {                           # Servers run forever
   client = server.accept        # Wait for a client to connect
   client.puts(Time.now.ctime)   # Send the time to the client
   client.puts "Closing the connection. Bye!"
   client.close                  # Disconnect from the client
}

次に、このサーバーをバックグラウンドで実行してから、上記のクライアントを実行して結果を確認します。

マルチクライアントTCPサーバー

インターネット上のほとんどのサーバーは、一度に多数のクライアントを処理するように設計されています。

Rubyの_Thread_クラスは、メインプログラムがより多くの接続を待つことを許可しながら、要求を受け入れ、すぐに接続を処理するための新しい実行スレッドを作成するマルチスレッドサーバーを簡単に作成できます- 

require 'socket'                 # Get sockets from stdlib

server = TCPServer.open(2000)    # Socket to listen on port 2000
loop {                           # Servers run forever
   Thread.start(server.accept) do |client|
   client.puts(Time.now.ctime)   # Send the time to the client
   client.puts "Closing the connection. Bye!"
   client.close                  # Disconnect from the client
   end
}

この例では、永続的なループがあり、server.acceptが応答すると、新しいスレッドが作成され、すぐに開始されて、スレッドに渡された接続オブジェクトを使用して、受け入れられた接続を処理します。 ただし、メインプログラムはすぐにループバックし、新しい接続を待機します。

この方法でRubyスレッドを使用するということは、コードが移植可能であり、Linux、OS X、およびWindows上で同じ方法で実行されることを意味します。

小さなWebブラウザー

ソケットライブラリを使用して、任意のインターネットプロトコルを実装できます。 ここに、例えば、ウェブページのコンテンツを取得するコードがあります- 

require 'socket'

host = 'www.finddevguides.com'     # The web server
port = 80                           # Default HTTP port
path = "/index"                 # The file we want

# This is the HTTP request we send to fetch a file
request = "GET #{path} HTTP/1.0\r\n\r\n"

socket = TCPSocket.open(host,port)  # Connect to server
socket.print(request)               # Send request
response = socket.read              # Read complete response
# Split response at first blank line into headers and body
headers,body = response.split("\r\n\r\n", 2)
print body                          # And display it
同様のWebクライアントを実装するには、 *Net
HTTP* などのビルド済みライブラリを使用してHTTPを操作できます。 これは、前のコードと同等のコードです-
require 'net/http'                  # The library we need
host = 'www.finddevguides.com'     # The web server
path = '/index'                 # The file we want

http = Net::HTTP.new(host)          # Create a connection
headers, body = http.get(path)      # Request the file
if headers.code == "200"            # Check the status code
   print body
else
   puts "#{headers.code} #{headers.message}"
end

FTP、SMTP、POP、およびIMAPプロトコルで動作する同様のライブラリを確認してください。

さらに読む

ソケットプログラミングのクイックスタートを提供しました。 これは大きなテーマであるため、詳細については、https://www.ruby-doc.org/stdlib/libdoc/socket/rdoc/indexl [Rubyソケットライブラリとクラスメソッド]を参照することをお勧めします。

Ruby-XML、XSLT、XPathチュートリアル

XMLとは何ですか？

拡張マークアップ言語（XML）は、HTMLやSGMLによく似たマークアップ言語です。 これは、World Wide Web Consortiumによって推奨されており、オープンスタンダードとして利用できます。

XMLは、オペレーティングシステムや開発言語に関係なく、プログラマが他のアプリケーションで読み取れるアプリケーションを開発できる、移植可能なオープンソース言語です。

XMLは、SQLベースのバックボーンを必要とせずに、少量から中量のデータを追跡するのに非常に役立ちます。

XMLパーサーのアーキテクチャとAPI

XMLパーサーには2つの異なるフレーバーがあります-

  • * SAXライク（ストリームインターフェイス）*-ここで、目的のイベントのコールバックを登録し、パーサーにドキュメントを処理させます。 これは、ドキュメントが大きい場合やメモリに制限がある場合に便利です。ファイルをディスクから読み取るときに解析し、ファイル全体がメモリに保存されることはありません。
  • * DOMに似た（オブジェクトツリーインターフェイス）*-これはWorld Wide Web Consortiumの推奨事項で、ファイル全体がメモリに読み込まれ、XMLドキュメントのすべての機能を表す階層（ツリーベース）形式で保存されます。

SAXは明らかに、大きなファイルを操作する場合、DOMほど速く情報を処理できません。 一方、DOMを排他的に使用すると、特に多くの小さなファイルで使用する場合、リソースを本当に殺す可能性があります。

SAXは読み取り専用ですが、DOMはXMLファイルの変更を許可します。 これら2つの異なるAPIは文字通り互いに補完するため、大規模なプロジェクトで両方を使用できない理由はありません。

Rubyを使用したXMLの解析と作成

XMLを操作する最も一般的な方法は、Sean RussellによるREXMLライブラリを使用することです。 2002年以来、REXMLは標準のRubyディストリビューションの一部となっています。

REXMLは、XML 1.0標準に準拠した純粋なRuby XMLプロセッサです。 これは_non-validating_プロセッサーであり、OASISのすべての非検証適合性テストに合格しています。

REXMLパーサーには、他の利用可能なパーサーよりも次の利点があります-

  • Rubyで100％記述されています。
  • SAXとDOMの両方の解析に使用できます。
  • 軽量で、2000行未満のコードです。
  • メソッドとクラスは本当に理解しやすいです。
  • SAX2ベースのAPIおよび完全なXPathサポート。
  • Rubyインストールで出荷され、個別のインストールは必要ありません。

私たちのすべてのXMLコードの例では、単純なXMLファイルを入力として使用しましょう- 

<collection shelf = "New Arrivals">
   <movie title = "Enemy Behind">
      <type>War, Thriller</type>
      <format>DVD</format>
      <year>2003</year>
      <rating>PG</rating>
      <stars>10</stars>
      <description>Talk about a US-Japan war</description>
   </movie>
   <movie title = "Transformers">
      <type>Anime, Science Fiction</type>
      <format>DVD</format>
      <year>1989</year>
      <rating>R</rating>
      <stars>8</stars>
      <description>A schientific fiction</description>
   </movie>
   <movie title = "Trigun">
      <type>Anime, Action</type>
      <format>DVD</format>
      <episodes>4</episodes>
      <rating>PG</rating>
      <stars>10</stars>
      <description>Vash the Stampede!</description>
   </movie>
   <movie title = "Ishtar">
      <type>Comedy</type>
      <format>VHS</format>
      <rating>PG</rating>
      <stars>2</stars>
      <description>Viewable boredom</description>
   </movie>
</collection>

DOMのような解析

最初に_tree fashion_でXMLデータを解析しましょう。 まず、 rexml/document ライブラリーを要求することから始めます。便宜上、REXMLをインクルードしてトップレベルのネームスペースにインポートすることがよくあります。 

#!/usr/bin/ruby -w

require 'rexml/document'
include REXML

xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)

# Now get the root element
root = xmldoc.root
puts "Root element : " + root.attributes["shelf"]

# This will output all the movie titles.
xmldoc.elements.each("collection/movie"){
   |e| puts "Movie Title : " + e.attributes["title"]
}

# This will output all the movie types.
xmldoc.elements.each("collection/movie/type") {
   |e| puts "Movie Type : " + e.text
}

# This will output all the movie description.
xmldoc.elements.each("collection/movie/description") {
   |e| puts "Movie Description : " + e.text
}

これは、次の結果を生成します- 

Root element : New Arrivals
Movie Title : Enemy Behind
Movie Title : Transformers
Movie Title : Trigun
Movie Title : Ishtar
Movie Type : War, Thriller
Movie Type : Anime, Science Fiction
Movie Type : Anime, Action
Movie Type : Comedy
Movie Description : Talk about a US-Japan war
Movie Description : A schientific fiction
Movie Description : Vash the Stampede!
Movie Description : Viewable boredom

SAXのような解析

同じデータ_movies.xml_を_stream指向の方法で処理するには、パーサーからの_callbacks_のターゲットとなるメソッドを持つ_listener_クラスを定義します。

注-小さなファイルにSAXのような構文解析を使用することは推奨されません。これは単なるデモの例です。 

#!/usr/bin/ruby -w

require 'rexml/document'
require 'rexml/streamlistener'
include REXML

class MyListener
   include REXML::StreamListener
   def tag_start(*args)
      puts "tag_start: #{args.map {|x| x.inspect}.join(', ')}"
   end

   def text(data)
      return if data =~/^\w*$/    # whitespace only
      abbrev = data[0..40] + (data.length > 40 ? "..." : "")
      puts "  text   :   #{abbrev.inspect}"
   end
end

list = MyListener.new
xmlfile = File.new("movies.xml")
Document.parse_stream(xmlfile, list)

これは、次の結果を生成します- 

tag_start: "collection", {"shelf"=>"New Arrivals"}
tag_start: "movie", {"title"=>"Enemy Behind"}
tag_start: "type", {}
   text   :   "War, Thriller"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Talk about a US-Japan war"
tag_start: "movie", {"title"=>"Transformers"}
tag_start: "type", {}
   text   :   "Anime, Science Fiction"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "A schientific fiction"
tag_start: "movie", {"title"=>"Trigun"}
tag_start: "type", {}
   text   :   "Anime, Action"
tag_start: "format", {}
tag_start: "episodes", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Vash the Stampede!"
tag_start: "movie", {"title"=>"Ishtar"}
tag_start: "type", {}
tag_start: "format", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Viewable boredom"

XPathとRuby

XMLを表示する別の方法はXPathです。 これは、XMLドキュメント内の特定の要素と属性を見つける方法を記述する一種の疑似言語であり、そのドキュメントを論理的な順序付けられたツリーとして扱います。

REXMLには、_XPath_クラスを介したXPathサポートがあります。 上記で見たように、ツリーベースの解析（ドキュメントオブジェクトモデル）を想定しています。 

#!/usr/bin/ruby -w

require 'rexml/document'
include REXML

xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)

# Info for the first movie found
movie = XPath.first(xmldoc, "//movie")
p movie

# Print out all the movie types
XPath.each(xmldoc, "//type") { |e| puts e.text }

# Get an array of all of the movie formats.
names = XPath.match(xmldoc, "//format").map {|x| x.text }
p names

これは、次の結果を生成します- 

<movie title = 'Enemy Behind'> ... </>
War, Thriller
Anime, Science Fiction
Anime, Action
Comedy
["DVD", "DVD", "DVD", "VHS"]

XSLTとRuby

Rubyで使用できるXSLTパーサーは2つあります。 それぞれの簡単な説明をここに示します。

ルビー・サブロトロン

このパーサーは、高橋正義によって作成および管理されています。 これは主にLinux OS用に書かれており、次のライブラリが必要です-

  • サブロット
  • アイコン
  • 海外駐在者

このモジュールは、 Ruby-Sablotron にあります。

XSLT4R

XSLT4RはMichael Neumannによって作成され、XMLの下のLibraryセクションのRAAにあります。 XSLT4Rはシンプルなコマンドラインインターフェイスを使用しますが、サードパーティのアプリケーション内で使用してXMLドキュメントを変換することもできます。

XSLT4Rを操作するにはXMLScanが必要です。これはXSLT4Rアーカイブに含まれており、100％Rubyモジュールでもあります。 これらのモジュールは、標準のRubyインストール方法（つまり、ruby install.rb）を使用してインストールできます。

XSLT4Rには次の構文があります- 

ruby xslt.rb stylesheet.xsl document.xml [arguments]

アプリケーション内からXSLT4Rを使用する場合は、XSLTを含めて必要なパラメーターを入力できます。 ここに例があります- 

require "xslt"

stylesheet = File.readlines("stylesheet.xsl").to_s
xml_doc = File.readlines("document.xml").to_s
arguments = { 'image_dir' => '/....' }
sheet = XSLT::Stylesheet.new( stylesheet, arguments )

# output to StdOut
sheet.apply( xml_doc )

# output to 'str'
str = ""
sheet.output = [ str ]
sheet.apply( xml_doc )

参考文献

  • REXMLパーサーの詳細については、https://www.germane-software.com/software/rexml/[REXMLパーサードキュメント]の標準ドキュメントを参照してください。
  • XSLT4Rはhttp://raa.ruby-lang.org/project/xslt4r/[RAA Repository]からダウンロードできます。

Rubyを使用したWebサービス-SOAP4R

SOAPとは何ですか？

Simple Object Access Protocol（SOAP）は、XMLおよび通常（必ずしもではないが）HTTPに基づくクロスプラットフォームで言語に依存しないRPCプロトコルです。

XMLを使用してリモートプロシージャコールを行う情報をエンコードし、HTTPを使用してその情報をネットワークを介してクライアントからサーバーに、またはその逆に転送します。

SOAPには、COMやCORBAなどの他のテクノロジーに比べていくつかの利点があります。たとえば、比較的安価な展開とデバッグのコスト、拡張性と使いやすさ、さまざまな言語とプラットフォームの実装の存在などです。

詳細については、簡単なチュートリアルリンク：/soap/index [SOAP]を参照してください。

この章では、RubyのSOAP実装（SOAP4R）に精通しています。 これは基本的なチュートリアルであるため、詳細が必要な場合は、他のリソースを参照する必要があります。

SOAP4Rのインストール

SOAP4Rは、中村浩によって開発されたRubyのSOAP実装であり、以下からダウンロードできます-

注-このコンポーネントが既にインストールされている可能性があります。 

Download SOAP
*gem* ユーティリティを知っている場合は、次のコマンドを使用してSOAP4Rおよび関連パッケージをインストールできます。
$ gem install soap4r --include-dependencies

Windowsで作業している場合は、上記の場所からzipファイルをダウンロードし、_ruby install.rb_を実行して標準のインストール方法を使用してインストールする必要があります。

SOAP4Rサーバーの作成

SOAP4Rは2種類のサーバーをサポートしています-

  • CGI/FastCGIベース（SOAP :: RPC :: CGIStub）
  • スタンドアロン（SOAP :: RPC：StandaloneServer）

この章では、スタンドアロンサーバーの記述について詳しく説明します。 以下のステップは、SOAPサーバーの作成に関係しています。

ステップ1-SOAP :: RPC :: StandaloneServerクラスを継承する

独自のスタンドアロンサーバーを実装するには、次のように_SOAP
StandaloneServer_の子になる新しいクラスを作成する必要があります-
class MyServer < SOAP::RPC::StandaloneServer
  ...............
end
注-FastCGIベースのサーバーを作成する場合は、_SOAP
RPC :: CGIStub_を親クラスとして使用する必要があります。残りの手順は同じです。

ステップ2-ハンドラーメソッドの定義

2番目のステップは、Webサービスメソッドを作成することです。これを外部に公開したいです。

これらは、単純なRubyメソッドとして作成できます。 たとえば、2つの数字を追加し、2つの数字を分割する2つの方法を書きましょう- 

class MyServer < SOAP::RPC::StandaloneServer
   ...............

   # Handler methods
   def add(a, b)
      return a &plus; b
   end
   def div(a, b)
      return a/b
   end
end

ステップ3-ハンドラーメソッドの公開

次のステップは、定義済みのメソッドをサーバーに追加することです。 _initialize_メソッドは、次の2つのメソッドのいずれかでサービスメソッドを公開するために使用されます- 

class MyServer < SOAP::RPC::StandaloneServer
   def initialize(*args)
      add_method(receiver, methodName, *paramArg)
   end
end

ここにパラメータの説明があります-

Sr.No. Parameter & Description
1

receiver

methodNameメソッドを含むオブジェクト。 methodDefメソッドと同じクラスでサービスメソッドを定義します。このパラメーターは_self_です。

2

methodName

RPC要求のために呼び出されるメソッドの名前。

3

paramArg

与えられた場合、パラメーター名とパラメーターモードを指定します。

inout_または_out_パラメーターの使用方法を理解するには、2つのパラメーター（inParamおよびinoutParam）を取り、1つの通常の戻り値（retVal）と2つの追加パラメーターを返す次のサービスメソッドを検討してください：_inoutParam_および_outParam- 

def aMeth(inParam, inoutParam)
   retVal = inParam &plus; inoutParam
   outParam = inParam . inoutParam
   inoutParam = inParam * inoutParam
   return retVal, inoutParam, outParam
end

今、私たちは次のようにこのメソッドを公開することができます- 

add_method(self, 'aMeth', [
   %w(in inParam),
   %w(inout inoutParam),
   %w(out outParam),
   %w(retval return)
])

手順4-サーバーの起動

最後のステップは、派生クラスのインスタンスを1つインスタンス化し、 start メソッドを呼び出してサーバーを起動することです。 

myServer = MyServer.new('ServerName', 'urn:ruby:ServiceName', hostname, port)

myServer.start

ここに必要なパラメータの説明があります-

Sr.No. Parameter & Description
1

ServerName

サーバー名、最も好きなものを与えることができます。

2

urn:ruby:ServiceName

ここで、_urn：ruby_は定数ですが、このサーバーに一意のServiceName名を付けることができます。

3

hostname

このサーバーがリッスンするホスト名を指定します。

4

port

Webサービスに使用される使用可能なポート番号。

例

さて、上記の手順を使用して、1つのスタンドアロンサーバーを記述しましょう- 

require "soap/rpc/standaloneserver"

begin
   class MyServer < SOAP::RPC::StandaloneServer

      # Expose our services
      def initialize(*args)
         add_method(self, 'add', 'a', 'b')
         add_method(self, 'div', 'a', 'b')
      end

      # Handler methods
      def add(a, b)
         return a &plus; b
      end
      def div(a, b)
         return a/b
      end
end
   server = MyServer.new("MyServer",
            'urn:ruby:calculation', 'localhost', 8080)
   trap('INT){
      server.shutdown
   }
   server.start
rescue => err
   puts err.message
end

実行されると、このサーバーアプリケーションは_localhost_でスタンドアロンSOAPサーバーを起動し、port 8080でリクエストをリッスンします。 _add_と_div_という1つのサービスメソッドを公開します。これらのメソッドは2つのパラメーターを取り、結果を返します。

今、次のようにバックグラウンドでこのサーバーを実行することができます- 

$ ruby MyServer.rb&

SOAP4Rクライアントの作成

_SOAP
RPC :: Driver_クラスは、SOAPクライアントアプリケーションの作成をサポートします。 この章では、このクラスについて説明し、アプリケーションに基づいてその使用方法を示します。

以下は、SOAPサービスを呼び出すために必要な最低限の情報です-

  • SOAPサービスのURL（SOAPエンドポイントURL）。
  • サービスメソッドの名前空間（メソッド名前空間URI）。 *サービスメソッドとそのパラメーターの名前。

次に、上記の例で定義された_add_および_div_という名前のサービスメソッドを呼び出すSOAPクライアントを作成します。

SOAPクライアントを作成する主な手順は次のとおりです。

手順1-SOAPドライバーインスタンスの作成

次のように新しいメソッドを呼び出して、_SOAP
RPC :: Driver_のインスタンスを作成します-
SOAP::RPC::Driver.new(endPoint, nameSpace, soapAction)

ここに必要なパラメータの説明があります-

Sr.No. Parameter & Description
1
  • endPoint*

接続するSOAPサーバーのURL。

2

nameSpace

このSOAP
RPC :: Driverオブジェクトで行われるすべてのRPCに使用する名前空間。
3

soapAction

HTTPヘッダーのSOAPActionフィールドの値。 nilの場合、これはデフォルトで空の文字列 ""になります。

ステップ2-サービスメソッドの追加

SOAPサービスメソッドを_SOAP
RPC :: Driver_に追加するには、_SOAP :: RPC :: Driver_インスタンスを使用して次のメソッドを呼び出します-
driver.add_method(name, *paramArg)

ここにパラメータの説明があります-

Sr.No. Parameter & Description
1

name

リモートWebサービスメソッドの名前。

2

paramArg

リモートプロシージャのパラメータの名前を指定します。

ステップ3-SOAPサービスを呼び出す

最後の手順は、次のように_SOAP
RPC :: Driver_インスタンスを使用してSOAPサービスに請求することです-
result = driver.serviceMethod(paramArg...)

ここで、_serviceMethod_は実際のWebサービスメソッドであり、_paramArg …​_はサービスメソッドを渡すために必要なリストパラメーターです。

例

上記の手順に基づいて、次のようにSOAPクライアントを作成します- 

#!/usr/bin/ruby -w

require 'soap/rpc/driver'

NAMESPACE = 'urn:ruby:calculation'
URL = 'http://localhost:8080/'

begin
   driver = SOAP::RPC::Driver.new(URL, NAMESPACE)

   # Add remote sevice methods
   driver.add_method('add', 'a', 'b')

   # Call remote service methods
   puts driver.add(20, 30)
rescue => err
   puts err.message
end

さらに読む

Rubyを使用したWebサービスの非常に基本的な概念だけを説明しました。 さらにドリルダウンする場合は、https://www.ruby-doc.org/stdlib/libdoc/soap/rdoc/indexl [Rubyを使用したWebサービス]で詳細を確認できる次のリンクがあります。

Ruby-Tkガイド

前書き

Rubyの標準的なグラフィカルユーザーインターフェイス（GUI）はTkです。 Tkは、John Ousterhoutが開発したTclスクリプト言語のGUIとして始まりました。

Tkには、唯一のクロスプラットフォームGUIであるという独自の特徴があります。 TkはWindows、Mac、Linuxで動作し、各オペレーティングシステムでネイティブのルックアンドフィールを提供します。

Tkベースのアプリケーションの基本コンポーネントは、ウィジェットと呼ばれます。 Tkでは、「ウィンドウ」と「ウィジェット」はしばしば同じ意味で使用されるため、コンポーネントはウィンドウとも呼ばれます。

Tkアプリケーションは、任意の数のウィジェットが別のウィジェット内に配置され、それらのウィジェットが別のウィジェット内に無限に配置されるウィジェット階層に従います。 Tkプログラムのメインウィジェットはルートウィジェットと呼ばれ、TkRootクラスの新しいインスタンスを作成することで作成できます。

  • ほとんどのTkベースのアプリケーションは同じサイクルに従います。ウィジェットを作成し、インターフェイスに配置し、最後に各ウィジェットに関連付けられたイベントをメソッドにバインドします。
  • 3つのジオメトリマネージャーがあります。 place、grid、および_pack_は、インターフェイス内の各ウィジェットのサイズと場所を制御します。

インストール

Ruby TkバインディングはRubyとともに配布されますが、Tkは別個のインストールです。 Windowsユーザーは、http：//aspn.activestate.com/ASPN/Downloads/ActiveTcl/[ActiveState’s ActiveTcl]からシングルクリックTkインストールをダウンロードできます。

MacおよびLinuxユーザーは、OSと一緒に既にインストールされている可能性が高いため、インストールする必要はありませんが、インストールされていない場合は、ビルド済みパッケージをダウンロードするか、https://www.tcl.tk/software/からソースを取得できますtcltk/downloadnow84.tml [Tcl Developer Xchange]。

シンプルなTkアプリケーション

Ruby/Tkプログラムの典型的な構造は、メインまたは root ウィンドウ（TkRootのインスタンス）を作成し、それにウィジェットを追加してユーザーインターフェイスを構築し、 Tk.mainloop を呼び出してメインイベントループを開始することです。 。

Ruby/Tkの従来の_Hello、World！_の例は次のようになります- 

require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
   text 'Hello, World!'
   pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop

ここでは、tk拡張モジュールをロードした後、_TkRoot.new_を使用してルートレベルフレームを作成します。 次に、_TkLabel_ウィジェットをルートフレームの子として作成し、ラベルにいくつかのオプションを設定します。 最後に、ルートフレームをパックし、メインGUIイベントループに入ります。

このスクリプトを実行すると、次の結果が生成されます-

Ruby/Tk Hello World

Ruby/Tkウィジェットクラス

Ruby/Tkを使用して目的のGUIを作成するために使用できる、さまざまなRuby/Tkクラスのリストがあります。

  • link：/ruby​​/ruby​​_tk_frame [TkFrame]フレームウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_button [TkButton]ボタンウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_label [TkLabel]ラベルウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_entry [TkEntry]エントリウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_checkbutton [TkCheckButton]チェックボタンウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_radiobutton [TkRadioButton]ラジオボタンウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_listbox [TkListbox]リストボックスウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_combobox [TkComboBox]リストボックスウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_menu [TkMenu]メニューウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_menubutton [TkMenubutton]メニューボタンウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_messagebox [Tk.messageBox]メッセージダイアログを作成して操作します。
  • link：/ruby​​/ruby​​_tk_scrollbar [TkScrollbar]スクロールバーウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_canvas [TkCanvas]キャンバスウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_scale [TkScale]スケールウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_text [TkText]テキストウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_toplevel [TkToplevel]トップレベルのウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_spinbox [TkSpinbox]スピンボックスウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_progressbar [TkProgressBar]プログレスバーウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_dialogbox [Dialog Box]ダイアログボックスウィジェットを作成および操作します。
  • link：/ruby​​/ruby​​_tk_notebook [Tk :: Tile :: Notebook]ノートブックのメタファーを使用して、限られたスペースにいくつかのウィンドウを表示します。
  • link：/ruby​​/ruby​​_tk_paned [Tk :: Tile :: Paned]垂直または水平に積み重ねられた複数のサブウィンドウを表示します。
  • link：/ruby​​/ruby​​_tk_separator [Tk :: Tile :: Separator]水平または垂直の区切りバーを表示します。 *リンク：/ruby​​/ruby​​_tk_fonts_colors_images [Ruby/Tkフォント、色、画像] Ruby/Tkフォント、色、画像について

標準構成オプション

すべてのウィジェットには、多くの異なる構成オプションがあり、一般にそれらの表示方法や動作を制御します。 使用可能なオプションは、もちろんウィジェットクラスによって異なります。

以下は、すべてのRuby/Tkウィジェットに適用できるすべての標準構成オプションのリストです。

____他のウィジェット固有のオプションもあり、それらはウィジェットとともに説明されます。

Sr.No. Options & Description
1
  • activebackground *⇒ String

アクティブな要素を描画するときに使用する背景色を指定します。 マウスカーソルが要素上にある場合、要素はアクティブであり、マウスボタンを押すと何らかのアクションが発生します。 「赤」、「青」、「ピンク」、「黄色」などの色の名前を使用できます。

2
  • activeborderwidth *⇒ Integer

アクティブな要素の周囲に描画される3D境界線の幅を示す負でない値を指定します。

3
  • activeforeground *⇒ String

アクティブな要素を描画するときに使用する前景色を指定します。

4
  • anchor* ⇒ String

ウィジェット内の情報の方法を指定します（例： テキストまたはビットマップ）がウィジェットに表示されます。 値 n 、 ne 、 e 、 se 、 s 、 sw 、 w 、 nw 、または center のいずれかでなければなりません。 たとえば、 nw は、左上隅がウィジェットの左上隅になるように情報を表示することを意味します。

5
  • background or bg *⇒ String

ウィジェットを表示するときに使用する通常の背景色を指定します。

6
  • bitmap *⇒ Bitmap

ウィジェットに表示するビットマップを指定します。 ビットマップが表示される正確な方法は、アンカーやジャスティファイなどの他のオプションの影響を受ける場合があります。

7
  • borderwidth or bd *⇒ Integer

ウィジェットの外側を囲む3D境界線の幅を示す負でない値を指定します。

8
  • compound* ⇒ String

ウィジェットがテキストとビットマップ/画像を同時に表示するかどうか、また表示する場合は、ビットマップ/画像をテキストに対して相対的に配置する場所を指定します。 値 none 、 bottom 、 top 、 left 、 right 、または center のいずれかでなければなりません。

9
  • cursor *⇒ String

ウィジェットに使用されるマウスカーソルを指定します。 可能な値は、「watch」、「arrow」などです。

10
  • disabledforeground *⇒ String

無効な要素を描画するときに使用する前景色を指定します。

11
  • exportselection* ⇒ Boolean

ウィジェット内の選択もX選択にする必要があるかどうかを指定します。 値には、 true 、 false 、 0 、 1 、 yes 、または no のいずれかを指定できます。 選択がエクスポートされた場合、ウィジェットで選択すると現在のX選択が選択解除され、ウィジェットの外部で選択するとウィジェット選択が選択解除され、ウィジェットは選択があると選択取得要求に応答します。

12
  • font *⇒ String

ウィジェット内にテキストを描画するときに使用するフォントを指定します。

13
  • foreground or fg *⇒ String

ウィジェットを表示するときに使用する通常の前景色を指定します。

14
  • highlightbackground *⇒ String

ウィジェットに入力フォーカスがない場合に、走査ハイライト領域に表示する色を指定します。

15
  • highlightcolor *⇒ String

入力フォーカスがあるときにウィジェットの周囲に描画される走査ハイライト長方形に使用する色を指定します。

16
  • highlightthickness *⇒ Integer

入力フォーカスがあるときにウィジェットの外側を囲むハイライト長方形の幅を示す負でない値を指定します。

17
  • image *⇒ Image

ウィジェットに表示する画像を指定します。これは、画像作成で作成されている必要があります。 通常、画像オプションが指定されている場合は、ビットマップまたはテキスト値を指定してウィジェットに表示する他のオプションをオーバーライドします。画像オプションを空の文字列にリセットして、ビットマップまたはテキスト表示を再度有効にすることができます。

18
  • jump *⇒ String

スクロールバーやスケールなど、値を調整するためにドラッグできるスライダーを備えたウィジェットの場合、このオプションは値の変更について通知を行うタイミングを決定します。 オプションの値はブール値でなければなりません。 値がfalseの場合、スライダーをドラッグすると更新が継続的に行われます。 値がtrueの場合、マウスボタンを放してドラッグを終了するまで更新は遅延します。その時点で、単一の通知が行われます。

19
  • justify *⇒ String

ウィジェットに複数行のテキストが表示されている場合、このオプションは行が互いにどのように並ぶかを決定します。* left 、 *center 、または right のいずれかでなければなりません。 *左*は行の左端がすべて整列することを意味し、*中央*は行の中心が整列することを意味し、*右*は行の右端が整列することを意味します。

20

offset ⇒ String

タイルのオフセットを指定します（ tile オプションも参照）。 2つの異なる形式 offset x、y または offset side を使用できます。sideは n 、 ne 、 e 、 se 、 s 、 sw 、 w 、 nw 、または center 。

21
  • orient *⇒ String

スクロールバーなど、水平または垂直の向きでレイアウトできるウィジェットの場合、このオプションは使用する向きを指定します。* horizo​​ntal または *vertical のいずれか、またはこれらのいずれかの省略形でなければなりません。

22
  • padx *⇒ Integer

X方向のウィジェットに追加で要求するスペースの量を示す負でない値を指定します。

23
  • pady *⇒ Integer

Y方向のウィジェットに追加で要求するスペースの量を示す負でない値を指定します。

24
  • relief* ⇒ Integer

ウィジェットに必要な3D効果を指定します。 許容値は、 raised 、 sunken 、 flat 、 ridge 、および groove です。

25
  • repeatdelay *⇒ Integer

自動リピートを開始する前にボタンまたはキーを押し続ける必要があるミリ秒数を指定します。 たとえば、スクロールバーの上矢印と下矢印で使用されます。

26

  • repeatinterval* ⇒ Integer

    *repeatdelay* と組み合わせて使用​​します。自動リピートが開始されると、このオプションは自動リピート間のミリ秒数を決定します
27
  • selectbackground *⇒ String

選択したアイテムを表示するときに使用する背景色を指定します。

28
  • selectborderwidth *⇒ Integer

選択したアイテムの周囲に描画する3-D境界線の幅を示す負でない値を指定します。

29
  • selectforeground *⇒ String

選択したアイテムを表示するときに使用する前景色を指定します。

30
  • setgrid *⇒ Boolean

このウィジェットがトップレベルウィンドウのサイズ変更グリッドを制御するかどうかを決定するブール値を指定します。 このオプションは通常、ウィジェット内の情報が自然なサイズ（文字のサイズ）であり、ウィンドウの寸法がこれらの単位の整数であることが理にかなっているテキストウィジェットで使用されます。

31
  • takefocus *⇒ Integer

キーボードトラバーサルを介してウィンドウからウィンドウにフォーカスを移動するときに使用される情報を提供します（TabやShift-Tabなど）。 フォーカスをウィンドウに設定する前に、走査スクリプトは最初にウィンドウが表示可能かどうかを確認します（ウィンドウとそのすべての祖先がマップされます）。そうでない場合、ウィンドウはスキップされます。 値0は、キーボードトラバーサル中にこのウィンドウを完全にスキップすることを意味します。 1は、このウィンドウが常に入力フォーカスを受け取ることを意味します。

32
  • text* ⇒ String

ウィジェット内に表示される文字列を指定します。 文字列の表示方法は、特定のウィジェットによって異なり、 anchor や justify などの他のオプションによって決定される場合があります。

33

textvariable ⇒ Variable

変数の名前を指定します。 変数の値は、ウィジェット内に表示されるテキスト文字列です。変数値が変更されると、ウィジェットは自動的に更新されて新しい値を反映します。 文字列がウィジェットに表示される方法は、特定のウィジェットによって異なり、 anchor や justify などの他のオプションによって決定される場合があります。

34
  • tile *⇒ Image

ウィジェットの表示に使用される画像を指定します。 画像が空の文字列の場合、通常の背景色が表示されます。

35
  • troughcolor *⇒ String

スクロールバーやスケールなどのウィジェットの長方形のトラフ領域に使用する色を指定します。

36
  • troughtile *⇒ Image

スクロールバーやスケールなどのウィジェットの長方形のトラフ領域に表示するために使用される画像を指定します。

37
  • underline *⇒ Integer

ウィジェットで下線を引く文字の整数インデックスを指定します。 このオプションは、デフォルトのバインディングで使用され、メニューボタンとメニューエントリのキーボードトラバーサルを実装します。 0はウィジェットに表示されるテキストの最初の文字に対応し、1は次の文字に対応し、以下同様に続きます。

38
  • wraplength *⇒ Integer

ワードラッピングを実行できるウィジェットの場合、このオプションは最大行長を指定します。

39
  • xscrollcommand *⇒ function

水平スクロールバーとの通信に使用されるコールバックを指定します。

40
  • yscrollcommand* ⇒ function

垂直スクロールバーとの通信に使用されるコールバックを指定します。

Ruby/Tkジ​​オメトリ管理

ジオメトリ管理は、要件ごとに異なるウィジェットを配置します。 Tkのジオメトリ管理は、マスターウィジェットとスレーブウィジェットの概念に依存しています。

マスターはウィジェットであり、通常はトップレベルのウィンドウまたはフレームであり、スレーブと呼ばれる他のウィジェットが含まれます。 ジオメトリマネージャーは、マスターウィジェットを制御し、表示するものを決定するものと考えることができます。

ジオメトリマネージャは、各スレーブウィジェットにその自然なサイズ、または理想的には表示するサイズを尋ねます。 次に、その情報を取得し、その特定のスレーブウィジェットの管理をジオメトリマネージャーに要求するときに、プログラムによって提供されるパラメーターと組み合わせます。

インターフェース内の各ウィジェットのサイズと場所を制御する3つのジオメトリマネージャー_place、grid 、 pack_があります。

  • link：/ruby​​/ruby​​_tk_grid [grid]ウィジェットをグリッドに配置するジオメトリマネージャ。
  • link：/ruby​​/ruby​​_tk_pack [pack]キャビティのエッジの周りをパックするジオメトリマネージャ。 *link：/ruby​​/ruby​​_tk_place [place]固定またはラバーシート配置用のジオメトリマネージャー。

Ruby/Tkイベント処理

Ruby/Tkは_event loop_をサポートします。これは、オペレーティングシステムからイベントを受け取ります。 これらは、ボタンを押す、キーストローク、マウスの動き、ウィンドウのサイズ変更などです。

Ruby/Tkがこのイベントループを管理します。 イベントがどのウィジェットに適用されるかがわかります（ユーザーがこのボタンをクリックしましたか？ キーが押された場合、どのテキストボックスにフォーカスがありますか？）、それに応じてディスパッチします。 個々のウィジェットはイベントに応答する方法を知っているため、たとえば、マウスがボタンの上を移動するとボタンの色が変わり、マウスが離れると元に戻ります。

より高いレベルでは、Ruby/Tkはプログラムでコールバックを呼び出して、ウィジェットに重大なことが起こったことを示します。いずれの場合も、アプリケーションがイベントまたはコールバックに応答する方法を指定するコードブロックまたは_Ruby Proc_オブジェクトを提供できます。

bindメソッドを使用して、基本的なウィンドウシステムイベントをそれらを処理するRubyプロシージャに関連付ける方法を見てみましょう。 最も単純な形式のバインドは、入力として、イベント名を示す文字列と、Tkがイベントの処理に使用するコードブロックを受け取ります。

たとえば、いくつかのウィジェットの最初のマウスボタンの_ButtonRelease_イベントをキャッチするには、次のように記述します- 

someWidget.bind('ButtonRelease-1') {
   ....code block to handle this event...
}

イベント名には、追加の修飾子と詳細を含めることができます。 修飾キーは、Shift _、 Control 、 Alt_などの文字列で、修飾キーの1つが押されたことを示します。

そのため、たとえば、ユーザーが_Ctrl_キーを押しながらマウスの右ボタンをクリックしたときに生成されるイベントをキャッチします。 

someWidget.bind('Control-ButtonPress-3', proc { puts "Ouch!" })

多くのRuby/Tkウィジェットは、ユーザーがそれらをアクティブにしたときに_callbacks_をトリガーできます。 前述のように、ウィジェットを作成するときにコマンドコールバックプロシージャを指定できます- 

helpButton = TkButton.new(buttonFrame) {
   text "Help"
   command proc { showHelp }
}

または、ウィジェットの_command_メソッドを使用して、後で割り当てることができます- 

helpButton.command proc { showHelp }

コマンドメソッドはプロシージャまたはコードブロックのいずれかを受け入れるため、前のコード例を次のように書くこともできます- 

helpButton = TkButton.new(buttonFrame) {
   text "Help"
   command { showHelp }
}

__ Ruby/Tkアプリケーションで次の基本的なイベントタイプを使用できます-

Sr.No. Tag & Event Description
1
  • "1" (one)*

マウスの左ボタンをクリックしました。

2

"ButtonPress-1"

マウスの左ボタンをクリックしました。

3

"Enter"

内部にマウスを移動しました。

4

"Leave"

マウスを外側に移動しました。

5

"Double-1"

ダブルクリック。

6

"B3-Motion"

ある位置から別の位置に右ボタンをドラッグします。

7

Control-ButtonPress-3

_Ctrl_キーとともに右ボタンが押されています。

8

Alt-ButtonPress-1

_Alt_キーとともにボタンを押します。

configureメソッド

_configure_メソッドを使用して、ウィジェット構成値を設定および取得できます。 たとえば、ボタンの幅を変更するには、次のようにいつでもconfigureメソッドを呼び出すことができます- 

require "tk"

button = TkButton.new {
   text 'Hello World!'
   pack
}
button.configure('activebackground', 'blue')
Tk.mainloop

現在のウィジェットの値を取得するには、次のように値なしでそれを指定します- 

color = button.configure('activebackground')

オプションなしでconfigureを呼び出すこともできます。これにより、すべてのオプションとその値のリストが表示されます。

cgetメソッド

オプションの値を単純に取得するために、configureは通常必要な情報より多くの情報を返します。 cgetメソッドは、現在の値のみを返します。 

color = button.cget('activebackground')

Ruby-LDAPチュートリアル

Ruby/LDAPはRubyの拡張ライブラリです。 OpenLDAP、UMich LDAP、Netscape SDK、ActiveDirectoryなどの一部のLDAPライブラリへのインターフェースを提供します。

アプリケーション開発用の共通APIはRFC1823で説明されており、Ruby/LDAPでサポートされています。

Ruby/LDAPインストール

完全なRuby/LDAPパッケージは、https://sourceforge.net/projects/ruby-ldap/[SOURCEFORGE.NET]からダウンロードしてインストールできます。

Ruby/LDAPをインストールする前に、次のコンポーネントがあることを確認してください-

  • Ruby 1.8.x（ldap/controlを使用する場合は少なくとも1.8.2）。
  • OpenLDAP、Netscape SDK、Windows 2003またはWindows XP。

これで、標準のRubyインストール方法を使用できます。 開始する前に、extconf.rbで利用可能なオプションを確認したい場合は、 '-help’オプションで実行します。 

$ ruby extconf.rb [--with-openldap1|--with-openldap2| \
                   --with-netscape|--with-wldap32]
$ make
$ make install

注-Windowsでソフトウェアをビルドする場合は、_make_の代わりに_nmake_を使用する必要がある場合があります。

LDAP接続を確立する

これは2段階のプロセスです-

ステップ1-接続オブジェクトの作成

LDAPディレクトリへの接続を作成する構文は次のとおりです。 

LDAP::Conn.new(host = 'localhost', port = LDAP_PORT)
  • host -これは、LDAPディレクトリを実行しているホストIDです。 _localhost_とします。
  • port -これは、LDAPサービスに使用されているポートです。 標準のLDAPポートは636および389です。 サーバーで使用されているポートを確認してください。使用していない場合は、LDAP :: LDAP_PORTを使用できます。
    この呼び出しは、ポート_port_上のサーバー_host_への新しい_LDAP
    Conn_接続を返します。

ステップ2-バインド

これは通常、セッションの残りに使用するユーザー名とパスワードを指定する場所です。

以下は、DN、 dn 、資格情報、 pwd 、およびバインド方法、 method を使用して、LDAP接続をバインドする構文です- 

conn.bind(dn = nil, password = nil, method = LDAP::LDAP_AUTH_SIMPLE)do
....
end

You can use the same method without a code block. In this case, you would need to unbind the connection explicitly as follows − 

conn.bind（dn = nil、パスワード= nil、method = LDAP :: LDAP_AUTH_SIMPLE）
....
conn.unbind

コードブロックが指定されている場合、_self_がブロックに渡されます。

適切な権限があれば、バインドメソッドのブロック内（バインドとバインド解除の間）で、検索、追加、変更、または削除の操作を実行できます。

例

ローカルサーバーで作業していると仮定して、適切なホスト、ドメイン、ユーザーID、パスワードなどを組み合わせてみましょう。 

#/usr/bin/ruby -w

require 'ldap'

$HOST =    'localhost'
$PORT =    LDAP::LDAP_PORT
$SSLPORT = LDAP::LDAPS_PORT

conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')
....
conn.unbind

Adding an LDAP Entry

Adding an LDPA entry is a two step process −

Step 1 − Creating LDAP::Mod object

We need LDAP::Mod object pass to conn.add method to create an entry. Here is a simple syntax to create LDAP::Mod object − 

Mod.new（mod_type、attr、vals）
  • mod_type − One or more option LDAP_MOD_ADD, LDAP_MOD_REPLACE or LDAP_MOD_DELETE.
  • attr − should be the name of the attribute on which to operate.
  • vals − is an array of values pertaining to attr. If vals contains binary data, mod_type should be logically OR’ed (|) with LDAP_MOD_BVALUES.

This call returns LDAP::Mod object, which can be passed to methods in the LDAP::Conn class, such as Conn#add, Conn#add_ext, Conn#modify and Conn#modify_ext.

Step 2 − Calling conn.add Method

Once we are ready with LDAP::Mod object, we can call conn.add method to create an entry. Here is a syntax to call this method − 

conn.add（dn、attrs）

This method adds an entry with the DN, dn, and the attributes, attrs. Here, attrs should be either an array of LDAP::Mod objects or a hash of attribute/value array pairs.

Example

Here is a complete example, which will create two directory entries − 

＃/usr/bin/ruby​​ -w

「ldap」が必要

$ HOST = 'localhost' $ PORT = LDAP :: LDAP_PORT $ SSLPORT = LDAP :: LDAPS_PORT

conn = LDAP :: Conn.new（$ HOST、$ PORT）conn.bind（ 'cn = root、dc = localhost、dc = localdomain'、 'secret'）

conn.perror（ "bind"）entry1 = [LDAP.mod（LDAP :: LDAP_MOD_ADD、 'objectclass'、['top'、 'domain']）、LDAP.mod（LDAP :: LDAP_MOD_ADD、 'o'、[' TTSKY.NET ']）、LDAP.mod（LDAP :: LDAP_MOD_ADD、' dc '、[' localhost ']）、]

entry2 = [LDAP.mod（LDAP :: LDAP_MOD_ADD、 'objectclass'、['top'、 'person']）、LDAP.mod（LDAP :: LDAP_MOD_ADD、 'cn'、['Zara Ali']）、LDAP。 mod（LDAP :: LDAP_MOD_ADD | LDAP :: LDAP_MOD_BVALUES、 'sn'、['ttate'、 'ALI'、 "zero \ 000zero"]）、]

begin conn.add（ "dc = localhost、dc = localdomain"、entry1）conn.add（ "cn = Zara Ali、dc = localhost、dc = localdomain"、entry2）rescue LDAP :: ResultError conn.perror（ "add" ）exit end conn.perror（ "add"）conn.unbind

Modifying an LDAP Entry

Modifying an entry is similar to adding one. Just call the modify method instead of add with the attributes to modify. Here is a simple syntax of modify method. 

conn.modify（dn、mods）

This method modifies an entry with the DN, dn, and the attributes, mods. Here, mods should be either an array of LDAP::Mod objects or a hash of attribute/value array pairs.

Example

To modify the surname of the entry, which we added in the previous section, we would write − 

＃/usr/bin/ruby​​ -w

「ldap」が必要

$ HOST = 'localhost' $ PORT = LDAP :: LDAP_PORT $ SSLPORT = LDAP :: LDAPS_PORT

conn = LDAP :: Conn.new（$ HOST、$ PORT）conn.bind（ 'cn = root、dc = localhost、dc = localdomain'、 'secret'）

conn.perror（ "bind"）entry1 = [LDAP.mod（LDAP :: LDAP_MOD_REPLACE、 'sn'、['Mohtashim']）、]

begin conn.modify（ "cn = Zara Ali、dc = localhost、dc = localdomain"、entry1）rescue LDAP :: ResultError conn.perror（ "modify"）exit end conn.perror（ "modify"）conn.unbind

Deleting an LDAP Entry

To delete an entry, call the delete method with the distinguished name as parameter. Here is a simple syntax of delete method. 

conn.delete（dn）

This method deletes an entry with the DN, dn.

Example

To delete Zara Mohtashim entry, which we added in the previous section, we would write − 

＃/usr/bin/ruby​​ -w

「ldap」が必要

$ HOST = 'localhost' $ PORT = LDAP :: LDAP_PORT $ SSLPORT = LDAP :: LDAPS_PORT

conn = LDAP :: Conn.new（$ HOST、$ PORT）conn.bind（ 'cn = root、dc = localhost、dc = localdomain'、 'secret'）

conn.perror（ "bind"）begin conn.delete（ "cn = Zara-Mohtashim、dc = localhost、dc = localdomain"）rescue LDAP :: ResultError conn.perror（ "delete"）exit end conn.perror（ "delete "）conn.unbind

Modifying the Distinguished Name

It’s not possible to modify the distinguished name of an entry with the modify method. Instead, use the modrdn method. Here is simple syntax of modrdn method − 

conn.modrdn（dn、new_rdn、delete_old_rdn）

This method modifies the RDN of the entry with DN, dn, giving it the new RDN, new_rdn. If delete_old_rdn is true, the old RDN value will be deleted from the entry.

Example

Suppose we have the following entry − 

dn：cn = Zara Ali、dc = localhost、dc = localdomain cn：Zara Ali sn：Aliオブジェクトクラス：person

Then, we can modify its distinguished name with the following code − 

＃/usr/bin/ruby​​ -w

「ldap」が必要

$ HOST = 'localhost' $ PORT = LDAP :: LDAP_PORT $ SSLPORT = LDAP :: LDAPS_PORT

conn = LDAP :: Conn.new（$ HOST、$ PORT）conn.bind（ 'cn = root、dc = localhost、dc = localdomain'、 'secret'）

conn.perror（ "bind"）begin conn.modrdn（ "cn = Zara Ali、dc = localhost、dc = localdomain"、 "cn = Zara Mohtashim"、true）rescue LDAP :: ResultError conn.perror（ "modrdn"） exit end conn.perror（ "modrdn"）conn.unbind

Performing a Search

To perform a search on a LDAP directory, use the search method with one of the three different search modes −

  • LDAP_SCOPE_BASEM − Search only the base node.
  • LDAP_SCOPE_ONELEVEL − Search all children of the base node.
  • *LDAP_SCOPE_SUBTREE *− Search the whole subtree including the base node.

Example

Here, we are going to search the whole subtree of entry dc = localhost, dc = localdomain for person objects − 

＃/usr/bin/ruby​​ -w

「ldap」が必要

$ HOST = 'localhost' $ PORT = LDAP :: LDAP_PORT $ SSLPORT = LDAP :: LDAPS_PORT

base = 'dc = localhost、dc = localdomain' scope = LDAP :: LDAP_SCOPE_SUBTREE filter = '（objectclass = person）' attrs = ['sn'、 'cn']

conn = LDAP :: Conn.new（$ HOST、$ PORT）conn.bind（ 'cn = root、dc = localhost、dc = localdomain'、 'secret'）

conn.perror（ "bind"）begin conn.search（base、scope、filter、attrs）{| entry | ＃識別名p entry.dnを出力＃すべての属性名を出力p entry.attrs＃属性 'sn'の値を出力p entry.vals（ 'sn'）＃エントリをハッシュとして出力p entry.to_hash} rescue LDAP :: ResultError conn .perror（ "search"）exit end conn.perror（ "search"）conn.unbind

This invokes the given code block for each matching entry where the LDAP entry is represented by an instance of the LDAP::Entry class. With the last parameter of search, you can specify the attributes in which you are interested, omitting all others. If you pass nil here, all attributes are returned same as "SELECT* " in relational databases.

The dn method (alias for get_dn) of the LDAP::Entry class returns the distinguished name of the entry, and with the to_hash method, you can get a hash representation of its attributes (including the distinguished name). To get a list of an entry’s attributes, use the attrs method (alias for get_attributes). Also, to get the list of one specific attribute’s values, use the vals method (alias for get_values).

Handling Errors

Ruby/LDAP defines two different exception classes −

  • In case of an error, the new, bind or unbind methods raise an LDAP::Error exception.
  • In case of add, modify, delete or searching an LDAP directory raise an LDAP::ResultError.

Further Reading

For complete details on LDAP methods, please refer to the standard documentation for LDAP Documentation.

Ruby-マルチスレッド

従来のプログラムには単一の「実行のスレッド」があり、プログラムを構成するステートメントまたは命令は、プログラムが終了するまで順番に実行されます。

マルチスレッドプログラムには、複数の実行スレッドがあります。 各スレッド内では、ステートメントは順番に実行されますが、スレッド自体は、たとえばマルチコアCPU上で並列に実行されます。 多くの場合、単一のCPUマシンでは、複数のスレッドが実際に並列で実行されるわけではありませんが、スレッドの実行をインターリーブすることで並列性がシミュレートされます。

Rubyでは、_Thread_クラスを使用してマルチスレッドプログラムを簡単に作成できます。 Rubyスレッドは、コードの並行性を実現するための軽量で効率的な方法です。

Rubyスレッドの作成

新しいスレッドを開始するには、_Thread.new_への呼び出しにブロックを関連付けます。 ブロック内のコードを実行するために新しいスレッドが作成され、元のスレッドは_Thread.new_からすぐに戻り、次のステートメントで実行を再開します- 

# Thread #1 is running here
Thread.new {
   # Thread #2 runs this code
}
# Thread #1 runs this code

例

次に、マルチスレッドRubyプログラムを使用する方法を示す例を示します。 

#!/usr/bin/ruby

def func1
   i = 0
   while i<=2
      puts "func1 at: #{Time.now}"
      sleep(2)
      i = i&plus;1
   end
end

def func2
   j = 0
   while j<=2
      puts "func2 at: #{Time.now}"
      sleep(1)
      j = j&plus;1
   end
end

puts "Started At #{Time.now}"
t1 = Thread.new{func1()}
t2 = Thread.new{func2()}
t1.join
t2.join
puts "End at #{Time.now}"

これにより、次の結果が生成されます– 

Started At Wed May 14 08:21:54 -0700 2008
func1 at: Wed May 14 08:21:54 -0700 2008
func2 at: Wed May 14 08:21:54 -0700 2008
func2 at: Wed May 14 08:21:55 -0700 2008
func1 at: Wed May 14 08:21:56 -0700 2008
func2 at: Wed May 14 08:21:56 -0700 2008
func1 at: Wed May 14 08:21:58 -0700 2008
End at Wed May 14 08:22:00 -0700 2008

スレッドのライフサイクル

_Thread.new_で新しいスレッドが作成されます。 シノニム_Thread.start_および_Thread.fork_を使用することもできます。

スレッドを作成した後、スレッドを開始する必要はありません。CPUリソースが利用可能になると自動的に実行を開始します。

Threadクラスは、実行中のスレッドを照会および操作するためのいくつかのメソッドを定義します。 スレッドは、_Thread.new_の呼び出しに関連付けられたブロック内のコードを実行し、実行を停止します。

そのブロックの最後の式の値はスレッドの値であり、Threadオブジェクトの_value_メソッドを呼び出すことで取得できます。 スレッドが完了するまで実行された場合、値はスレッドの値をすぐに返します。 それ以外の場合、_value_メソッドはブロックされ、スレッドが完了するまで戻りません。

クラスメソッド_Thread.current_は、現在のスレッドを表すThreadオブジェクトを返します。 これにより、スレッドは自分自身を操作できます。 クラスメソッド_Thread.main_は、メインスレッドを表すThreadオブジェクトを返します。 これは、Rubyプログラムが開始されたときに開始された実行の初期スレッドです。

特定のスレッドが終了するのを待つには、そのスレッドの_Thread.join_メソッドを呼び出します。 呼び出しスレッドは、指定されたスレッドが終了するまでブロックします。

スレッドと例外

メインスレッドで例外が発生し、どこでも処理されない場合、Rubyインタープリターはメッセージを出力して終了します。 メインスレッド以外のスレッドでは、未処理の例外によりスレッドの実行が停止します。

未処理の例外のためにスレッド t が終了し、別のスレッド s が_t.joinまたはt.value、_を呼び出すと、 t で発生した例外がスレッド s で発生します。

_Thread.abort_on_exception_がデフォルトの状態である_false_である場合、未処理の例外は現在のスレッドを強制終了し、残りはすべて実行を継続します。

スレッドで未処理の例外を使用してインタープリターを終了するには、クラスメソッド_Thread.abort_on_exception_を_true_に設定します。 

t = Thread.new { ... }
t.abort_on_exception = true

スレッド変数

スレッドは通常、スレッドの作成時にスコープ内にある変数にアクセスできます。 スレッドのブロックに対してローカルな変数はスレッドに対してローカルであり、共有されません。

スレッドクラスには、スレッドローカル変数を作成して名前でアクセスできる特別な機能があります。 スレッドオブジェクトをハッシュのように扱い、[] =を使用して要素に書き込み、[]を使用してそれらを読み返します。

この例では、各スレッドは、変数カウントの現在の値をキー_mycount_を持つthreadlocal変数に記録します。 

#!/usr/bin/ruby

count = 0
arr = []

10.times do |i|
   arr[i] = Thread.new {
      sleep(rand(0)/10.0)
      Thread.current["mycount"] = count
      count &plus;= 1
   }
end

arr.each {|t| t.join; print t["mycount"], ", " }
puts "count = #{count}"

これは、次の結果を生成します- 

8, 0, 3, 7, 2, 1, 6, 5, 4, 9, count = 10

メインスレッドは、サブスレッドが終了するのを待ってから、それぞれがキャプチャした_count_の値を出力します。

スレッドの優先度

スレッドのスケジューリングに影響を与える最初の要因は、スレッドの優先度です。優先度の高いスレッドは、優先度の低いスレッドよりも先にスケジュールされます。 より正確には、スレッドは、実行を待機している優先度の高いスレッドがない場合にのみCPU時間を取得します。

_priority = _および_priority_を使用して、Ruby Threadオブジェクトの優先度を設定および照会できます。 新しく作成されたスレッドは、それを作成したスレッドと同じ優先度で開始されます。 メインスレッドは優先度0で開始します。

実行を開始する前にスレッドの優先順位を設定する方法はありません。 ただし、スレッドは、最初のアクションとして自身の優先順位を上げたり下げたりできます。

スレッドの除外

2つのスレッドが同じデータへのアクセスを共有し、少なくとも1つのスレッドがそのデータを変更する場合、一貫性のない状態のデータがスレッドに表示されないように特に注意する必要があります。 これは_スレッド除外_と呼ばれます。 

*Mutex* は、いくつかの共有リソースへの相互排他的アクセスのための単純なセマフォロックを実装するクラスです。 つまり、特定の時間にロックを保持できるスレッドは1つだけです。 他のスレッドは、ロックが使用可能になるのを待つか、ロックが使用不可であることを示す即時エラーを受け取ることを選択する場合があります。

共有データへのすべてのアクセスを_mutex_の制御下に置くことにより、一貫性とアトミック操作を保証します。 例を見てみましょう。最初はmutaxなし、2番目はmutaxあり-

Mutaxを使用しない例

#!/usr/bin/ruby
require 'thread'

count1 = count2 = 0
difference = 0
counter = Thread.new do
   loop do
      count1 &plus;= 1
      count2 &plus;= 1
   end
end
spy = Thread.new do
   loop do
      difference &plus;= (count1 - count2).abs
   end
end
sleep 1
puts "count1 :  #{count1}"
puts "count2 :  #{count2}"
puts "difference : #{difference}"

これは、次の結果を生成します- 

count1 :  1583766
count2 :  1583766
difference : 0
#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new

count1 = count2 = 0
difference = 0
counter = Thread.new do
   loop do
      mutex.synchronize do
         count1 &plus;= 1
         count2 &plus;= 1
      end
   end
end
spy = Thread.new do
   loop do
      mutex.synchronize do
         difference &plus;= (count1 - count2).abs
      end
   end
end
sleep 1
mutex.lock
puts "count1 :  #{count1}"
puts "count2 :  #{count2}"
puts "difference : #{difference}"

これは、次の結果を生成します- 

count1 :  696591
count2 :  696591
difference : 0

デッドロックの処理

スレッドの除外に_Mutex_オブジェクトの使用を開始するときは、_deadlock_を避けるように注意する必要があります。 デッドロックは、すべてのスレッドが別のスレッドによって保持されているリソースの取得を待機しているときに発生する状態です。 すべてのスレッドがブロックされているため、保持しているロックを解除できません。 また、ロックを解除できないため、他のスレッドはそれらのロックを取得できません。

これは、_条件変数_が登場する場所です。 _条件変数_は、リソースに関連付けられた特定の_mutex_の保護内で使用される単純なセマフォです。 使用できないリソースが必要な場合は、条件変数で待機します。 そのアクションは、対応する_mutex_のロックを解除します。 リソースが利用可能であることを他のスレッドが通知すると、元のスレッドは待機状態から抜け出し、同時にクリティカル領域のロックを取り戻します。

例

#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new

cv = ConditionVariable.new
a = Thread.new {
   mutex.synchronize {
      puts "A: I have critical section, but will wait for cv"
      cv.wait(mutex)
      puts "A: I have critical section again! I rule!"
   }
}

puts "(Later, back at the ranch...)"

b = Thread.new {
   mutex.synchronize {
      puts "B: Now I am critical, but am done with cv"
      cv.signal
      puts "B: I am still critical, finishing up"
   }
}
a.join
b.join

これは、次の結果を生成します- 

A: I have critical section, but will wait for cv
(Later, back at the ranch...)
B: Now I am critical, but am done with cv
B: I am still critical, finishing up
A: I have critical section again! I rule!

スレッド状態

次の表に示すように、5つの可能な状態に対応する5つの可能な戻り値があります。 _status_メソッドは、スレッドの状態を返します。

Thread state Return value
Runnable run
Sleeping Sleeping
Aborting aborting
Terminated normally false
Terminated with exception nil

スレッドクラスメソッド

以下のメソッドは_Thread_クラスによって提供され、プログラムで利用可能なすべてのスレッドに適用できます。 これらのメソッドは、次のように_Thread_クラス名を使用して呼び出されます- 

Thread.abort_on_exception = true

____これは、利用可能なすべてのクラスメソッドの完全なリストです-

Sr.No. Methods & Description
1

Thread.abort_on_exception

exception_条件でグローバル_abortのステータスを返します。 デフォルトは_false_です。 _true_に設定すると、スレッドで例外が発生した場合、すべてのスレッドが中止されます（プロセスはexit（0）になります）

2

Thread.abort_on_exception=

_true_に設定すると、例外が発生した場合、すべてのスレッドが中止されます。 新しい状態を返します。

3

Thread.critical

グローバル_thread critical_状態のステータスを返します。

4

Thread.critical=

グローバル_thread critical_状態のステータスを設定し、それを返します。 _true_に設定すると、既存のスレッドのスケジューリングが禁止されます。 新しいスレッドの作成と実行をブロックしません。 特定のスレッド操作（スレッドの停止または強制終了、現在のスレッドでのスリープ、例外の発生など）により、クリティカルセクションにある場合でもスレッドがスケジュールされることがあります。

5

Thread.current

現在実行中のスレッドを返します。

6

Thread.exit

現在実行中のスレッドを終了し、別のスレッドの実行をスケジュールします。 このスレッドがすでに終了するようにマークされている場合、_exit_は_Thread._を返します。これがメインスレッドまたは最後のスレッドである場合、プロセスを終了します。

7

Thread.fork \{ block }

Thread.newの同義語。

8

Thread.kill( aThread )

指定された_a Thread_を終了させます

9

Thread.list

実行可能または停止されているすべてのスレッドの_Thread_オブジェクトの配列を返します。 糸。

10

Thread.main

プロセスのメインスレッドを返します。

11 Thread.new( [ arg ] ) \{
args

block }*

ブロックで指定された命令を実行する新しいスレッドを作成し、実行を開始します。 _Thread.new_に渡された引数はすべてブロックに渡されます。

12

Thread.pass

スレッドスケジューラを呼び出して、実行を別のスレッドに渡します。

13 Thread.start( [ args ] ) \{
args

block }*

基本的に_Thread.new_と同じです。 ただし、クラス_Thread_がサブクラス化されている場合、そのサブクラスで_start_を呼び出しても、サブクラスの_initialize_メソッドは呼び出されません。

14

Thread.stop

現在のスレッドの実行を停止して_sleep_状態にし、別のスレッドの実行をスケジュールします。 _critical_条件をfalseにリセットします。

スレッドインスタンスメソッド

これらのメソッドは、スレッドのインスタンスに適用できます。 これらのメソッドは、次のように_Thread_のインスタンスを使用して呼び出されます- 

#!/usr/bin/ruby

thr = Thread.new do   # Calling a class method new
   puts "In second thread"
   raise "Raise exception"
end
thr.join   # Calling an instance method join

____これは、利用可能なすべてのインスタンスメソッドの完全なリストです-

Sr.No. Methods & Description
1

thr[ aSymbol ]

属性リファレンス-シンボルまたは_aSymbol_名のいずれかを使用して、スレッドローカル変数の値を返します。 指定された変数が存在しない場合、_nil_を返します。

2

thr[ aSymbol ] =

属性の割り当て-シンボルまたは文字列を使用して、スレッドローカル変数の値を設定または作成します。

3

thr.abort_on_exception

_thr_の_abort on exception_条件のステータスを返します。 デフォルトは_false_です。

4

thr.abort_on_exception=

_true_に設定すると、_thr_で例外が発生した場合、すべてのスレッド（メインプログラムを含む）が中止されます。 プロセスは事実上_exit（0）_になります。

5

thr.alive?

_thr_が実行中またはスリープ中の場合、_true_を返します。

6

thr.exit

_thr_を終了し、別のスレッドの実行をスケジュールします。 このスレッドがすでに終了するようにマークされている場合、_exit_は_Thread_を返します。 これがメインスレッドまたは最後のスレッドである場合、プロセスを終了します。

7

thr.join

呼び出しスレッドは実行を中断し、_thr_を実行します。 _thr_が終了するまで戻りません。 結合されていないスレッドは、メインプログラムが終了すると強制終了されます。

8

thr.key?

指定された文字列（またはシンボル）がスレッドローカル変数として存在する場合、_true_を返します。

9

thr.kill

_Thread.exit_の同義語。

10

thr.priority

_thr_の優先度を返します。 デフォルトはゼロです。優先度の高いスレッドは、優先度の低いスレッドよりも先に実行されます。

11

thr.priority=

_thr_の優先度を整数に設定します。 優先度の高いスレッドは、優先度の低いスレッドよりも先に実行されます。

12

thr.raise( anException )

_thr_から例外を発生させます。 呼び出し元は_thr_である必要はありません。

13

thr.run

_thr_をウェイクアップし、スケジューリングの対象にします。 クリティカルセクションにない場合は、スケジューラを呼び出します。

14

thr.safe_level

_thr_に対して有効な安全レベルを返します。

15

thr.status

thr_のステータスを返します。_thr_がスリープまたはI/Oで待機している場合は_sleep _、 thr_が実行中の場合は_run 、 thr_が正常に終了した場合はfalse、thr_が例外で終了した場合は_nil。

16

thr.stop?

_thr_がデッドまたはスリープ状態の場合、_true_を返します。

17

thr.value

thrが_Thread.join_を介して完了するまで待機し、その値を返します。

18

thr.wakeup

_thr_をスケジューリングの対象としてマークしますが、I/Oでブロックされたままになる場合があります。

Ruby-組み込み関数

_Kernel_モジュールは_Object_クラスに含まれているため、そのメソッドはRubyプログラムのどこでも使用できます。 受信者なしで呼び出すことができます（機能フォーム）。 したがって、それらはしばしば関数と呼ばれます。

____組み込み関数の完全なリストは、参照用にここに記載されています-

Sr.No. Methods & Description
1

abort

プログラムを終了します。 例外が発生した場合（つまり、$！ nilではない）、エラーメッセージが表示されます。

2

Array( obj)

to_aryまたはto_aを使用して配列に変換した後、objを返します。

3

at_exit \{…​}

プログラムの終了時に実行するブロックを登録します。 ENDステートメントに似ていますが、ENDステートメントはブロックを1回だけ登録します。

4

autoload( classname, file)

初めて使用されるときにファイルからロードされるクラスclassnameを登録します。 classnameは文字列またはシンボルです。

5

binding

現在の変数とメソッドのバインディングを返します。 返される_Binding_オブジェクトは、2番目の引数として_eval_メソッドに渡すことができます。

6

block_given?

メソッドが_block_で呼び出された場合、trueを返します。

7 *callcc \{

…​}*

_Continuation_オブジェクトcをブロックに渡し、ブロックを実行します。 _callcc_は、グローバル終了またはループ構造に使用できます。

8

caller([ n])

_file：line_の形式の文字列の配列で現在の実行スタックを返します。 nが指定されている場合、n番目のレベルからスタックエントリを返します。

9

catch( tag) \{…​}

ブロックの実行中に呼び出されたスローにより、非ローカル出口をキャッチします。

10

chomp([ rs = $/])

終了改行を削除した変数$ _の値を返し、結果を$ _に割り当てます。 改行文字列の値は、rsで指定できます。

11

chomp!([ rs = $/])

$ _から改行を削除し、所定の文字列を変更します。

12

chop

最後の文字（1バイト）を削除した$ _の値を返し、結果を$ _に割り当てます。

13

chop!

$ _から最後の文字を削除し、その場所の文字列を変更します。

14

eval( str[, scope[, file, line]])

_str_をRubyコードとして実行します。 評価を実行するバインディングは、_scope_で指定できます。 コンパイルするコードのファイル名と行番号は、_file_とlineを使用して指定できます。

15

exec( cmd[, arg…​])

コマンド_cmd_を実行して、現在のプロセスを置き換えます。 複数の引数が指定されている場合、コマンドはシェル展開なしで実行されます。

16

exit([ result = 0])

_result_がステータスコードとして返され、プログラムを終了します。

17

exit!([ result = 0])

_ensure_などの出口処理をバイパスしてプログラムを強制終了します。

18

fail(…​)

raise（…​）を参照

19

Float( obj)

objをfloatに変換した後に返します。 数値オブジェクトは直接変換されます。 nilは0.0に変換されます。文字列は、0x、0b基数プレフィックスを考慮して変換されます。 残りはobj.to_fを使用して変換されます。

20

fork

  • フォーク \{…​} *

子プロセスを作成します。 _nil_は子プロセスで返され、子プロセスのID（整数）は親プロセスで返されます。 ブロックが指定されている場合、子プロセスで実行されます。

21
  • format( fmt[, arg…​])*

sprintfを参照してください。

22

gets([ rs = $/])

コマンドラインまたは標準入力から1行で指定されたファイル名を読み取ります。 レコード区切り文字列は、rsで明示的に指定できます。

23

global_variables

グローバル変数名の配列を返します。

24

gsub( x, y)

  • gsub（x）\ {...}*

$ _のxに一致するすべての文字列をyに置き換えます。 ブロックが指定されている場合、一致した文字列はブロックの結果に置き換えられます。 変更された結果は$ _に割り当てられます。

25

gsub!( x, y)

  • gsub！（x）\ {...}*

文字列がその場で変更されることを除き、gsubと同じ置換を実行します。

26

Integer( obj)

objを整数に変換した後に返します。 数値オブジェクトは直接変換されます。 nilは0に変換されます。文字列は、0x、0b基数プレフィックスを考慮して変換されます。 残りはobj.to_iを使用して変換されます。

27 *lambda \{

…​}*

  • proc \ {
x

…​}*

  • ラムダ *

proc

ブロックを_Proc_オブジェクトに変換します。 ブロックが指定されていない場合、呼び出し元のメソッドに関連付けられているブロックが変換されます。

28
  • load( file[, private = false])*

_file_からRubyプログラムをロードします。 _require_とは異なり、拡張ライブラリはロードされません。 _private_が_true_の場合、プログラムは匿名モジュールにロードされるため、呼び出し元プログラムの名前空間が保護されます。

29

local_variables

ローカル変数名の配列を返します。

30

loop \{…​}

コードのブロックを繰り返します。

31

open( path[, mode = "r"])

  • open（path [、mode = "r"]）\ {
f

…​}*

_file_を開きます。 ブロックが指定されている場合、ブロックは引数として渡された開かれたストリームで実行されます。 ブロックが終了すると、ファイルは自動的に閉じられます。 _path_がパイプ

で始まる場合、次の文字列がコマンドとして実行され、そのプロセスに関連付けられたストリームが返されます。 32

p( obj)

inspectメソッドを使用してobjを表示します（多くの場合、デバッグに使用されます）。

33

print([ arg…​])

argを_ $ defout_に出力します。 引数が指定されていない場合、$ _の値が出力されます。

34

printf( fmt[, arg…​])

sprintf_を使用して_fmt_に従ってargをフォーマットし、結果を $ defout_に出力します。 フォーマットの仕様については、sprintfを参照してください。

35
*proc \{

…​}*

proc

ラムダを参照してください。

36

putc( c)

デフォルトの出力（_ $ defout_）に1文字を出力します。

37

puts([ str])

文字列をデフォルトの出力（_ $ defout_）に出力します。 文字列が改行で終わらない場合、文字列に改行が追加されます。

38

raise(…​)

  • 失敗します（…​） *

例外を発生させます。 例外クラスが指定されていない場合は、_RuntimeError_を想定します。 _rescue_句で引数なしで_raise_を呼び出すと、例外が再度発生します。 レスキュー句の外側でこれを行うと、メッセージのない_RuntimeError_が発生します。* fail *は、raiseの廃止された名前です。

39

rand([ max = 0])

0以上max以下の擬似乱数を生成します。 maxが指定されていないか、0に設定されている場合、0以上1未満の浮動小数点数として乱数が返されます。 _srand_は、擬似ランダムストリームを初期化するために使用できます。

40

readline([ rs = $/])

EOFの読み取り時にEOFError例外を発生させることを除いて、getsと同等です。

41

readlines([ rs = $/])

コマンドライン引数として指定されたファイル名または標準入力の内容を保持する文字列の配列を返します。

42

require( lib)

ライブラリ（拡張ライブラリを含む）_lib_が最初に呼び出されたときにロードします。 requireは同じライブラリを複数回ロードしません。 _lib_に拡張子が指定されていない場合、requireは.rb、.soなどを追加しようとします。

43

scan( re)

  • スキャン（再）\ {
 x

…​} *

$ _。scanと同等です。

44
  • select( reads[, writes = nil[, excepts = nil[, timeout = nil]]])*

IOオブジェクトの配列として渡される3種類のIOオブジェクトの入力、出力、および例外のステータスの変化をチェックします。 _nil_は、チェックする必要のない引数に渡されます。 ステータスに変化があったIOオブジェクトの配列を含む3要素配列が返されます。 _nil_はタイムアウト時に返されます。

45

set_trace_func( proc)

トレース用のハンドラーを設定します。 _proc_は、文字列または_proc_オブジェクトです。 _set_trace_func_は、デバッガーとプロファイラーによって使用されます。

46

sleep([ sec])

sec秒間プログラムの実行を中断します。 secが指定されていない場合、プログラムは永久に中断されます。

47

split([ sep[, max]])

$ _。splitと同等です。

48

sprintf( fmt[, arg…​])

  • format（fmt [、arg …​]） *

argがfmtに従ってフォーマットされた文字列を返します。 フォーマットの仕様は、Cプログラミング言語のsprintfの仕様と本質的に同じです。 _fmt_の変換指定子（％の後に変換フィールド指定子）は、対応する引数のフォーマットされた文字列に置き換えられます。 提出された変換のリストを次のセクションで示します。

49
  • srand([ seed])*

乱数の配列を初期化します。 _seed_が指定されていない場合、初期化はシードの時間およびその他のシステム情報を使用して実行されます。

50

String( obj)

obj.to_sを使用して文字列に変換した後、objを返します。

51

syscall( sys[, arg…​])

番号_sys_で指定されたオペレーティングシステム呼び出し関数を呼び出します。 _sys_の数と意味はシステムに依存します。

52

system( cmd[, arg…​])

_cmd_をコマンドラインの呼び出しとして実行します。 複数の引数が指定されている場合、コマンドはシェル拡張なしで直接実行されます。 戻りステータスが0（成功）の場合、_true_を返します。

53

sub( x, y)

  • sub（x）\ {...}*

$ _のxに一致する最初の文字列をyに置き換えます。 ブロックが指定されている場合、一致した文字列はブロックの結果に置き換えられます。 変更された結果は$ _に割り当てられます。

54

sub!( x, y)

  • sub！（x）\ {...}*

文字列がその場で変更されることを除いて、subと同じ置換を実行します。

55

test( test, f1[, f2])

文字_test_で指定されたさまざまなファイルテストを実行します。 読みやすくするために、この関数ではなくFileクラスのメソッド（File
readable？など）を使用する必要があります。 引数のリストについては、次のセクションで説明します。
 56

throw( tag[, value = nil])

シンボルまたは文字列_tag_で待機しているcatch関数にジャンプします。 valueは、_catch_によって使用される戻り値です。

57

trace_var( var, cmd)

  • trace_var（var）\ {...}*

グローバル変数のトレースを設定します。 変数名はシンボルとして指定されます。 _cmd_は文字列またはProcオブジェクトです。

58

trap( sig, cmd)

  • trap（sig）\ {...}*

シグナルハンドラーを設定します。 sigは、文字列（SIGUSR1など）または整数です。 SIGはシグナル名から省略できます。 EXITシグナルまたはシグナル番号0のシグナルハンドラーは、プロセスの終了直前に呼び出されます。

59

数字の関数

以下は、数値に関連する組み込み関数のリストです。 彼らは次のように使用する必要があります- 

#!/usr/bin/ruby

num = 12.40
puts num.floor      # 12
puts num + 10       # 22.40
puts num.integer?   # false  as num is a float.

これは、次の結果を生成します- 

12
22.4
false

____仮定、 n は数字です-

Sr.No. Methods & Description
1

n PLUS num

  • n-num* *n* num * *n/num*

算術演算を実行します：加算、減算、乗算、除算。

2

n % num

nのモジュラスを返します。

3

n * num*

べき乗。

4

n.abs

nの絶対値を返します。

5

n.ceil

n以上の最小の整数を返します。

6

n.coerce( num)

numとnを含む配列を返します。両方とも、相互に操作できるタイプに変換される可能性があります。 数値演算子の自動型変換で使用されます。

7

n.divmod( num)

nをnumで除算した商とモジュラスを含む配列を返します。

8

n.floor

n以下の最大の整数を返します。

9

n.integer?

nが整数の場合、trueを返します。

10

n.modulo( num)

nをnumで除算し、_floor_で商を四捨五入して得られたモジュラスを返します

11

n.nonzero?

ゼロでない場合はnを返し、そうでない場合はnilを返します。

12

n.remainder( num)

  • n* を *num* で除算し、商から小数部を削除して得られた剰余を返します。 *result* と *n* は常に同じ符号を持ちます。
13

n.round

最も近い整数に丸められたnを返します。

14

n.truncate

nを小数部を削除した整数として返します。

15

n.zero?

nが0の場合、ゼロを返します。

16

n & num

  • n

num*

n ^ num

ビット演算：AND、OR、XOR、および反転。

17

n << num

  • n >> num*

ビット単位の左シフトおよび右シフト。

18

n[num]

最下位ビットから* num *番目のビットの値、n [0]を返します。

19

n.chr

文字コード n の文字を含む文字列を返します。

20

n.next

  • n.succ*

nに続く次の整数を返します。 n + 1と同等です。

21

n.size

  • n* のマシン表現のバイト数を返します。
 22
*n.step( upto, step) \{ n

…​}*

ブロックを n から upto に反復し、毎回 step ずつ増加します。

23
*n.times \{ n

…​}*

ブロックを n 回繰り返します。

24

n.to_f

  • n* を浮動小数点数に変換します。 浮動小数点変換は精度情報を失う可能性があります。
 25

フロートの関数

____これは、特に浮動小数点数用のRuby組み込み関数のリストです。 浮動小数点数 f があると仮定します-

Sr.No. Methods & Description
1

Float::induced_from(num)

_num_を浮動小数点数に変換した結果を返します。

2

f.finite?

_f_が無限ではなく、f.nanがfalseの場合、trueを返します。

3

f.infinite?

_f_が正の無限大の場合は1、負の無限大の場合は-1、それ以外の場合はnilを返します。

4

f.nan?

_f_が有効なIEEE浮動小数点数でない場合、trueを返します。

数学のための関数

____これは、Ruby組み込み数学関数のリストです-

Sr.No. Methods & Description
1

atan2( x, y)

アークタンジェントを計算します。

2

cos( x)

xの余弦を計算します。

3

exp( x)

指数関数（eのx乗）を計算します。

4

frexp( x)

xの名目小数と指数を含む2要素配列を返します。

5

ldexp( x, exp)

xの値に2のexp乗を返します。

6

log( x)

xの自然対数を計算します。

7

log10( x)

xの10を底とする対数を計算します。

8

sin( x)

xの正弦を計算します。

9

sqrt( x)

xの平方根を返します。 xは正でなければなりません。

10

tan( x)

xのタンジェントを計算します。

変換フィールド指定子

関数_sprintf（fmt [、arg …​]）およびformat（fmt [、arg …​]）_は、argがfmtに従ってフォーマットされた文字列を返します。 フォーマットの仕様は、Cプログラミング言語のsprintfの仕様と本質的に同じです。 _fmt_の変換指定子（％の後に変換フィールド指定子）は、対応する引数のフォーマットされた文字列に置き換えられます。

____次の変換指定子は、Rubyの形式でサポートされています-

Sr.No. Specifier & Description
1

b

バイナリ整数

2

c

単一の文字

3

d,i

10進整数

4

e

指数表記（例、2.44e6）

5

E

指数表記（例：2.44E6）

6

f

浮動小数点数（例：2.44）

7

g

指数が-4未満の場合は％eを使用し、それ以外の場合は％fを使用します

8

G

指数が-4未満の場合は％Eを使用し、そうでない場合は％fを使用します

9

o

8進整数

10

s

文字列またはto_sを使用して変換されたオブジェクト

11

u

符号なし10進整数

12.

x

16進整数（例：39ff）

13

X

16進整数（例：39FF）

以下は使用例です- 

#!/usr/bin/ruby

str = sprintf("%s\n", "abc")   # => "abc\n" (simplest form)
puts str

str = sprintf("d=%d", 42)      # => "d=42" (decimal output)
puts str

str = sprintf("%04x", 255)     # => "00ff" (width 4, zero padded)
puts str

str = sprintf("%8s", "hello")  # => " hello" (space padded)
puts str

str = sprintf("%.2s", "hello") # => "he" (trimmed by precision)
puts str

これは、次の結果を生成します- 

abc
d = 42
00ff
   hello
he

テスト関数の引数

関数_test（test、f1 [、f2]）_は、文字_test_で指定された次のファイルテストのいずれかを実行します。 読みやすさを改善するには、この関数ではなくFileクラスのメソッド（たとえば、File
readable？）を使用する必要があります。

____これは、1つの引数を持つファイルテストです-

Sr.No. Argument & Description
1

?r

f1は呼び出し元の有効なuidで読み取り可能ですか？

2

?w

f1は呼び出し元の有効なuidによって書き込み可能ですか？

3

?x

f1は呼び出し元の有効なuidで実行可能ですか？

4

?o

f1は呼び出し元の実効uidによって所有されていますか？

5

?R

f1は呼び出し元の実際のuidで読み取り可能ですか？

6

?W

f1は呼び出し元の実際のuidによって書き込み可能ですか？

7

?X

f1は呼び出し元の実際のuidによって実行可能ですか？

8

?O

f1は呼び出し元の実際のuidによって所有されていますか？

9

?e

f1は存在しますか？

10

?z

f1の長さはゼロですか？

11

?s

f1のファイルサイズ（0の場合はnil）

12

?f

f1は通常のファイルですか？

13

?d

f1はディレクトリですか？

14

?l

f1はシンボリックリンクですか？

15

?p

f1は名前付きパイプ（FIFO）ですか？

16

?S

f1はソケットですか？

17

?b

f1はブロックデバイスですか？

18

?c

f1はキャラクターデバイスですか？

19

?u

f1にはsetuidビットが設定されていますか？

20

?g

f1にsetgidビットが設定されていますか？

21

?k

f1にはスティッキービットが設定されていますか？

22

?M

f1の最終変更時刻。

23

?A

f1の最終アクセス時刻。

24

?C

f1の最終iノード変更時刻。

____2つの引数を持つファイルテストは次のとおりです-

Sr.No. Argument & Description
1

?=

f1とf2の変更時間は等しいですか？

2

?>

f1の変更時間はf2よりも新しいですか？

3

?<

f1の変更時間はf2よりも古いですか？

4

?-

f1はf2へのハードリンクですか？

以下に使用例を示します。 main.rbが読み取り、書き込み、および実行の許可なしで存在すると仮定します- 

#!/usr/bin/ruby

puts test(?r, "main.rb" )   # => true
puts test(?w, "main.rb" )   # => true
puts test(?x, "main.rb" )   # => false

これは、次の結果を生成します- 

true
false
false

Ruby-定義済み変数

Rubyの事前定義変数はプログラム全体の動作に影響を与えるため、ライブラリでの使用はお勧めしません。

ほとんどの事前定義変数の値には、代替手段でアクセスできます。

次の表に、Rubyのすべての定義済み変数を示します。

シニア

変数名と説明

1

＆ドル;！

最後に発生した例外オブジェクト。 例外オブジェクトには、_rescue_句の⇒を使用してアクセスすることもできます。

2

  • ＆dollar;＆commat; *

最後に発生した例外のスタック_backtrace_。 スタック_backtrace_情報は、最後の例外のException＃backtraceメソッドによって取得できます。

3

＆ドル;/

入力レコードの区切り文字（デフォルトでは改行）。 _gets、readline、_などは、入力レコード区切り文字をオプションの引数として取ります。

4

＆ドル;\

出力レコード区切り文字（デフォルトではnil）。

5

＆ドル;、

印刷する引数とArray＃joinの間の出力セパレーター（デフォルトではnil）。 Array＃joinに明示的に区切り文字を指定できます。

6

＆ドル;;

分割のデフォルトのセパレーター（デフォルトではnil）。 String＃splitには明示的に区切り文字を指定できます。

7

＆ドル;。

現在の入力ファイルから読み取られた最後の行の番号。 ARGF.linenoと同等です。

8

＆ドル; <

ARGFの同義語。

9

  • ＆ドル;> *

$ defoutの同義語。

10

  • ＆ドル; 0 *

実行されている現在のRubyプログラムの名前。

11

  • ＆dollar;＆dollar; *

実行されている現在のRubyプログラムのプロセスpid。

12

＆ドル;？

最後のプロセスの終了ステータスが終了しました。

13

＆ドル;：

$ LOAD_PATHの同義語。

14

  • ＆dollar; DEBUG *

-dまたは—​debugコマンドラインオプションが指定されている場合はtrue。

15

  • ＆dollar; defout *

print_および_printf（デフォルトでは_ $ stdout_）の出力先。

16

  • ＆ドル; F *

-aが指定されているときに_split_からの出力を受け取る変数。 この変数は、-aまたはコマンドラインオプションが-pまたは-nオプションとともに指定された場合に設定されます。

17

  • ＆dollar; FILENAME *

現在ARGFから読み取られているファイルの名前。 ARGF.filenameと同等です。

18

  • ＆dollar; LOAD_PATH *

loadおよびrequireメソッドでファイルをロードするときに検索されるディレクトリを保持する配列。

19

  • ＆dollar; SAFE *

セキュリティレベル

0→外部から提供された（汚染された）データのチェックは実行されません。 （デフォルト）

1→汚染されたデータを使用した潜在的に危険な操作は禁止されています。

2→プロセスおよびファイルに対する潜在的に危険な操作は禁止されています。

3→新しく作成されたすべてのオブジェクトは汚染されていると見なされます。

4→グローバルデータの変更は禁止されています。

20

  • ＆dollar; stdin *

標準入力（デフォルトではSTDIN）。

21

  • ＆dollar; stdout *

標準出力（デフォルトではSTDOUT）。

22

  • ＆dollar; stderr *

標準エラー（デフォルトではSTDERR）。

23

  • ＆dollar; VERBOSE *

-v、-w、または—​verboseコマンドラインオプションが指定されている場合はtrue。

24

  • ＆dollar;-x *

インタープリターオプション-xの値（x = 0、a、d、F、i、K、l、p、v）。 これらのオプションは以下のとおりです

25

  • ＆ドル; -0 *

インタプリタオプション-xの値と$/のエイリアス。

26

  • ＆dollar; -a *

インタープリターオプション-xの値。オプション-aが設定されている場合はtrue。 読み取り専用

27

  • ＆dollar; -d *

インタプリタオプション-xの値と$ DEBUGのエイリアス

28

  • ＆ドル; -F *

インタープリターオプション-xの値と$;のエイリアス。

29

  • ＆dollar; -i *

インタープリターオプション-xの値とインプレース編集モードでは、拡張子が保持されます。それ以外の場合はnilです。 インプレース編集モードを有効または無効にできます。

30

  • ＆ドル; -I *

インタプリタオプション-xの値と$：のエイリアス。

31

  • ＆ドル; -l *

インタープリターオプション-xの値。オプション-lisが設定されている場合はtrue。 読み取り専用

32

  • ＆dollar; -p *

インタープリターオプション-xの値。オプション-pisが設定されている場合はtrue。 読み取り専用

33

＆ドル;_

ローカル変数、getsによって最後に読み取られた文字列、または現在のスコープ内のreadline。

34

＆ドル;〜

ローカル変数、_MatchData_は最後の一致に関連しています。 Regex＃matchメソッドは、最後の一致情報を返します。

35

＆ドル; n（$ 1、$ 2、$ 3 …​）

最後のパターン一致のn番目のグループで一致した文字列。 m [n]と同等です。mは_MatchData_オブジェクトです。

36

＆ドル;＆

最後のパターン一致で一致した文字列。 m [0]と同等です。mは_MatchData_オブジェクトです。

37

＆ドル; `

最後のパターン一致で一致する前の文字列。 m.pre_matchと同等です。mは_MatchData_オブジェクトです。

38

＆ドル;'

最後のパターン一致の一致に続く文字列。 m.post_matchと同等です。mはMatchDataオブジェクトです。

39

  • ＆dollar;＆plus; *

最後のパターン一致で最後に正常に一致したグループに対応する文字列。

Ruby-定義済み定数

次の表は、Rubyのすべての定義済み定数を示しています-

注-TRUE、FALSE、およびNILは下位互換性があります。 true、false、およびnilを使用することをお勧めします。

Sr.No. Constant Name & Description
1

TRUE

真の同義語。

2

FALSE

falseの同義語。

3

NIL

nilの同義語。

4

ARGF

コマンドライン引数またはコマンドライン引数がない場合の標準入力として渡されるファイルの仮想連結へのアクセスを提供するオブジェクト。 ＆dollar; <の同義語。

5

ARGV

プログラムに渡されるコマンドライン引数を含む配列。 ＆dollar; *の同義語。

6

DATA

ENDディレクティブに続くコード行を読み取るための入力ストリーム。 ENDがコードに存在しない場合は定義されません。

7

ENV

プログラムの環境変数を含むハッシュのようなオブジェクト。 ENVはハッシュとして処理できます。

8

RUBY_PLATFORM

Rubyインタープリターのプラットフォームを示す文字列。

9

RUBY_RELEASE_DATE

Rubyインタープリターのリリース日を示す文字列

10

RUBY_VERSION

Rubyインタープリターのバージョンを示す文字列。

11

STDERR

標準エラー出力ストリーム。 _＆dollar; stderr_のデフォルト値。

12

STDIN

標準入力ストリーム。 ＆dollar; stdinのデフォルト値。

13

STDOUT

標準出力ストリーム。 ＆dollar; stdoutのデフォルト値。

14

TOPLEVEL_BINDING

Rubyのトップレベルのバインディングオブジェクト。

Ruby-関連ツール

標準のRubyツール

標準のRubyディストリビューションには、インタープリターと標準ライブラリに加えて便利なツールが含まれています-

これらのツールは、多くの労力を費やすことなく、Rubyプログラムのデバッグと改善に役立ちます。 このチュートリアルでは、これらのツールを使用して非常に良いスタートを切ることができます。

  • リンク：/ruby​​/ruby​​_gems [ RubyGems −] + RubyGemsはRuby用のパッケージユーティリティで、Rubyソフトウェアパッケージをインストールして最新の状態に保ちます。
  • リンク：/ruby​​/ruby​​_debugger [* Rubyデバッガ*-] +バグに対処するために、Rubyの標準ディストリビューションにはデバッガーが含まれています。 これは、複雑なプログラムのデバッグに使用できる_gdb_ユーティリティに非常に似ています。
  • リンク：/ruby​​/interactive_ruby [インタラクティブRuby（irb） −] + irb（Interactive Ruby）は、石塚敬寿によって開発されました。 これにより、プロンプトでコマンドを入力し、プログラムを実行しているかのようにインタープリターに応答させることができます。 irbは、Rubyの実験や探索に役立ちます。
  • リンク：/ruby​​/ruby​​_profiler [* Rubyプロファイラー*-] + Rubyプロファイラーは、ボトルネックを見つけることにより、低速プログラムのパフォーマンスを改善するのに役立ちます。

追加のRubyツール

Ruby標準ディストリビューションにバンドルされていない便利なツールは他にもあります。 ただし、自分でインストールする必要があります。

  • リンク：/ruby​​/eruby [ eRuby：埋め込みRuby −] + eRubyは埋め込みRubyの略です。 これは、ASP、JSP、PHPに類似したHTMLファイルなど、他のファイルにRubyコードのフラグメントを埋め込むツールです。
  • リンク：/ruby​​/ruby​​_interactive_reference [ ri：Ruby Interactive Reference −] +特定のメソッドの動作について質問がある場合は、riを呼び出してメソッドの簡単な説明を読むことができます。

Rubyツールとリソースの詳細については、リンク：/ruby​​/ruby​​_resources [* Ruby便利なリソース*]をご覧ください。

Ruby-便利なリソース

以下のリソースには、Rubyに関する追加情報が含まれています。 これについての詳細な知識を得るためにそれらを使用してください。

Rubyの便利なリンク

  • メインRubyサイト-公式Rubyサイト。 すべてのドキュメント、チュートリアル、ニュースなどの完全なリストを見つけてください。
  • https://www.ruby-doc.org [Ruby Documentation]-Rubyドキュメントサイト。
  • Ruby Application Archive-特定のプラットフォーム用にコンパイルされたRubyプログラム、ライブラリ、ドキュメント、およびバイナリパッケージのコレクション。
  • Rails API-Rails APIの包括的なリスト
  • https://railsconf.com [Rails Conf]-RailsConf、Ruby Central、Inc.の共同発表 O’Reilly Media、Inc.は、Railsに特化した最大の公式カンファレンスです。
  • XSLT4R-RubyでXSLTのモジュールをダウンロードします。
  • REXML-Rubyで書かれた強力なパーサー。 完全なAPIドキュメントとインストールは、サイトで入手できます。
  • Ruby LDAP-RubyでのLDAPプロトコルの実装。 完全なAPIドキュメントが利用可能です。
  • MySQLホームページ-ここでは、最新のMySQLリリースをダウンロードでき、MySQLニュースアップデートを入手できます。 メーリングリストは、MySQLを使用して動的なWebサイトを構築したい人にとっても素晴らしいリソースです。

Rubyの便利な本

このページにサイトを登録するには、 contact @ finddevguides.com にメールを送信してください。

「https://www.finddevguides.com/index.php?title=Ruby-quick-guide&oldid=79262」から取得
Powered by MediaWiki