【Ruby】【基礎】

 

# 【Ruby 塊】
=begin
1 塊由大量代碼構成
2 塊中代碼包含在{}內
3 從與其相同名稱的函數調用
4 可使用yield語句調用塊
=end
def test
  p '在test方法內'
  yield
  p '又回到了test方法內'
  yield
end

test {p '你在塊內'}
#也能夠傳遞由參數的yield
def test
  yield 5
  p '在方法內'
  yield 100
end
test {|i| p "你在塊#{i}內"}

# 傳遞多個參數
def test
  yield 5,100
  p '在方法內'
  yield 6,90
end
test {|a,b| p "你在塊#{b}和#{a}內"}
=begin
"你在塊100內"
"你在塊100和5內"
"在方法內"
"你在塊90和6內"
=end
#另外一種調用塊的方式
def test(&block)
  block.call
end
test {p 'hello world!'}    #"hello world!"

# 【【運算符】】

#【比較運算符】
=begin
<=> 聯合比較運算符，相等返回0；第一個數大返回1；第二個數大返回-1
== 值相等
.eql? 類型相同且值相等
.equal? 是否具備相同的對象ID(內存地址是否相同)
=== 判斷是否具備相同的類，或父類 判斷兩個實例對象是否具備血緣關係。另外一種說法  判斷case 語句的 when 子句內的 相等
=end

puts 1 == 1.0                 #true

puts 1 === 1.0                #true
puts 1 === "abc"              #false
puts (1...10) ===  5          #true
puts (1...10) === 3           #true
puts (1..3) === 3             #true
puts (1...3) === 3            #false
 
puts 1.eql?(1)        #true
puts 1.eql?(1.0)      #false

puts 1.equal?(1)        #true
puts 1.equal?(1.0)      #false

a = 1
b = a
A = 'ABC'
B = A
AA = "A"
BB = AA + ""
print "a's ID : ",a.object_id,"\n"
print "b's ID : ",b.object_id,"\n"
print "A's ID : ",A.object_id,"\n"
print "B's ID : ",B.object_id,"\n"
print "AA's ID : ",AA.object_id,"\n"
print "BB's ID : ",BB.object_id,"\n"
print 'AA == BB : ',AA == BB,"\n"
print 'AA.eql?(BB) : ',AA.eql?(BB),"\n"
print 'AA.equal?(BB) : ',AA.equal?(BB),"\n"
print 'a.equal?(1) : ', a.equal?(1),"\n"
print 'b.equal?(1) : ',b.equal?(1),"\n"
print 'a.equal?(b) : ',a.equal?(b),"\n"
print '1.equal?(a) : ',1.equal?(a),"\n"
print '1.equal?(b) : ',1.equal?(b),"\n"
print 'A.equal?(B) : ',A.equal?(B),"\n"
=begin
a's ID : 3
b's ID : 3
A's ID : 70215304749280
B's ID : 70215304749280
AA's ID : 70215304749260
BB's ID : 70215304749180
AA == BB : true
AA.eql?(BB) : true
AA.equal?(BB) : false
a.equal?(1) : true
b.equal?(1) : true
a.equal?(b) : true
1.equal?(a) : true
1.equal?(b) : true
A.equal?(B) : true
=end

#【Ruby defined運算符】 以方法調用的形式判斷傳遞的表達式是否已定義。返回表達式的描述字符串，若是表達式未定義則返回nil.
foo = 42
puts defined? foo      #local-variable
puts defined? $_       #global-variable
puts defined? bar      #打印了一個空行

puts defined? puts     #method
puts defined? puts(var)#打印了一個空行
puts defined? unpack   #打印了一個空行

#【Ruby 中的.運算符 和  :: 運算符】經過在方法名稱前加上類或模塊名稱和 . 來調用類或模塊中的方法。你可使用類或模塊名稱和兩個冒號 :: 來引用類或模塊中的常量
#例子
# 定義在主Object類上的常量
MR_COUNT = 0
module Foo
  MR_COUNT = 0
  #設置全局計數爲1
  ::MR_COUNT = 1
  #設置局部計數爲2
  MR_COUNT = 2
end

puts MR_COUNT         #1
puts Foo::MR_COUNT    #2

#例子
CONST = ' out there '
class Inside_one

end

#【Ruby 點運算符 "." 和雙冒號運算符 "::"】
=begin
你能夠經過在方法名稱前加上類或模塊名稱和 . 來調用類或模塊中的方法。你可使用類或模塊名稱和兩個冒號 :: 來引用類或模塊中的常量。

:: 是一元運算符，容許在類或模塊內定義常量、實例方法和類方法，能夠從類或模塊外的任何地方進行訪問。

請記住：在 Ruby 中，類和方法也能夠被看成常量。

你只須要在表達式的常量名前加上 :: 前綴，便可返回適當的類或模塊對象。

若是 :: 前的表達式爲類或模塊名稱，則返回該類或模塊內對應的常量值；若是 :: 前未沒有前綴表達式，則返回主Object類中對應的常量值。 。
=end
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             # out there inside one
puts Inside_two.new.where_is_my_CONST             # inside two
puts Object::CONST +  Inside_two::CONST           # out there inside two
puts Inside_two::CONST + CONST                    # inside two out there
puts Inside_one::CONST                            ##<Proc:0x15d0c81b@D:/DATA/wangxue/RubymineProjects/untitled/class_and_obj.rb:5>
puts Inside_one::CONST.call + Inside_two::CONST   # in there inside two

# 【模塊】
=begin
1。 相似於類，但有不一樣
2。 模塊不能實例化
3。 模塊沒有子類
4。 模塊只能被另外一個模塊定義
=end


# 例子 同級目錄下有 trip.rb 裏面有模塊Trip  ；同級目錄下有 moral.rb 裏面有模塊 Moral
$LOAD_PATH << '.'   # 【備註】從當前目錄中搜索被引用的文件。若是不像使用$LOAD_PATH 可以使用 require_relative 來從一個相對目錄引用文件。

require 'trip'
require 'moral'

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


# 例子 同級下有support.rb ，裏面有模塊 Week
$LOAD_PATH << '.'
require 'support'

class Decade
include Week

  num_of_year = 10
  def num_of_months
    puts Week::FIRST_DAY
    numbers = 10*12
    puts numbers
  end
end

d1 = Decade.new
puts Week::FIRST_DAY
Week.week_in_month
Week.week_in_year
d1.num_of_months
=begin
Sunday
you have four weeks in a month
you have 52 weeks in a year
Sunday
120
=end


# 【Ruby 中的 Mixins】
=begin
面向對象的概念。
當一個類能夠從多個父類繼承類的特性時，該類顯示爲多重繼承。
Ruby不能直接支持多重繼承，可是Ruby的模塊有另外一個神奇的功能。它幾乎消除了多重繼承的須要，一共了一種名爲mixin的裝置。
Ruby沒有真正實現多重繼承，而是採用成爲mixin技術做爲替代品，將模塊include到類定義中，模塊中的方法就mix進了類中。
=end

#例子
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


# 【【Ruby字符串】】String
# 例子
x,y,z = 12,36,72
puts "x 的值：#{x}"
puts "x + y 的值： #{x + y}"
puts "x + y + z 的平均值： #{(x + y + z)/3}"
=begin
x 的值：12
x + y 的值： 48
x + y + z 的平均值： 40
=end

# 【字符串的內建方法】
# 例子
myStr = String.new("THIS IS TEST")
foo = myStr.downcase()
puts "#{foo}"
puts foo
=begin
this is test
this is test
=end

# 【字符串的公共方法】
=begin
序號 方法 & 描述
1  str % arg
使用格式規範格式化字符串。若是 arg 包含一個以上的替代，那麼 arg 必須是一個數組。如需瞭解更多格式規範的信息，請查看"內核模塊"下的 sprintf。
2  str * integer
返回一個包含 integer 個 str 的新的字符串。換句話說，str 被重複了 integer 次。
3  str + other_str
鏈接 other_str 到 str。
4  str << obj
鏈接一個對象到字符串。若是對象是範圍爲 0.255 之間的固定數字 Fixnum，則它會被轉換爲一個字符。把它與 concat 進行比較。
5  str <=> other_str
把 str 與 other_str 進行比較，返回 -1（小於）、0（等於）或 1（大於）。比較是區分大小寫的。
6  str == obj
檢查 str 和 obj 的相等性。若是 obj 不是字符串，則返回 false，若是 str <=> obj，則返回 true，返回 0。
7  str =~ obj
根據正則表達式模式 obj 匹配 str。返回匹配開始的位置，不然返回 false。
8  str[position] # 注意返回的是ASCII碼而不是字符
str[start, length]
str[start..end]
str[start...end]
使用索引截取子串
9  str.capitalize
把字符串轉換爲大寫字母顯示。
10 str.capitalize!
與 capitalize 相同，可是 str 會發生變化並返回。
11 str.casecmp
不區分大小寫的字符串比較。
12 str.center
居中字符串。
13 str.chomp
從字符串末尾移除記錄分隔符（$/），一般是 \n。若是沒有記錄分隔符，則不進行任何操做。
14 str.chomp!
與 chomp 相同，可是 str 會發生變化並返回。
15 str.chop
移除 str 中的最後一個字符。
16 str.chop!
與 chop 相同，可是 str 會發生變化並返回。
17 str.concat(other_str)
鏈接 other_str 到 str。
18 str.count(str, ...)
給一個或多個字符集計數。若是有多個字符集，則給這些集合的交集計數。
19 str.crypt(other_str)
對 str 應用單向加密哈希。參數是兩個字符長的字符串，每一個字符的範圍爲 a.z、 A.Z、 0.九、 . 或 /。
20 str.delete(other_str, ...)
返回 str 的副本，參數交集中的全部字符會被刪除。
21 str.delete!(other_str, ...)
與 delete 相同，可是 str 會發生變化並返回。
22 str.downcase
返回 str 的副本，全部的大寫字母會被替換爲小寫字母。
23 str.downcase!
與 downcase 相同，可是 str 會發生變化並返回。
24 str.dump
返回 str 的版本，全部的非打印字符被替換爲 \nnn 符號，全部的特殊字符被轉義。
25 str.each(separator=$/) { |substr| block }
使用參數做爲記錄分隔符（默認是 $/）分隔 str，傳遞每一個子字符串給被提供的塊。
26 str.each_byte { |fixnum| block }
傳遞 str 的每一個字節給 block，以字節的十進制表示法返回每一個字節。
27 str.each_line(separator=$/) { |substr| block }
使用參數做爲記錄分隔符（默認是 $/）分隔 str，傳遞每一個子字符串給被提供的 block。
28 str.empty?
若是 str 爲空（即長度爲 0），則返回 true。
29 str.eql?(other)
若是兩個字符串有相同的長度和內容，則這兩個字符串相等。
30 str.gsub(pattern, replacement) [or]
str.gsub(pattern) { |match| block }
返回 str 的副本，pattern 的全部出現都替換爲 replacement 或 block 的值。pattern 一般是一個正則表達式 Regexp；若是是一個字符串 String，則沒有正則表達式元字符被解釋（即，/\d/ 將匹配一個數字，但 '\d' 將匹配一個反斜槓後跟一個 'd'）。
31 str[fixnum] [or] str[fixnum,fixnum] [or] str[range] [or] str[regexp] [or] str[regexp, fixnum] [or] str[other_str]
使用下列的參數引用 str：參數爲一個 Fixnum，則返回 fixnum 的字符編碼；參數爲兩個 Fixnum，則返回一個從偏移（第一個 fixnum）開始截至到長度（第二個 fixnum）爲止的子字符串；參數爲 range，則返回該範圍內的一個子字符串；參數爲 regexp，則返回匹配字符串的部分；參數爲帶有 fixnum 的 regexp，則返回 fixnum 位置的匹配數據；參數爲 other_str，則返回匹配 other_str 的子字符串。一個負數的 Fixnum 從字符串的末尾 -1 開始。
32 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 ]
替換整個字符串或部分字符串。與 slice! 同義。
33 str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { |match| block }
執行 String#gsub 的替換，返回 str，若是沒有替換被執行則返回 nil。
34 str.hash
返回一個基於字符串長度和內容的哈希。
35 str.hex
把 str 的前導字符看成十六進制數字的字符串（一個可選的符號和一個可選的 0x），並返回相對應的數字。若是錯誤則返回零。
36 str.include? other_str [or] str.include? fixnum
若是 str 包含給定的字符串或字符，則返回 true。
37 str.index(substring [, offset]) [or]
str.index(fixnum [, offset]) [or]
str.index(regexp [, offset])
返回給定子字符串、字符（fixnum）或模式（regexp）在 str 中第一次出現的索引。若是未找到則返回 nil。若是提供了第二個參數，則指定在字符串中開始搜索的位置。
38 str.insert(index, other_str)
在給定索引的字符前插入 other_str，修改 str。負值索引從字符串的末尾開始計數，並在給定字符後插入。其意圖是在給定的索引處開始插入一個字符串。
39 str.inspect
返回 str 的可打印版本，帶有轉義的特殊字符。
40 str.intern [or] str.to_sym
返回與 str 相對應的符號，若是以前不存在，則建立符號。
41 str.length
返回 str 的長度。把它與 size 進行比較。
42 str.ljust(integer, padstr=' ')
若是 integer 大於 str 的長度，則返回長度爲 integer 的新字符串，新字符串以 str 左對齊，並以 padstr 做爲填充。不然，返回 str。
43 str.lstrip
返回 str 的副本，移除了前導的空格。
44 str.lstrip!
從 str 中移除前導的空格，若是沒有變化則返回 nil。
45 str.match(pattern)
若是 pattern 不是正則表達式，則把 pattern 轉換爲正則表達式 Regexp，而後在 str 上調用它的匹配方法。
46 str.oct
把 str 的前導字符看成十進制數字的字符串（一個可選的符號），並返回相對應的數字。若是轉換失敗，則返回 0。
47 str.replace(other_str)
把 str 中的內容替換爲 other_str 中的相對應的值。
48 str.reverse
返回一個新字符串，新字符串是 str 的倒序。
49 str.reverse!
逆轉 str，str 會發生變化並返回。
50 str.rindex(substring [, fixnum]) [or]
str.rindex(fixnum [, fixnum]) [or]
str.rindex(regexp [, fixnum])
返回給定子字符串、字符（fixnum）或模式（regexp）在 str 中最後一次出現的索引。若是未找到則返回 nil。若是提供了第二個參數，則指定在字符串中結束搜索的位置。超出該點的字符將不被考慮。
51 str.rjust(integer, padstr=' ')
若是 integer 大於 str 的長度，則返回長度爲 integer 的新字符串，新字符串以 str 右對齊，並以 padstr 做爲填充。不然，返回 str。
52 str.rstrip
返回 str 的副本，移除了尾隨的空格。
53 str.rstrip!
從 str 中移除尾隨的空格，若是沒有變化則返回 nil。
54 str.scan(pattern) [or]
str.scan(pattern) { |match, ...| block }
兩種形式匹配 pattern（能夠是一個正則表達式 Regexp 或一個字符串 String）遍歷 str。針對每一個匹配，會生成一個結果，結果會添加到結果數組中或傳遞給 block。若是 pattern 不包含分組，則每一個獨立的結果由匹配的字符串、$& 組成。若是 pattern 包含分組，每一個獨立的結果是一個包含每一個分組入口的數組。
55 str.slice(fixnum) [or] str.slice(fixnum, fixnum) [or]
str.slice(range) [or] str.slice(regexp) [or]
str.slice(regexp, fixnum) [or] str.slice(other_str)
See str[fixnum], etc.
str.slice!(fixnum) [or] str.slice!(fixnum, fixnum) [or] str.slice!(range) [or] str.slice!(regexp) [or] str.slice!(other_str)
從 str 中刪除指定的部分，並返回刪除的部分。若是值超出範圍，參數帶有 Fixnum 的形式，將生成一個 IndexError。參數爲 range 的形式，將生成一個 RangeError，參數爲 Regexp 和 String 的形式，將忽略執行動做。
56 str.split(pattern=$;, [limit])
基於分隔符，把 str 分紅子字符串，並返回這些子字符串的數組。
若是 pattern 是一個字符串 String，那麼在分割 str 時，它將做爲分隔符使用。若是 pattern 是一個單一的空格，那麼 str 是基於空格進行分割，會忽略前導空格和連續空格字符。
若是 pattern 是一個正則表達式 Regexp，則 str 在 pattern 匹配的地方被分割。當 pattern 匹配一個玲長度的字符串時，str 被分割成單個字符。
若是省略了 pattern 參數，則使用 $; 的值。若是 $; 爲 nil（默認的），str 基於空格進行分割，就像是指定了 ` ` 做爲分隔符同樣。
若是省略了 limit 參數，會抑制尾隨的 null 字段。若是 limit 是一個正數，則最多返回該數量的字段（若是 limit 爲 1，則返回整個字符串做爲數組中的惟一入口）。若是 limit 是一個負數，則返回的字段數量不限制，且不抑制尾隨的 null 字段。
57 str.squeeze([other_str]*)
使用爲 String#count 描述的程序從 other_str 參數創建一系列字符。返回一個新的字符串，其中集合中出現的相同的字符會被替換爲單個字符。若是沒有給出參數，則全部相同的字符都被替換爲單個字符。
58 str.squeeze!([other_str]*)
與 squeeze 相同，可是 str 會發生變化並返回，若是沒有變化則返回 nil。
59 str.strip
返回 str 的副本，移除了前導的空格和尾隨的空格。
60 str.strip!
從 str 中移除前導的空格和尾隨的空格，若是沒有變化則返回 nil。
61 str.sub(pattern, replacement) [or]
str.sub(pattern) { |match| block }
返回 str 的副本，pattern 的第一次出現會被替換爲 replacement 或 block 的值。pattern 一般是一個正則表達式 Regexp；若是是一個字符串 String，則沒有正則表達式元字符被解釋。
62 str.sub!(pattern, replacement) [or]
str.sub!(pattern) { |match| block }
執行 String#sub 替換，並返回 str，若是沒有替換執行，則返回 nil。
63 str.succ [or] str.next
返回 str 的繼承。
64 str.succ! [or] str.next!
至關於 String#succ，可是 str 會發生變化並返回。
65 str.sum(n=16)
返回 str 中字符的 n-bit 校驗和，其中 n 是可選的 Fixnum 參數，默認爲 16。結果是簡單地把 str 中每一個字符的二進制值的總和，以 2n - 1 爲模。這不是一個特別好的校驗和。
66 str.swapcase
返回 str 的副本，全部的大寫字母轉換爲小寫字母，全部的小寫字母轉換爲大寫字母。
67 str.swapcase!
至關於 String#swapcase，可是 str 會發生變化並返回，若是沒有變化則返回 nil。
68 str.to_f
返回把 str 中的前導字符解釋爲浮點數的結果。超出有效數字的末尾的多餘字符會被忽略。若是在 str 的開頭沒有有效數字，則返回 0.0。該方法不會生成異常。
69 str.to_i(base=10)
返回把 str 中的前導字符解釋爲整數基數（基數爲 二、 八、 10 或 16）的結果。超出有效數字的末尾的多餘字符會被忽略。若是在 str 的開頭沒有有效數字，則返回 0。該方法不會生成異常。
70 str.to_s [or] str.to_str
返回接收的值。
71 str.tr(from_str, to_str)
返回 str 的副本，把 from_str 中的字符替換爲 to_str 中相對應的字符。若是 to_str 比 from_str 短，那麼它會以最後一個字符進行填充。兩個字符串均可以使用 c1.c2 符號表示字符的範圍。若是 from_str 以 ^ 開頭，則表示除了所列出的字符之外的全部字符。
72 str.tr!(from_str, to_str)
至關於 String#tr，可是 str 會發生變化並返回，若是沒有變化則返回 nil。
73 str.tr_s(from_str, to_str)
把 str 按照 String#tr 描述的規則進行處理，而後移除會影響翻譯的重複字符。
74 str.tr_s!(from_str, to_str)
至關於 String#tr_s，可是 str 會發生變化並返回，若是沒有變化則返回 nil。
75 str.unpack(format)
根據 format 字符串解碼 str（可能包含二進制數據），返回被提取的每一個值的數組。format 字符由一系列單字符指令組成。每一個指令後能夠跟着一個數字，表示重複該指令的次數。星號（*）將使用全部剩餘的元素。指令 sSiIlL 每一個後可能都跟着一個下劃線（_），爲指定類型使用底層平臺的本地尺寸大小，不然使用獨立於平臺的一致的尺寸大小。format 字符串中的空格會被忽略。
76 str.upcase
返回 str 的副本，全部的小寫字母會被替換爲大寫字母。操做是環境不敏感的，只有字符 a 到 z 會受影響。
77 str.upcase!
改變 str 的內容爲大寫，若是沒有變化則返回 nil。
78 str.upto(other_str) { |s| block }
遍歷連續值，以 str 開始，以 other_str 結束（包含），輪流傳遞每一個值給 block。String#succ 方法用於生成每一個值。

=end

# 【字符串 unpack 指令】
=begin
指令 返回 描述
A  String 移除尾隨的 null 和空格。
a  String 字符串。
B  String 從每一個字符中提取位（首先是最高有效位）。
b  String 從每一個字符中提取位（首先是最低有效位）。
C  Fixnum 提取一個字符做爲無符號整數。
c  Fixnum 提取一個字符做爲整數。
D, d Float  把 sizeof(double) 長度的字符看成原生的 double。
E  Float  把 sizeof(double) 長度的字符看成 littleendian 字節順序的 double。
e  Float  把 sizeof(float) 長度的字符看成 littleendian 字節順序的 float。
F, f Float  把 sizeof(float) 長度的字符看成原生的 float。
G  Float  把 sizeof(double) 長度的字符看成 network 字節順序的 double。
g  Float  把 sizeof(float) 長度的字符看成 network 字節順序的 float。
H  String 從每一個字符中提取十六進制（首先是最高有效位）。
h  String 從每一個字符中提取十六進制（首先是最低有效位）。
I  Integer  把 sizeof(int) 長度（經過 _ 修改）的連續字符看成原生的 integer。
i  Integer  把 sizeof(int) 長度（經過 _ 修改）的連續字符看成有符號的原生的 integer。
L  Integer  把四個（經過 _ 修改）連續字符看成無符號的原生的 long integer。
l  Integer  把四個（經過 _ 修改）連續字符看成有符號的原生的 long integer。
M  String 引用可打印的。
m  String Base64 編碼。
N  Integer  把四個字符看成 network 字節順序的無符號的 long。
n  Fixnum 把兩個字符看成 network 字節順序的無符號的 short。
P  String 把 sizeof(char *) 長度的字符看成指針，並從引用的位置返回 \emph{len} 字符。
p  String 把 sizeof(char *) 長度的字符看成一個空結束字符的指針。
Q  Integer  把八個字符看成無符號的 quad word（64 位）。
q  Integer  把八個字符看成有符號的 quad word（64 位）。
S  Fixnum 把兩個（若是使用 _ 則不一樣）連續字符看成 native 字節順序的無符號的 short。
s  Fixnum 把兩個（若是使用 _ 則不一樣）連續字符看成 native 字節順序的有符號的 short。
U  Integer  UTF-8 字符，做爲無符號整數。
u  String UU 編碼。
V  Fixnum 把四個字符看成 little-endian 字節順序的無符號的 long。
v  Fixnum 把兩個字符看成 little-endian 字節順序的無符號的 short。
w  Integer  BER 壓縮的整數。
X     向後跳過一個字符。
x     向前跳過一個字符。
Z  String 和 * 一塊兒使用，移除尾隨的 null 直到第一個 null。
@     跳過 length 參數給定的偏移量。
實例
嘗試下面的實例，解壓各類數據。
"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"]
=end


#【【Ruby數組】】Array
=begin
uby 數組是任何對象的有序整數索引集合。數組中的每一個元素都與一個索引相關，並可經過索引進行獲取。
數組的索引從 0 開始，這與 C 或 Java 中同樣。一個負數的索相對於數組的末尾計數的，也就是說，索引爲 -1 表示數組的最後一個元素，-2 表示數組中的倒數第二個元素，依此類推。
Ruby 數組可存儲諸如 String、 Integer、 Fixnum、 Hash、 Symbol 等對象，甚至能夠是其餘 Array 對象。
Ruby 數組不須要指定大小，當向數組添加元素時，Ruby 數組會自動增加
=end

# 【建立數組】
# 例子
name = Array.new(20)
puts name.length        #20
puts name.size          #20

# 例子  能夠給數組中的每一個元素賦值
names = Array.new(4,'mac')
puts names
=begin
mac
mac
mac
mac
=end
puts "#{names}"       #["mac", "mac", "mac", "mac"]


# 例子  new 塊，填充元素
num1 = Array.new(10)
num2 = Array.new(10){|e| e = e * 2}
puts "#{num1}"          #[nil, nil, nil, nil, nil, nil, nil, nil, nil, nil]
puts "#{num2}"          #[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# 數組建立方法2
num2 = Array.[](1,2,3)
# 數組建立方法3
num3 = Array[1,2,3]
puts "#{num2}"          #[1, 2, 3]
puts "#{num3}"          #[1, 2, 3]

# 數組建立方法4，使用範圍
num4 = Array(1...4)
puts "#{num4}"          #[1, 2, 3]

# 【數組的內建方法】
digits = Array(1...4)
num = digits.at(3)
puts "#{num}"           #什麼都沒打印，不知道爲何

=begin
序號 方法 & 描述
1  array & other_array
返回一個新的數組，包含兩個數組中共同的元素，沒有重複。
2  array * int [or] array * str
返回一個新的數組，新數組經過鏈接 self 的 int 副本建立的。帶有 String 參數時，至關於 self.join(str)。
3  array + other_array
返回一個新的數組，新數組經過鏈接兩個數組產生第三個數組建立的。
4  array - other_array
返回一個新的數組，新數組是從初始數組中移除了在 other_array 中出現的項的副本。
5  str <=> other_str
把 str 與 other_str 進行比較，返回 -1（小於）、0（等於）或 1（大於）。比較是區分大小寫的。
6  array | other_array
經過把 other_array 加入 array 中，移除重複項，返回一個新的數組。
7  array << obj
把給定的對象附加到數組的末尾。該表達式返回數組自己，因此幾個附加能夠連在一塊兒。
8  array <=> other_array
若是數組小於、等於或大於 other_array，則返回一個整數（-一、 0 或 +1）。
9  array == other_array
若是兩個數組包含相同的元素個數，且每一個元素與另外一個數組中相對應的元素相等（根據 Object.==），那麼這兩個數組相等。
10 array[index] [or] array[start, length] [or]
array[range] [or] array.slice(index) [or]
array.slice(start, length) [or] array.slice(range)
返回索引爲 index 的元素，或者返回從 start 開始直至 length 個元素的子數組，或者返回 range 指定的子數組。負值索引從數組末尾開始計數（-1 是最後一個元素）。若是 index（或開始索引）超出範圍，則返回 nil。
11 array[index] = obj [or]
array[start, length] = obj or an_array or nil [or]
array[range] = obj or an_array or nil
設置索引爲 index 的元素，或者替換從 start 開始直至 length 個元素的子數組，或者替換 range 指定的子數組。若是索引大於數組的當前容量，那麼數組會自動增加。負值索引從數組末尾開始計數。若是 length 爲零則插入元素。若是在第二種或第三種形式中使用了 nil，則從 self 刪除元素。
12 array.abbrev(pattern = nil)
爲 self 中的字符串計算明確的縮寫集合。若是傳遞一個模式或一個字符串，只考慮當字符串匹配模式或者以該字符串開始時的狀況。
13 array.assoc(obj)
搜索一個數組，其元素也是數組，使用 obj.== 把 obj 與每一個包含的數組的第一個元素進行比較。若是匹配則返回第一個包含的數組，若是未找到匹配則返回 nil。
14 array.at(index)
返回索引爲 index 的元素。一個負值索引從 self 的末尾開始計數。若是索引超出範圍則返回 nil。
15 array.clear
從數組中移除全部的元素。
16 array.collect { |item| block } [or]
array.map { |item| block }
爲 self 中的每一個元素調用一次 block。建立一個新的數組，包含 block 返回的值。
17 array.collect! { |item| block } [or]
array.map! { |item| block }
爲 self 中的每一個元素調用一次 block，把元素替換爲 block 返回的值。
18 array.compact
返回 self 的副本，移除了全部的 nil 元素。
19 array.compact!
從數組中移除全部的 nil 元素。若是沒有變化則返回 nil。
20 array.concat(other_array)
追加 other_array 中的元素到 self 中。
21 array.delete(obj) [or]
array.delete(obj) { block }
從 self 中刪除等於 obj 的項。若是未找到相等項，則返回 nil。若是未找到相等項且給出了可選的代碼 block，則返回 block 的結果。
22 array.delete_at(index)
刪除指定的 index 處的元素，並返回該元素。若是 index 超出範圍，則返回 nil。
23 array.delete_if { |item| block }
當 block 爲 true 時，刪除 self 的每一個元素。
24 array.each { |item| block }
爲 self 中的每一個元素調用一次 block，傳遞該元素做爲參數。
25 array.each_index { |index| block }
與 Array#each 相同，可是傳遞元素的 index，而不是傳遞元素自己。
26 array.empty?
若是數組自己沒有包含元素，則返回 true。
27 array.eql?(other)
若是 array 和 other 是相同的對象，或者兩個數組帶有相同的內容，則返回 true。
28 array.fetch(index) [or]
array.fetch(index, default) [or]
array.fetch(index) { |index| block }
嘗試返回位置 index 處的元素。若是 index 位於數組外部，則第一種形式會拋出 IndexError 異常，第二種形式會返回 default，第三種形式會返回調用 block 傳入 index 的值。負值的 index 從數組末尾開始計數。
29 array.fill(obj) [or]
array.fill(obj, start [, length]) [or]
array.fill(obj, range) [or]
array.fill { |index| block } [or]
array.fill(start [, length] ) { |index| block } [or]
array.fill(range) { |index| block }
前面三種形式設置 self 的被選元素爲 obj。以 nil 開頭至關於零。nil 的長度至關於 self.length。最後三種形式用 block 的值填充數組。block 經過帶有被填充的每一個元素的絕對索引來傳遞。
30 array.first [or]
array.first(n)
返回數組的第一個元素或前 n 個元素。若是數組爲空，則第一種形式返回 nil，第二種形式返回一個空的數組。
31 array.flatten
返回一個新的數組，新數組是一個一維的扁平化的數組（遞歸）。
32 array.flatten!
把 array 進行扁平化。若是沒有變化則返回 nil。（數組不包含子數組。）
33 array.frozen?
若是 array 被凍結（或排序時暫時凍結），則返回 true。
34 array.hash
計算數組的哈希代碼。兩個具備相同內容的數組將具備相同的哈希代碼。
35 array.include?(obj)
若是 self 中包含 obj，則返回 true，不然返回 false。
36 array.index(obj)
返回 self 中第一個等於 obj 的對象的 index。若是未找到匹配則返回 nil。
37 array.indexes(i1, i2, ... iN) [or]
array.indices(i1, i2, ... iN)
該方法在 Ruby 的最新版本中被廢棄，因此請使用 Array#values_at。
38 array.indices(i1, i2, ... iN) [or]
array.indexes(i1, i2, ... iN)
該方法在 Ruby 的最新版本中被廢棄，因此請使用 Array#values_at。
39 array.insert(index, obj...)
在給定的 index 的元素前插入給定的值，index 能夠是負值。
40 array.inspect
建立一個數組的可打印版本。
41 array.join(sep=$,)
返回一個字符串，經過把數組的每一個元素轉換爲字符串，並使用 sep 分隔進行建立的。
42 array.last [or] array.last(n)
返回 self 的最後一個元素。若是數組爲空，則第一種形式返回 nil。
43 array.length
返回 self 中元素的個數。可能爲零。
44 array.map { |item| block } [or]
array.collect { |item| block }
爲 self 的每一個元素調用一次 block。建立一個新的數組，包含 block 返回的值。
45 array.map! { |item| block } [or]
array.collect! { |item| block }
爲 array 的每一個元素調用一次 block，把元素替換爲 block 返回的值。
46 array.nitems
返回 self 中 non-nil 元素的個數。可能爲零。
47 array.pack(aTemplateString)
根據 aTemplateString 中的指令，把數組的內容壓縮爲二進制序列。指令 A、 a 和 Z 後能夠跟一個表示結果字段寬度的數字。剩餘的指令也能夠帶有一個表示要轉換的數組元素個數的數字。若是數字是一個星號（*），則全部剩餘的數組元素都將被轉換。任何指令後均可以跟一個下劃線（_），表示指定類型使用底層平臺的本地尺寸大小，不然使用獨立於平臺的一致的尺寸大小。在模板字符串中空格會被忽略。
48 array.pop
從 array 中移除最後一個元素，並返回該元素。若是 array 爲空則返回 nil。
49 array.push(obj, ...)
把給定的 obj 附加到數組的末尾。該表達式返回數組自己，因此幾個附加能夠連在一塊兒。
50 array.rassoc(key)
搜索一個數組，其元素也是數組，使用 == 把 key 與每一個包含的數組的第二個元素進行比較。若是匹配則返回第一個包含的數組。
51 array.reject { |item| block }
返回一個新的數組，包含當 block 不爲 true 時的數組項。
52 array.reject! { |item| block }
當 block 爲真時，從 array 刪除元素，若是沒有變化則返回 nil。至關於 Array#delete_if。
53 array.replace(other_array)
把 array 的內容替換爲 other_array 的內容，必要的時候進行截斷或擴充。
54 array.reverse
返回一個新的數組，包含倒序排列的數組元素。
55 array.reverse!
把 array 進行逆轉。
56 array.reverse_each {|item| block }
與 Array#each 相同，可是把 array 進行逆轉。
57 array.rindex(obj)
返回 array 中最後一個等於 obj 的對象的索引。若是未找到匹配，則返回 nil。
58 array.select {|item| block }
調用從數組傳入連續元素的 block，返回一個數組，包含 block 返回 true 值時的元素。
59 array.shift
返回 self 的第一個元素，並移除該元素（把全部的其餘元素下移一位）。若是數組爲空，則返回 nil。
60 array.size
返回 array 的長度（元素的個數）。length 的別名。
61 array.slice(index) [or] array.slice(start, length) [or]
array.slice(range) [or] array[index] [or]
array[start, length] [or] array[range]
返回索引爲 index 的元素，或者返回從 start 開始直至 length 個元素的子數組，或者返回 range 指定的子數組。負值索引從數組末尾開始計數（-1 是最後一個元素）。若是 index（或開始索引）超出範圍，則返回 nil。
62 array.slice!(index) [or] array.slice!(start, length) [or]
array.slice!(range)
刪除 index（長度是可選的）或 range 指定的元素。返回被刪除的對象、子數組，若是 index 超出範圍，則返回 nil。
63 array.sort [or] array.sort { | a,b | block }
返回一個排序的數組。
64 array.sort! [or] array.sort! { | a,b | block }
把數組進行排序。
65 array.to_a
返回 self。若是在 Array 的子類上調用，則把接收參數轉換爲一個 Array 對象。
66 array.to_ary
返回 self。
67 array.to_s
返回 self.join。
68 array.transpose
假設 self 是數組的數組，且置換行和列。
69 array.uniq
返回一個新的數組，移除了 array 中的重複值。
70 array.uniq!
從 self 中移除重複元素。若是沒有變化（也就是說，未找到重複），則返回 nil。
71 array.unshift(obj, ...)
把對象前置在數組的前面，其餘元素上移一位。
72 array.values_at(selector,...)
返回一個數組，包含 self 中與給定的 selector（一個或多個）相對應的元素。選擇器能夠是整數索引或者範圍。
73 array.zip(arg, ...) [or]
array.zip(arg, ...){ | arr | block }
把任何參數轉換爲數組，而後把 array 的元素與每一個參數中相對應的元素合併。

數組 pack 指令
下表列出了方法 Array#pack 的壓縮指令。
指令 描述
@  移動到絕對位置。
A  ASCII 字符串（填充 space，count 是寬度）。
a  ASCII 字符串（填充 null，count 是寬度）。
B  位字符串（降序）
b  位字符串（升序）。
C  無符號字符。
c  字符。
D, d 雙精度浮點數，原生格式。
E  雙精度浮點數，little-endian 字節順序。
e  單精度浮點數，little-endian 字節順序。
F, f 單精度浮點數，原生格式。
G  雙精度浮點數，network（big-endian）字節順序。
g  單精度浮點數，network（big-endian）字節順序。
H  十六進制字符串（高位優先）。
h  十六進制字符串（低位優先）。
I  無符號整數。
i  整數。
L  無符號 long。
l  Long。
M  引用可打印的，MIME 編碼。
m  Base64 編碼字符串。
N  Long，network（big-endian）字節順序。
n  Short，network（big-endian）字節順序。
P  指向一個結構（固定長度的字符串）。
p  指向一個空結束字符串。
Q, q 64 位數字。
S  無符號 short。
s  Short。
U  UTF-8。
u  UU 編碼字符串。
V  Long，little-endian 字節順序。
v  Short，little-endian 字節順序。
w  BER 壓縮的整數 \fnm。
X  向後跳過一個字節。
x  Null 字節。
Z  與 a 相同，除了 null 會被加上 *。
實例
嘗試下面的實例，壓縮各類數據。
實例
a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
puts a.pack("A3A3A3")   #=> "a  b  c  "
puts a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
puts n.pack("ccc")      #=> "ABC"
以上實例運行輸出結果爲：
a  b  c
abc
ABC
=end



# 【【哈希】】 Hash
=begin
健值對集合。相似於數組，不過索引不侷限於數字。
索引幾乎能夠是任何對象
和數組有一個很重要的區別，無序的，若是順序很重要，就使用數組了。
=end

#建立哈希
month1 = Hash.new
puts "#{month1}"          #{}
puts month1[0]            #空
puts month1[72]           #空
month2 = Hash.new("months")
puts "#{month2}"          #{}
puts month2[0]            #months
puts month2[72]           #months
month3 = Hash.new"months"
puts "#{month3}"          #{}
puts month3[0]            #months
puts month3[72]           #months

# 例子
H = Hash['a' => 100,'b' => 200]
puts H['a']         #100
puts H['b']         #200

# 【備註】可以使用任意Ruby對象做爲鍵或值，甚至可使用數組
#[1,'jan']  =>  'January'

# 例子
months = Hash.new("months")
months = {'1' => 'January','2' => 'Febrary',[1,'jan']  =>  'January'}
keys = months.keys
puts "#{keys}"          #["1", "2", [1, "jan"]]

#【【Ruby日期、時間】】Date Time

# 例子 獲取當前日期和時間
time1 = Time.new
puts "當前時間：#{time1}"
print "當前時間：" , time1.inspect, "\n"

time2 = Time.now
puts "當前時間：#{time2}"
print "當前時間：", time2.inspect
=begin
當前時間：2018-07-07 12:42:17 +0800
當前時間：2018-07-07 12:42:17 +0800
當前時間：2018-07-07 12:42:17 +0800
當前時間：2018-07-07 12:42:17 +0800
=end


# 【獲取Date & Time 組件】
time = Time.new
puts "當前時間：" ,time
puts time.year      #2018
puts time.month     #7
puts time.day       #7【一個月中的第幾天】
puts time.wday      #6【一週中的星期幾】
puts time.yday      #188【一年中的第幾天】
puts time.hour      #12
puts time.min       #46
puts time.sec       #20
puts time.usec      #840399【微秒】
puts time.zone      #CST   【備註】能夠表示四個國家的標準時間，四個不一樣的時區，根據當前編程環境自行判斷的結果

# 【Time.utc Time.gm  Time.local 函數】格式化
puts Time.local(2018,7,7)         #2018-07-07 00:00:00 +0800
puts Time.local(2018,7,7,13,29)   #2018-07-07 13:29:00 +0800
puts Time.utc(2018,7,7,13,29)     #2018-07-07 13:29:00 UTC
puts Time.gm(2018,7,7,13,28)      #2018-07-07 13:28:00 UTC  【備註】格林威治時間，通UTC


# 時間組件組成的數組
time = Time.new
values = time.to_a
puts "#{values}"            #[32, 35, 13, 7, 7, 2018, 6, 188, false, "CST"]  【備註】[sec,min,hour,day,month,year,wday,yday,isdst,zone]

# 該數組可被傳到Time.utc  Time.local 來獲取日期的不一樣格式
time = Time.now
values = time.to_a
puts Time.utc(*values)      #2018-07-07 13:38:38 UTC

# 【獲取時間的方式，從紀元以來的秒數（平臺相關）】
time = Time.now.to_i        #紀元以來的秒數
puts time
time_obj = Time.at(time)    #把秒數轉成Time對象
puts time_obj
time_f = Time.now.to_f      #返回紀元以來的秒數，包含微秒
puts time_f
=begin
1530942192
2018-07-07 13:43:12 +0800
1530942192.656307
=end

# 【時區和夏令時】
time = Time.now

puts time.zone              #CST
puts time.utc_offset        #28800 【相對於utc的多少秒偏移】
puts time.zone              #CST
puts time.isdst             #false 【若是utc沒有夏令時】
puts time.utc?              #false 【若是在utc時區】
puts time.localtime         #2018-07-07 13:57:50 +0800
time.gmtime                 #【轉換爲UTC】
puts time.getlocal          #2018-07-07 13:57:50 +0800  【備註】返回本地時區中一個新的Time對象
puts time.getutc            #2018-07-07 06:03:31 UTC    【備註】返回utc中一個新的Time對象
puts time                   #2018-07-07 05:59:47 UTC
puts time.zone
puts time.utc_offset
puts time.isdst
puts time.utc?
time.localtime         # 轉換回本地時間
puts time.getlocal
puts time.getutc
=begin
CST
28800
CST
false
false
2018-07-07 14:05:03 +0800
2018-07-07 14:05:03 +0800
2018-07-07 06:05:03 UTC
2018-07-07 06:05:03 UTC
UTC
0
false
true
2018-07-07 14:05:03 +0800
2018-07-07 06:05:03 UTC
=end

# 【格式化時間和日期】
time = Time.now

puts time.to_s
puts time.ctime
puts time.localtime
puts time.strftime('%Y-%m-%d %H:%M:%S')
=begin
Sat Jul  7 14:09:16 2018
2018-07-07 14:09:16 +0800
2018-07-07 14:09:16
=end

=begin
時間格式化指令
下表所列出的指令與方法 Time.strftime 一塊兒使用。
指令 描述
%a 星期幾名稱的縮寫（好比 Sun）。
%A 星期幾名稱的全稱（好比 Sunday）。
%b 月份名稱的縮寫（好比 Jan）。
%B 月份名稱的全稱（好比 January）。
%c 優選的本地日期和時間表示法。
%d 一個月中的第幾天（01 到 31）。
%H 一天中的第幾小時，24 小時制（00 到 23）。
%I 一天中的第幾小時，12 小時制（01 到 12）。
%j 一年中的第幾天（001 到 366）。
%m 一年中的第幾月（01 到 12）。
%M 小時中的第幾分鐘（00 到 59）。
%p 子午線指示（AM 或 PM）。
%S 分鐘中的第幾秒（00 或 60）。
%U 當前年中的週數，從第一個星期日（做爲第一週的第一天）開始（00 到 53）。
%W 當前年中的週數，從第一個星期一（做爲第一週的第一天）開始（00 到 53）。
%w 一星期中的第幾天（Sunday 是 0，0 到 6）。
%x 只有日期沒有時間的優先表示法。
%X 只有時間沒有日期的優先表示法。
%y 不帶世紀的年份表示（00 到 99）。
%Y 帶有世紀的年份。
%Z 時區名稱。
%% % 字符。
=end

# 【時間算法】
now = Time.now
puts now

past = now - 10
puts past

future = now + 10
puts future

diff = future - now
puts diff
=begin
2018-07-07 14:14:17 +0800
2018-07-07 14:14:07 +0800
2018-07-07 14:14:27 +0800
10.0
=end

# 【【Ruby 範圍】】
=begin
1. 做爲序列的範圍
2。做爲條件的範圍
3。做爲間隔的範圍
=end

# 【做爲序列的範圍】
$, = ","  # Array 值分隔符
range1 = (1..10)
puts "#{range1}"            #1..10
puts range1                 #1..10
range1_1 = range1.to_a
puts "#{range1_1}"          #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

range2 = ('bar'..'bat').to_a
puts "#{range2}"            #["bar", "bas", "bat"]

# 例子  遍歷
digits = 0..9

puts digits.include?(5)
ret = digits.min
puts "最小值：#{ret}"

ret = digits.max
puts "最大值：#{ret}"

ret = digits.reject {|i| i < 5}
puts "不符合條件的是：#{ret}"

digits.each do |digit|
  puts "在循環中： #{digit}"
end
=begin
最小值：0
最大值：9
不符合條件的是：[5, 6, 7, 8, 9]
在循環中： 0
在循環中： 1
在循環中： 2
在循環中： 3
在循環中： 4
在循環中： 5
在循環中： 6
在循環中： 7
在循環中： 8
在循環中： 9
=end

#【做爲條件的範圍】
score = 70

result = case score
         when 0..40
           "糟糕的分數"
         when 41..60
           "快要及格"
         when 61..70
           "及格分數"
         when 71..100
           "良好分數"
         else
           "錯誤的分數"
         end

puts result  #及格分數

#【做爲間隔的判斷】
if ((1..5) === 5)
  puts "5 在 (1..5) 裏"
end

if (('a'..'j') === 'c')
  puts "c 在 ('a'..'j') 裏"
end

if (('a'..'j') === 'z')
  puts "z 在 ('a'..'j') 裏"
end
=begin
5 在 (1..5) 裏
c 在 ('a'..'j') 裏
=end

#【【迭代器】】each collect
# 迭代器是集合支持的方法。在Ruby中，數組和哈希能夠稱之爲集合。迭代器返回集合的全部元素。

# 【each】
ary = [1,2,3,4,5]
ary.each do |i|
  puts i
end
print "****************\n"
puts ary
=begin
1
2
3
4
5
****************
1
2
3
4
5
=end

# 【collect】
a = [1,2,3]
b = a.collect{|x|x}
puts b
=begin
1
2
3
=end

#例子
a = [1,2,3]
b = a.collect{|x| 10 * x}
puts "#{b}"         #[10, 20, 30]

#【【文件的輸入與輸出】】
=begin
Ruby提供了一整套I/O相關的方法，在內核(Kernel)模塊中實現。全部的I/O方法派生自I／O類。
=end

# 【gets】
=begin
puts 'enter a value:'
value = gets
puts value
=end

#【putc】puts輸出整個字符串到屏幕上。putc一次輸出一個字符。
str = 'Hello Ruby!'
putc str     #H
putc "\n"

#【打開和關閉文件】
=begin
模式 描述
r  只讀模式。文件指針被放置在文件的開頭。這是默認模式。
r+ 讀寫模式。文件指針被放置在文件的開頭。新寫入的覆蓋原有的。
w  只寫模式。若是文件存在，則重寫文件。若是文件不存在，則建立一個新文件用於寫入。
w+ 讀寫模式。若是文件存在，則重寫已存在的文件。若是文件不存在，則建立一個新文件用於讀寫。
a  只寫模式。若是文件存在，則文件指針被放置在文件的末尾。也就是說，文件是追加模式。若是文件不存在，則建立一個新文件用於寫入。
a+ 讀寫模式。若是文件存在，則文件指針被放置在文件的末尾。也就是說，文件是追加模式。若是文件不存在，則建立一個新文件用於讀寫。
=end

aFile = File.new('input.txt','r') # input.txt 內容
if aFile
  content = aFile.sysread(20)
  puts content
else
  puts 'unable to open file!'
end
#This is a sample tex  【備註】輸入文件的頭20個字符，文件指針將被放置在文件中第21個字符的位置。

# 【syswrite方法】

aFile = File.new('input.txt','r+')
if aFile
  aFile.syswrite('ABCDEFG')
else
  puts 'unable to open file!'
end
# 如今文件內容 ABCDEFG a sample text file for testing perpose.


# 【each_byte】
# 當前文件內容 this is a sample text file for testing perpose.

aFile = File.new('input.txt','r+')
if aFile
  aFile.syswrite('ABCDEF')
  aFile.rewind
  #aFile.each_byte {|ch| putc ch;putc ?.}         #【備註】這一句與下面一句是等價的
  aFile.each_byte {|ch| putc ch;putc '.'}
else
  puts 'unable to open file!'
end
=begin
文件內容：ABCDEFG a sample text file for testing perpose.
控制檯打印：
A.B.C.D.E.F.G. .a. .s.a.m.p.l.e. .t.e.x.t. .f.i.l.e. .f.o.r. .t.e.s.t.i.n.g. .p.e.r.p.o.s.e...
.
=end

# 練習
putc "\n"
putc 'a';
putc ?.
putc '.'
putc "\n"
=begin
a..
=end

#【IO readlines方法】逐行返回

=begin
此時文件的內容：
ABCDEFG a sample text file for testing perpose.
這是第二行。
=end
arr = IO.readlines('input.txt')
puts arr[0]
puts arr[1]
=begin
ABCDEFG a sample text file for testing perpose.
這是第二行。
=end

# 【IO foreach方法】與IO.readlines方法不一樣的是，IO.foreach方法與塊關聯
# #例子   將把文件 test 的內容逐行傳給變量 block，而後輸出將顯示在屏幕上
# =begin
# 此時文件的內容：
# ABCDEFG a sample text file for testing perpose.
# 這是第二行。
# =end
IO.foreach('input.txt'){|block| puts block}
=begin
ABCDEFG a sample text file for testing perpose.
這是第二行。
=end

#【重命名和刪除文件】 rename  delete
File.rename('input.txt','input.txt')
#此時看到已經變名字了
File.rename('input.txt','input.txt')
#此時看到名字已經改回來了

# 【文件查詢】
# 打開文件前，檢查文件是否已存在
File.open('a.txt') if File::exists?('a.txt')

# 查詢文件是不是一個文件
puts File.file?('input.txt')                        #true

# 檢查給定的文件名是不是一個目錄
puts File::directory?('/usr/local/bin')     #true
puts File::directory?('input.txt')          #false

# 檢查文件是否可讀、可寫、可執行
puts File.readable?('input.txt')            #true
puts File.writable?('input.txt')            #true
puts File.executable?('input.txt')          #false

# 檢查文件大小是否爲0
puts File.zero?('input.txt')                #false

# 返回文件大小
puts File.size?('input.txt')                #67

# 檢查文件的類型
puts File.ftype('input.txt')                #file
=begin
ftype 方法經過返回下列中的某個值來標識了文件的類型：file、 directory、 characterSpecial、 blockSpecial、 fifo、 link、 socket 或 unknown。
=end

# 文件被建立、修改、最後訪問的時間
puts File::ctime('input.txt')
puts File::mtime('input.txt')
puts File::atime('input.txt')

# 【【Ruby中的目錄】】全部文件都包含在目錄中。File 處理文件。Dir 處理目錄。

# 查看當前目錄
puts Dir.pwd                    #/Users/suren/RubymineProjects/ruby_test_one

# 獲取指定目錄內的文件和目錄列表
puts Dir.entries('/Users/suren/RubymineProjects/ruby_test_one')
=begin
  返回一個數組
.
..
.idea
arith.rb
class_and_obj.rb
data.rb
grammer.rb
input.txt
moral.rb
support.rb
test_one.rb
trip.rb
x.rb
=end
puts Dir.entries('/Users/suren/RubymineProjects/ruby_test_one').join(' ')
#. .. .idea arith.rb class_and_obj.rb data.rb grammer.rb input.txt moral.rb support.rb test_one.rb trip.rb x.rb

# Dir.foreach返回一個數組，包含指定目錄內的全部項，同Dir.entries
Dir.foreach('/Users/suren/RubymineProjects/ruby_test_one') do |entry|
  puts entry
end
=begin
.
..
.idea
arith.rb
class_and_obj.rb
data.rb
grammer.rb
input.txt
moral.rb
support.rb
test_one.rb
trip.rb
x.rb
=end

# 建立目錄
#Dir.mkdir('aa',755)  # 還能夠順便設置文件的權限

# 建立文件 & 臨時目錄
=begin
臨時文件是那些在程序執行過程當中被簡單地建立，但不會永久性存儲的信息。
Dir.tmpdir 提供了當前系統上臨時目錄的路徑，可是該方法默認狀況下是不可用的。能夠把Dir.tmpdir 和 File.join 一塊兒用，建立一個獨立於平臺的獨立文件
=end

# 例子
require 'tmpdir'
tempfilename = File.join(Dir.tmpdir,'tingtong')
puts tempfilename           # 本次執行結果： /var/folders/7b/v65b2_394_jdz_24k80htg840000gn/T/tingtong
tempfile = File.new(tempfilename,'w')
tempfile.puts "This is a temporary file"
tempfile.rewind
tempfile_for_read = File.new(tempfilename,'r')
value = tempfile_for_read.sysread(30)
puts value
tempfile.close
tempfile_for_read.close
File.delete(tempfilename)
=begin
/var/folders/7b/v65b2_394_jdz_24k80htg840000gn/T/tingtong
This is a temporary file
=end

#例子 Ruby的標準庫包含了Tempfile,可用於建立臨時文件
require 'tempfile'
f = Tempfile.new('tingtong4')
f.puts "Hello Ruby!"
puts f.path             # 當前執行結果：/var/folders/7b/v65b2_394_jdz_24k80htg840000gn/T/tingtong420180707-60134-1g73o9p
f.close

# 【【Ruby異常】】
=begin
從 begin 到 rescue 中的一切是受保護的。若是代碼塊執行期間發生了異常，控制會傳到 rescue 和 end 之間的塊。
對於 begin 塊中的每一個 rescue 子句，Ruby 把拋出的異常與每一個參數進行輪流比較。若是 rescue 子句中命名的異常與當前拋出的異常類型相同，或者是該異常的父類，則匹配成功。
若是異常不匹配全部指定的錯誤類型，咱們能夠在全部的 rescue 子句後使用一個 else 子句
=end

# 例子
begin
   file = open("/unexistant_file")
   if file
      puts "File opened successfully"
   end
rescue
      file = STDIN
end
#puts  "#{file}==#{STDIN}\n"               ##<IO:0x007f9c6409c718>==#<IO:0x007f9c6409c718>

begin #開始
  #試圖打開一個不存在的文件，注意，其實直接調用open也能夠！Ruby實在太亂了！不過 open 返回的是File對象而不是文件內容
  file = open('/cygdrive/d/workspace/notexists')
  if file
    puts "文件打開正常，path=#{file.path}"
  end
rescue Errno::ENOENT => e #文件打不開的具體異常類型是這種，很奇怪把！
  #STDIN 是標準輸入，此處意思是若是拿不到File對象就用標準輸入對象代替，並無什麼特別的用意
  file = STDIN
  puts "這是一種Errno::ENOENT"
  puts
  #用 e.inspect能夠看到具體的異常類型
  puts "e.inspect #{e.inspect}"
  puts
  # 用 e.message 能夠打印出信息
  puts "e.message: #{e.message}"
  puts
  #用 e.backtrace.inspect 能夠打印出堆棧
  puts "e.backtrace.inspect: #{e.backtrace.inspect}"
  puts
  puts "異常信息: #{$!}"
  puts
  puts "異常代碼位置: #{$@}"
rescue StandardError => e #獲取e對象
  #STDIN 是標準輸入，此處意思是若是拿不到File對象就用標準輸入對象代替，並無什麼特別的用意
  file = STDIN
  puts "這是一種StandardError" #默認都是StandardError
rescue => e #還能夠直接不寫類型，意思是全部類型，至關於else了
  #STDIN 是標準輸入，此處意思是若是拿不到File對象就用標準輸入對象代替，並無什麼特別的用意
  file = STDIN
  puts "不知道是什麼類型的Error"
ensure
  puts "怎樣都會進入的代碼"
end #結束

#逗號隔開並非連在一塊兒輸出，而是屢次調用print方法的意思
print file, " == ", STDIN
=begin
這是一種Errno::ENOENT

e.inspect #<Errno::ENOENT: No such file or directory @ rb_sysopen - /cygdrive/d/workspace/notexists>

e.message: No such file or directory @ rb_sysopen - /cygdrive/d/workspace/notexists

e.backtrace.inspect: ["/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:3:in `initialize'", "/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:3:in `open'", "/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:3:in `<top (required)>'", "-e:1:in `load'", "-e:1:in `<main>'"]

異常信息: No such file or directory @ rb_sysopen - /cygdrive/d/workspace/notexists

異常代碼位置: ["/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:3:in `initialize'", "/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:3:in `open'", "/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:3:in `<top (required)>'", "-e:1:in `load'", "-e:1:in `<main>'"]
怎樣都會進入的代碼
#<IO:0x007fcbe909c718> == #<IO:0x007fcbe909c718>
=end

# 【retry】
begin
  file = open('/unexistant_file')
  if file
    puts "File opened successfully"
  end
rescue
  filename = open('input.txt')
  retry
end
puts filename

# 【retry】
#例子  死循環了
=begin
begin
  file = open('/unexistant_file')
  if file
    puts "File opened successfully"
  end
rescue
  filename = open('/input.txt')
  retry
end
puts filename
=end

# 例子 針對上面例子的解決方案

aa = 'input1.txt'
begin
  file = open($aa)
  if file
    puts 'file opened successfully'
  end
rescue
  $aa = 'input.txt'
  retry
end
puts file

=begin
如下是處理流程：
打開時發生異常。
跳到 rescue。fname 被從新賦值。
經過 retry 跳到 begin 的開頭。
此次文件成功打開。
繼續基本的過程。
注意：若是被從新命名的文件不存在，本實例代碼會無限嘗試。因此異常處理時，謹慎使用 retry。

【備註】我這裏並未打印出任何內容
=end

# 【raise】
=begin
語法
raise

或

raise "Error Message"

或

raise ExceptionType, "Error Message"

或

raise ExceptionType, "Error Message" condition
第一種形式簡單地從新拋出當前異常（若是沒有當前異常則拋出一個 RuntimeError）。這用在傳入異常以前須要解釋異常的異常處理程序中。
第二種形式建立一個新的 RuntimeError 異常，設置它的消息爲給定的字符串。該異常以後拋出到調用堆棧。
第三種形式使用第一個參數建立一個異常，而後設置相關的消息爲第二個參數。
第四種形式與第三種形式相似，您能夠添加任何額外的條件語句（好比 unless）來拋出異常。
=end


# 例子

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'
=begin
I am before the raise
I am rescued.
I am after the begin block
=end

#例子
begin
  raise 'A test Exception.'
rescue Exception => e
  puts e.message
  puts e.backtrace.inspect
end
=begin
A test Exception.
["/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:70:in `<top (required)>'", "-e:1:in `load'", "-e:1:in `<main>'"]
=end

# 【ensure】至關於finally

begin
  raise 'A Test Exception'
rescue Exception => e
  puts e.message
  puts e.backtrace.inspect
ensure
  puts 'Ensuring execution'

end
=begin
A Test Exception
["/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:83:in `<top (required)>'", "-e:1:in `load'", "-e:1:in `<main>'"]
Ensuring execution
=end

# 【else】只有在代碼主體未拋出異常時執行
# 例子
begin
  puts "I'm not  raising exeception."
rescue Exception => e
  puts e.message
  puts e.backtrace.inspect
else
  puts "Congratuations-- no errors!"
ensure
  puts 'Ensuring execution'
end

=begin
I'm not  raising exeception.
Congratuations-- no errors!
Ensuring execution
=end


#throw/cathc
#例子

#例子
"""
def promptAndGet(prompt)
  print prompt
  res = readline.chomp
  throw :quitRequested if res == '!'
  return res
end

catch :quitReques do
## 首先進入catch塊中，這是第一句被執行的，進入quitRequested方法，若是不輸入感嘆號，就不throw,直接返回調用處，這一行返回結果給name變量。而後接着執行catch中的下一行，直到readline.chmop接收到一個感嘆號，此時會拋出異常，catch不會接，只會終止。
  name = promptAndGet('Name:')
  age = promptAndGet('age:')
  sex = promptAndGet('sex:')
end

promptAndGet('Name11:')
"""
'''
Name:wxue
age:er
sex:femail
Name11:wxue
'''


#例子
"""
def promptAndGet(prompt)
  print prompt
  res = readline.chomp
  throw :quitRequested if res == '!'
  return res
end

catch :quitReques do
  name = promptAndGet('Name:')
  age = promptAndGet('age:')
  sex = promptAndGet('sex:')
end

promptAndGet('Name11:')
"""
"""
Name:wxue
age:23
sex:femail
Name11:!
/Users/suren/RubymineProjects/ruby_test_one/x.rb:31:in `throw': uncaught throw :quitRequested (UncaughtThrowError)
from /Users/suren/RubymineProjects/ruby_test_one/x.rb:31:in `promptAndGet'
 from /Users/suren/RubymineProjects/ruby_test_one/x.rb:41:in `<top (required)>'
 from -e:1:in `load'
from -e:1:in `<main>'
"""

#例子
"""
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:')
end
promptAndGet('Name11:')
"""
"""
Name:wxue
age:23
sex:femail
Name11:!
/Users/suren/RubymineProjects/ruby_test_one/x.rb:85:in `throw': uncaught throw :quitRequested (UncaughtThrowError)
 from /Users/suren/RubymineProjects/ruby_test_one/x.rb:85:in `promptAndGet'
 from /Users/suren/RubymineProjects/ruby_test_one/x.rb:94:in `<top (required)>'
 from -e:1:in `load'
 from -e:1:in `<main>'
"""

#例子
"""
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:')
end
promptAndGet('Name11:')
"""
'''
Name:wxue
age:er
sex:femail
Name11:wxue
'''
#【備註】Ruby和其餘語言不太同樣，這裏throw。。catch，不是主要處理異常的，而能夠理解成控制流程的。

# 【類Exception】
=begin
Ruby 的標準類和模塊拋出異常。全部的異常類組成一個層次，包括頂部的 Exception 類在內。下一層是七種不一樣的類型：
Interrupt
NoMemoryError
SignalException
ScriptError
StandardError
SystemExit
Fatal 是該層中另外一種異常，可是 Ruby 解釋器只在內部使用它。
ScriptError 和 StandardError 都有一些子類，可是在這裏咱們不須要了解這些細節。最重要的事情是建立咱們本身的異常類，它們必須是類 Exception 或其子代的子類
=end

#例子 
=begin

class FileSaveError < StandardError
  attr_reader :reason
  def initialize(reason)
    @reason = reason
  end
end

File.open('inpu.txt', "w") do |file|
  begin
    # 寫出數據 ...
  rescue
    # 發生錯誤
    raise FileSaveError.new($!)
  end
end

a = FileSaveError.new('abc')
p a.reason    #abc

=end

# 【Ruby】【Symbol】
p :foo.object_id

p :foo.object_id

p :"foo".object_id

p :'foo'.object_id

p "foo".object_id

p "foo".object_id

p 'foo'.object_id

p 'foo'.object_id
=begin

2002
2002
2002
2002
2004
2006
2008
2010
=end

# 【:: 和 :】
# :: 是 引用或調用各類對象（Ruby中一切皆對象）: 是symbol
# ::例子  【若是 Foo::小寫(new,test)---->就去需找方法 若是 Foo::大寫(A,VERSION)--->就去尋找常量】
class Mao
  PPP='aaaaa'
  def ppp
    puts "maohaofu"
  end

end
def maomao
  puts ::Mao.new::ppp
  puts ::Mao:: new::ppp # 和上一行同樣效果
  puts ::Mao::PPP
end
maomao()
=begin
這樣會不會明白些

輸出

maohaofu

maohaofu

aaaaa
=end



# : 例子
=begin

Symbol 是什麼
Ruby 是一個強大的面向對象腳本語言（本文所用 Ruby 版本爲1.8.6），在 Ruby 中 Symbol 表示「名字」，好比字符串的名字，標識符的名字。
建立一個 Symbol 對象的方法是在名字或者字符串前面加上冒號：

建立 symbol 對象

:foo
:test

:」abc」
:」I am a boy」

你可能會問，字符串就是字符串，幹嘛還有字符串的名字？這是由於在 Ruby 中字符串也是一種對象，即 String 對象。不管其結構仍是操做和 Symbol 對象都是不一樣的。
在 Ruby 中每個對象都有惟一的對象標識符（Object Identifier），能夠經過 object_id 方法來獲得一個對象的標識符。咱們來看看 Symbol 對象和 String 對象的差異：

Ruby 對象標識符

irb(main):001:0> puts :foo.object_id
327458
=> nil
irb(main):002:0> puts :foo.object_id
327458
=> nil
irb(main):003:0> puts :"foo".object_id
327458
=> nil
irb(main):004:0> puts "foo".object_id
24303850
=> nil
irb(main):005:0> puts "foo".object_id
24300010
=> nil
irb(main):006:0> puts "foo".object_id
24296170
=> nil

能夠看到，前三行語句中的 :foo （或者 :"foo"）都是同一個 Symbol 對象，其 object id 爲327458，然後三行中的字符串」foo」都是不一樣的對象，其 object id 依次爲24303850、243000十、24296170。
可見，每一個 String 對象都是不一樣的，即使他們包含了相同的字符串內容；而對於 Symbol 對象，一個名字（字符串內容）惟一肯定一個 Symbol 對象。
值得注意的是建立 Symbol 對象的字符串中不能含有’\0’字符，而 String 對象是能夠的。

非法 Symbol 字符串

irb(main):001:0>  :"fo\0o"
SyntaxError: compile error
(irb):1: symbol cannot contain '\0'
from (irb):1
irb(main):002:0> :"foo\0"
SyntaxError: compile error
(irb):2: symbol cannot contain '\0'
from (irb):2
irb(main):003:0> puts "foo\0".object_id
24305140
=> nil
irb(main):004:0> puts "fo\0o".object_id
24301000
=> nil
irb(main):005:0>

    除了能夠採用通常的字符串，還可使用操做符（例如+, -, *, /），變量，常量，方法甚至類的名字來建立Symbol 對象，例如:+就是一個合法的 Symbol 。實際上，在 Ruby 內部操做符、變量等名字自己就是做爲Symbol 處理的，例如當你定義一個實例變量時， Ruby 會自動建立一個 Symbol 對象，例如 @test 對應爲 :@test 。

實例變量的 Symbol
                
class Test     
 attr_accessor :test
end
 
這個類定義了一個具備讀寫方法的實例變量 @test 。實際上 Ruby 建立了兩個 Symbol ，一個是實例變量的symbol :@test ，另外一個是 :test 。那若是使用字符串對象 」test」 做爲參數呢？也能夠，仍然會建立兩個 symbol，:test 和 :@test ，爲何還會建立 :test 呢？這是和Ruby的實現相關的（至少Ruby1.8.6裏是這樣）。
注意，類變量 @@test 和實例變量 @test 對應的 Symbol 顯然是不一樣的。記住：名字相同，則Symbol 相同。

名字相同， Symbol 相同
                
class Test     
  puts :Test.object_id
  Test = 10
  puts :Test.object_id
  
  def Test       
    puts :Test.object_id
  end  
end 

Test.new.Test


運行結果
                
224298
224298
224298


名字不一樣， Symbol 不一樣
                
class Test     
  puts :Test.object_id

  @@test = 10
  puts :@@test.object_id
  def test       
    puts :test.object_id
    @test = 10      
    puts :@test.object_id

  end  
end 

t =Test.new  
t.test  


運行結果
                
224298
288068
79858
288108
 
第一個例子裏，類名、常量名和方法名都是 Test ，所以相應的 Symbol 對象都是 :Test 。不用擔憂， Ruby 能夠很好區分它在不一樣上下文中到底表示什麼。固然這並非一個好的編程風格，但對於理解 Ruby 的 Symbol仍是有幫助的： Symbol 表示一個名字，僅此而已。
Symbol 對象一旦定義將一直存在，直到程序執行退出。全部 Symbol 對象存放在 Ruby 內部的符號表中，能夠經過類方法Symbol.all_symbols 獲得當前 Ruby 程序中定義的全部 Symbol 對象，該方法返回一個 Symbol 對象數組。因爲 Symbol 比較多，你能夠 dump 到文件中來查看。

all_symbols 方法
                
irb(main):001:0> Symbol.all_symbols.size
=> 4047
irb(main):002:0> Symbol.all_symbols[0..9]
=> [:@level_notifier, :ppx, :msg_dn, :version, :secs, :@user, :pos, :socketpair,
 :TkENSURE, :HTTPAccepted]
irb(main):003:0> File.open("sym", "w") do |file| file.puts Symbol.all_symbols end
=> nil
 
 
Symbol 和 String
Symbol 對象和 String 對象是徹底不一樣的東西，對象標識符很明確的說明了這一點。除此以外，咱們還能夠從兩種對象的方法上區分。
查看 Ruby 庫參考，你會發現 String 類有很是多的方法，包括 Mixed-in 方法（Ruby中一個類經過 include 其餘模塊而獲得的方法，實現多重繼承的效果）、類方法和實例方法；而 Symbol 類只有一個類方法 all_symbols 和7個實例方法。
例如，能夠經過 []= 方法改變 string 的內容，而 symbol 則不行：

[]= 方法比較
                
irb(main):001:0> s="test"
=> "test"
irb(main):002:0> s[0]='1'
=> "1"
irb(main):003:0> puts s
1est
=> nil
irb(main):004:0> sym=:test
=> :test
irb(main):005:0> sym[0]=1
NoMethodError: undefined method `[]=' for :test:Symbol
        from (irb):5
irb(main):006:0>
 
雖然 Symbol 和 String 是不一樣的對象，但它們之間關係很密切。 Ruby 提供了方法在 Symbol和 String 之間轉換。
Symbol 轉化爲 String
使用 to_s 或 id2name 方法將 Symbol 轉化爲一個 String 對象：

Symbol 到 String
                
irb(main):001:0> :test.id2name
=> "test"
irb(main):002:0> :test.to_s
=> "test"
irb(main):003:0> :"I am a boy".to_s
=> "I am a boy"
 
注意，每一個 String 對象都是惟一的，所以對一個 Symbol 調用屢次將產生多個 String 對象。
String 轉化爲 Symbol
除了在字符串前面加冒號，還可使用 to_sym 或 intern 方法將 String 轉化爲 Symbol ，若是該 Symbol 已經存在，則直接返回。

String 到 Symbol
                
irb(main):001:0> var1 = "test".to_sym
=> :test
irb(main):002:0> var2 = "test".intern
=> :test
irb(main):003:0> var1 == var2
=> true
irb(main):004:0>
 
 
使用 Symbol
正如前邊提到的， Ruby 內部一直在使用 Symbol ，好比 Ruby 程序中的各類名字，Symbol本質上是 Ruby 符號表中的東西。使用 Symbol 處理名字能夠下降 Ruby 內存消耗，提升執行速度，這點咱們在下一篇文章中會看到。
那麼 Symbol 對咱們有什麼用呢？固然也是內存。使用 String 的開銷太大了，由於每個String 都是一個對象。想一想前邊的例子，一個字符串每出現一次 Ruby 就會建立一個 String 對象。
一般來說，當你面臨 String 仍是 Symbol 的選擇時，能夠參考如下標準：
若是使用字符串的內容，這個內容可能會變化，使用 String
若是使用固定的名字或者說是標識符，使用 Symbol
那麼何時咱們會用到名字呢？不少時候都會，好比枚舉值、關鍵字（哈希表關鍵字、方法的參數）等等
做爲哈希表的 key
哈希表是 Symbol 應用最爲普遍的地方。
在ruby中，哈希和數組相似，一個哈希表是一系列 key/value 對的集合，只不過它的 key 取值範圍更普遍，能夠是任何對象，好比正則表達式。但一般咱們都會取有意義的 key ，好比 String、Symbol 。
下面這個哈希表表示按城市分類的一些機器的集合。

一個哈希表例子

hosts{
  'beijing' => 'machine1',
      'shanghai'  => 'machine2',
      'guangzhou' => 'machine3',
      'tianjin' =>  'machine4',
      'shenzhen' =>　'machine5'
}

若是要引用 beijing 的機器，使用 hosts['beijing'] 。但若是咱們程序中要頻繁引用哈希表中 value ，這樣就不大好了，由於 Ruby 對每一次字符串引用都會生成一個 String 對象，累積下來這個開銷是至關大的。
咱們徹底可使用 Symbol ，由於對於這些 key 來說，咱們用的就是名字而已，例以下面hosts[:beijing]


使用 Symbol 做爲 key

hosts　=　{
  　:beijing　=>　'machine1',
               　:shanghai　=>　'machine2',
                             　:guangzhou　=>　'machine3',
                                            　:tianjin 　=>　'machine4',
                                                          　:shenzhen　=>　'machine5'
}

哈希參數
一般咱們定義的函數的參數的個數和順序是寫死的，調用函數的時候要確保參數的個數、順序匹配，有時候這樣很不方便，使用哈希參數能夠解決這個問題。
ROR 中就大量地運用這種方式，也許你已經看到了，處處都是 Symbol 和哈希。好比：

使用哈希參數的方法調用

link_to 'Show', :action => 'show', :id => product

add_column :products, :price, :decimal,
           :precision => 8, :scale => 2, :default => 0

使用哈希參數的方法能夠以下定義，前半部分爲固定參數，後面爲可變參數，或者乾脆全採用哈希參數：

哈希參數

def my_method(para1, …, options={})
#your code
end

def my_method(options={})
#your code
end

若是你但願設定一些默認參數，並容許調用者更改這些參數，可使用哈希對象的 merge! 方法
hsh.merge!( other_hash )。該方法將 other_hash 裏內容加到 hsh 中，若是other_hash 與 hsh 有重複的 key ，則 key在 other_hash 中的 value 覆蓋 hsh 中對應 key 的 value 。

方法定義-使用默認參數

class Test
  def my_method(opts={})
    default_opts={:arg1 => 10, :arg2 => "abc"}
    default_opts.merge!(opts)
    default_opts.each{|key,value| puts "#{key} is #{value}"}
  end
end

t = Test.new
t.my_method :arg1=>5, :arg3=>"def"


運行結果

arg1 is 5
arg2 is abc
arg3 is def

原文參考地址：https://blog.csdn.net/besfanfei/article/details/7966850

# 別的網站的講解
Symbol看起來像一個沒有引號的字符串前加了個冒號:myname
固然你也能夠用冒號加引號的形式聲明帶空格的symbol。
:'my name'or :"my name" Symbol是不變的，不能夠像其餘變量同樣對它進行賦值運算。
好比這樣的寫法是錯誤的:myname = "Tom"。 相反Symbol能夠做爲值賦給其餘變量好比mystring = :myname。

=end

【【其餘文件】】

# 【chop & chomp】
=begin
還沒開始系統性的學習Ruby，最近在看metasploit框架的exploit會涉及到Ruby腳本，也就硬着頭皮一遍查閱資料一遍作些筆記吧。

Ruby字符串中存在chop和chomp的內置函數。我在http://www.w3cschool.cc/ruby/ruby-string.html中獲得的關於Ruby字符串chop和chomp的用法介紹以下：


str.chomp
從字符串末尾移除記錄分隔符（$/），一般是 \n。若是沒有記錄分隔符，則不進行任何操做。
str.chomp!
與 chomp 相同，可是 str 會發生變化並返回。
str.chop
移除 str 中的最後一個字符。
str.chop!
與 chop 相同，可是 str 會發生變化並返回。
單從這幾句話，仍是有些不明白（貌似借鑑於perl語言中的chop和chomp函數的用法），而後百度了一下，我在http://blog.chinaunix.net/uid-20691105-id-1568659.html獲得以下內容：


chomp和chop的區別:
    chomp:去掉字符串末尾的\n或\r
chop:去掉字符串末尾的最後一個字符,無論是\n\r仍是普通字符
"hello".chomp            #=> "hello"
"hello\n".chomp          #=> "hello"
"hello\r\n".chomp        #=> "hello"
"hello\n\r".chomp        #=> "hello\n"
"hello\r".chomp          #=> "hello"
"hello".chomp("llo")     #=> "he"
"string\r\n".chop   #=> "string"
"string\n\r".chop   #=> "string\n"
"string\n".chop     #=> "string"
"string".chop       #=> "strin"

首先，能夠看到print是不輸出換行符的（不會自動換行），可是會解析雙引號中的轉義字符，
能夠看到print輸出了字符串中的換行符\n和回車符\r。我以前有點迷惑的是「\r\n」,「\n\r」這兩個先後順序不一樣時，
chop和chomp函數是如何處理的。從運行的結果看，當字符串最後面跟的是「\r\n」時，」\r\n」都會被去掉，
而當字符串最後面跟的是」\n\r」時，只會去掉回車符。好吧，總算是明白了。
=end

input.txt

suport.rb:

module Week
  FIRST_DAY = 'Sunday'
  def Week.week_in_month
    puts 'you have four weeks in a month'
  end
  def Week.week_in_year
    puts 'you have 52 weeks in a year'
  end
end

moral.rb:

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

  end
end

#【控制流程】【循環語句】5.times{  |i|  print "這是第",i,"次","\n"}3.times{  print "hi"}print "\n"1.upto(9){  |i|  print i if i < 7}print "\n"9.downto(1){  |i|  print i if i < 7}print "\n"(1..9).each{  |i|  print i if i < 7}print "\n"0.step(11,3){  |i|  print i}print "\n"1.step(11,3){  |i|  print i}=begin這是第0次這是第1次這是第2次這是第3次這是第4次hihihi123456654321123456036914710=endprint "\n"#【【循環控制】】i = 0['Perl','Python','Ruby','Scheme'].each{  |lang|  i += 1  if i == 3    break  end  p [i,lang]}=begin[1, "Perl"][2, "Python"]=endi = 0['Perl','Python','Ruby','Scheme'].each{  |lang|  i += 1  if i == 3    redo  end  p [i,lang]}=begin[1, "Perl"][2, "Python"][4, "Ruby"][5, "Scheme"]=endi = 0['Perl','Python','Ruby','Scheme'].each{  |lang|  i += 1  if i == 3    next  end  p [i,lang]}=begin[1, "Perl"][2, "Python"][4, "Scheme"]=end#【【數據類型】】#例子 數值類型的相互轉換puts 12.to_f                          #12.0puts 12.0.to_i                        #12#例子 字符串和數值的相互轉化puts "12.34estts".to_f                #12.34puts "12.34esdff".to_i                #12puts 12.34.to_s                       #"12.34"puts 12.to_s                          #12#浮點數的處理 四捨五入p 1.2.round                           #1p 1.8.round                           #2p -1.2.round                          #-1p -1.8.round                          #-2#浮點數、進位取整。。p 1.5.ceil                            #2p -1.5.ceil                           #-1#返回小於或等於num的最大整數p 1.5.floor                           #1p -1.5.floor                          #-2#【數組】#初始化#B = []#B = Array.new                         #Array#p B.class#數組的獲取B = [1,2,3]p B[0]        #1p B[1]        #2#數組運算和經常使用函數#& 交集p [1,1,3,5]&[1,3]                     #[1, 3]# *p [1,2,3] * 3p [1,2,3] * ' - 'p [1,2,3] * " - "=begin[1, 2, 3, 1, 2, 3, 1, 2, 3]"1 - 2 - 3""1 - 2 - 3"=end# + 串聯p [1,2,3] + [4,5]                   #[1, 2, 3, 4, 5]p [1,2,3,4] + [4,5]                 #[1, 2, 3, 4, 4, 5]# - 數組差集 ：返回新數組，該數組是原數組的拷貝，並刪除了出現再other_array中的元素p [1,1,2,2,3,3,4,5] - [1,2,4]       #[3, 3, 5]# << 將給定的對象添加到數組的末尾p [1,2] << "c" << "d" << [4,5]     #[1, 2, "c", "d", [4, 5]]a = [1,2,3,2,1]a.delete(2)p a           #[1, 3, 1]a = [1,2,3,2,1]a.delete_at(2)p a           #[1, 2, 2, 1]a = [1,[2,[3]],[4],5]a.flatten!p a           #[1, 2, 3, 4, 5]a = [2,5,3,5,1]a.sort!p a           #[1, 2, 3, 5, 5]#【字符串】#長度p "ruby".length     #4p "ruby".size       #4#分割字符串str = "hello world ! !"p str.split         #["hello", "world", "!", "!"]p str.split(" ")    #["hello", "world", "!", "!"]#字符串去空格str = "hello world ! !"p str.strip          #正常應該是"helloworld!!"str = "hello world ! !"p str.strip!         #正常應該是"helloworld!!"#字符串替換str = "hello world  !!"p str.sub("!","ruby")   #"hello world  ruby!"str = "hello world !!"p str.gsub("!","ruby")  #"hello world rubyruby"# 字符串的運算# *p "Ho" * 3            #"HoHoHo"p "hello" + "world"   #"helloworld"# << 把給定的對象串聯到str 若是這個對象是一個值在0~255之間的fixnum，在串聯以前會把它轉成一個字符a = "hello"p a << 33p a << "world"# 索引，相似數組str = "abcdef"p str[0]          #"a"p str[0].chr      #"a"p str[2]          #"c"p str[2].chr      #"c"p str[1,2]        #"bc"p str[1,3]        #"bcd"#【哈希】#初始化h = {"R" => "Ruby"}hash2 = Hash.newp h["R"]            #"Ruby"#哈希的元素能夠是哈希，但哈希的鍵是惟一的table = {"A" => {"a" => "x","b" => "y"},"B" => {"a" => "v","b" => "w"}}p table["A"]["a"]    #"x"p table["B"]["a"]    #"v"#刪除元素h = {"R" => "Ruby"}h.delete("R")p h                   #{}p h["R"]              #nil#大小h = {"a" => "b","c" => "d"}p h.length            #2p h.size              #2#【【正則】】#匹配str = "hello,kaichuan,Welcome!"p str =~ /kaichuan/         #6p str =~ /a/                #7p str =~ /ABC/              #nil#不匹配str = "hello,kaichuan,Welcom!"p str !~ /kaichuan/         #falsep str !~ /a/                #falsep str !~ /ABC/              #true

# 知識點 參考地址：https://blog.csdn.net/tse_e/article/details/54930073