.\" spec -  -*- Indented-Text -*- created at: Tue May 25 15:18:26 JST 1993

* Ϥ

RubyϡUNIXǼڤ˥֥Ȼظץߥ󥰡פ򤷤Ȥ˾
¸뤿ޤ줿ΤɬפȻפ줿:

    * ʸˡ䵡ǽñǤ롥
    * ֥Ȼظץߥ󥰤򥵥ݡȤ뵡ǽ
      ĸȤ߷פƤ롥
    * 󥢥饦ɥबû(󥿥ץ꥿Ǥ)
    * OS(UNIX)εǽñѤǤ롥
    * ץȸȤƻȤ롥
    * ϤfreeǤ롥

ʤɤǤ롥֥ȻظȤưŪǤSmalltalkC++ʤɤ
ξΰƤϤ뤬ä˼ڤʥץߥ󥰤Ȥ˷
ƤꡤʾξƤΤǤϤʤäץȸ
ǤPerl Tcl˥֥Ȼظǽɲäƥ¸ߤ뤬
ϡּڤ˥ץߥ󥰡פȤƤϤƤ⡤դ˥
Ȼظǽääơξ
߷פ줿Rubyħ:

    * 󥿥ץ꥿Ǥ롥
    * ñ㳰ξʤʸˡ
    * ʬʥ֥Ȼظǽġ
    * Ǥ񤭤䤹(黻ҷʤ)
    * ١쥯롥
    * 㳰ǽ롥
    * ʬ˶Ϥʥ饹Ȥ߹ޤƤ롥
    * OS򥢥뵡ǽ󶡤롥
    * ĥ䤹

ʤɤǤ롥RubyshPerlΤäƤͤˤȤäƤξＱˤʤ뤿ä
Τǡθ줫μʰܹԤǽǤȻפ롥ץޤ 
RubyΥ֥ȻظǽˤĤƳؤ٤С궯ϤʤȤǤ褦
ʤ

Cǥ饹᥽åɤ򵭽Ҥɲä뤳ȤRuby򹹤˶Ϥˤ
뤳ȤǤ롥ΥץåȥեǤRubyưŪ˥֥ȥե
󥯤Ǥ뤷ǤʤƤRubyƥѥ뤷Ȥ߹ߥ
ɲäΤưפǤ(PerlʤɤϤ뤫ưפǤ)

* Lexical structure

ߤrubyμϥ饯åȤȤASCIIѤ롥rubyʸ
ʸ̤롥̻ҤǤʤǤդΤȤ˶ʸ򤪤
Ȥ롥ʸϥڡ(space)(tab)ľ(vertical
tab) CR(carriage return)(form feed)Ǥ롥(newline)
˼³ˤ϶ʸȤơʳǤʸζڤȤƲ
ᤵ롥

̻Ҥϱʸ("_"ޤ)Ϥޤꡤѿ³ΤǤ롥ruby
̻ҤĹ¤Ϥʤߤμϼ̻ҤȤƥޥХȥ 
(EUC,SJIS)̤ʤ

Хѿ̾"$"³̻Ҥޤϵ1ʸ󥹥ѿ
"@"³̻ҡ饹"%"³̻ҤǤ롥᥽å̾
ѿ̾ȥ饹̾ñʤ뼱̻ҤѤ롥

** 

ץȸνˤʤ餤ʸʸɽ(?#)ʳ`#'
ޤǤϥȤȸʤ

** ͽ

ͽϰʲ̤Ǥ

  alias		else		in		resque		when
  and		elsif		include		retry		while
  break		end		module		return		yield
  case		ensure		nil		self		__END__
  class		fail		or		super		__FILE__
  continue	for		protect		then		__LINE__
  def		if		redo		undef

ͽϥ饹̾᥽å̾ѿ̾ʤɤѤ뤳ȤϤǤʤ

** ڤʸ

ʸʤɤΥƥʳξζʸ(֤ȥڡ)Ӳ
(\n)ڤ국Ȥʤ롥˲Ԥ

    a +
    b

Τ褦˹ԤǽꡤιԤ³Ȥʾζ
ڤȤƤǧ롥

* ץ

:

  print "hello world!\n"

ץϼ¤٤ΤǤ롥ȼδ֤ϥߥ(`;')ޤϲ
ԤǶڤ()

 ιԤ˷³뤳ȤʻˤϲԤϼζڤˤʤʤ

* 

RubyǤnilʳɾ롥CPerl ʤɤȤϰۤʤꡤ0 
""(ʸ)ϵȤɾʤΤǵĤ뤳ȡ

** ʸ

  "..."   # ХååβѿŸ
  '...'   # Хååβʤ(\\\'ϲ᤹)

Хåå嵭ˡ

          \t      (0x09)
          \n      ʸ(0x0a)
          \r      ʸ(0x0d)
          \f      ڡʸ(0x0c)
          \b      Хåڡ(0x08)
          \a      ٥(0x07)
          \e      (0x1b)
  	  \#	  ʸ`#'Τ
        \nnn      8ʿɽ(n0-7)
        \xnn      16ʿɽ(n0-9,a-f)
         \^c      ȥʸ(cASCIIʸ)
        \C-c      ȥʸ(Ʊ)
        \M-c      ᥿ʸ(c|0x80)
   \ʳ      ʸΤ

ѿŸ

֥륯(`"')ǰϤޤ줿ʸɽǤ `#{ѿ̾}'Ȥ
ѿƤŸ뤳ȤǤ롥ѿѿ(`$',`@',`%')
 ǻϤޤˤ`#ѿ̾'ȤǤŸǤ롥ʸ`#'³ʸ
 `{',`$',`@',`%'ǤʤСΤޤ`#'ȤƲᤵ롥

** ޥɽ

RubyǤshΤ褦˥ޥɤμ¹Է̤ʸƥΤ褦˻ȤȤ
Ǥ롥``ǰϤޤ줿ʸϡ֥륯ȤƱͤ˥Хåå嵭
ˡβѿŸԤʤ줿塤ޥɤȤƼ¹Ԥ졤μ¹Է
ʸȤͿ롥ޥɤɾ뤿Ӥ˼¹Ԥ롥

** ɽ

  /.../

           ^      Ƭ
           $      
           .      Ǥդ1ʸ
          \w      ѿ[0-9A-Za-z_]Ʊ
          \W      ѿ
          \s      ʸ[ \t\n\r\f]Ʊ
          \S      ʸ
          \d      [0-9] Ʊ
          \D      
          \b      춭ʸ(ʸ饹)
          \B      춭ʸ
          \b      (0x08)(ʸ饹)
         [ ]      ʸ饹
           *      ľɽ0ʾη֤
           +      ľɽ1ʾη֤
       {m,n}      m󤫤nη֤
           ?      0ޤ1
           |      
         ( )      ɽޤȤ

¾ʸƱХåå嵭ˡѿŸͭǤ롥

** 磻ɥɼ

  <...>

	   *	  Ǥդʸ(ʸޤ)Ȱ
	   ?	  Ǥդ1ʸȰ
	 [ ]	  []Τ줫1ʸȰ
	{..}	  {}(ޤǶڤ줿)줫ʸȰ

¾ʸƱХåå嵭ˡѿŸͭǤ롥

** ͥƥ

         123      
        -123      (Ĥ)
       1_234      (10ʿ`_'ޤळȤǤ)
      123.45      ư
      1.2e-3      ư
      0xffff      16
        0377      8
          ?a      ʸ`a'Υ(97)
       ?\C-a      ȥaΥ(1)
       ?\M-a      ᥿aΥ(225)
    ?\M-\C-a      ᥿-ȥaΥ(129)

   :ܥ       ̻/ѿ̾/黻ҤȰабapplyʤ
		  ǥ᥽åɤꤹʤɤ˻Ȥ

?ɽǤƤΥХåå嵭ˡͭǤ롥

** ѿ

Rubyѿϥ(ͭϰ)ȼ̿(ͭ)ˤä4ʬव졤
μѿ̾κǽΰʸǷꤵ롥̾ѿ2ʸܰʹߤ
ѿޤ`_'Ǥ뤬ƥѿΰϡ`$'+1ʸεפȤ
ѿ롥ѿ̾Ĺ˴ؤ̤¤Ϥʤ

ѿΥפ˴ؤ餺Ƥʤѿ򻲾Ȥͤnil
Ǥ롥μѿɬפʤ

*** Хѿ

:

  $foobar
  $/

`$'ǻϤޤѿΥפϥХǤꡤץΤɤǤ
ȤǤ롥μ̿ϥץμ̿

*** 󥹥ѿ

:

  @foobar

`@'ǻϤޤѿϥ󥹥ѿǤꡤΥ饹ޤϥ֥饹
᥽åɤ黲ȤǤ롥פϥ᥽åǤꡤμ̿ϥ֥
Ȥμ̿

*** 饹̾/⥸塼̾/ѿ

:

  Array
  Math
  foobar

ե٥åȤޤ`_'ǻϤޤѿϼ̻ҤȤƤФ졤ѿ
饹̾ޤϥ⥸塼̾Ǥ롥

֤Ǥϼ̻Ҥϥ饹/⥸塼̾Ȥߤʤ뤬(륯饹
¸ߤʤͤnil)κդ˸줿̻ҤϡΥ
ǤϥѿȤƸʤ졤Ʊ̾Υ饹⥸塼ϱ롥
ΰ̣Ǽ̻ҤؤȤƤƯġ

        Array       		# 󥯥饹 Array
        Array = 15		# ʸArrayϥѿ
        print Array, "\n"	# `15'Ϥ

ȤƤβϥѥ˹Ԥʤ뤿ᡤ̻Ҥؤ
ºݤ˼¹ԤƤ⤵ʤƤ⡤ʹߤΥǤϤμ̻Ҥ
ѿȤߤʤ롥

        Array       		# 󥯥饹 Array
        if %FALSE
          Array = 15    	# Υɤϼ¹Ԥʤ
				# ʹArrayϥѿȤߤʤ롥
        end
        print Array, "\n"  	# `nil'Ϥ

Υ롼ϰ츫ʣ饹/⥸塼̾ȥѿ̾ʣ
ʤ¤ꡤ̤ΥѿͤnilǤȹͤƤ⺹٤Ϥ
RubyȤ߹ߥ饹ʸΥե٥åȤǻϤޤ̾Ĥ
ꡤ桼⥯饹/⥸塼̾ˤʸǻϤޤ뼱̻Ҥ򡤥
ѿ̾ˤϾʸޤ`_'ǻϤޤ뼱̻ҤȤȤ򶯤侩롥

ѿΥפ̿⤽Υ֥åνޤ(ȥåץ٥Υ
ѿϥץνλޤ)Ǥ롥

*** 饹

:

  %foobar

`%'ǻϤޤѿϥ饹ǤꡤΥ饹ƤΥ֥饹Υ
󥹤黲ȤǤ롥ؤϥȥåץ٥롤ʤ᥽åɤ
Ǥ٥ǤΤǽǤ롥ѿϥ饹֤ͤͭ졤
ͤѹ뤳ȤǤʤ

*** ѿ

̾ѿʳ˵ѿȸƤФüѿ4Ĥ롥

      self   | ߤΥ᥽åɤμ¹Լ
       nil   | Nil饹ͣΥ󥹥(ɽ)
    __FILE__ | ץȤΥե̾(ʸ)
    __LINE__ | ߤιֹ()

εѿˤäƤͤѹ뤳ȤϤǤʤ
ѿؤ㳰ȯ롥

** ̤ˤ륰롼ԥ

:

  (1+2)*3
  (foo();bar())

ϳ̤ˤäƥ롼ԥ󥰤뤳ȤǤ롥

  `('  `)'

̤ˤñʤ뼰ǤϤʤ¤(ץ)֤Ȥ
롥

  `('  `;' ... `)'

¤ӤͤϺǸɾͤǤ롥ĤޤͤϺǸɾ
ͤˤʤ롥

** 

:

  [1, 2, 3]

Array饹Υ󥹥󥹤Ǥ롥뼰ϰʲη
롥

  `[' , ... `]'

줾μɾ̤ޤ֤ǿ0ζ
뤿ˤ϶

  `[' `]'

Ѥ롥

** Ϣ

:

  {1=>2, 2=>4, 3=>6}

ϢȤǤդΥ֥Ȥ򥭡(ź)ȤƻǤ롥Ruby 
ϢDict()饹Υ󥹥󥹤Ǥ롥ܺ٤ϥ饹Dictι
򻲾Ȥ줿ϢϢ󼰤ϰʲηǤ롥

  `{'  `=>' ... `}'

줾μɾ̤򥭡ͤȤϢ󥪥֥Ȥ֤
ǿ0Ϣ뤿ˤ϶Ϣ

  `{' `}'

Ѥ롥Ǥ1İʾ夢硤ۣǤʤ`{', `}'ϾάǤ롥

** ᥽åɸƽм

:

  foo.bar()
  foo.bar
  bar()

֥Ȥ˥åŪʹʸåǤꡤδ
ܷϰʲ̤Ǥ롥

  1 `.' ᥽å̾ `(' 1... [`,' `*' n ]`)'

1ɾ륪֥ȤΡ̻Ҥǻꤵ᥽åɤƤ
ФֺǸΰ`*'³(ñ)Ǥ硤μɾ
(ǤʤѴ)ŸơȤɲä롥

åǡ쥷Фselfξ硤쥷Фά̾Υץ
ߥ󥰸ˤؿΤ褦ʷǥ᥽åɤƤӽФȤǤ롥

᥽åɸƤӽФǤۣ椵ʤˤϳ̤άǤ롥ۣ椵
ȤʲʸޤͽǻϤޤǤ롥

	(, [, {, <, /, %, +, -, if, while

㡧
	      foo bar+baz	# ᥽åɸƤӽФfoo(bar+baz)
	      foo (1+2)*5	# ᥽åɸƤӽФ(foo(1+2)) * 5
	      foo 1		# ᥽åɸƤӽФfoo(1)
	      foo -1		# ѿfoo - 1

쥷Фꤷ᥽åɸƤӽФǤϤξ1Ĥʤˤ
άǤ롥

᥽å̾ȤƤǤդμ̻ҤѤ뤳ȤǤ롥ѿ̾Ȥϼ̻Ҥ
֤̾㤦ΤǽʣƤ⹽ʤ

饹ʸγǻꤵ줿᥽åɤȥ饹Moduleunexport᥽åɤ
ꤵ줿᥽åɤϴؿŪ᥽åɤȸƤФ졤ؿǤƤӽФ
Ǥʤ(DEF)

** SUPER

:

  super
  super(1,2,3)

åüʥȤƥѡ饹Υ᥽åɤθƤӽФ
롥ηϥ᥽åɤ˥ѡ饹Ѥ뤿
˻Ȥ

  super

ߤΥ᥽åɤͿ줿Τޤޥѥ饹Ʊ̾Υ᥽åɤƤ
ФȤͿ줿ѿͤѹƤ⡤ϤΤϸΰ
ͤǤ롥

  super`(' ... `)'

ȤȤ˥ѡ饹Ʊ̾Υ᥽åɤƤӽФֺǸΰ
`*'³̾Υ᥽åɸƤӽФƱͤŸϤ롥

** 

:

  foo = bar
  foo[0] = bar
  foo.bar = baz

ˤѿФ()ȡץñˤ뤿Υ
å奬ȤƤ롥ϰʲηǤ롥

  ѿ `=' 

ϼɾѿͤȤ롥饹⥸塼䵿ѿ
ˤǤʤ饹⥸塼ѹ뤿ˤclass
moduleѤ롥ϱ黻ҷȤäƤ뤬᥽åɤǤϤʤ
Ǻ뤳ȤϤǤʤ

󥿥å奬ȤƤϰʲΤΤ롥

Ǥؤ

  1`[' 2... `]' `=' n

1ɾ륪֥Ȥˡ2鼰nޤǤȤơ"[]="
Ȥ᥽åɤƤӽФ

°

  1 `.' ̻ `=' 2

1ɾ륪֥(쥷Фά줿`self')
Фơ"̻="Ȥ᥽åɤ 2ȤƸƤӽФ

** 

:

  foo += 12

ͤΤΤ˱黻ä뤿˼롥

  1 op= 2     # 1ǽǤʤФʤʤ

ηŪˡּ1 = 1 op 2פƱͤɾ롥1
1󤷤ɾʤΤǡ1Ѥϡּ1 = 1 op 2
Ȥưۤʤ̤Ȥʤ롥opȤƻȤ黻Ҥ

        +, -, *, /, %, **, &, |, ^, <<, >>

11Ǥ롥黻Ҥ`='δ֤˥ڡƤϤʤ

** ¿

:

  foo, bar, baz = 1, 2, 3
  foo, = list()
  foo, *rest = list2()

ƱʣѿԤʤȤǤ롥ηϰʲ̤Ǥ롥

     `,' [ `,' ...] [`*' ]=  [, ...]

դμĤʤϡͤȤ(ɬפʤto_a᥽
ɤѴ)Ǥ򤽤줾캸դ롥ʳξˤϡ
줾μͤդ롥դοȱդǤοʤ
ˤ­ʤѿˤ nil졤;äǤ̵뤵롥¿
κǸǤ`*'硤ĤưȤ롥

    foo, bar = [1, 2]		# foo = 1; bar = 2
    foo, bar = 1, 2		# foo = 1; bar = 2
    foo, bar = 1		# foo = 1; bar = nil

    foo, bar, baz = 1, 2	# foo = 1; bar = 2; baz = nil
    foo, bar = 1, 2, 3		# foo = 1; bar = 2
    foo,*bar = 1, 2, 3		# foo = 1; bar = [2, 3]

¿ͤ(Ѵ줿)դǤ롥

** 黻Ҽ

:

  1+2*3/4

ץߥ󥰤ؤΤ˰Υ᥽åɸƤӽФ湽¤ϱ黻ҷ
Ȥ롥Rubyˤϰʲˤ黻Ҥ롥ΤΤۤɷ̤
Ʊα黻Ҥη̤ƱǤ롥

      [](󻲾), []=()
	-(unary)  +(unary)  !  ~
        **
        *  /  % 
        +  -
        <<  >>
        &
        |  ^
        >  >=  <  <=
        <=> ==  !=  =~  !~
        &&
        ||
        .. ..
        ::
        =() (+=, -=, ..)
	and
	or
      if while

ۤȤɤα黻ˤϥ᥽åɸƤӽФȤƲᤵ(饹˺
Ǥ)ǤʤüʤΤ롥Ǥʤü黻
Ҥ

        =(), ...(ϰ), !(), &&(), and, |(), or,
        if, while

9Ĥα黻ҤȤȤȤ߹碌ˤʤ !=, !~ Ӽ黻
Ǥ롥
  
Ǥü黻Ұʳα黻ҷϰʲΤ褦ʥ᥽åɸƤӽФȸ
ʤ롥

ñ黻(+, -, ~)

  1. 黻 ()

(Ϣޤ)Ǥλ(1 `[' 2... `]')

  1. `[]' (2...)

Ǥ( 1 `[' 2... `]' `=' n)

  1. `[]=' (2...)

ʳ2黻( 黻 )

  1. 黻 (2)

ϤޤǤ⤽Υ᥽åɸƤӽФȤƲᤵȤ
ǡrubyץǤҤȤ櫓ǤϤʤ

** IF

  if 1 [then]
    1 
  [elsif 2 [then]
    2 ]... 
  [else 
    n ]
  end

ȽǼ1ξ˼1ɾ롥ʳξϼ2ɾ
롥Rubyifelse ifǤelifǤʤelsififϢ³ԤʤȤ
դ뤳ȡ

ifξȽμǤʸɽƥϼ$_=~ ƥפ
άǤȤߤʤ롥

** IF

   if 

､(if)μԤ뼰äɾ롥ưбif
ƱͤǤ롥ifҤΤĤͤϾ郎Ωˤϼ͡
ΩξˤnilǤ롥

** CASE

  case 0
  [when 1 [, 2]... [then]
    1 ]..
  [else
    n ]
  end

ʬCswitchPascalcase˻Ƥ롥breakæФ뤳Ȥ
μ˷³뤳ȤʤΤա

ΰפϡּn =~ 0]ǹԤʤ롥Ĥޤꡤ

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

ϰʲifȤۤǤ롥

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

** AND 

  1 `&&' 2
  1 `and' 2

1ɾͤ(nilʳ)ǤС2ɾ롥`and'ͥ
̤㤤̾Ǥ롥

andξդμǤʸɽƥϼ$_=~ ƥפξά
Ȥߤʤ롥

** OR 

  1 `||' 2
  1 'or 2

1ɾͤǤС2ɾ롥`or'̤ͥ㤤
̾Ǥ롥

orξդμǤʸɽƥϼ$_=~ ƥפξά
Ȥߤʤ롥

** ϰϻ꼰

  1 `...' 2

1ˤʤޤǤϵ֤θϼ2֤ޤǤϿ֤2 
ˤʤо֤ϵ롥

黻`...'ξդϾＰǤꡤ `...'ξդμǤʸ
ɽƥϼ$_=~ ƥפξά$.==פξά
Ȳᤵ롥

** NOT 

  `!' 

ǤеǤп֤

`!'Ǥʸɽƥϼ$_=~ ƥפξάǤȤ
ʤ롥


  1 `!=' 2

!(1 == 2)פξά

  1 `!~' 2

!(1 ~= 2)פξά

** WHILE

  while 
    
  end

ɾͤδ֡򷫤֤¹Ԥ롥whileͤnilǤ롥

whileξȽμǤʸɽƥϼ$_=~ ƥ
ξάǤȤߤʤ롥

** WHILE 

  ñ㼰 while 

֤(while)ϤޤԤ뼰ɾƤＰɾ
ǡ٤ϼ¹Ԥ뤳Ȥˤʤ롥whileҤΤĤͤnil
롥

** ƥ졼(֤)

ƥ졼Ȥ湽¤(ä˥롼)ݲΤѤ᥽åɤ
Ǥ롥ɤ(֥åȸƤФ)ꤷƥƥ졼Ƥ
Фȡƥ졼Ŭͤ򥻥åȤƥ֥åɾ(餯
ʣ)ƥ졼Υ֥åθƤӽФyieldѤ()

ƥ졼θƤӽФϰʲιʸǹԤʤ롥

ƥ졼Ȥ湽¤(ä˥롼)ݲΤѤ᥽åɤ
Ǥ롥ƥ졼θƤӽФϰʲιʸǹԤʤ롥

   `{' ѿ... `|' ... `}'

ּפ֥åȤꤷּפΥ᥽åɤ򥤥ƥ졼Ȥɾ
롥ּפΥȥåץ٥Υ᥽åɤƥ졼ȤƸƤӽФ졤
쥷Фɽ䡤μϥƥ졼ȤƤϸƤӽФʤּ
ʣμޤơƥ졼Ȥƽ˸ƤФ롥

ƥ졼yield¹Ԥȡǻꤵ줿ͤdoǻꤵ
줿ѿ졤֥å¹Ԥ롥֥åμ¹ԤλȤ
ͤ yieldͤȤ֤롥᥽åɤƥ졼ȤƸƤӽ
줿ɤϥ᥽åiterator_p()ͤΤ뤳ȤǤ롥ˤ 
Enumerable⥸塼grep᥽åɤΤ褦˥ƥ졼ȤƸƤФ줿
̤Υ᥽åɤȤƸƤФ줿Ȥưۤʤ᥽åɤ⤢롥

** FOR

֥ȤγǤФԤʤη󶡤Ƥ롥
ϰʲ̤ꡥ

  for ѿ.. in 
    
  end

γǤФ¹Ԥ롥ϰʲμǤ롥

  ().each `{' ѿ.. `|'  `}'

äƼͤΥ֥Ȥ᥽åeachʤ硤for¹Ԥ
㳰ȯ롥

** YIELD

  yield `(' [ [`,' ...]])
  yield

ƥ졼ǥ֥åθƤӽФԤʤyield¹Ԥ᥽åɤ
ƥ졼ȤƸƤӽФƤʤˤ㳰ȯ롥yield ͤϥ
åͤǤ롥

yieldΰγ̤ۣǤʤ¤άǤ롥

** FAIL

  fail `(' [å] `)'

㳰ȯ롥åͿ줿ˤȯե
ֹ̾򥷥ƥѿ`$@'ˡå`$!'˥åȤ롥

failΰγ̤ۣǤʤ¤άǤ롥

** PROTECT

ͽʤ֤ȯˤ㳰ȯ롥RubyǤ㳰
ªơƻԤꡤԤʤäꤹ뤳ȤǤ롥

  protect
    1
  [resque
    2 ]
  [ensure
    3]
  end

1¹Ԥμ¹㳰ȯresqueǻꤵ줿2¹
롥ensure᤬¸ߤprotectλɬ(ｪλ
Ǥʤ㳰, return, break, continue, redoʤɤˤæФǤ)3
¹Ԥ롥

** RETURN

  return [[`,' ...]]

ͤͤȤƥ᥽åɤμ¹Ԥλ롥2İʾͿ줿
ˤϡǤȤ᥽åɤͤȤ롥Ĥʤ
ˤ nil ͤȤʤ롥

** BREAK

  break

break ϥ롼פæФ롥CȰ㤤breakϤäȤ¦Υ롼פæФ
Ѥcase ȴѤϻʤ

** CONTINUE
  continue

continueϤäȤ¦Υ롼פμη֤Ϥ롥

** REDO

  redo

redoϥ롼׾ΥåԤʤ鷺ߤη֤ľ

** RETRY

  retry

protectresqueǻȤprotectϤᤫ¹Ԥ롥㳰Ԥʤ
ƤƻԤΤ˻ȤresqueʳretryѤ줿㳰ȯ
롥

** 饹

饹빽ϰʲ̤Ǥ롥

   class 饹̾ [`:' ѡ饹̾ ]
       
   end

饹̾Ǥդμ̻ҤǤ(ʸǻϤ뤳Ȥ侩)饹
ΥͥȤϤǤʤΤ¾Ǥϥ饹Ǥʤ

** ⥸塼

⥸塼빽ϰʲ̤Ǥ롥

   module 饹̾
       
   end

⥸塼̾ʸǻϤޤ뼱̻ҤǤ롥饹Ʊ͡⥸塼
ͥȤǤʤ

** ᥽å

̾(ðۥ᥽åɤǤʤ)᥽åηϰʲ̤Ǥ롥̾᥽
ϥͥȤǤʤΤǡ᥽åǤϥ᥽åƤӸ
ӽФʤ

    def ᥽å̾ [`('  [`,' ...][`,' `*' ] `)']
        
    end

᥽å̾ϼ̻ҤޤʸǤ롥黻Ҥκ򤹤ˤʸ
ǻꤹ롥¤ӤκǸ`*'硤¿Ϳ줿
°ϡǸΰȤͿ(­ʤˤϥ顼)

᥽åɤˤϴؿŪ᥽åɤ̾᥽åɤ롥ؿŪ᥽åɤϴؿ
ǤƤӽФȤǤäƳ륯饹ȤΥ֥饹Υ
åɤ餷ƤӽФȤǤʤ

˥᥽åɤ硤饹γˤdefϴؿŪ᥽
ɤ饹ˤdef̾Υ᥽åɤ롥
ѡ饹Υ᥽åɤˤ᥽åɤβĻϥ
ѡ饹Υ᥽åɤΤΤѤ

᥽åɤβĻѹˤModule饹export/unexport᥽
ɤѤ롥

** ðۥ᥽å

᥽åˤϤ⤦ðۥ᥽åɤ롥ðۥ᥽åɤȤϤ
Υ֥Ȥ˸ͭΥ᥽åɤǤ롥ϰʲ̤Ǥ롥

   def  `.' ᥽å̾ [`('  [`,' ...][`,' `*' ] `)']
       
   end

ηϼͤǤ륪֥Ȥðۥ᥽åɤ롥ͤ 
(ӥȥ󥯥饹Ǥʤ)̾索֥Ȥ饹ޤϥ⥸塼Ǥ
ɬפ롥̾᥽åȤϰۤʤꡤðۥ᥽åɤϥ᥽å
ǤͥȤ뤳ȤǤ롥

ðۥ᥽åɤ̾ϷѾʤ㳰Ȥƥ饹ðۥ᥽åɤϤ
Υ֥饹ˤѾ롥ؤХ饹ðۥ᥽åɤ¾Υ
Ȼظƥˤ륯饹᥽åɤƯ򤹤롥

** INCLUDE

⥸塼򥤥󥯥롼ɤ뤳Ȥˤäơ饹ޤϥ⥸塼˵ǽ
ɲäǤ롥⥸塼򥤥󥯥롼ɤ硤Υ⥸塼(
Υ⥸塼뤬˥󥯥롼ɤƤ⥸塼)ƤΥ᥽åɤ
Ѥ̤Τ򤹤Х󥯥롼ɤϸꤵ줿¿ŷѾȤ롥

¾Υ⥸塼򥤥󥯥롼ɤ빽ϰʲ̤Ǥ롥

   include ⥸塼̾ [`,' ⥸塼̾...]

ߤΥ饹ޤϥ⥸塼(ȥåץ٥ǤObject饹)˻
ꤷ⥸塼򥤥󥯥롼ɤ롥

** ALIAS

ʲηǥ᥽åɤ̾Ĥ뤳ȤǤ롥

   alias ᥽å̾1 ᥽å̾2

̾դ줿᥽åɤϡλǤΥ᥽åѤΥ
åɤƤ⡤Ť᥽åɤƤӽФ줿ΤƱƯ
롥

** UNDEF

᥽åɤäˤundefѤ롥

   undef ᥽å̾

ꤷ᥽åɤä

defˤ̾undefˤäȤȥ饹Υ󥿥ե
򥹡ѡ饹Ωѹ뤳ȤǤ롥᥽åɤself 
˥åäƤ⤢Τǡ褯դʤȴ¸Υ᥽å
ưʤʤǽ롥

* Ȥ߹ߴؿ

Rubyˤϸ̩ʰ̣ǤϴؿϤʤKernel饹δؿ᥽åɤ(Ƥ
̾說饹ؿǸƤӽФΤ)ؿŪѤ롥ؿŪ
Ѥ᥽åɤʲˤ롥Υ᥽åɤݤˤϸ
ͤƹԤʤ٤Ǥ롥

   _exit(status)

	ץμ¹Ԥλ롥statusλơȤ롥
	exit()Ȥϰäơ㳰ʤɤϰڹԤʤʤfork()θ塤
	ץλʤɤѤ롥

   do()

	֥å1٤¹Ԥ륤ƥ졼֥åޤȤ뤿
	¸ߤ롥Ȥ:

	  do { foobar() } while (baz())

   eof()

	ޥɥ饤󤫤ϤEOFãƤ硤֤

   eval(expr)

        exprȤͿ줿ʸrubyץȤƲᡤ¹Ԥ롥

   exec(command)

        ߼¹ԤƤץλơcommandʸǻꤵ
        ̥ץư롥

   exit([status])

        ץμ¹Ԥλ롥statusȤͿ줿硤
        ͤRubyޥɤνλơȤ롥ǥեȤ0

   fork()

        forkƥॳ¹Ԥҥץ롥ܺ٤
        fork(2)򻲾ȤΤȡƥץ¦ǤϻҥץΥץid
        ֤ҥץ¦Ǥnil֤餫θǻҥץ
        ˼Ԥˤ㳰ȯ롥

   format(format, ...)

        եޥåȤȤͿ줿ʸCsprintfƱ褦
        ᤷŸʸ֤᥽åsprintf()̾

	RubyˤformatҤγĥˤĤƤsprintf()ι򻲾Ȥ
	ȡ

   getc()

        ɸϤʸФͤɤ߹ʸʸ
        (ASCII)ɽFixnumǤ롥

   getenv(name)

        name˳ĶѿФ$ENV[name]Ʊ

   gets()

        ȤͿ줿ե(ʤɸ)ǹ벾
        Ūʥե(ƥѿ`$<'ǥǤ)ɤ߹
        ǡɤ߹ߤˤϤʸ֤եν
        ãˤnil֤Ԥζڤϥƥѿ`$/'ˤä
        ѹǤ롥ɤ߹ʸϥƥѿ`$_'ˤ⥻åȤ롥

   gsub(pattern, replace)

        ƥѿ`$_'λؤʸФִԤʤʸ
        pattern˥ޥåʬreplace֤롥String饹
        gsub᥽åɤβ򻲾ȤΤȡgsub᥽åɤ`$_'ͤ򹹿
        롥

   iterator_p()

        ᥽åɤƥ졼ȤƸƤӽФ줿˿Ǥʤ˵
        ֤Ҹ졥

   kill(signal, pid...)

        pidǻꤵ줿ץ˥ʥ롥ʥϥʥ
        椫̾ǻꤹ롥ͤĥʥ(뤤ϥʥ̾
        `-')ͿȥץǤϤʤץ롼פ˥ʥ
        롥

   load(file)

        fileɤ롥fileɤѥϥƥѿ$LOAD_PATH
        Ƿꤵ롥

   open(file[, mode])

        file򥪡ץ󤷤ơFile֥Ȥ֤ե̾ϥ
        󤹤ե򼨤ե̾`|'ǻϤޤˤ³ʸ
        򥳥ޥɤȤƵưѥץ饤롥

        ޥ̾"-"Ǥopen()Rubyλҥץ
        λҥץȤΥѥפ֤

        modeϥեΥ⡼ɤꤹ롥ϰʲΤΤ
        줫ʸǤ롥

            r   ɤ߹ѡopenեϤ餫¸ߤƤ
                ɬפ롥

            r+  ɤ߽ξѡopenեϤ餫¸ߤƤ
                ɬפ롥

            w   񤭹ѡե뤬¸ߤƤ硤Ĺ0ˤ
                롥¸ߤƤʤп˥ե롥

            w+  ɤ߽ξѡɤ߹ߤԤʤ뤳Ȱʳ"w"ƱƯ
                򤹤롥

            a   ɲý񤭹ѡեϤ餫¸ߤƤɬ
                롥񤭹ߤϥեκǸɲä롥

            a+  ɤ߽ξѡե뤬¸ߤƤʤп˺
                롥֤ϥեκǸ˽롥

        ⡼ɤά줿ΥǥեȤ"r"Ǥ롥

   print(arg1, ..., argn)

        ˽Ϥ롥Ϳʤˤϥ쥷ФϤ롥
        ʸʳΥ֥ȤȤͿ줿ˤϡ
	֥Ȥto_s᥽åɤˤäʸѴƤϤ롥
        ƥѿ`$;'(ϥեɥѥ졼)nilǤʤͤ
        ȤƤˤϡưδ֤ˤʸϤ롥ƥ
        ѿ`$\'(ϥեɥѥ졼)nil ǤʤͤåȤ
        ˤϡǸˤϤ롥

   printf([port, ]format, arg1, ..., argn)

        Cprintf()Ʊformat˽ʸѴϤ
        롥1IOΥ֥饹Υ󥹥󥹤ǤäϤΥ
        ֥ȤФƽϤԤʤǥեȤ$stdout˽Ϥ롥

	RubyˤformatҤγĥˤĤƤsprintf()ι򻲾Ȥ
	ȡ

   rand(max)

        0maxۤʤϰϤȯ롥ͤFixnum

   require(file)

	fileɤ롥loadȤưΰ㤤requireϥɤե
	Υեѥѿ`$"'˳ФƤơ˥ɤե
	ƥɤʤǤ롥ºݤ˥ɤˤ%TRUE˥
	ɤƤˤ%FALSE֤

   select(reads[, writes[, execpts[, timeout]]])

        select(2)¹Ԥ롥reads/writes/execptsˤIO(ޤϤΥ
        饹)Υ󥹥󥹤Ϳ롥timeoutFixnum / Float
        / TimeΤ줫ǻꤹ롥ͤtimeoutΩˤ
        nilǤʤȤ3Ǥ֤γǤ//
        㳰ԤΥ֥ȤǤȤƻġ

   setenv(name, value)

        nameǻꤵĶѿvalue˥åȤ롥$ENV[name]=value
        ƱƯ򤹤롥

   sleep([sec])

        secäץμ¹Ԥߤ롥secά줿硤ץ
        SIGALRMʤ¤ꡤʵפ˥꡼פ롥ºݤ˥꡼
        פÿ֤

   sprintf(format, ...)

        formatʸCsprintfƱ褦˲ᤷŸ
        ʸ֤᥽åformat()̾


	formatҤCsprintf()դ(Ruby
	 unsignedʤΤǡ%uϽ)˲ä, %b, %B, %O, %XȤ
	ȤǤ롥%bϿͤ2ɽ%B, %O, %XϤ줾2ʡ8ʡ
	16ʿɽԤʤονκݤ2ɽǤϤʤ
 	ɽƬ`-'ĤΤɽ롥

   srand([])

        νͤꤷŤ֤ͤͤά줿
        time(3)֤ͤǥեȤȤ롥

   sub(pattern, replace)

        ƥѿ`$_'λؤʸФִԤʤʸǺ
        pattern˥ޥåʬreplace֤롥sub᥽å
        `$_'ͤ򹹿롥¾ξܺ٤˴ؤƤString饹sub
        ᥽åɤβ򻲾ȤΤȡ

   syscall(num, arg...)

	numǻꤵ줿ֹΥƥॳ¹Ԥ롥2ʹߤ
	ƥॳΰȤϤʸޤǤʤ
	ʤʤ

   system(command)

        ޥɤ¹Ԥνλơ֤

   trap(command, signal...)

        signalγߤäcommand¹Ԥ롥signalϥ
        ʥ̾ʥֹ桥commandȤ"SIG_IGN"ޤ"IGNORE"
        ꤷˤϤΥʥ̵뤹(ǽʤ)"SIG_DFL"
        "DEFAULT"ꤷϥǥեȤưԤʤ

   wait()

        ҥץλΤԤλҥץpid֤
        ҥץĤʤnil֤

   waitpid(pid, flags)

        λҥץνλԤΥץλ˿
        ҥץ¸ߤʤΥ֥å󥰥⡼ɤǻҥץ
        ޤλƤʤˤnil֤waitpid(2)wait4(2)
        ƤʤޥǤflagsϤĤnilޤ0ǤʤФ
        ʤ

* Ȥ߹ѿ

   $!           顼åfailꤹ롥

   $@           顼ȯΥե̾ȹֹ椬

                    "ե:ֹ[:᥽å̾()]"

                ηǳǼ롥

   $&           Ǹѥޥå

   $`		ǸΥѥޥåǥޥåʸʸ

   $'		ǸΥѥޥåǥޥåʸθ³ʸ

   $+		ǸθѥǥޥåǸγ

   $1..$9       Ǹѥޥånܤγ̤˥ޥå
                ͤǼ롥̤ʤniläƤ롥

   $~           ǸΥޥå˴ؤ󡥤򥻥åȤ$&$1..$9
                ͤѲ롥

   $=           ѿͤnilǤʤѥޥåʸ
                Ӥǥե٥åȤʸʸ̤ʤǥե
                Ȥnil(̤)

   $/           ϥ쥳ɥѥ졼եʸФeach
                Ԥʤʬʸꤹ롥$/˶ʸ("")ꤹ
                ñ̤ϤԤʤnilꤹΤ
                ɤ߹ࡥ$/ˤɽϻȤʤǥեȤ
                "\n"

   $\           ϥ쥳ɥѥ졼ѿʸꤹ
                write()print()٤˺ǸˤʸղäƽϤ
                롥ǥեȤnil(ʤˤɲäʤ)

   $,		Array:join()ΥǥեȤζڤʸprint()γư
		δ֤˽Ϥʸ

   $;		String:split()ΥǥեȤζڤʸ

   $.           Ǹɤϥեιֹ桥

   $<		(ʤɸ)ǹ벾ۥե롥Ĥޤ
		gets()$<.gets()Ʊ̣Ǥ롥$<.fileǸɤ߹
		Υե륪֥Ȥ$<.filenameǤΥե
		̾롥(Ф: `<'ϥϸ)

   $>		printprintfΥǥեȤν补ͤ$stdout-i 
		ץꤷˤɤ߹߸Ʊ̾Υե
		롥(Ф: `>'ϥν)

   $_           Ǹgets()ʤɤɤ߹ʸ

   $0           rubyץȤ̾ѿps(1)ν
		Ѳ롥

   $*           rubyץȤͿ줿rubyȤФ
                Ƥ롥

   $$           ߼¹rubyץpid

   $?           Ǹ˼¹Ԥҥץstatus

   $:		եɤ˸ǥ쥯ȥؤΥѥ
                ޤ󡥵ưˤϥǥե(ѥ˻ꤹ
                )˲äơĶѿRUBYLIBͤrubyư-Iץ
                ǻꤵ줿ͤɲä롥(Ф: ϴĶ
                PATHζڤʸǤ)

   $"		˥ɤ줿ե̾ޤrequire()Ʊ
		ե2ɤʤѤ롥(Ф:
		prevent files to be doubly quoted(loaded))

   $ARGF	$<̾

   $ARGV        $*̾

   $DEBUG	`-d'ե饰ξ()

   $ENV		Ķѿ˥Ϣʸ򥭡ȤͿ
		бĶѿͤ롥Ķѿ¸ߤ
		nil֤롥

   $FILENAME	ۥե`$<'Ǹɤ߹(᥽ågets()
	     	ɤǤ)ե̾$<.filenameƱ

   $LOAD_PATH   $:̾

   $stdin       ɸ
   $stdout      ɸ
   $stderr      ɸ२顼

   $VERBOSE	`-v'ե饰ξ()

   $VERSION     rubyΥС򼨤ʸ


   %TRUE        t
   %FALSE       nil

        줾쿿ͤɽȽǤnil򵶡ʳƤͤ
        ȤȽǤ뤿ᡤ%TRUEͤɽŪʿͤȤʾΰ
        ̣ʤäơ᥽åɤͤǤȤȤȡ
        줬%TRUE֤ȤȤϸ̩ˤƱǤϤʤ(ҸŪѤ
        ᥽åɤ񿿤ͤȤ%TRUE֤褦ˤϤʤäƤ
        )Ĥޤ

	  if some.method() then .. else .. end

	

	  if some.method() == %TRUE then .. else .. end

        ϴˤƱǤϤʤ%FALSE˴ؤƤϡΤ褦
        ʤ

* Ȥ߹ߥ饹ȥ⥸塼

** Array(饹)

źȤΥ饹Ǥ롥ϰŪˤ``[...]''
Ԥʤ롥

SuperClass: Object

Included Modules: Enumerable

Methods:

   self[nth]
   self[start..end]
   self[start, length]

        Ǥ˥롥ǽηǤnthܤǤ
        ֤2ܤηǤstartܤǤendܤǤޤ
        ʬ֤3ܤηǤstartܤlengthĤǤޤ
        ʬ֤

   self[nth] = val
   self[start..end] = val
   self[start, length] = val

        Ǥѹ롥ǽηǤnthܤǤval
        ѹ롥2ܤηstartܤǤendܤǤޤǤ
        valѹ롥3ܤηǤstartܤlengthĤǤval
        ѹ롥

        2ܡ3ܤηǤvalǤʤФʤʤ

        :

          ary = [1, 2, 3, 4, 5]
          ary[0..2] = [0, 0] # Ƥ [0, 0, 4, 5]
          ary[1, 0] = [7]    # Ƥ [0, 7, 0, 6, 5]

   self + other

        Ϣ롥selfotherξƤҤ
        ֤

   self * times

        η֤

   self - other

        κ黻selfotherǤƤο
        ֤ʣǤ1٤롥

   self * other

	ѱ黻ξ˴ޤޤǤʤ뿷֤
	ʣǤ1٤롥

   self | other

	±黻ξˤ줫˴ޤޤǤƴޤ࿷
	֤ʣǤ1٤롥

   self << obj

        objɲä롥self֤ΤC++ŪϢǤ롥

   assoc(key)

        Ϣۥꥹ(CONSڥǤȤ)򸡺1Ǥkey
        ("=="Ӥ)֤

   clear

	礭0ˤ롥

   delete(val)

	valȰפǤ롥

   delete_if

        Ǥ륤ƥ졼֥åɾͤλб
        Ǥ󤫤롥

   each

        γǤͿ륤ƥ졼

   fill(val)
   fill(val, start[, length])
   fill(val, start..end)

	(λꤵ줿ʬ)Ǥͤvalꤹ롥2֤η
	lengthά줿νޤǤĹȤ롥ꤵ줿
	ʬ󤬸ϰϤۤϼưŪ˳ĥ롥

   index(val)

	valǽǤΥǥå֤Ǥ¸
	ʤnil֤

   indexes(ary)
   indexes(index-1, ..., index-n)

	1ܤηǤȤƼơǤ򥤥ǥ
	ȤǤޤ֤2ܤηǤϳưͤ
	ǥåȤǤޤ֤

   join([sep])

        ǤϢ뤷ʸ֤ǤʸѴ졤
        sep򶴤Ϣ뤵롥sepά줿ˤϥƥѿ`$,'
        ͤѤ롥

   length
   size

        Ĺ(ǿ)֤

   push(obj)

        objɲä롥

   pack(template)

        Ƥtemplateʸˤäơ1Ĥʸ˥ѥå
        롥ѥåʸ֤ƥץ졼ȤϷʸȤĹ
        (ά1)¤٤ΤǤ롥ĹȤ`*'ꤵ줿
        ֻĤΥǡơפĹɽ

        ʸϰʲΤΤ롥

          a     ASCIIʸ(nullʸͤ)
          A     ASCIIʸ(ڡͤ)
          b     ӥåȥȥ(̥ӥåȤ̥ӥå)
          B     ӥåȥȥ(̥ӥåȤ鲼̥ӥå)
          h     16ʸ(̥˥֥뤬)
          H     16ʸ(̥˥֥뤬)
          c     char
          C     unsigned char
          s     sort
          S     unsigned sort
          i     int
          I     unsigned int
          l     long
          L     unsigned int
          n     ͥåȥХȥshort
          N     ͥåȥХȥlong
          f     ñư(¸)
          d     ư(¸)
          x     ʥХ
          X     1Хȸ
          @     а֤ؤΰư

   pop

        Ǥơ֤

   rassoc(value)

        Ϣۥꥹ(2ǤǤȤ)򸡺2Ǥ
        value("=="Ӥ)֤

   shift

        ƬǤơ֤

   sort

        Ƥ򥽡Ȥ롥ƥ졼ȤƸƤӽФ줿ϥ֥
        ɾͤǤ羮ꤹ롥礭
        0顥̾Υ᥽åɤȤƸƤӽФ줿ϳ
        `<=>'Ӥ롥

   to_a

	ʬȤ֤оΤѰդƤ᥽åɤǤޤ
	򤯤ʤ

   unshift(obj)

        objƬɲä롥

Single Methods:

   Array[item...]

	ǤȤ롥

** Bignum(饹)

̵¿ĹΥ饹黻η̤FixnumϰǤˤϼ
ưŪ˥饹FixnumѴ롥ŪRubyץǤFixnum 
BignumѴϰۤΤ˹ԤΤǡռɬפ̵FloatȤ
˴ؤƤϡBignum Floatgenericity⤤Τˤؤ餺
Bignum礭ͤɽǤΤǡѴ˷ǽ
롥


SuperClass: Integer

Methods:

   self + other
   self - other
   self * other
   self / other
   self % other
   self ** other

        ѱ黻줾¡ѡ;Ѿ֤

   ~ self
   self | other
   self & other
   self ^ other

        ӥåȱ黻줾ӥåȿž¡ѡ¾Ū¤
        ֤

   self << bits
   self >> bits

        եȱ黻줾bitsӥåȤ˥ӥåȥեȤԤʤ

   divmod(other)

	Ⱦ;2Ǥ֤

** Block(饹)

ƥ졼Ϥ³ޤȤ᤿֥ȡ¹Ԥ륳ɤ
ʤƥ(ѿ)ʤɤ¸롥

SuperClass: Object

Methods:

    call(arg[, ...])

	֥å¹Ԥ롥

Single Methods:

    new

	֥å롥yield¹ԤǤǤΥ᥽å
	ƤФȡλǼ¹Ԥ٤ɤ߹֥
	(Block)롥

** Class(饹)

饹Υ饹긷̩ȥ饹ðۥ᥽åɤѾ뤿
ˡ줾᥿饹ȸƤФ̾Τʤ饹򥯥饹Ȥƻ
ClassϤΥ᥿饹Υ饹Ǥ(ʬä?)β⤬
ǤʤƤ⡤RubyȤȤ˲λپʤ饹ˤðۥ᥽åɤ
Ǥȡѡ饹줿ðۥ᥽åɤϤΥ֥饹
ǤͭǤΤнʬǤ롥

SuperClass: Module

Private Methods:

   attr(name[, public])

	Υ饹Υ󥹥󥹤Фnameǻꤵ°롥
	ܤModuleattr᥽åɤι򻲾ȤΤȡ

Methods:

   new(...)

        饹Υ󥹥󥹤롥¿ξ礳Υ᥽åɤϥ֥
        饹ðۥ᥽åɤˤäƥС饤ɤ졤饹ˤäư
        ۤʤ롥

** Comparable(⥸塼)

ӱ黻饹ΤMixinΥ⥸塼򥤥󥯥롼ɤ뤳
Ȥˤäơ`<=>'黻Ҥ¾α黻ҤϤѤ
Ǥ롥

Methods:

   self == other

        selfother֤

   self > other

        selfother礭֤

   self >= other

        selfother礭֤

   self < other

        selfother꾮֤

   self <= other

        selfother꾮֤

   between(min, max)

        selfminmaxϰˤ֤

** Cons(饹)

ǡ(ڥ)ɽ륯饹̾`::'黻ҤѤƹԤʤ
롥LispCONSڥƱͤListѤ뤳Ȥ⤢롥
Cons饹Υ᥽å`[]',`[]=',`each'CONSڥʤꥹȤФ
ư褦߷פƤ롥

:
	a=1::2::3
	a[0]		# a[0] => 1
	a[2] = 5	# a => 1::5::3
	for i in a
	  print i
	end		# prints `153'

SuperClass: Object

Included Modules: Enumerable

Methods:

   self [nth]

	CONSڥʤꥹȤnthܤǤ֤бǤ¸
	ߤʤnil֤

   self [nth]= val

	CONSڥʤꥹȤnthܤǤѹ롥ꥹȤĹ
	nthǻꤷĹûơбǤ¸ߤʤ
	㳰ȯ롥nthꥹȤĹˤϥꥹȤ
	Ǥɲä롥

   car

	CONSڥΥǡCAR֤

   car=(val)

	CONSڥCARΥǡѹ롥

   cdr

	CONSڥΥǡCDR֤

   cdr=(val)

	CONSڥCDRΥǡѹ롥

   copy

	CONSڥʤꥹȤʣ֤(shallow copy)

   each

	CONSڥʤꥹȤγǤͿ륤ƥ졼

** DBM(饹)

NDBMե򥢥륯饹ǡȤʸǤʤФ
ʤȤ¤ȡǡե¸ȤƤ 
Dict饹Ʊͤ˰ȤǤ롥NDBMƤʤƥǤ
Υ饹ʤ

SuperClass: Object

Included Modules: Enumerable

Methods:

   self [key]

        key򥭡Ȥ֤ͤ

   self [key]= value

        key򥭡ȤơvalueǼ롥valueȤnilꤹȡ
        keyФܤκȤʤ롥

   clear

	DBMեȤˤ롥

   close

        DBMե򥯥롥ʸ㳰ȯ롥

   delete(key)

        key򥭡ȤȤ롥

   delete_if

	Ǥ륤ƥ졼key::valueȤڥͿơ֥
	ɾͤλܤ롥

   each
   each_pair

        key::valueʤڥͿ륤ƥ졼

   each_key

        ƤkeyФƷ֤ƥ졼

   each_value

        ƤvalueФƷ֤ƥ졼

   has_key(key)
   includes(key)

        keyǡ١¸ߤ֤

   has_value(value)

        valueͤȤȤǡ١¸ߤ
        ֤

   indexes(ary)
   indexes(key-1, ..., key-n)

	1ܤηǤʸȤƼơǤ򥭡
	ȤǤޤ֤2ܤηǤϳưͤ򥭡
	Ǥޤ֤.

   keys

        ǡ١¸ߤ륭Ƥޤ֤

   length
   size

	ǡ١Ǥο֤(:ߤμ¸Ǥǿ
	뤿˥ǡ١Τǡ빽Ȥ⤤
	ĤƻȤ.)

   to_a

	ǡ١key-valueڥǤȤ֤

   values

        ǡ١¸ߤƤޤ֤

Single Methods:

   open(dbname[, mode])

        dbnameǻꤷǡ١⡼ɤmodeꤷƥץ
        롥modeξάͤ0666Ǥ롥modeȤnilꤹȥǡ
        ١¸ߤʤˤϿ˥ץ󤻤nil֤

** Dict(饹)

񤢤뤤ϢǤդΥ֥ȤźȤǤΥ饹Ǥ
롥HashȤ̾Ǥ⥢Ǥ롥Ϣ󥪥֥Ȥϰ
ŪˤϢ``{a=>b,..}'' ǹԤʤ롥

SuperClass: Object

Included Modules: Enumerable

Methods:

   self [key]

        key򥭡Ȥ֤ͤ

   self [key]= value

        key򥭡ȤơvalueǼ롥valueȤnilꤹȤ
        keyФܤκȤʤ롥ĤޤꡤDictͤȤnil
        ȤϤǤʤ

   clear

	Ϣˤ롥

   delete(key)

        key򥭡ȤȤ롥

   delete_if

	Ǥ륤ƥ졼key::valueȤڥͿơ֥
	ɾͤλܤ롥

   each
   each_pair

        key::valueʤڥͿ륤ƥ졼

   each_key

        ƤkeyФƷ֤ƥ졼

   each_value

        ƤvalueФƷ֤ƥ졼

   has_key(key)
   includes(key)

        key¸ߤ֤

   has_value(value)

        valueͤȤȤ¸ߤ֤

   indexes(ary)
   indexes(key-1, ..., key-n)

	1ܤηǤȤƼơǤ򥭡Ȥ
	Ǥޤ֤2ܤηǤϳưͤ򥭡Ȥ
	ޤ֤

   keys

        ¸ߤ륭Ƥޤ֤

   length
   size

	Ǥο֤

   to_a

	key-valueڥǤȤ֤

   values

        ¸ߤƤޤ֤

Single Methods:

   Dict[key, value...]

	ܤΰkeyܤΰvalueȤ뼭롥

   new

        ()񥪥֥Ȥ֤

** Directory(饹)

ǥ쥯ȥǤ֤ǥ쥯ȥꥹȥ꡼ΤΥ饹
DirȤ̾Ǥ⥢Ǥ롥

SuperClass: Object

Included Modules: Enumerable

Methods:

   close

        ǥ쥯ȥꥹȥ꡼򥯥롥ʸ㳰ȯ
        롥

   each

        ǥ쥯ȥγǤͿ륤ƥ졼

   getwd
   pwd

        ȥǥ쥯ȥ֤

   rewind

        ǥ쥯ȥꥹȥ꡼Ƭ˥ꥻåȤ롥

   seek(pos)

        ǥ쥯ȥꥹȥ꡼ΰ֤posꤹ롥

   tell

        ǥ쥯ȥꥹȥ꡼θߤΰ֤֤

Single Methods:

   chdir(path)

        ȥǥ쥯ȥpathѹ롥

   chroot(path)

        ץΥ롼ȥǥ쥯ȥѹ롤Ʊ̾Υƥॳ
        ƱƯ򤹤롥ϼ¸uidѥ桼Ǥ
        ¤Ƥ롥롼ȥǥ쥯ȥ򸵤᤹(롼ȥǥ쥯
        ѹ)ˡ󶡤Ƥʤ

   mkdir(path[, mode])

        modeǻꤵ줿⡼ɤĥǥ쥯ȥpath롥⡼
        umaskˤäƽ롥modeΥǥեͤ0777

   open(path)

        pathФǥ쥯ȥꥹȥ꡼򥪡ץ󤹤롥

   rmdir(path)

        pathǻꤵ줿ǥ쥯ȥ롥ǥ쥯ȥ϶Ǥ
        ɬפ롥

** Enumerable(⥸塼)

ǤФ뷫֤Ԥʤ饹ΤMixinΥ⥸塼򥤥
롼ɤ뤿ˤϡ᥽å`each'ɬפ롥

Methods:

   collect

        ǤФƥ֥åɾ̤ƴޤ֤

   find

        ǤФƥ֥åɾͤˤʤäǽǤ֤

   find_all

        ǤФƥ֥åɾͤǤäǤƴޤ
        ֤

   grep(pattern)

         =~ patternפΩƤǤޤ֤
        졼ȤѤ줿Ͼ嵭ξΩǤФƥ֥
        ¹Ԥ롥

   includes(val)

	val`=='δطˤǤĻ֤

   index(val)

	val`=='δطˤ륪֥Ȥܤ˸줿֤
	ֺǽǤ0ˤʤ롥Ǥ¸ߤʤˤnil֤
	ʤ饹ФƤϤޤ̣ʤ

   length

	Ǥο֤

   min

	ǾǤ֤ƤǤߤ`<=>'᥽åɤӤǤ
	뤳ȤꤷƤ롥

   max

	Ǥ֤Ǥ`<=>'᥽åɤӤǤ뤳Ȥ
	Ƥ롥

   reverse

        ƤǤս¤٤֤

   sort

        ƤǤ򥽡Ȥ֤

** Etc(⥸塼)

/etcǥ쥯ȥʲξ뤿Υ⥸塼롥饹˥󥯥롼
ƻȤȤǤ롥

Methods:
Single Methods:

   getlogin

	ʬlogin֤̾줬Ԥgetpwuid()Ѥ
	ɤ

   getpwnam(name)

	/etc/passwdե(뤤DBMեNISǡ١)
	name̾passwdȥ֤ͤpasswd¤
	ΤǰʲΥФġ

	  struct passwd
	    name 	# 桼̾(ʸ)
	    passwd	# ѥ(ʸ)
	    uid		# 桼ID()
	    gid		# 롼ID()
	    gecos	# gecosե(ʸ)
	    dir		# ۡǥ쥯ȥ(ʸ)
	    shell	# 󥷥(ʸ)
	    # ʹߤΥФϥƥˤäƤ󶡤ʤ
	    change	# ѥѹ()
	    quota	# ()
	    age		# ()
	    class	# 桼饹(ʸ)
	    comment	# (ʸ)
	    expire	# ͭ()	    
	  end

	ܺ٤getpwnam(3)򻲾ȤΤȡ

   getpwuid([uid])

	uid桼IDȤpasswdȥ֤ͤgetpwnam()
	ƱͤǤ롥άˤgetuid()ͤѤ롥ܺ٤
	getpwuid(3)򻲾ȤΤȡ

   getgrgid(gid)

	/etc/groupե(뤤ϡgetpwnam)򸡺gid򥰥롼
	IDȤ륰롼ץȥ֤ͤgroup¤Τǰʲ
	Фġ

	  struct group
	    name 	# 롼̾(ʸ)
	    passwd	# 롼פΥѥ(ʸ)
	    gid		# 롼ID()
	    mem		# 롼ץ̾
	  end

	ܺ٤getgrgid(3)򻲾ȤΤȡ

   getgrnam(name)

	nameȤ̾Υ롼ץȥ֤ͤgetgrgid()Ʊ
	ͤǤ롥ܺ٤getgrnam(3)򻲾ȡ

   group

	ƤΥ롼ץȥ˥뤿Υƥ졼

   passwd

	Ƥpasswdȥ˥뤿Υƥ졼

** File(饹)

ե륢ΤΥ饹᥽åopen()롥ޤ
饹ðۥ᥽åɤȤtestΥեƥȱ黻Υ᥽åɤ
Ƥ(FileTest⥸塼Υ᥽åɷ)

SuperClass: IO

Methods:

   atime

        եκǽ֤

   ctime

        եκǽơѹ֤

   chmod(mode)

        եΥѡߥåѹ(cf chmod(2))

   chown(owner, group)

        եνͭԤȥ롼פѹ(cf chown(2))nil-1
        ꤹ뤳ȤˤäƽͭԤ䥰롼פ򸽺ߤΤޤѤʤǤ
        ȤǤ롥

   eof

        եνüã˿֤

   lstat

        ե˴ؤStat¤Τ֤lstatϥե뤬ܥ
        󥯤ǤХ󥯤ΤΤ˴ؤStat¤Τ֤¤
        ƤˤĤƤstat򻲾ȤΤȡ

   mtime

        եκǽ֤

   rewind

        եΥեݥ󥿤ΰ֤Ƭ˰ư롥

   path

        եΥѥ֤̾

   seek(offset, ptrname)

        եΥեݥ󥿤ΰ֤offset˰ư롥ptrname
        012Τ줫Ǥäơ줾եƬ߰֡
        եνüΤΤ줫Ф򼨤

   stat

        ե˴ؤStat¤Τ֤(Struct 򻲾)

	  struct stat
	    dev	 	# ե¸ߤǥХ
	    ino		# եi-nodeֹ
	    mode	# ⡼
	    nlink	# ϡɥ󥯤ο
	    uid		# ͭԤΥ桼ID
	    gid		# ͭԤΥ롼ID
	    rdev	# ǥХID(ڥեΤ)
	    size	# ե륵(byte)
	    blksize	# ե륷ƥˤŬڤʥ֥å
	    blocks	# ֥å
	    atime	# ǽ
	    mtime	# ǽ
	    ctime	# ǽѹ
	  end

	ܺ٤fstat(2)򻲾ȤΤȡƥƤ
	stat¤Τ˳Фʤ0ꤵƤ롥

   tell

        եθߤΥեݥ󥿤ΰ֤֤

   truncate(length)

        եڤΤƤƺlengthХȤˤ롥եwrite⡼
        ɤǥץ󤵤ƤʤФʤʤ

Single Methods:

   atime(filename)

        filenameκǽ֤

   ctime(filename)

        filenameκǽơѹ֤

   chmod(mode, path, file...)

        եΥѡߥåѹ(cf chmod(2))ѹե
        ֤fileˤϥ磻ɥɤ

   chown(owner, group, file...)

        եνͭԤȥ롼פѹ(cf chown(2))nil-1
        ꤹ뤳ȤˤäƽͭԤ䥰롼פ򸽺ߤΤޤѤʤǤ
        ȤǤ롥ѹե֤fileˤϥ磻ɥɤ
        

   link(old, new)

        oldؤΥϡɥnew롥link(2)Ʊ¤롥

   mtime(filename)

        filenameκǽ֤

   readlink(path)

        ܥåpathƤʸȤ֤

   rename(from, to)

        ե̾fromtoѹ롥rename(2)ȡtoȤ̾
        Υե뤬¸ߤˤϤޤΥե뤬롥

   stat(filename)

        filenameΥեStat¤Τ֤

   symlink(old, new)

        oldؤΥܥånew롥

   truncate(path, length)

        pathǻꤵ줿եڤΤƤƺlengthХȤˤ롥

   type(filename)

	filenameΥեΥפɽʸ֤ʸ"file"
	"directory""characterSpecial""blockSpecial""fifo"
	"link""socket"ΤΤ줫ĤǤ롥

   unlink(file...)

        ե롥ǥ쥯ȥκˤDir.rmdirȤȡ
        fileˤϥ磻ɥɤ

   utime(atime, mtime, file...)

        եΥatimeˡmtimeꤹ롥
        atimemtimeϿޤTime饹Υ󥹥󥹤ǤʤФʤ
        fileˤϥ磻ɥɤ


 ʳFileTest⥸塼Υ᥽åɤðۥ᥽åɤȤƻġ

** FileTest(⥸塼)

եƥѥ᥽åɤ򽸤᤿⥸塼롥󥯥롼ɤѤ뤳
Ǥ롥

Methods:
Single Methods:

   b(filename)

        filenameΥե뤬֥åڥեǤ
        

   c(filename)

        filenameΥե뤬饯ڥեǤ
        ֤

   executable(filename)
   x(filename)

        filenameΥե뤬¹Բǽλ֤

   exists(filename)
   e(filename)
   a(filename)

        filenameΥե뤬¸ߤ֤

   G(filename)

        filenameΥեgid¸롼פgidƱ֤

   isdirectory(filename)
   d(filename)

        filenameǥ쥯ȥλ֤

   isfile(filename)
   f(filename)

        filenameΥե뤬̾եλ֤

   islink(filename)
   l(filename)

        filenameΥե뤬ܥå󥯤Ǥ֤

   ispipe(filename)
   p(filename)

        filenameΥե뤬̾Ĥѥ(FIFO)Ǥ֤

   issocket(filename)
   S(filename)

        filenameΥե뤬åȤǤ֤

   owned(filename)
   O(filename)

        filenameΥե¸桼ͭƤ֤

   readable(filename)
   r(filename)

        filenameΥեɤߤȤǽλ֤

   R(filename)

        filenameΥեuid/gidɤߤȤǽλ֤

   setuid(filename)
   u(filename)

        filenameΥեsetuidӥåȤåȤƤ֤

   setuid(filename)
   g(filename)

        filenameΥեsetuidӥåȤåȤƤ֤

   size(filename)
   s(filename)

        filenameΥե뤬¸ߤե礭֤¸ߤ
        ʤnil֤

   sticky(filename)
   g(filename)

        filenameΥեstickyӥåȤåȤƤ֤

   writable(filename)
   w(filename)

        filenameΥե뤬uid/gidǽ񤭹߲ǽλ֤

   W(filename)

        filenameΥե뤬񤭹߲ǽλ֤

   z(filename)

        filenameΥե뤬¸ߤ礭0Ǥ֤

** Fixnum(饹)

31bit(ޥlongĹ-1 bit)Υ饹builtin classǤ롥
饹pointer¨ͤǤ뤿call by valueǸƤӽФħŪ
Ǥ(¾Υ饹call by reference)黻η̤31bitۤ
ϼưŪBignum(̵¿Ĺ)˳ĥ롥

ƥ졼upto()downto()step()Ϸ֤ΤѤ졤̤
Range饹Ѥ®Ǥ롥

SuperClass: Integer

Methods:

   self + other
   self - other
   self * other
   self / other
   self % other
   self ** other

        ѱ黻줾¡ѡ;Ѿ֤

   ~ self
   self | other
   self & other
   self ^ other

        ӥåȱ黻줾ӥåȿž¡ѡ¾Ū¤
        ֤

   self << bits
   self >> bits

        եȱ黻줾bitsӥåȤ˥ӥåȥեȤԤʤ

   self .. max

        ϰϻꡥself  maxޤǤϰϥ֥Ȥ֤

   downto(min)

        ƥ졼selfminޤǲ˷֤

   id2name

	ͤIDȤߤʤơʸ֤ʸ
	¸ߤʤnil֤

   step(max, step)

        ƥ졼selfmaxޤstepѲʤ顤֤

   to_f

        selfFloatѴΤ֤

   to_i

        self򤽤Τޤ֤

   upto(max)

        ƥ졼selfmaxޤǷ֤

** Float(饹)

 ưΥ饹

SuperClass: Numeric

Methods:

   self + other
   self - other
   self * other
   self / other
   self % other
   self ** other

        ѱ黻줾¡ѡ;Ѿ֤

   self == other
   self > other

        ӱ黻

   coerce(num)

        numfloatѴ롥FloatǤ¾ο
        FixnumBignumǤ롥

   to_f

        self򤽤Τޤ֤

   to_i

        selfѴ̤֤

Single Methods:

   new(float)

	floatƱͤĿFloat֥Ȥ֤

** GC(⥸塼)

RubyȤ߹ߤgarbage collectorԤʤΥ⥸塼롥Υ
塼Υ᥽åɤѤ뤳ȤˤäơŪGCߤ᤿ꡤGCε
륿ߥ󥰤椷Ǥ롥

Methods:

   garbage_collect

        GC򳫻Ϥ롥GC.startפƱ

Single Methods:

   disable

        GCػߤ롥

   enable

        GCĤ롥

   start

        GC򳫻Ϥ롥

** Glob(饹)

磻ɥɤΥ饹磻ɥɤΥƥ<...>ȤǤ
롥ɽȤۤƱ褦˻Ȥ뤬ϵǽʤ
ɥɤŸǽ롥

SuperClass: Object

Included Modules: Enumerable

Methods: 

   self =~ string

        磻ɥɤʸ˥ޥåˤϿ򡤤ʤ
        nil֤

   each

	磻ɥɤ˥ޥåե̾Ϳ륤ƥ졼

Single Methods:

   new(string)

        ʸ磻ɥɤѴ֥Ȥ֤

** Integer(饹)

饹ºݤϤ礭ˤäFixnumBignumĤΥ֥饹
Ǽ¸Ƥ롥IntegerϤΥѡ饹Ȥʤݥ饹Ǥ
롥RubyǤϤۤȤɤξ硤FixnumBignumζ̤ɬפʤߤѴ
ϼưŪ˹Ԥʤ롥ӥåȤߤʤˤϡ̵¤Ĺ
ĥӥåȹͤƹʤ

SuperClass: Numeric

Methods:

   self[idx]

	idxӥåܤåȤƤ1åȤƤʤ
	0֤

   chr

	ο򥳡ɤȤʸޤ1ʸʸ֤̤
	Ĺ1ʾʸˤĤơδطΩ롥

		str[0].chr == str[0,1]

	ʸϰ(0..255)ˤʤ㳰ȯ롥

   is_integer

	Ĥ⿿֤

** IO(饹)

ϤΤδܥ饹

SuperClass: Object

Included Modules: Enumerable

Methods:

   self << object

        objectϤ롥objectʸǤʤˤϥ᥽åto_sѤ
        ʸѴ롥selfͤȤΤǡC++Τ褦`<<'
        ϢȤ롥

        :

            $stdout << 1 << " is a " << Fixnum << "\n"

   close

        ϥݡȤ򥯥롥ʸΤΥ֥ȤФ
        ϥ顼ˤʤ롥

   each

        Ԥɤ߹Ǥ뤿Υƥ졼Ԥζڤϥƥ
        `$/'ˤäѹǤ롥ɤ߹ʸϥƥѿ`$_'
        ⥻åȤ롥

   each_byte()

        ʸɤ߹Ǥ뤿Υƥ졼ʸʸɤɽ
        FixnumǤ롥

   fileno
   to_i

        IO֥ȤȤäƤեǥץ(Fixnum)֤

   flush

        Хåեեå夹롥

   getc

        ɤ߹ǡɤ߹ߤˤϤʸ֤ե
        νãˤnil֤ͥ᥽ågetc() 
        $stdin.getcƱ̣Ǥ롥

   gets

        ɤ߹ǡɤ߹ߤˤϤʸ֤ե
        νãˤnil֤

   isatty

        ϥݡȤttyǤ֤

   puts(obj)

        objϤ롥self << objפƱ̣Ǥ롥

   read([length])

        lengthХɤ߹ǡʸ֤lengthά줿
        ˤϡƤΥǡɤ߹ࡥ

   readlines

	եɤ߹ǳƹԤǤȤƤ֤

   sync

	ߤνƱ⡼ɤ򿿵֤ͤƱ⡼ɤλϽϴ
	θƽ˥Хåեեå夵롥

   sync=(newstate)

        Ʊ⡼ɤꤹ롥

   sysread(length)

        stdioͳread(2)ѤϤԤʤϤ줿ǡ
        ޤʸ֤եνãˤnil֤
        read(2)ˤɬlengthХȤʸɤ߹ޤ櫓
        ǤϤʤgets()getc()ʤstdioͳ᥽åɤȺѤ
        ȤϥХåե󥰤ʤɤǻפư򤹤뤳Ȥ롥

   syswrite(str)

        stdioͳˡwrite(2)ѤƽϤԤʤΥ᥽å
        ϥХåե󥰤ʤstdioƤ뤳ȤϰڹԤʤʤ
        syswriteϼºݤ˽񤭹Хȿ֤print()printf() 
        syswrite()ѤΤϿ侩Ǥʤ

   write(str)

        strϤ롥ϤХȿ֤

** Kernel(饹)

ƤΥ饹δ쥯饹RubyȤ߹ߤƤδؿ᥽åɤϤΥ饹
Ƥ롥ؿ᥽åɤˤĤƤϡִؿפιܤ򻲾ȤΤȡ

SuperClass: ʤ

Methods:

   ! self

        ꡥNon-nilΥ֥Ȥξ˵(nil)֤Υ᥽
        ɤNil饹ǤϺ쿿֤

   self == other
   equal(other)

        ֥ȤΰȽꡥ쥷ФȰΰפ
        ֤Kernel饹ǤΥ֥ȤƱλ
        "=="᥽åɤϳƥ֥Ȥ˱ƺɬפ
        롥"=="᥽åɤˤϡhash᥽åɤ⤽˹
        ƺɬפ롥

        equal()᥽åɤ"=="᥽åɤ̾ǡ"=="Ǥ
        ֥ȤƱȽԤʤѤ롥ä
        equal()᥽åɤϥ֥饹Ǻ٤ǤϤʤ

   self != other

        "=="ꡥ"=="᥽åɤƤӽФƤΤǡϺ
        ɬפϤʤ

   self =~ other

        ޥåǥեȤư"=="ƱǤ롥"=~"caseӤ
        Ѥ롥

   !~

        "=~"ꡥ"=~"᥽åɤƤӽФƤΤǡϺ
        ɬפϤʤ

   self :: other

        selfotherǤȤCONSڥ֤α黻ҤϱǤ
        Τǡa::b::c  (a::(b::c)) Ȳᤵ롥

   is_nil

        ֥ȤnilǤ뤫ɤKernel饹ǤϿ
        Nil饹ǺƤ롥

   id

        ƥ֥ȤФưդFixnum֤FixnumϼʬȤ
        ΤǡidפƤƱ֥ȤǤ뤳Ȥݾڤʤ
        Ĥޤꡤ

		obj1.id == obj2.id

	ΩƤ⡤ɤ餫FixnumǤСobj1obj2ƱǤ
	Ȥϸ¤ʤξFixnumǤʤȤݾڤǤС2
	ĤΥ֥ȤƱǤ뤳Ȥϳμ¤Ǥ롥

   hash

        ֥ȤΥϥå(Fixnum)֤Dict饹ǥȤʤ
        ֥ȤǼΤѤƤ.A == BפΩ
        ɬA.hash == B.hashפΩɬפΤǡ"=="
        ˤɬ⤽˹碌ƺ뤳ȡ


** Math(⥸塼)

ư黻򥵥ݡȤ륯饹Math⥸塼ƱΥ᥽å
ðۥ᥽åɤȤξƤΤǡðۥ᥽åɤƤӽФƻ
Ȥȡ饹˥󥯥롼ɤƻȤȤȤξǤ롥

  :

        pi = Math.atan2(1, 1) * 4;
        include Math
        pi2 = atan2(1, 1)

Methods:
Single Methods:

   atan2(x, y)

        С-ФϰϤX/YΥ󥸥Ȥ֤

   cos(x)
   sin(x)
   tan(x)

        饸ɽ줿xλѴؿ֤ͤ

   exp(x)

        xλؿؿ֤ͤ

   log(x)

        xμп֤

   log10(x)

        xξп֤

   sqrt(x)

        xʿ֤xͤǤˤ㳰ȯ롥

   cbrt(x)

        xΩ֤

** Module(饹)

⥸塼Υ饹

SuperClass: Object

Private Methods:

   attr(name[, public])

	Υ⥸塼򥤥󥯥롼ɤ饹Υ󥹥󥹤Ф 
	nameǻꤵ°ղä°Ф륢᥽åɤ
	롥attr("attr")ϥ饹˰ʲ˼ɤɲä
	ȤۤƱǤ롥

	  def attr; @attr; end

	άǽ2publicͿơĤͤnilǤʤ
	Ϥ°ˤ°᥽åɤѰդ졤ǽˤ
	롥attr("attr", %TRUE)ϥ饹˰ʲΥɤɲä
	ȤۤƱǤ롥

	  def attr; @attr; end
	  def attr=(val); @attr = val; end

	°᥽åɤ뤳Ȥˤäơư
	ѹǤ롥㤨

	  attr("test", %TRUE)
	  def test=(val)
	    print("test was ", @test, "\n")
	    print("and now is ", @test = val, "\n")
	  end

	Τ褦°ͤɽ褦ʤȤǽǤ롥attr
	ϥ᥽åɤǤƤϡǥեȤΥ
	᥽åɤʤ

Methods:

   export(name[, name..])

	nameǻꤵ줿᥽åɤ̾ǸƤӽФǽˤ롥Ǥ
	̾᥽åɤǤˤϲ⤷ʤ

   to_s

        ⥸塼ʸɽ֤⥸塼ξʸɽϥ
        塼̾Ǥ롥

   unexport(name[, name..])

	nameǻꤵ줿᥽åɤؿǤƤӽФǽˤ롥
	Ǥ˴ؿ᥽åɤǤˤϲ⤷ʤ

** Nil(饹)

ɽ֥nilΥ饹ѿ()nilNil饹ͣΥ
󥹥󥹤Ǥ롥

SuperClass: Kernel

Methods:

   self + other

	otherưʸǤother֤

   ! self

        ˿֤

   is_nil

        ˿֤

** Numeric(饹)

̤ɽݥ饹

SuperClass: Object

Included Modules: Comparable

Methods:

   + self

        ֥selfΤΤ֤

   - self

        0 - selfפ֤֥ͤ饹ǤΨŪ˺뤳
        ȤԤ롥

   abs

	֤ͤ

   divmod(other)

	Ⱦ;Υڥ֤

   next

	ο֤οȤϤοۤǾǤ롥

** Object(饹)

Ƥ̾說饹Υѥ饹̾說饹Υ󥹥󥹤ΰŪʿ
Ƥ롥Υ饹Υ֥饹Ǥʤ饹KernelNilȡ
Ȥ߹ߴؿƤBuiltinǤ롥

SuperClass: Builtin

Methods:

   init_object


   is_member_of(class)

        ֥self饹classΥ󥹥󥹤Ǥ֤

   is_kind_of(class)

        ֥self饹classΥ֥饹Υ󥹥󥹤
        ֤

   clone

        ֥Ȥʣ롥󥹥󥹤¨ͤǤFixnum饹
        ʳΥ饹ξ硤obj.equal(obj.clone)פϵǤ뤬¿
        ξobj == obj.cloneפϿǤ롥

   to_s

        ֥Ȥʸɽ֤Υ᥽åɤŪprint()
        format()᥽åɤѤƤ롥

   to_a

	֥ȤѴ롥ͥ륯饹Ƥ
	եȤϡΥ֥ȼȤޤ1Ǥ֤

** Process(⥸塼)

ץ˴ؤԤʤΥ⥸塼롥Math⥸塼Ʊͤ
ƤΥ᥽åɤðۥ᥽åɤȤƤ̾Υ᥽åɤȤƤȤ롥
Processϥץ֥ȤΥ饹ǤϤʤơץΥ᥽
ɤޤȤ᤿ΤǤ뤳Ȥդ뤳ȡ

Methods:
Single Methods:

   egid

	ץθߤμ¸GID֤

   egid=(gid)

	ץθߤμ¸GIDgid˥åȤ롥
	
   euid

	ץθߤμ¸UID֤

   euid=(uid)

	ץθߤμ¸UIDuid˥åȤ롥
	
   getpgrp([pid])

	pidǻꤵ줿ץ߽°Ƥץ롼פid
	֤pidάpid0Ϳϸ߼¹ԤƤ
	оݤˤ롥

   getpriority(which, who)

	whichwhoǻꤵץץ롼ס桼θ
	̤֤ͥܺ٤getpriority(2)򻲾ȡProcess⥸塼
	ǤwhichȤƻǤ%PRIO_PROCESS%PRIO_PGRP
	%PRIO_USERƤ롥

   gid

	ץθߤμGID֤

   gid=

	ץθߤμGIDgid˥åȤ.

   pid

	ץΥץID֤ϥƥѿ`$$'ͤƱ
	롥

   ppid

	ƥץΥץΥץID֤UNIXǤľܤοƥץ
	λ硤ƥץpid1(initpid)ˤʤ롥

   setpgrp(pid, pgrp)

	pidǻꤵ줿ץΥץ롼פpgrpˤ롥pid0
	Ϳȸ߼¹Υץоݤˤ롥

   setpriority(which, who, prio)

	whichwhoǻꤵץץ롼ס桼θ
	̤ͥprioꤹ롥ܺ٤setpriority(2)򻲾ȤΤȡ

   uid

	ץθߤμUID֤

   uid=

	ץθߤμUIDuid˥åȤ.

** Range(饹)

ϰϥ֥ȤΥ饹ϰϥ֥Ȥ`..'黻Ҥˤä졤
ŪˤϰʲΤ褦ʻȤ򤹤

        for i in 1..5
          ...
        end

ξϰʲ®.

        do 1.upto(5)
          ...
        end

ϰϥ֥Ȥ`..'黻ҤξդComparableޤ९饹Υ
󥹥󥹤ǤвǤ⹽ʤϰϤϻȽޤळȤդ
.

SuperClass: Object

Included Modules: Enumerable

Methods:

   self =~ other

        selfotherƱ饹Фϰϥ֥Ȥǡϰ
        other(start <= other <= end)֤case
        ϰϻꤹǤ롥㤨

            case i
              when 1, 3..5
                ...
            end case

        Τ褦ʥɤ񤯤ȤǤ롥

   each

        ϰ¸ߤ륪֥ȤͿ륤ƥ졼forΤ
        Ѥ롥

   end

        ϰϤν֤

   start

        ϰϤλ֤

** Socket(饹)

SuperClass: BasicSocket

åȤΤΤФ륷ƥॳ٥Υ󶡤륯饹
PerlΥåȤФ륢Ʊ٥εǽ󶡤Ƥ롥Υ
Ǥϥåȥɥ쥹pack줿ʸǡꤹ롥UDPåȤϤ
Υ饹ȤäѤ롥

Methods:

   accept

	³դơ³Ф륽åȤȥɥ쥹
	ڥ֤accept(2)򻲾ȡ

   bind(addr)

	bind(2)ƱƯ򤹤롥addrpack줿åȥɥ쥹¤
	ΤǤ롥

   connect(addr)

	connect(2)ƱƯ򤹤롥addrpack줿åȥɥ쥹
	¤ΤǤ롥

   listen(backlog)

	listen(2)ƱƯ򤹤롥

   recv(len[, flags])

	åȤǡꡤʸȤ֤lenϼ
	Ĺꤹ롥flagsˤĤƤrecv(2)򻲾ȡflagsΥ
	եͤ0Ǥ롥

   recvfrom(len[, flags])

	recvƱͤ˥åȤǡ뤬ͤʸ
	꥽åȤΥɥ쥹ΥڥǤ롥ˤĤƤrecvƱ͡

   send(mesg, flags[, to])

	åȤ𤷤ƥǡ롥flags˴ؤƤsend(2)򻲾Ȥλ
	connectƤʤåȤФƤǤtoꤹɬ
	פ롥ºݤäǡĹ֤

Single Methods:

   open(domain, type, protocol)
   new(domain, type, protocol)

	åȤ롥domaintypeprotocolϥ󥯥롼
	եƤͤǻꤹ롥domaintype˴ؤ
	ϡʸǻǤ뤬٤Ƥ򥫥СƤݾڤϤʤ

   socketpair(domain, type, protocol)

	åȤΥڥ֤λ openƱǤ롥
   

** Regexp(饹)

ɽΥ饹ɽΥƥ/.../ȤɽưŪ
뤿ˤ

        Regexp.new(ʸ)

Ȥ롥String饹`=~'ϤȤ¿Υ᥽åɤɽ
ؤʸͿ줿ˤŪɽΤǡ
Ȥ󤷤Ȼפ䡤ɽʸʸζ̤Ū˻
ꤷʤɰʳŪȻפȤϾʤϤ

SuperClass: Object

Methods:

   self =~ string

        ɽʸ˥ޥå硤ޥå֤֤ޥå
        ʤnil֤

   ~ self

        $_ =~ selfפƱ

Single Methods:

   complie(string[, casefold])
   new(string[, casefold])

        ʸɽѴ֥Ȥ֤άǽ2
        Ϳ줿ˤϡɽ֥Ȥϥƥ
        ѿ`$='ͤ˴ؤ餺λʸʸ̵뤷λ
        ̤롥ꤵʤϥޥåԤʤäΥƥѿ
        `$='ͤˤäƶ̤뤫ʤꤵ롥

   quote(str)

	ʸɽǰ̣ʸ򥨥פ롥ʸ
	֤

** BasicSocket(饹)

åȤɽݥ饹Ūʥåϥ֥饹롥
㤨Х󥿡ͥåȥɥᥤξTCPsocketѤ롥

SuperClass: IO

Methods:

   getopt(level, optname)

	åȤΥץ롥getsockopt(2)򻲾ȤΤȡ
	ץƤޤʸ֤

   getpeername

	³ΥåȤξ롥ѥå줿sockaddr¤
	٥˥פʸ֤롥getpeername(2)򻲾ȤΤȡ

   getsockname

	åȤξ롥ѥå줿sockaddr¤Τ٥˥
	ʸ֤롥getsockname(2)򻲾ȤΤȡ

   setopt(level, optname, optval)

	åȤΥץꤹ롥setsockopt(2)򻲾ȤΤȡ

   shutdown(how)

	åȤΰʹߤ³λ롥how0Ǥʹߤμ
	how1Ǥϡʹߤݤ롥how2λˤϡ
	ʹߤȤ˵ݤ롥shutdown(2)򻲾ȡ

** String(饹)

ʸ󥯥饹Rubyʸϥ̥륿ߥ͡ȤǤϤʤΤǡХʥǡ
ⰷ롥äƤɤ餫ȤñʤʸȤХǤ롥
λۤ˴Ťơɽ˴ؤ᥽åɰʳ2byteϤʸռ
ƤʤϺԤμȴǤϤʤտŪˤƤΤǤ(
Ƥ)

SuperClass: Object

Included Modules: Comparable, Enumerable

Methods:

   self + other

        ʸϢ롥Ϣ뤵줿ʸ֤

   self * times

        ʸη֤㤨

            "x" * 4 == "xxxx"

        Ǥ롥

   self == other
   self > other

        ʸӡƥѿ$=nilǤʤˤʸʸ
        ̤ӤԤʤ

   self =~ other

        ʸΥޥåotherɽʸotherʸξ
        ưŪɽѴ롥ޥåϥޥå֡
        ʤänil֤롥

   ~ self

        $_ =~ selfפƱ

   self[nth]
   self[beg..end]
   self[beg,len]

        ƤμФ1ܤηǤnthХܤΥǡFixnumȤ
        ֤2ܤηǤbegХܤendХܤޤǤʬʸ
        ֤(ξüޤ)3ܤηǤbegХܤlenХ
        ʬʬʸ֤

   self[nth] = val
   self[beg..end] = val
   self[beg,len] = val

        Ƥι1ܤηǤnthХܤΥǡval ()
        롥2ܤηbegХܤendХܤޤǤʬʸ
        valȤͿ줿ʸ֤롥3ܤηbeg
        ܤlenХʬʬʸvalȤͿ줿ʸ
        ֤롥

   capitalize

	ʸκǽʸ(줬ե٥åȤǤ)ʸ
	ѴĤʸΥե٥åȤʸ֤롥

   chop

        ʸκǸΥХȤڤȤʸѹ뤳Ȥ
        դ뤳ȡ

   crypt(salt)

        crypt(3)ѤưŹ沽ʸ֤salt2ХȰʾĹ
        ǤդʸǤ롥

   delete(str)

	ʸΤstr˴ޤޤʸ롥ʸλtr
	ƱͤǤꡤa-babޤǤϰϤƬ^ʸ(
	ޤƤʤΤ)̣롥ʸѹ뤳Ȥ
	դ뤳ȡ

   downcase

        ʸΥե٥åȤƾʸ֤ʸ֤

   each

        ʸ󤫤1Ԥɤ߹Ǥ륤ƥ졼

   each_byte

        ʸΤ줾ΥХȤˤĤƷ֤ƥ졼

   gsub(pattern, replace)

        ʸpattern˥ޥåʬreplace֤롥
        ִʸreplace&\0ϥޥåʸˡ\1..\9n
        γ̤Ƥ֤롥

   hex

        ʸ16ʿɽʸȲᤷơѴ롥

   index(substr[, pos])

        substrǽ˽и֤֤posͿȤΰ֤鸡
        򳫻Ϥ롥Ĥʤˤnil֤

   intern

	ʸ˰դб֤ʸϥʥʸޤǤϤ
	ʤ

   length
   size

        ʸĹ(Хȿ)֤

   ljust(width)
   rjust(width)
   center(width)

	ʸ򤽤줾졤ͤᡤͤᡤ󤻤widthʸ
	֤ʸĹwidthĹϸʸ֤ڤ
	ʤ

   next

        selfendޤǡּΡʸ֤ʸȤϿϿ
        ȤơʸϱʸȤä夬νԤʤ줿
        ΤǤ롥

                "aa".next => "ab"
                "99".next => "100"
                "a9".next => "b0"

   oct

        ʸ8ʿɽʸȲᤷơѴ롥8ʿ
        /[0-7]+/ǤꡤʸƬ餳Υѥ˥ޥå
        ʬѴ롥ƤϤޤʤʸФ
        Ƥ0֤perlȤϰäʸ0xϤޤäƤ뤫Ȥ
         16ʿȸʤƤ줿ϤʤƬ08ʿ
        ǧ졤0֤

   reverse

        ʸγƥХȤս¤٤ʸ֤ʸ2ХȤ
        ʸޤǤƤ⤪ʤ˥Хñ̤ȿž롥
        split2Хʸ򤹤Τǡ2Хʸޤʸʸ
        ñ̤ȿžˤ

                "ʸ".split(//).reverse.join("")

        ȤФ褤

   rindex(substr[, pos])

        ʸsubstrǸ˽и֤֤posͿȤΰ
        Ǹλ롥Ĥʤˤnil֤indexȤ
        1)ʸ鸡롥2)substrȤɽդ
        ʤ2Ǥ롥

   split([sep[, limit]])

        ʸsepǻꤵ줿ѥˤäơեɤʬ䤹롥
        sepά줿ΥǥեȤϥƥѿ`$;'ͤѤ
        롥limitꤵ줿ˤϺlimitĤΥեɤʬ䤹롥
        split()ʬ䤵줿ʸޤ֤sepǻꤵ줿ѥ
        󤬶ʸȥޥåʸ1ʸĤʬ䤵롥

   squeeze([str])

	ʸΤstr˴ޤޤʸϢ³Ƥ硤ʸ˰
	̤롥strά줿硤٤ƤʸоݤȤ롥ʸ
	λtrƱͤǤꡤ`a-b'abޤǤϰϤƬ`^'
	ʸ(ޤޤƤʤΤ)̣롥ʸ
	뤳Ȥդ뤳ȡ

   strip

	ʸζ

   sub(pattern, replace)

        ʸpattern˥ޥåʬreplace֤롥ִʸ
        replace&\0ϥޥåʸˡ\1..\9 nܤγ
        Ƥ֤롥sub()gsub()ȰۤʤꡤǽΥޥå
        ִ롥

   sum([bits])

	ʸbitsӥåȤΥå롥άͤ16Ǥ롥ruby
	ǤϰʲΥɤSystem V`sum'ץƱͤ롥

	  while gets()
	    sum += $_.sum
	  end
	  sum %= 65536

   swapcase

        ʸΥե٥åȤΤʸʸˡʸʸ
        ֤롥

   to_f

        ʸFloatѴ롥

   to_i

        ʸ10ʿɽʸȲᤷơѴ롥

   toupper

        ʸΥե٥åȤʸ֤ʸ֤
        tr("a-z", "A-Z")꾯®

   tolower

        ʸΥե٥åȤƾʸ֤ʸ֤
        tr("A-Z", "a-z")꾯®

   tr(search, replace)

        ʸsearchʸ˴ޤޤʸ¸ߤСreplaceʸ
        бʸ֤롥replaceʸ󤬾ά줿
        ϶ʸͿ줿ȸʤreplaceʸsearchʸ
        ûreplaceʸκǸʸ֤Ƥȸ
        searchʸûˤбʸΤʤreplace
        ñ̵뤵(BSDtrư)

	searchʸreplaceʸ`a-b'Ȥ줿硤
	abޤǤϰϤʸASCIIξǻꤷȤˤʤ롥
	searchʸκǽʸ`^'Ǥ硤³ʸ*ޤ
	ʤ*ʸִоݤˤʤ롥

	tr(1)εǽΤʸ뵡ǽϢ³ʸ򰵽̤
	ǽ̤Υ᥽åɤʬ䤵Ƥ롥εǽˤĤƤ
	deletesqueeze򻲾ȤΤȡ

	ؤΤᡤstr.tr(src,repl).squeeze(repl)᥽å
	tr_s(src,repl) 󶡤Ƥ롥

   unpack(template)

        ʸtemplateʸˤäƥѥåǤ
        ޤ֤templateʸArray饹pack᥽åɤȤ
        ƱͤǤ롥

          a     ASCIIʸ(³nullʸ䥹ڡĤ)
          A     ASCIIʸ(³nullʸ䥹ڡ)
          b     ӥåȥȥ(̥ӥåȤ̥ӥå)
          B     ӥåȥȥ(̥ӥåȤ鲼̥ӥå)
          h     16ʸ(̥˥֥뤬)
          H     16ʸ(̥˥֥뤬)
          c     char
          C     unsigned char
          s     sort
          S     unsigned sort
          i     int
          I     unsigned int
          l     long
          L     unsigned int
          n     ͥåȥХȥshort
          N     ͥåȥХȥlong
          f     ñư(¸)
          d     ư(¸)
          x     1ХɤФ
          X     1Хȸ
          @     а֤ؤΰư

	rubyunpackperlȰäƥåη׻ǽʤȤ
	դ뤳ȡ


   upcase

        ʸΥե٥åȤʸ֤ʸ֤

   upto(end)

        selfϤޤäơendޤǡּΡʸͿ륤ƥ졼
        ʸȤstr.nextͿʸǤ롥

        Υ᥽åɤRange:eachѤƤΤǡʲΤ褦ʽ
        ǽǤ롥

                for i in "a" .. "ba"
                  print(i, "\n");
                end

        a, b, c, .. aa, .. az, baޤǤƹԤ˽Ϥ롥
        

        դʤФʤΤϡνλȽ羮طǤϤʤ 
        `=='ȽꤵƤ뤿ᡤ`..'黻Ҥκդͤ³ʸ˱
        դʸ󤬴ޤޤƤʤʲΤ褦ʾ̵¥롼פ
        ٤äƤޤ

                for i in "0" .. "1a"
                  print(i, "\n");
                end

        ԤϤ񤯤ȤˤäǤƨƤ褦ȤƤȹͤ
        ⤤뤫⤷ʤο¬

Single Methods:

   new(string)

	stringƱƤĿʸ֤

** Struct(饹)

¤Υ饹ʣΥǡޤȤѤ(: Time::times)
ǡޤȤˤ󥯥饹Ѥ뤳Ȥ⤢뤬(: select)
¤ΤȤ٤ϰʲΤ褦ʾǤ롥

  (1) Ǥο

      ǤοưΤϹ¤ΤȤΤˤϸʤ

  (2) Ǥο¿

      ʹ֤٤ưפ˰복ǰο7ĤޤǤǤȤ⤬롥
      β˽СǤ4İʾ夢ǡξѤ
      硤ǿ*2(ĤޤꥪեåȤȤΰ̣)7ۤ롥äơ
      Τ褦ʾˤϹ¤ΤȤä򤷤䤹Ȼפ롥

  (3) Ʊ̤ʤ

      ¤Τ㴳Ȥ⤤Τǡ®٤ˤʤ 
      (㤨Ʊ̤ʤ)Ϲ¤ΤλѤŬڤǤʤ
      ǽ롥

ƹ¤Τˤϥ̾Ʊ̾ΰΤʤ᥽åɤ롥

ܥɥǡ¤Τɽ뤿ˤϰʲηȤ

  struct ¤̾
     ..
  end

ץǤηǹ¤Τ櫓ǤϤʤ

SuperClass: Object

Included Modules: Enumerable

Methods:

   self[idx]

	idxλidxܤǤ֤idxʸλidxƱ̾
	ΥФǤ֤

   values

	¤ΤΥФͤǤ˻֤㤨аʲΥɤ
	ʬpasswdȥϤ뤳ȤǤ롥

	  print(Etc.getpwuid().values.join(":"), "\n")

	νϤ`grep "$USER" /etc/passwd'νϤ;ʬʥեɤ
	Ĥ(ƥˤäưۤʤ)ʳƱǤ롥

Single Methods:

   new(name, member::value...)

	nameȤ̾Ĺ¤Τ롥memberϹ¤ΤΥФ
	ɽʸǤꡤvalueϤͤǤ롥줿¤Τϥ
	Фǻꤵ줿̾ðۥ᥽åɤƤơΥ᥽å
	ˤäƥФƤ뤳ȤǤ롥

** TCPserver(饹)

TCP/IPȥ꡼෿³Υ¦ΥåȤΥ饹Υ饹ˤä
ñ˥åȤѤФΥץߥ󥰤Ǥ롥㤨echo
ФϰʲΤ褦ˤʤ롥

 gs = TCPserver.open(4444)
 socks = [gs]

 while %TRUE
   nsock = select(socks);
   if nsock == nil; continue end
   for s in nsock[0]
     if s == gs
       socks.push(s.accept)
     else
       if s.eof
 	 s.close
	 socks.delete(s)
       else
	 str = s.gets
	 s.write(str)
       end
     end
   end
 end

SuperClass: TCPsocket

Methods:

   accept

	饤Ȥ³׵դ³TCPsocketΥ
	󥹤֤

Single Methods:

   new([host, ]service)
   open([host, ]service)

	service/etc/services(ޤNIS)ϿƤ륵ӥ̾
	ݡֹǻꤹ롥hostꤷϻꤷۥȤ
	³դ롥άƤΥۥȤ³׵
	롥

** TCPsocket

󥿡ͥåȥɥᥤΥȥ꡼෿åȤΥ饹̾IO饹
֥饹ƱͤϤǤ롥Υ饹ˤäƥåȤѤ
饤Ȥñ˵ҤǤ롥桼Ϥ򤽤ΤޤޥФž
ϰʲΤ褦ˤʤ롥

 s = TCPsocket("localhost", 4444)
 while gets()
   s.write($_)
   print(s.read)
 end

SuperClass: BasicSocket

Methods:

   addr

	åȤ³ɽ֤γǤ1
	ʸ "AF_INET"2Ǥportֹ桤3ǤۥȤɽʸ
	Ǥ롥

   peeraddr

	³襽åȤξɽ֤γǤ
	addr᥽åɤ֤ƱǤ롥

Single Methods:

   open(host, service)
   new(host, service)

	hostǻꤷۥȤserviceǻꤷݡȤ³
	Ȥ֤hostϥۥ̾ޤϥ󥿡ͥåȥɥ쥹򼨤ʸ
	service/etc/services(ޤNIS)ϿƤ륵
	̾ݡֹǤ롥

** Time(饹)

֤ɽ饹羮ӤʤɤǤ롥Time.nowǸߤλ֤뤳
Ǥ롥ޤեΥॹפ᥽åɤͤ⤳Υ
Υ󥹥󥹤Ǥ롥

SuperClass: Object

Included Modules: Comparable

Methods:

   self <=> other

        otherTimeΥ󥹥󥹤Ϳ줿
        ˤ1970ǯ 1 1 00:00:00 GMTÿǤ
        ƻȤӤԤʤ

   asctime
   ctime
   to_s

        date(1)ʸѴ롥

   gmtime

        ॾνԤʤʤGMTǤλ롥Υ᥽å
        ȤäTime饹Υ󥹥󥹤ϡʸλѴGMT
        ԤʤgmtimeϼʬȤ֤

	ɥλɽˤ

	  print(Time.now.gmtime, "\n")

	ȤФ褤

   localtime

        ॾνԤʤä(ǥե)localtime
        ϼʬȤ֤

   to_i
   tv_sec

        1970ǯ 1 1 00:00:00 GMTޤǤÿ֤
        secondʬǤ⤢롥

   sec
   min
   hour
   mday
   year
   wday
   yday
   zone
   isdst

        ŪݻƤtm¤ΤƤ֤zoneʳ֤
        zoneϥॾɽʸ֤(cf localtime(3))

   strftime(format)

        formatʸ˽äʸѴ̤֤format
        ʸȤƻǤΤ ʲ̤Ǥ롥

                %A      ̾(Sunday, Monday,...)
                %a      ξά̾(Sun, Mon,...)
                %B      ̾(January, February,...)
                %b      ξά̾(Jan, Feb,...)
                %c      ɽ(cf ctime(3))
                %d      ʿǤ(01-31)
                %H      24λ(00-23)
                %I      12λ(01-12)
                %j      ǯ̻(001-366)
                %M      ʬ(00-59)
                %m      ɽ(01-12)
                %p      ޤϸ(AM,PM)
                %S      (00-61)
                %U      ɽǽ1
                        Ϥޤ(00-53)
                %W      ɽǽη1
                        Ϥޤ(00-53)
                %w      ɽ0(0-6)
                %X      (: 15:01:06)
                %x      (: Fri Jan 14 1994)
                %Y      ɽ
                %y      β2(00-99)
                %Z      ॾ
                %%      % 

   usec
   tv_usec

        micro secondʬ֤

Single Methods:

   now

        ߤλɽTime饹Υ󥹥󥹤롥

   at(time)

        timeƱɽTime饹Υ󥹥󥹤롥time
        Time饹Υ󥹥󥹤뤤Ͽ(/ư)Ǥꡤ
        ξ1970ǯ 1 1 00:00:00 GMTÿǤȤƻ
        ׻롥

   times

        ߤΥץȤλҥץ񤷤桼/ƥCPU
        ѻ¤ΤȤ֤(Struct򻲾)

	  struct tms
	    utime	# ץΥ桼
	    stime	# ץΥƥ
	    cutime	# ҥץΥ桼
	    cstime	# ҥץΥƥ
	  end

	֤ñ̤äǤꡤưͿ롥ܺ٤
        times(3)򻲾ȤΤȡ

** UNIXserver

UNIXȥ꡼෿³Υ¦ΥåȤΥ饹

SuperClass: UNIXsocket

Methods:

   accept

	饤Ȥ³׵դ³UNIXsocketΥ
	󥹤֤

** UNIXsocket

UNIXɥᥤΥȥ꡼෿åȤΥ饹̾IO饹Υ֥饹
ƱͤϤǤ롥

SuperClass: BasicSocket

Methods:

   addr

	åȤ³ɽ֤γǤ1
	ʸ "AF_UNIX"2ǤpathǤ롥

   path

	UNIXåȤΥѥ֤

   peeraddr

	³襽åȤξɽ֤γǤ
	addr᥽åɤ֤ƱǤ롥

Single Methods:

   open(path)
   new(path)

	pathǻꤷѥ̾Ѥ³åȤ֤

* CȤΥ󥿥ե

rubyCȤΥ󥿡ե󶡤C줫Υ饹⥸塼
CǵҤ᥽åɤrubyΥ᥽åɤθƤӽФ
졼θƤӽФ㳰ʤɤԤʤȤ롥ޤOSм
ԻCǽ񤫤줿⥸塼ɤ뤳Ȥ롥

Ūʥ󥿥ե˴ؤƤϡ̥ɥ(źեե C-IF)
ȤΤȡ

* ʸˡ

ʲϵBNFǵҤrubyʸˡǤ롥ΤʵҤparse.y򻲾
줿

PROGRAM		: COMPEXPR

COMPEXPR	: EXPR (TERM EXPR)* [TERM]

EXPR		: MLHS `=' ARGS
		| ASSOCS
		| return ARGS
		| fail ARGS
		| yield ARGS
		| identifier CALL_ARGS
		| PRIMARY `.' identifier CALL_ARGS
		| super CALL_ARGS
		| undef FNAME
		| alias FNAME FNAME
		| include identifier (`,' identifier)*
		| EXPR if EXPR
		| EXPR while EXPR
		| EXPR and EXPR
		| EXPR or EXPR
		| ARG

ARG		: LHS `=' ARG
		| LHS OP_ASGN ARG
		| ARG `..' ARG
		| ARG `...' ARG
		| ARG `+' ARG
		| ARG `-' ARG
		| ARG `*' ARG
		| ARG `/' ARG
		| ARG `%' ARG
		| ARG `**' ARG
		| `+' ARG
		| `-' ARG
		| ARG `|' ARG
		| ARG `^' ARG
		| ARG `&' ARG
		| ARG `<=>' ARG
		| ARG `>' ARG
		| ARG `>=' ARG
		| ARG `<' ARG
		| ARG `<=' ARG
		| ARG `==' ARG
		| ARG `!=' ARG
		| ARG `=~' ARG
		| ARG `!~' ARG
		| `!' ARG
		| `~' ARG
		| ARG `<<' ARG
		| ARG `>>' ARG
		| ARG `::' ARG
		| ARG `&&' ARG
		| ARG `||' ARG
		| PRIMARY

PRIMARY		: LITERAL
		| VARIABLE
		| super `(' [CALL_ARGS] `)'
		| super
		| PRIMARY `[' [ARGS] `]'
		| `[' [ARGS] `]'
		| `{' ARGS `}'
		| `{' ASSOCS `}'
		| redo
		| break
		| continue
		| retry
		| return
		| fail `(' ARGS `)'
		| fail `(' `)'
		| fail
		| yield `(' ARGS `)'
		| yield `(' `)'
		| yield
		| PRIMARY `{' [ITER_VAR] `|' COMPEXPR `}'
		| identifier `(' [CALL_ARGS] `)'
		| PRIMARY `.' identifier `(' [CALL_ARGS] `)'
		| PRIMARY `.' identifier
		| if EXPR THEN
		  COMPEXPR
		  (elsif EXPR THEN COMPEXPR)*
		  [else COMPEXPR]
		  end
		| while EXPR TERM COMPEXPR end
		| case COMPEXPR
		  (when ARGS THEN)+
		  [else COMPEXPR]
		  end
		| for ITER_VAR in EXPR TERM
		  COMPEXPR
		  end
		| protect
		  COMPEXPR
		  [resque COMPEXPR]
		  [ensure COMPEXPR]
		  end
		| `(' COMPEXPR `)'
		| class identifier `:' identifier
		  COMPEXPR
		  end
		| module identifier
		  COMPEXPR
		  end
		| def FNAME ARGLIST
		  COMPEXPR
		  end
		| def SINGLETON `.' FNAME ARGLIST
		  COMPEXPR
		  end

THEN		: TERM
		| then
		| TERM then

ITER_VAR	: LHS
		| MLHS

MLHS		: LHS `,' [LHS (`,' LHS)*] [`*' LHS]

LHS		: VARIABLE
		| PRIMARY `[' [ARGS] `]'
		| PRIMARY `.' identifier 

CALL_ARGS	: ARGS
		| ASSOCS
		| ARGS `,' ASSOCS
		| ARGS `,' `*' ARG

ARGS 		: ARG
		| ARGS `,' ARG

ARGLIST		: `('[identifier(`,'identifier)*][`*'identifier]`)'
		| TERM

SINGLETON	: VARIABLE
		| `(' COMPEXPR `)'

ASSOCS		: ASSOC (`,' ASSOC)*

ASSOC		: ARG `=>' ARG

VARIABLE	: identifier
		| VARNAME
		| nil
		| self
		| `__FILE__'
		| `__LINE__'

LITERAL		: numeric
		| SYMBOL
		| STRING
		| REGEXP
		| GLOB

TERM		: `;'
		| `\n'

겼ϻǧ롥

SYMBOL		: `:'FNAME
		| `:'VARNAME

FNAME		: identifier | `::' | `..' | `|' | `^' | `&'
		| `<=>' | `==' | `=~' | `>' | `>=' | `<' | `<='
		| `<<' | `>>' | `+' | `-' | `*' | `/' | `%' | `**'
		| `~' | `+@' | `-@' | `[]' | `[]='

VARNAME		: GLOBAL
		| `@'identifier
		| `%'identifier

GLOBAL		: `$'identifier
		| `$'any_char

STRING		: `"' any_char* `"'
		| `'' any_char* `''
		| ``' any_char* ``'

REGEXP		: `/' any_char* `/'

GLOB		: `<' any_char* `>'

* ռ

RubyθͤC, Perl, EiffelγƸˤν˱ƶƤ. 
¾˱ƶȤƤtcl, AWK, bourne shell, CLU, Sather,
Icon, Smalltalk, Emacs Lispʤɤ. ޤrubyθͤꤹ뤿
˶ϤƲäʲˤ(ɾά): ͷ
ƣϺ¼ΣţáغDECʤ@ֺ.ٻ̡

-------------------------------------------------------
Local variables:
fill-column: 70
end:
