Calls block once for each element in self, passing that element as a parameter. 



   a = [ "a", "b", "c" ]

   a.each {|x| print x, " -- " }



produces: 



   a -- b -- c --

Returns a new array with the results of running block once for every element in enum. 



   (1..4).collect {|i| i*i }   #=> [1, 4, 9, 16]

   (1..4).collect { "cat"  }   #=> ["cat", "cat", "cat", "cat"]

enum.detect(ifnone = nil) {| obj | block } => obj or nil
enum.find(ifnone = nil) {| obj | block } => obj or nil

Passes each entry in enum to block. Returns the first for which block is not false. 

If no object matches, calls ifnone and returns its result when it is specified, or returns nil 



   (1..10).detect  {|i| i % 5 == 0 and i % 7 == 0 }   #=> nil

   (1..100).detect {|i| i % 5 == 0 and i % 7 == 0 }   #=> 35

enum.inject(initial) {| memo, obj | block } => obj
enum.inject {| memo, obj | block } => obj

Combines the elements of enum by applying the block to an accumulator value (memo) and each element in turn.

At each step, memo is set to the value returned by the block. The first form lets you supply an initial value 

for memo. The second form uses the first element of the collection as a the initial value 

(and skips that element while iterating). 



   # Sum some numbers

   (5..10).inject {|sum, n| sum + n }              #=> 45

   # Multiply some numbers

   (5..10).inject(1) {|product, n| product * n }   #=> 151200



   # find the longest word

   longest = %w{ cat sheep bear }.inject do |memo,word|

      memo.length > word.length ? memo : word

   end

   longest                                         #=> "sheep"



   # find the length of the longest word

   longest = %w{ cat sheep bear }.inject(0) do |memo,word|

      memo >= word.length ? memo : word.length

   end

   longest                                         #=> 5

Builds a set of characters from the other_str parameter(s) using the procedure described for String#count. 

Returns a new string where runs of the same character that occur in this set are replaced by a single character. 

If no arguments are given, all runs of identical characters are replaced by a single character. 



   "yellow moon".squeeze                  #=> "yelow mon"

   "  now   is  the".squeeze(" ")         #=> " now is the"

   "putters shoot balls".squeeze("m-z")   #=> "puters shot balls"

str.chomp(separator=$/) => new_str

Returns a new String with the given record separator removed from the end of str (if present). 

If $/ has not been changed from the default Ruby record separator, 

then chomp also removes carriage return characters (that is it will remove \n, \r, and \r\n). 



   "hello".chomp            #=> "hello"

   "hello\n".chomp          #=> "hello"

   "hello\r\n".chomp        #=> "hello"

   "hello\n\r".chomp        #=> "hello\n"

   "hello\r".chomp          #=> "hello"

   "hello \n there".chomp   #=> "hello \n there"

   "hello".chomp("llo")     #=> "he"

Reads the next ``line’’ from the I/O stream; lines are separated by sep_string.

 A separator of nil reads the entire contents, and a zero-length separator reads the input a 

paragraph at a time (two successive newlines in the input separate paragraphs). 

The stream must be opened for reading or an IOError will be raised. 

The line read in will be returned and also assigned to $_. Returns nil if called at end of file. 



   File.new("testfile").gets   #=> "This is line one\n"

   $_                          #=> "This is line one\n"

ios.flush => ios

Flushes any buffered data within ios to the underlying operating system 

(note that this is Ruby internal buffering only; the OS may buffer the data as well). 



   $stdout.print "no newline"

   $stdout.flush



produces: 



   no newline

In ruby everything is an object

"내가 알고 있는 지식이 바둑알만한 타원에서, 농구공 만한타원으로.. 점점 커지게되면 될수록

즉, 표면적이 넓어지져 모르는 부분을 많이 접하면 접할수록 자신의 부족함을 느낀다는.."