Canoeist Castle

ruby regex

2013-04-06T00:00:00-07:00

正则表达式是非常重要的一个工具，在任何编程语言中，都会使用它来进行对文本的匹配，而且它也是非常用到的一个工具，掌握好正则表达式的使用非常重要。

基本用法

正则表达式经常和字符串方法结合使用，不过，我们还是先了解一下最基本的自身用法。那先认识一个叫做 =~ 的操作符，它就是正则匹配的操作符，它是这样使用的：

>> /o/ =~ 'hello world'           # => 4
>> /ol/ =~ 'hello world'          # => nil

如果发现了有匹配项，ruby 就回返回在字符串中哪一个位置匹配的，而没有匹配则回返回 nil。在 ruby 中，你也可以在 =~ 符的左边放字符串，右边放正则表达式：

>>  'hello world' =~ /o/          # => 4

一般都喜欢使用上面的那种做法，也即正则表达式放在 =~ 符的左边。同样，正则表达式也可以放入到一个变量中，然后要使用的时候调用，就像下面这种方法使用：

>> pattern = /o/
>> pattern =~ 'hello ruby'        # => 4
>> pattern =~ 'the new world'     # => 9

还有常用的方法是使用 match() 方法，用法是 pattern.match(str) ，有匹配的话则返回 MatchData ，不然就返回 nil：

>> r = /o/.match('hello world')   # => #<MatchData "o">
>> r.class                        # => MatchData

正则表达式语法

这里一个庞大的、复杂的部分，还好，可以一步一步从简单的开始，掌握好了再逐步的去掌握更复杂的模式，而这种正则表达式语法可以使用到多种编程语言中，包括 python，java，和像 bash 一样的脚本语言中，并且，在 linux 的命令中也是要以使用的。

这里从最基本的 [] 开始，它是使用过程中最常用到的方法，用法如下：

>> /[aeiou]/.match('hello world') # => #<MatchData "e">  匹配元音字符
>> /[a-z]/.match('hello world')   # => #<MatchData "h">  匹配小写字母
>> /[0-9]/.match('hello world')   # => nil               匹配数字

然后，再在上面的基础上加点通配符，它们是：

.     匹配任何的 1 个字符
?     匹配 0 个或者是 1 个
*     匹配 0 个或者是多个
+     匹配 1 个或者是多个

>> /[a-z]?/.match('hello world')  # => #<MatchData "h">
>> /[a-z]*/.match('hello world')  # => #<MatchData "hello">
>> /[a-z]+/.match('hello world')  # => #<MatchData "hello">

上面的 a-z? 这个表达式装匹配任意的小写字母，或者是没有，也可能匹配成功，比方说：

>> /[a-z]?/.match('')             # => #<MatchData "">
>> /[a-z]?/.match('0')            # => #<MatchData "">
>> /ruby?/.match('ruby')          # => #<MatchData "ruby">  匹配 rub 也会成功

一般常用的是 + 号比较多点，它可以用来匹配，比方说用户名：

>> /[a-zA-Z0-9_]+/.match('ruby')                 # => #<MatchData "ruby">
>> /[a-zA-Z0-9_]+/.match('example@hotmail.com')  # => #<MatchData "example">

当然，老是 a-zA-Z0-9 或 0-9 这样常用到的匹配模式，正则表达示也为什么准备了一些方法来简化，可以使用：

\d     匹配数字，也就是 0-9
\s     匹配空白字符，换行回车什么的
\w     匹配单词，和 [a-zA-Z0-9_] 是一样的

它们的大写形式，\D、 \S、 \W 是取这些字符的反，比如 \D 就是除 0-9 以外的任意字符。

>> /\w+/.match('example@hotmail.com')          # => #<MatchData "example">

还有行首和行尾匹配，^ 是行首，$ 是行尾，比方说上面的那个 /\w+/..match(‘example@hotmail.com’) 去匹配 example@hotmail.com，但如果前面还有其它字符的话，也会匹配成功，比如：

>> /\w+/..match('***example@hotmail.com')      # => #<MatchData "example">

这时就需要加入行首限定符了，开头必须是要以 a-zA-Z0-9_ 这部分的内容：

>> /^\w+/.match('example@hotmail.com')         # => #<MatchData "example">

另外，还有 \A 匹配字符串开始和 \z 匹配字符串结尾。

正则表达式的最基咄的部分就这些了，后面将会绘写一点比较复杂的内容。

参考资料

正则表达式匹配查询 Rubular

ruby string

2013-04-05T00:00:00-07:00

字符串是应用程序中最最常用到的部分了，大多数应用程序中，字符串对象占用的比例都超过了 50%，全面的理解和合理的使用字符串才不会使用你的应用程序占用过多的内存。所以，了解字符串如何在程序里的使用也是至关重要的。

字符串创建

字符串通常都是使用引单来创建的，在 Ruby 中，使用 ’ 单引号和使用 ” 双引号创建的字符串是不一样的。使用单引号创建的字符串是最简单形式的字符串，什么意思呢？其它它是和双引号的字符串的比较来说的，过不了多久你就可以明白了。

>> 'This is new string.'            # => "This is new string."

字符串就是这样被创建出来的，这谁都知道。如果字符串是这样的 ‘This’s new string.’ 你去创建看看，里面一个单引号，这样，ruby 就不知道哪哪一个单引号是结束标记了。这个时候应该这样：

>> 'This\'s new string.'            # => "This's new string."

在这里，加上了一个反斜线做为转码标记，一般来说，在单引号引用的字符串中，如果你要使用单引号和反斜线，就要使用反斜线进行转义。

>> 'a\b' == 'a\\b'                  # => true

而由双引号引用的字符串可以支持更多的转义，比如 \t talbe 符号，\n 换行符，等等都可以支持。可以在双引号引用的字符串变量中放入单引号而无须转义。

>> s = "The new string.\nIt's greate!"  # => "The new string.\nIt's greate!"
>> puts  s                              # => The new string.
                                             It's greate!

双引号引用的字符串除了支持各种转义符外，还支持字符串内插值，它是 #{} 来表示的，非常的常用：

>> num = 4 
>> "Num is a #{num}"                # => "Num is a 4"
>> "PI is #{Math::PI}"              # => "PI is 3.141592653589793"

Ruby 中还支持一种采用 %q 和 %Q 来引导的字符串变量，%q 使用的是单引号引用规则，而 %Q 是双引号引用规则，后面再接一个 ( [ { 等等的开始界定符和与 } ] ) 等等的末尾界定符，

>> %q(This's new string.)               # => "This's new string."
>> %Q<The new string.\nIt's great!>     # => "The new string.\nIt's great!"

字符串基本操作

如果想要连接两个字符串的，一种最简单的方式是使用 + 运算符来操作，用它来连接字符串，但要注意一点的是，它只能用来连接字符串，不能连接字符串和数字这样的结构，必须使用 to_s() 转换才行：

>> "Hello" + " " + "world"          # => "Hello world"
>> "Hello" + " " + 123.to_s         # => "Hello 123"

当然，最方便的还是使用刚才的字符串内插的方法，它可以自动的调用 to_s() 来进行转换，就像刚才我们使用的那个例子一样。另外，使用 « 操作符也是非常使得的方法：

>> word = "Hello"                   # => "Hello"
>> word << " "                      # => "Hello "
>> word << "Ruby"                   # => "Hello Ruby"

字符串就是字符和合集，可以当做数组来操作：

>> s = 'hello'
>> s.length                         # => 5  同样的方法还有 size()
>> s[0]                             # => "h"
>> s[-1]                            # => "o"
>> s.each_char{|a| print a}         # hello  each_char() 返回单个字符

字符串常用 API

Ruby 提供了大量的字符串相关 API 来方便开发者使用，

include?() 和 index()

使用 include?() 方法来查找字符串是否包含有指定的对象，返回值为 ture 或者是 false;而 index() 则会返回找到的对象位于第几个元素。

>> s = "hello"
>> s.include? "e"                   # => true
>> s.include? "a"                   # => false
>> s.index("d")                     # => nil
>> s.index("o")                     # => 4

start_with?() 和 end_with?()

如果在开头的位置找到指定的对象则返回 ture ，否则返回 false。而另一个方法是在最后的位置查找：

>> s = "hello"
>> s.start_with?("he")              # => true
>> s.end_with?("oo")                # => false

sub() 和 gsub()

这两个方法都是替代字符串中的相对应的对象的，第一个 sub() 方法是替换到找到的第一个对象，而 gsub() 则是替换所有的找到的对象。当然可以使用正则表达式来进行强大的匹配，在以前的正则表达式的部分在详细的了解。同时，它们也都还有一个还有 ! 的方法，用来改变原来的字符串对象：

>> s = "hello"
>> s.sub('l','*')                   # => "he*lo"
>> s.gsub('l','*')                  # => "he**o"
>> s.gsub(/[aeiou]/, '*')           # => "h*ll*"

strip()， lstrip() 和 rstrip()

这三个方法都是去掉字符串对象中开头的或结尾部分的空白符（空格，回车和换行），中间的空格是不会给去掉的。strip() 是去掉两边的空白符，lstrip() 是左边的空白符，而 rstrip() 是右边的空白符。它们都有对应的 ! 方法：

>> s = "   hello   "
>> s.strip                          # => "hello"
>> s.lstrip                         # => "hello   "
>> s.rstrip                         # => "   hello"

chomp() 和 chop()

这两个方法是用于去除字符串对象后面的符号的，chop() 是去除最后一个符号，这个不太常用，而 chomp() 是去除字符串后面的 \r，\n 或是 \r\n，常用于获取用户输入后，去掉最后的那个回车符。

>> a = "hello\r"                    
>> a.chomp                          # => "hello"
>> s = gets.chomp                   # 获得用户输入，并去掉最后的回车符

split()

该方法可以根据指定的对象来分隔字符串，果然没有指定字符串的话则会使用空格来分隔字符串，它将始终会返回数组对象：

>> "Ruby is greate".split           # => ["Ruby", "is", "greate"]
>> "1,2,3,4".split(",")             # => ["1", "2", "3", "4"]

upcase(), downcase() 和 capitalize()

这几个方法可以改变字符串在的大小字，而 capitalize() 是将首字符大写，后面的字符小写；同时这几个方法也有带 ! 的方法，可以将返回结果覆盖到自身：

>> "Ruby is greate".downcase        # => "ruby is greate"
>> "Ruby is greate".upcase          # => "RUBY IS GREATE"
>> "Ruby is greate".capitalize      # => "Ruby is greate"

ljust(), rjust() 和 center()

可以按对齐的方法输出字符串，用的比较少：

>> "ruby".center(20)                 # => "        ruby        "

count()

记数方法，可以统计指定的字符串出现的数量：

>> "Ruby is greate".count("r")      # => 1
>> "Ruby is greate".count(" ")      # => 2

to_i(), to_f(), to_sym(), to_complex()

将字符串对象转换成指定的格式，i 是整数，f 是浮点数，sym 是 hash 中用的符号，complex 是复数：

>> "10".to_i                        # => 10
>> "a10a".to_i                      # => 0
>> "10a".to_i                       # => 10

参考资料

Ruby 1.9.3 String

ruby time

2013-04-04T00:00:00-07:00

关于时间的操作也是编程过程中常常要使用到的，比如获取时间、比较时间、记录时间等，学会关于时间的操作也不是很复杂。

获取当前时间

使用 Time 类提供的一系列方法可以得到与时间相关的各种操作，最基本的一个就是获取当前的时间了：

>> Time.now                 # => 2013-04-04 15:34:27 +0800
>> Time::now                # => 2013-04-04 15:34:30 +0800

这两个方法是一样的，一般习惯于用上面的 Time.now() 方法来得到时间，反正是的年月日时间和时区这样的一个格式。所以 now() 方法获得的是我当前的时间，同时也是北京时间，+08:00 这样的时间内。

那要获得世界统一时间怎么办呢？首先得了解两个概念，GMT (Greenwich Mean Time) 和 UTC (Coordinated Universal Time)，这两个是一样的概念，ruby 中把它们同本地时间做了区分。可以通过下面的方法来获得世界统一时间：

>> Time.now.getutc          # => 2013-04-04 07:49:28 UTC
>> Time.now.getgm           # => 2013-04-04 07:49:31 UTC

这里把当前的时间对象存放到一个时间对象中，而使用几个觉的方法：

>> t = Time.now             # => 2013-04-04 16:07:45 +0800
>> t.zone                   # => "中国标准时间"
>> t.year                   # => 2013
>> t.month                  # => 4
>> t.day                    # => 4
>> t.hour                   # => 16
>> t.min                    # => 7
>> t.sec                    # => 45

创建时间对象

可以通过使用 local() 函数来创建一个时间对象，同样在 ruby 里面是区分本地时区的时间和世界统一时区的时间的，比如创建本时时间用的是：

local(year, month, day, hour, min, sec, usec_with_frac) → time
mktime(year, month, day, hour, min, sec, usec_with_frac) → time

而世界时间用的是：

utc(year, month, day, hour, min, sec, usec_with_frac) → time
gm(year, month, day, hour, min, sec, usec_with_frac) → time

上面的两个方法中，很好理解，除了至少是需要一个 year 参数外，其它的都可以省略：

>> Time.local(2012)           # => 2012-01-01 00:00:00 +0800
>> Time.local(2012, 2, 14)    # => 2012-02-14 00:00:00 +0800
>> Time.local(2012, 2, 14, 12, 23, 59)    # => 2012-02-14 12:23:59 +0800
>> Time.utc(2013)             # => 2013-01-01 00:00:00 UTC

时间的转换

存在时间对象中的值，是一个从 1970 年 1 月 1 号 0 点 0 分到现在的时间的秒记的，怎么样，很奇怪吧。我们首先来看一下把时间对象转换成浮点数和字符串：

>> t = Time.now                # => 2013-04-04 16:07:45 +0800
>> t.to_f                      # => 1365062865.369408  1970 年到今天的秒数
>> t.to_s                      # "2013-04-04 16:07:45 +0800"

这里再来创建一个 1970 年的时间来解理一下：

>> history = Time.utc(1970)     # => 1970-01-01 00:00:00 UTC
>> history.to_f                 # => 0.0
>> history = Time.utc(1971)     # => 1971-01-01 00:00:00 UTC
>> history.to_f                 # => 31536000.0  一年有这么多秒

原来是秒数，那肯定就可以非常方便的去比较和计算了。

时间的计算和比较

可以在时间上做加，减运算来计算时间，当然也可以做乘除运算，但是没有什么意义。做加减运算当然是以秒来进行的，现在，让我们加上一点时间来看看效果：

>> t = Time.now                 # => 2013-04-04 16:26:07 +0800
>> t + 10                       # => 2013-04-04 16:26:17 +0800    加了 10 秒
>> t + (60 * 10)                # => 2013-04-04 16:36:07 +0800    加了 10 分
>> t + (60 * 60 * 24)           # => 2013-04-05 16:26:07 +0800    加了 1 天

再来看看距离明年还有多长的时间，这个操作须要新建一个时间对象，让他们做减法运算：

>> future = Time.local(2014)    # => 2014-01-01 00:00:00 +0800
>> future - t                   # => 23441632.515555   得到的值是秒数
>> (future - t) / (60 * 60 * 24)    # => 271.31519115225694   转换成了天数

通过将得到的秒数进行计算而得到天数。时间的比较也是很容易的，也就是浮点数之间的比较而以：

>> t < future                   # => true

其它的逻辑运算也是支持的。

友好的显示时间

通过 Time 类带的 strftime() 这个方法，可以将时间转换成人类容易读懂的方式，它的形式多种多样，我们看几个常用的方式。

>> t = Time.now                 # => 2013-04-04 16:26:07 +0800
>> t.strftime("%Y%m%d")         # => "20130404"
>> t.strftime("post at %F")     # => "post at 2013-04-04"
>> t.strftime("at %I:%M%p")     # => "at 04:26PM"

更多的用法当然可以去查 API 文档。

其它的 API

>> t.monday?                    # => false   星期一么？
>> t.thursday?                  # => true    星期四么？
>> t.wday                       # => 4       一周里的第几天？
>> t.yday                       # => 94      一年里的第几天？

参考资料

Time

ruby arrays

2013-04-03T00:00:00-07:00

在编程过程中，最常用到的数据结构就包括 array ，所以掌握到 array 的使用是非常重要的。Array 是一种有序的序列，可以在其中储存各种对象，对，各种的，包括数值，字符串，对象。

Array 创建

Array 的创建是非常容易的，一般最常用的方式都是通过下面的方面来创建一个 Array 的：

>> num = [1, 2, 3, 4]           # => [1, 2, 3, 4]
>> num[0]                       # => 1
>> num[5]                       # => nil   不存在的 index 显示为 nil

可以通过上面的这些方式来创建 array，也可以通过下面的两种来创建新的 array，一种是给变量赋值一个空的数组，另一种方法是使用 Array 类来创建一个新的实例。Array 类是使用 ruby 语言在编程过程中经常需要使用到的类，它包含了很的方法，这些方法可以执行各式各样的任务，在后面就会有详细的介绍。

首先来了解创建两个空 array 的方法：

>> a1 = []                      # => []
>> a2 = Array.new               # => []
>> a1.class                     # => Array
>> a2.class                     # => Array

你还可以通过给 new 方法来指定参数完成创建的过程，第一个参数是数组元素的个数，第二个参数是内容，如果省略第二个参数的话，刚会创建 nil 对象：

>> Array.new(3)                 # => [nil, nil, nil]
>> Array.new(3, 3)              # => [3, 3, 3]
>> Array.new(3) {|num| num + 1} # => [1, 2, 3]

这里也还有一种特殊的方式，是使用 %w 或者 %W 来创建，元素之间无须使用“ , ”号来分隔元素，只需要使用空格就可以了。

>> a3 = %w[this is a new array] # => ["this", "is", "a", "new", "array"]
>> a3.class                     # => Array

同时，还可以通过 to_a() 方法，来将 Range 对象转换成数组元素，当然，还可能将其它的对象也转换也数组对象：

>> (1..9).to_a                  # => [1, 2, 3, 4, 5, 6, 7, 8, 9]
>> ('a'..'e').to_a              # => ["a", "b", "c", "d", "e"]

Ruby 中的数组元素可以是任何对象，这也是解释性语言中一个非常方便的功能，元素不必为统一的对象，下面是一个例子：

>> mix = [1, "a", true, [1, 2, 3]]
=> [1, "a", true, [1, 2, 3]]
>> mix.class
=> Array

这个叫 mix 的数组中有数字对象，字符串对象，布尔对象和数组对象，非常的易用。

Array 的长度

Array 的长度就是该数组里有多少个元素，可以使用 array 的 length() 和 size() 方法来获得，它们是一样的功能：

>> num = [1, 2, 3, 4]
>> num.length                   # => 4
>> num.size                     # => 4

也可以使用方法来判断数组中有没有元素，empty?() 是常被用到的方法：

>> num.nil?                     # => false
>> num.empty?                   # => false
>> [].nil?                      # => false
>> [].empty?                    # => true

Array 访问

Array 是有序的集合，和所有其它的编程语言一样，从序号 0 开始计数，也就是第一个元素是 0，第二个元素是 1。如果你去访问 array 中不存在的元素的话，ruby 不会返回错误，只会返回一个 nil 对象，这点和其它的编程语言是不一样的。

用上面已经创建好的 num 数组来访问看下效果：

>> num[0]                       # => 1
>> num[5]                       # => nil 访问不存在的元素

同时还有一些访问方法，可以通过数组长度来访问，也可以通过负数来访问。Array 中的最后一个元素记做 -1，倒数第二个元素记做 -2，看下演示：

>> num[-1]
=> 4
>> num[num.size]                #num.size 是数组的长度，这里为 4
=> nil                          #num 数组的最后一个元素为 num[3]，num[4] 就是 nil
>> num[num.size - 1]
=> 4
>> num[-num.size]
=> 1

还可以访问数据内容的范围，同样也是使用 [ ] 方法来操作，第一个参数同样是数组中元素的位置，第二个参数为需要返回的元素个数。

>> num = (1..9).to_a            # 对 num 数组重新进行赋值
=> [1, 2, 3, 4, 5, 6, 7, 8, 9]
>> num[2, 3]
=> [3, 4, 5]
>> num[7, 3]
=> [8, 9]

那如何访问数组中从第几个元素到第几个元素这样的内容，可以使用 Range 来进行操作：

>> num[3..5]                    #从第 4 个元素到第 6 个元素
=> [4, 5, 6]
>> num[3..-1]                   #从第 4 个元素到最后一个元素
=> [4, 5, 6, 7, 8, 9]

还可以使用方法 first() 来获取 array() 中第一个元素和 last() 访问最后一个元素：

>> num.first                    # => 1
>> num.last                     # => 9

Array 元素赋值

对 array 对象中的元素进行赋值和对普通的变量进行赋值是差不多的，只是数组需要指定要操作的是哪一个元素，也可以同时指定对哪几个元素进行操作：

>> num[3] = 5                   #将第 4 个元素改成数字 5
=> 5
>> num
=> [1, 2, 3, 5, 5, 6, 7, 8, 9]
>> num << 10
=> [1, 2, 3, 5, 5, 6, 7, 8, 9, 10]

向数组里面添加其它的元素使用 « 操作符是十分容易的一件事，这也是常常用到的方法。如果在数组后添加一个元素，ruby 自动的会为空白的内容添加上 nil ，下面就是一个例子：

>> num[14] = 15                # => 15
>> num
=> [1, 2, 3, 5, 5, 6, 7, 8, 9, 10, nil, nil, nil, nil, 15]

还有一种比较常用到的方式是使用并行赋值，这是这样的：

>> words = %w[hello world]     # => ["hello", "world"]
>> word1, word2 = words        # => ["hello", "world"]
>> word1                       # => "hello"
>> word2                       # => "world"

这里，一次性的把数组的值赋值给了两个变量，分别为 word1 和 word2，非常方便。

Array 常用 API 及操作

Array 属于 Enumerable 对象的子类，它也因此而继承了该对向的方法，同样的，hash 也是该类的子类，也具备这些方法，它们被统称为集合。

each()

对 array 内的的元素进行迭代是最常用的到的，也就是把 array 中的元素一个接一个的取出来，使用 each() 方法来操作，按序号一次取一个元素：

>> num = (1..9).to_a
>> num.each{|x| print x}        # => 123456789

还有一个不常用的到 each() 方法可以把 index 也就是索引也迭代出来：

>> num.each_with_index{|x,i| print "#{i}:#{x},"}
0:1,1:2,2:3,3:4,4:5,5:6,6:7,7:8,8:9

collect() 和 map()

常用到的方法还有 collect() 方法，它把结果使用到集后中的每一个元素上，但它并不会改变原来集后的内容，它只返回一个新的 array 对象。如果使用带有 ! 的方法，则原数组才会被替换成新的数组对象：

>> num.collect{|x| x * 2 }      # => [2, 4, 6, 8, 10, 12, 14, 16, 18]
>> num                          # => [1, 2, 3, 4, 5, 6, 7, 8, 9]

下面是使用还有 ! 符号的 collect 方法， num 对象被改变了：

>> num.collect!{|x| x * 2 }     # => [2, 4, 6, 8, 10, 12, 14, 16, 18]
>> num                          # => [2, 4, 6, 8, 10, 12, 14, 16, 18]

Ruby 中也有同样的方法，比如 collect 和 map 是同样的功能，length 和 size 也是一样的功能。不信你将 collect() 方法换成 map() 方法试试。

select()

你想找出数组中满足某一条件的内容，就可以使用 select() 方法来完成，它也会返回一个新的数组，同时 ruby 也提供了一个 select!() 方法来将结果返回给自身。

>> num = (1..9).to_a            # => [1, 2, 3, 4, 5, 6, 7, 8, 9]
>> num.select{|x| x % 2 == 0}   # => [2, 4, 6, 8]
>> num.select{|x| x > 5}        # => [6, 7, 8, 9]

sort()

对一个 array 进行排序，可以按照从小到大的次序，也可以对其进行反向排序：

>> num = [3, 2, 5, 7, 4]
>> num.sort                         # => [2, 3, 4, 5, 7]    正向排序
>> num.sort{|x, y| y <=> x}         # => [7, 5, 4, 3, 2]    反向排序

也可以对字符串进行排序，首先会比较首字母在字母表中的位置，如果相同的话，就会比较第二个字母在字母表的位置，以此类推：

>> word = ["apple", "orange", "banana"]     # => ["apple", "orange", "banana"]
>> word.sort()                              # => ["apple", "banana", "orange"]

include?() 和 index()

通过 include?() 方法可以 array 中查找指定的内容，所以只能返回找到了和没有找到，也就是 ture 和 false，这里省略的 ( ) 来让表达更好理解， ruby 方法中是可以省略括号的：

>> num.include? 4                   # => true
>> num.include? 1                   # => false
>> word.include? "apple"            # => true

使用 member?() 方法也具也同 include?() 方法一样的效果。

而使用 index() 不仅可以知道 array 中有没有指定的对象，而且还可以知道这个对象所处的位置的 index 值是多少，如果有多个值得话，也只会返回找到的第一个：

>> num.index(1)                     # => nil
>> num.index(4)                     # => 4
>> word.index("apple")              # => 0

count() 和 uniq()

使用这两个方法，一个可以计算出 array 中有多少个这种对象，而另一个则是将 array 中相同的对象都只显示一次，这表述还真难，看下演示吧：

>> num = [1, 1, 2, 2, 3, 3, 4, 5, 5]
>> num2.count(2)                        # => 2   出现了 2 次 '2' 这个数字
>> num2.uniq                            # => [1, 2, 3, 4, 5]

push() pop() 和 shift()

使用这几个方法，可以将数组当成是一个栈来使用，后进先出的栈和先进先出的栈都可以很方便的实现，使用 push() 是向数组的最后压入一个元素，而使用 pop() 将会使数组的最后一个元素被弹出：

>> a = []                           # => []
>> a.push(2)                        # => [2]
>> a.push(3)                        # => [2, 3]
>> a.pop()                          # => 3
>> a                                # => [2]

而 shift() 方法可以使数组的第一个元素被弹出：

>> a.push(4)                        # => [2, 4]
>> a.shift()                        # => 2
>> a                                # => [4]

和字符串相关的方法

Ruby 提供了一些关于 array 操作和字符串相关的方法，可以把 array 对象转换成字符串对象：

>> [1, 2, 3].join                   # => "123"
>> [1, 2, 3].join(',')              # => "1,2,3"
>> [1, 2, 3].to_s                   # => "[1, 2, 3]"
>> [1, 2, 3].inspect                # => "[1, 2, 3]"

这个 inspect() 方法是将数组转换成方例人类阅读的方法，它和 to_s 方法的效果是一样的。

总结

Array 对象是 ruby 中最常用到的数据结构，所以，撑握它的用法是十分的重要，这里居然指出了一般在工作中最常用到的关于 Array 的操作，但还有更多的用法需要我们去查看 API 文档来学习。

参考资料

Ruby 1.9.3 Array
Ruby 2.0 Array

ruby basic

2013-04-02T00:00:00-07:00

Ruby 一个语法非常接近英语语法的编程语言，也非常的适合于人类去阅读，比起 python 来说，它们有很多的相似之处。同做为一门解释性语言，它们有着很多相似的地方，但因为出现了 rails 这个框架，ruby 也是母以子贵了。

但做为一门程序语言来说，无论是编译性的，如 C，JAVA，还是解释性的，如 python，ruby，php，学习他们无非就是基本的语法加上核心的类库，这样你就可以算是入门了。如果你和我一样，只是用这些语言来提高自身的工作效率，自动化完成一些任务，而不是专业化的程序员来说，花一个月学习一门解释性语言是非常值得的。

当然这里我学习 ruby 是因为那强大的 rails 框架可以非常容易的创建出强大的 Web 网站，而且 ruby 也可以有助于帮助我完成日常的部分工作。

最后，当你学会了使用一种语言的那话，那么再学习其它的编程语言可就是相当容易了的。

参考资料

在线学习网站 codecademy
在线学习网站 rubymonk
书籍《Ruby 编程语言》
官网 ruby
Ruby API API

jquery dom and ajax

2013-03-31T00:00:00-07:00

DOM 操作方法

jQuery 中提供了大量的对 DOM 的操作方法，可以完成各种不同的功能，要适当的情况下选择不同的方法吧：

1. 在每个匹配的元素中插入新元素

* .append()
* .appendto()
* .prepend()
* .prependTo()

2. 在每个匹配的元素相邻的位置插入新元素

* .after()
* .insertAfter()
* .before()
* .insertBefore()

3. 在每个匹配的元素外部插入新元素

* .wrap()

4. 用新的元素或文本替换每个匹配的元素

* .html()
* .text()

5. 移除每个匹配元素中的元素

* .empty()

6. 从文档中移除每个匹配元素及其后代元素，但不实际删除它们

* .remove()

AJAX 数据格式

AJAX 支持多种数据格式，就目前的网络发展状态来看得话，JSON 和 XML 比较流行，而由于目前 Web Service 的兴起，使得 JSON 这种格式得到了广泛的应用，因为它比 XML 更加简洁。

虽然 JSON 比较简洁易懂，也可以使用 jQuery 的 eval() 函数来解释，但需要注意的是 JSON 数据需要小心的构建，如果数据内包含有一些无法识别的和特殊的字符来说， javascript 可能无法解释成功，会导致页面上不会显示任何的内容，以现在的浏览器来说也不会报错。

当然，要使用 AJAX 现在有很多第三方的库来简化使用，但这需要你使用的具体的开发环境来选择，而且，根据你应用的 AJAX 的多少来决定使用轻量级还是重量级的套件。当然，也可以使用一些前端的 javascript 的框架来增强应用的可交互性，比如使用 embar.js 。

总结

尽管 jQuery 的 AJAX 功能非常的强大，但我们仍然可以使用第三方插件来让它变得更加的容易操作。

jQuery Effictive

2013-03-30T00:00:00-07:00

效果是 jQuery 里的一大特色，通过使用各种不同的效果，而达到吸引浏览者注意力，增加页面美感的功能。

修改内联 CSS

虽然我们可以通过前面用到的 .addClass() 和 .removeClass() 来添加和移除元素相应的 CSS，但有时我们需要直接的去设置没有在样式表中定义的样式时，可以使用 .css() 方法来完成。它的语法是：

.css(‘property’, ‘value’)
.css({‘property1’: ‘value’, ‘property2’: ‘value2’})

比如这里可以为 #header 的 ID 设置它的字体大小：

$('#header').css('fontSize', '2 em')

基本的隐藏和显示

jQuery 提供了两个方法，一个是 .hide() 一个是 .show()，当调用 .hide() 方法的时候，jQuery 会记住调用对象的 display 值，一般来说是 block 或者是 inline ，主要是为了方便执行 .show() 的时候不会导致显示出现问题，比如 li 做的导航。同时它会把 display 值设置为 none。

$('li.eq(1)').hide()

效果和速度

在上面的方法 .show() 和 .hide() 中，可以指定一个速度参数，会产生动画的，值可以是 slow （0.6 秒），normal （0.4秒）和 fast （0.2秒）。当然你也可以指定时间，以毫秒数来计，比如：.show(850)

此外，还可以使用淡入和淡出的效果， .fadeIn() 和 .fadeOut() ，同样，也可以指定速度参数。

自定义动画效果

除此之外，可以使用 jQuery 提供的 .animate() 方法来自定义动画，不过这么高级的功能一般我是用不上的，只能用好别人写好的动画效果就行了。

总结

这里我们讲到了一些最常用的 jQuery 效果，比如使用 .css() 方法给指定的元素添加样式，或使用 .hide() 和 .show() 方法来隐藏和显示元素。

jQuery Event

2013-03-29T00:00:00-07:00

jQuery 提供了很多的事件响应方式来增强 javascript 里原来就有的响应方式，非常更于大家的使用。

$(document).ready()

该方法在上面已经介绍过，它最主要的功能就是在页面的 DOM 载入完成后执行。它和页面载入完成是有区别的，比如一个页面上面有很多的视频和图片的话，一般来说，页面的 DOM 结构在整个页面的大小中所占的比例是非常小的，这就是说，不用长时间的等待视频和图片加载完成，而此时 jQuery 就可以使用了。

$(document).ready(function(){
  // do something
});

是最常用的使用方式了，document 是可以省略的，所以这里的代码也可以写成：

$().ready(function(){
  // do something
});

当然，jQuery 也会默认的去执行一次 .ready() 调用，那也就是说，下面的方法是同样的效果：

$(function(){
  // do something
});

一般来说，虽然可以简写使用，但绝大多数的工程师还是倾向于采用完整的写法，因为这种写法更便于人类的阅读，毕竟代码还是会给人来维护的。

简单事件

jQuery 使用改进的 javascript 事件方法来触发事件，它使用 .bind() 来添加一系列的动作。比如：

$('#button').bind('click', function(){
  $('body').removeClass('large');
});

当单击一个 ID 名称为 button 的元素时，则移除 body 标签里面 .large CSS。同样，你也可以使用 jQuery 中提供的更简单易懂的 click() 方法来代替 bind() ：

$('#button').click(function(){
  $('body').removeClass('large');
});

复合事件

对于触发事件后，以多个函数作为响应的事件，称为复合事件。最常见的是 .toggle() 和 .hover() 这两个方法。

这里的 .toggle() 方法接受两个函数作为参数，当第一次单击时执行第 1 个函数，第二次单击里执行第 2 个函数，比如：

$(document).ready(function(){
  $('#button').toggle(function(){
    $('#button .button').addClass('hidden');
  },function(){
    $('#button .button').removeClass('hidden');
  });
});

由于这个方法太常用了，所以，jQuery 为我们提供了一个自己检查该类是否存在的方法 .toggleClass() ：

$(document).ready(function(){
  $('#button').click(function(){
    $('button .button').toggleClass('hidden');
  });
});

而 .hover() 方法则是一个和 :hover 这个 CSS 伪类选择器差不多的方法，当鼠标进入和移出元素时的操作。

模仿用户操作

有的时候我们需要去模仿用户的操作，比如点击某个元素：

$(document).ready(function(){
  $('#button').trigger('click');
});

或者也可以使用更简单的方法：

$(document).ready(function(){
  $('#button').click();
});

总结

事件是 jQuery 里面一个重要的内容，也是触发整个 jQuery 行为的基础，根据不同的触发事件响应不同的动作。

jQuery Selector

2013-03-28T00:00:00-07:00

使用 jQuery 选择器可以非常方便的在 DOM 中选择你想要操作的内容，而且也有很多的方法来使你非常方便选择既定的部分。

$(document).ready()

jQuery 中最常使用到的内容，就是在文件的 DOM 元素加载完成后执行 ready() 里面的内容，比如：

$(docutment).ready(function(){
  alert("Hello jQuery!");
});

会弹出一个上面显示 “Hello jQuery” 的对话框。

$()

最基本的情况下，使用 $() 符号来选择 html 文件中的对象：

* 选择标签：$('p')
* 选择 ID ：$('#id-name')
* 选择 class：$('.class-name')

XPath 选择符

XPath （XML Path Language，XML 路径语言）是 XML 文档中识别不同的元素或值的，与 CSS 使用的方式类似。

比如要选择所有的带 title 属性的链接，可以使用：

$('a[@title]')

也可以结合使用正则表达式来选择，比如下面的几个例子：

* $('a[@href^="mailto:"]') 为选择链接标签中的 href 属性里以 mailto: 开头的链接
* $('a[@href$=".pdf"]') 为选择链接标签中的 href 属性里以 .pdf 结尾的链接
* $('a[@href*="mysite.com"]') 为选择链接标签中的 href 属性里带有 mysite.com 的链接

自定义选择符

除了 CSS 和 XPath 选择符外，jQuery 自带了一些特殊的选择符，这些选择符一般使用 : 来标识。

* $('p:eq(1)')   选择第两个 p 标签
* $('tr:odd')  选择 tr 标签的奇数行
* $('tr:even')  选择 tr 标签的偶数行
* $('td:contains("Henry")')  选择 td 标签中含有 "Henry" 内容的标签

注意：javastrip 是以 0 开始计数的，所以 jQuery 中也是使用 0 开始。

DOM 遍历方法

* $('tr:not([th]):odd')
* $('td:contains("Henry")').siblings().addClass('highlight')  选择出所有包含 Henry 内容的同类标签并添加样式
* $('td:contains("Henry")').parent().find('td:gt(0)').addClass('highlight')

同时这也是 jQuery 中的连缀使用。

总结

选择器是在网页开发的过程中经常性会用到的内容，可以从最简单的 CSS 选择器开始学习和使用，然后，再慢慢的熟悉比较复杂的 XPath 和 jQuery 自定义选择器的使用。

jQuery Basic Concept

2013-03-28T00:00:00-07:00

比起 javascript 复杂难忘的语法， jQuery 用起来令人惬意多了，虽然它本身就是一个使用 javascrip 开发出来的库，但其强大的功能，方便的 DOM 操作，使其在几乎现阶段所有的网页中都有不同程度的使用。而使用 jQuery 可省去了使用　Javascript 那样的麻烦，虽然如此，但一般来说还是要学点 javascript 的语法的。

这里记录下了我学习 jQuery 中最重要的内容和过程，当然首先是从哪些地方找到这样学习材料：

图书《jQuery 基础教程》
在线学习网站 codecademy
官方网站 jQuery

这里我是从 jQuery 1.9.1 这个版本来做演示的，下面是最基本的演示文件：

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <title>JQuery 练习页面</title>
  </head>
  <body>
    <h1>Hello, JQuery!</h1>
    <p>JQuery 是一个非常优秀的 Javascrip 框架。</p>

    <script src="javascript/jquery-1.9.1.js"></script>
  </body>
</html>

如果你在网站中部署 jQuery 的话，可以使用 CDN 网络来加快 jQuery 的载入速度：

//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js

好，马上开始。

CCNP Basic Concept

2013-03-23T00:00:00-07:00

单区域 OSPF 配置
OSPF 区域的基本概念 * 三张表
LSA 1 和 LSA 2

OSPF 是一个典型的基于链路状态的路由协议，它可以被高效的应用于大型的网络结构中。在这里，我会从最基本和最简单的地方起步，一步一步的来了解这个丰富多彩和功能强大的协议。

这张环境图是比较简单的，三个路由器，R1 和 R2 使用以太网链路连接，而 R2 和 R3 使用点对点的链路连接，到时我们可以看到这两种不同的链路环境会带来什么样的区别。

基本设置

首先，你得保证你的网络环境是通畅的，然后我们就开始设置 OSPF跌幅协议，让整个网络环境全可达。先从 R1 和 R2 开始，使用下面的命令来完成最简单的 OSPF 的设置。

R1(config)#router ospf 1
R1(config-router)#network 10.12.0.1 0.0.0.0 area 0

R2(config)#router ospf 1
R2(config-router)#network 10.12.0.2 0.0.0.0 area 0

设置完成之后，我们大概可以在 R2 路由器上看到下面的内容：

*Mar  1 00:13:22.227: %OSPF-5-ADJCHG: Process 1, Nbr 10.12.0.1 on FastEthernet0/0 from LOADING to FULL, Loading Done

大致的意思是说什么从 LOADING 到了 FULL ，载入完成，等下我们再来解释这是什么意思。先说说上面的命令，首先：

R1(config)#router ospf 1

这个是在路由器上启动 1 号进程来执行 OSPF，这个进程号没有什么强制性的规定，你可以使用任何一个你想用的数字，当然，不要超过 65535 就可以了。进程和你计算机上的进程是一个概念，两个不路由器进程号不一致同样也是可以连接的，就好像两台 PC 上不同进程的 QQ 一样也可以通迅一样。

R2(config-router)#network 10.12.0.2 0.0.0.0 area 0

而这个命令是让路由器去匹配自身上的网络地址，将其加入到 OSPF 协议中，network 是命令，而 10.12.0.2 是本地的接口的 IP 地址，0.0.0.0 是反掩码，这两个加起来就是匹配 10.12.0.2 这个地址连接的网络段。而最后的 area 0 是 OSPF 里的特有的概念，区域 0 ，因为 OSPF 可以管理大型的网络，为了降低网络的复杂性和管理的便利，使用 area 区域来管理，而 0 这个是特殊的区域，称为骨干区域，反正就是必有的一个区域，所有其它的区域必须连接到它。

提示在单区域 OSPF 中，也可以不使用区域 0 ，而多区域中必须有一个区域 0。

路由查看

现在，你可以把整个网络都剩下的部分也按同样的方法设置好：

R2(config)#router ospf 1
R2(config-router)#network 10.23.0.2 0.0.0.0 area 0

R3(config)#router ospf 1
R3(config-router)#network 10.23.0.3 0.0.0.0 area 0

设置完成后，你马上就可以得到刚才的那个 LOAD to FULL 的信息，现在整个网络就全达了，如何知道呢？可以使用命令：

R3#show ip ro
Codes: C - connected, S - static, R - RIP, M - mobile, B - BGP
       D - EIGRP, EX - EIGRP external, O - OSPF, IA - OSPF inter area
       N1 - OSPF NSSA external type 1, N2 - OSPF NSSA external type 2
       E1 - OSPF external type 1, E2 - OSPF external type 2
       i - IS-IS, su - IS-IS summary, L1 - IS-IS level-1, L2 - IS-IS level-2
       ia - IS-IS inter area, * - candidate default, U - per-user static route
       o - ODR, P - periodic downloaded static route

Gateway of last resort is not set

     10.0.0.0/24 is subnetted, 2 subnets
O       10.12.0.0 [110/65] via 10.23.0.2, 00:00:20, Serial0/0
C       10.23.0.0 is directly connected, Serial0/0

看到那个带 O 的路由项了没有：

O       10.12.0.0 [110/65] via 10.23.0.2, 00:00:20, Serial0/0

当然，这个上面还有 IA，E1，E2 以后才会认识。

这个就是 R3 通过 OSPF 学习到的，而且也了解到它是通过 10.23.0.2 这个接口可以到达的，现在，你可以试下使用 ping 命令，从 R3 去 ping R1 的接口地址：

R3#ping 10.12.0.1

Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 10.12.0.1, timeout is 2 seconds:
!!!!!

没有问题的，网络已经通过 OSPF 全部学习到了。

OSPF 基本信息

现在开始进一步的去掌握更多的 OSPF 的特性，先使用一个简单的命令：

R1#show ip ospf
 Routing Process "ospf 1" with ID 10.12.0.1
 Supports only single TOS(TOS0) routes
 Supports opaque LSA
 Supports Link-local Signaling (LLS)
 Initial SPF schedule delay 5000 msecs
 Minimum hold time between two consecutive SPFs 10000 msecs
 Maximum wait time between two consecutive SPFs 10000 msecs
 Minimum LSA interval 5 secs. Minimum LSA arrival 1 secs
 LSA group pacing timer 240 secs
 Interface flood pacing timer 33 msecs
 Retransmission pacing timer 66 msecs
 Number of external LSA 0. Checksum Sum 0x000000
 Number of opaque AS LSA 0. Checksum Sum 0x000000
 Number of DCbitless external and opaque AS LSA 0
 Number of DoNotAge external and opaque AS LSA 0
 Number of areas in this router is 1. 1 normal 0 stub 0 nssa
 External flood list length 0
    Area BACKBONE(0)
        Number of interfaces in this area is 1
        Area has no authentication
        SPF algorithm last executed 00:17:03.660 ago
        SPF algorithm executed 2 times
        Area ranges are
        Number of LSA 3. Checksum Sum 0x01C89B
        Number of opaque link LSA 0. Checksum Sum 0x000000
        Number of DCbitless LSA 0
        Number of indication LSA 0
        Number of DoNotAge LSA 0
        Flood list length 0

看几个 OSPF 的重要信息，第一个就是 RID，位于上面命令的第一行中：

Routing Process "ospf 1" with ID 10.12.0.1

英文还是很好理解的，路由器进程 ospf 1 ，对吧，然 ID 10.12.0.1 就是 OSPF ID 了，它是一个不同于路由器名称的标识符，它标识的是在 OSPF 中路由器是如何标识其它路由器的，而这个 ID 的生成方式是通过本地的最大 IP 地址产生的，果然有回环地址的话，那么就是回环地址成为 OSPF ID。当然，有多个回环地址那么就是回环地址中最大的成为 OSPF ID。

下面的 Area BACKBONE(0) 显示出了这个路由器所在的区域是 backbone ，既骨干区域，也就是区域 0。下面可以看到 SPF algorithm 的一些情况，OSPF 使用该算法来生成路由表，马上会了解到成生的方法。

OSPF 的三张表

OSPF 的原理比较复杂，但简单的理解你可以这样想，每一个路由器都通过它的邻居来获得信息，也就是邻居所知道的网络连接情况，然后把它加入到自己的数据库中，然后，通过 SPF 算法，得到路由表。

它们的关系是这样：邻居表 –> LSDB 数据库 –> 路由表

在 R2 这台路由器上，可以查看它的邻居情况：

R2#show ip ospf neighbor

Neighbor ID     Pri   State           Dead Time   Address         Interface
10.23.0.3         0   FULL/  -        00:00:32    10.23.0.3       Serial1/0
10.12.0.1         1   FULL/BDR        00:00:35    10.12.0.1       FastEthernet0/0

上面的内容不难，只是那个 Pri 以后会了解到，那是关于在多播环境中选举用的。再来认识下数据库中都是些什么？

R2#show ip ospf database

            OSPF Router with ID (10.23.0.2) (Process ID 1)

                Router Link States (Area 0)

Link ID         ADV Router      Age         Seq#       Checksum Link count
10.12.0.1       10.12.0.1       425         0x80000002 0x00D301 1
10.23.0.2       10.23.0.2       344         0x80000003 0x00B102 3
10.23.0.3       10.23.0.3       346         0x80000001 0x00B83B 2

                Net Link States (Area 0)

Link ID         ADV Router      Age         Seq#       Checksum
10.12.0.2       10.23.0.2       425         0x80000001 0x00794B

这上面可以 OSPF 中用于传递链路信息的 LSA，上面一节中看到的路由表，就是由这张表通过 SPF 算法来得到的。这张数据库在整个网络中都是一样的，就好像是一张地图，所有的人都拿到的同一张地图，只不到每个人的位置不同，到不同目的地的路径也不同而以，这个就是要靠 SPF 生成的路由表来告诉你怎么走。

OSPF LSA

LSA 就是 Link-State Advertisement (链路状态通告)，每个路由器都会给它的邻居通告自己数据库中的 LSA，一般 30 分钟会将全部的 LSA 通告给自己的邻居，一般情况下也通告变化了的 LSA 信息，非常的省流量，不像 RIP 总是通告全部的路由信息。

上面的单区域 OSPF 中使用到了 Router Link States，也叫 1 类 LSA，路由器 LSA，它会被扩散到当然区域内的所有路由上。

而 Net Link States ，2 类 LSA 也就是网络 LSA，它是由多播网络产生的，比如这里的以太网。

OSPF 有多达 11 种的 LSA，你只需要知道五种就行了，以后会逐步的认识到。

总结

好了，这里的内容够多了的，讲到了 OSPF 的基本配置，区域的概念，骨干区域，OSPF 路由器 ID，三张表，LSA 1 和 LSA 2，还是需要一点时间去消化的。

Modify Site for youself

2013-03-23T00:00:00-07:00

现在，我们已经有了一个可以使用的网站了，但目前我们的站点还是默认的站点样式，现在我们通过一些简单的修改来自定义相关的内容。在这里，我们将了解到：

删除演示页面
如何自定义导航条
发表 post 和 page
了解 post 和 page

一、删除演示页面

为了演示网站的用法和基本的 Markdown 的语法，Jekyll Bootstrap 准备了一个演示页面，你可以看看大致的语法是什么样的、category 和 tags 是怎么写的。当然，在你自己的站点上你可能需要把它删除。

1　使用资源管理器或命令将 _post/core-samples 目录给删除掉，同时删除的还有里面的一个文件，2011-12-29-jekyll-introduction.md。

2　在 git 的本地仓库里也将将目录删除，使用命令 git rm -r _post/core-samples。

3　然后，使用命令提交变动：

$ git add .
$ git commit -m "delete demo file and directory"
$ git push

二、自定义首页内容和导航条

现在，我们可以看到右上角自动生成的那个导航栏了，这个导航栏现在是 Archive Categories Pages Tags，我们可以根据自己的需要去定制它的内容，想要去添加一个 about。我们应该生成 page ，page 的内容不会被自动的生成到 archive 分类中，而 categories 和 tags 是关于 archive 内容的。

1　生成 Page。使用如可以使用命令：

$ rake page name="about.html"

或者自己去手动的去创建文件。两种方法都行。文件可以是 about.me 或都是 about.html。

2　文件内容，不管你是使用命令生成或都是自己创建的文件，里面都要有这样的内容：

---
layout: page
title: "About"
description: ""
---

要显示到导航条上，就要在上面的 description 的下面加上：

group: navigation

系统自动就会在导航条上显示出来了，如果你不想要某个项目，比如 tags，那你就可以在 tags.html 这个文件中将 group: navigation 删除掉就行了。

三、发表一个 Post

现在，是时候来发表自己的第一个 Post 了。

1　使用如下命令来创建一个 Post：

$ rake post title = “Hello world”

该命令会自动的在 _posts 目录下面生成一个以日期开头的文件，就样这样的格式 2013-03-23-hello-world.md ，这种 md 文件可以使用 Markdown 的方法来编辑，也可以使用 HTML 格式来编辑，非常方便。

2　设置文件头，使用你喜欢的文本编辑器来打开文件，我用的是 sublime 这款免费、功能强大的编辑器，首先修改文件头里的信息：

---
layout: post
title: "Build this site on Github"
description: ""
category: 
tags: []
---

根据需要，加上你想上的内容，category 是该 Post 属于什么类别，tags 当然就是标签了，多个 tag 中间使用 “,” 去分隔就行了。

3　编辑文件，你可以在里面输入任何的内容了，使用 markdown 格式和 HTML 格式都可以，混合写都行。你可以通过本地的 Jekyll 站点来查看效果。

四、主页内容

现在，对于 Jekyll 的简单的操作和设置你应该都知道了，同样，主页的内容也是很简单定制的，你可以通过编写 index.md 中的内容，来达到定制自己首页的内容。

参考资料

Jekyll Github 站点
Jekyllbootstrap Jekyllbootstrap 主页
Jekyllbootstrap Github 站点
Markdown Markdown 语法

Build this site on Github

2013-03-23T00:00:00-07:00

我们将在这里学到如何在 github 上构建自己的网站，它可以是你喜欢的任何网站，也可以是一个 BLOG 系统，在篇文章中我们将学会：

如何使用 Jekyll 在 github 上建立网站
如何在本地运行和调试网站
定义站点的基本结构
上传网站到 github

一、入门

我们可以使用 Jekyll 在 github 上建立站点，但是功能和界面全部都没有，还得要自己去做，而使用 jekyllbootstrap 就非常的方便了，它集成了很多的功能和 Bootstrap 来美化界面，就非常方便了。

1　创建 Repository 我们需要去 [Github](https://github.com/) 上创建一个新的 Repository，这个 Repository 的名称为 USERNAME.github.com，其中的 USERNAME 是你的 github 账号的名称。完成教程之后就可以通过 USERNAME.github.com 来访问了！

2　现在，你可以通过下面的命令来下载 jekyllbootstrap 了，并把它上传到你自己的 github 上面了。

git clone https://github.com/plusjade/jekyll-bootstrap.git USERNAME.github.com
$ cd USERNAME.github.com
$ git remote set-url origin git@github.com:USERNAME/USERNAME.github.com.git
$ git push origin master

3　大概等 10 分钟之后，你就可以通过使用 http://USERNAME.github.com 来访问你的自己的网站了。

二、本地运行

我们可以在本地查看编辑的效果，如果满意的话，就可以上传到 github 上。

1　首先，你需要安装 jekyll 。

$ gem install jekyll

2　然后，你可以运行命令：

$ cd USERNAME.github.com 
$ jekyll --server

这个时候，你就可以通过 http://localhost:4000/ 来访问你自己的本地站点了，你将可以看到下面的内容：

三、与中文相关的问题

你肯定是要在网站中输入与中文相关的内容的，但启动 server 的时候会出错下面的错误提示

Liquid Exception: incompatible character encodings: UTF-8 and GBK in post

这个时候可以这样解决：

1　首先，打开 jekyll 的 lib 文件，convertible.rb ，我用的是 windows 7 系统，在 C:\RailsInstaller\Ruby1.9.3\lib\ruby\gems\1.9.1\gems\jekyll-0.12.1\lib\jekyll 这个目录下面。

2　然后将该文件的 28 行：

self.content = File.read(File.join(base, name))

改成：

self.content = File.read(File.join(base, name), :encoding => "utf-8")

四、自定义网站基本信息

打开目录中的 _config.yml 文件，会看到如下的内容：

title : Jekyll Bootstrap
tagline: Site Tagline
author :
  name : Name Lastname
  email : blah@email.test
  github : username
  twitter : username
  feedburner : feedname

从字面意识上就很容易理解了，其中的那个 tagline 就是大标题后面跟着的那个字体稍微淡点的副标题。再下面一点，有个

production_url : http://username.github.com

把 username 改成你自己的名字就行了。

五、上传到 github

1　发布内容，可以使用 git 的命令来完成，和使用 git 管理其它的开源项目是一样的：

$ git add .
$ git commit -m "Add new content"
$ git push origin master

2　现在，你就可以通过 USERNAME.github.com 来访问了，内容等你上传完就会更新了，不用第一次建站需要等待十分钟左右的时间了，看到的效果和你在本地看到的效果是一样的。

参考资料

Jekyll Github 站点
Jekyllbootstrap Jekyllbootstrap 主页
Jekyllbootstrap Github 站点
Markdown Markdown 语法