BlogJava-最爱Java-随笔分类-《Ruby on Rails》入门经典

笔记五. 构建简单的Rails应用程序

Brian — Sat, 10 Jan 2009 13:25:00 GMT

摘要: 5.1 访问用户提供的数据新建一个应用程序，并建立一个Look的控制器。 app\controllers\look_controller.rb class LookController < ApplicationController def at ... 阅读全文

Brian 2009-01-10 21:25 发表评论

笔记四. 欢迎进入Rails

Brian — Fri, 09 Jan 2009 12:44:00 GMT

4.1 创建应用程序框架
    使用rails创建应用程序框架，只要在创建框架所在的目录下输入rails applicationName命令即可，如需要创建名为first应用程序的框架，则输入rails first即可。rails会自动帮你创建一大堆目录和所必须要的文件。这些目录和文件的用户我们以后一一再说明。
    启动rails配套的Web服务器，使用ruby script/server命令。记得这个命令要在first目录下运行。

4.2 模型-视图-控制器架构
    关于模型-视图-控制器的架构觉得实在没什么可说的，老套了不要老套了。直接看实现：
    1. 使用ruby script/generate controller Hello命令。这个命令会创建一个hello的控制器。看命令的交互提示就知道其创建了3个文件，而hello_control.rb就是Hello控制器的控制文件啦。
    2. 查看hello_control.rb看代码，可得知其继承与ApplicationController文件。我们给这个文件添加一个动作，将文件修改成如下：

class HelloController < ApplicationController
def there
end
end

    这样就有一个there的动作了。启动服务器，查看http://localhost:3000/hello/there。
    3. 服务器会提示"Template is missing"，这是正常的。因为有了动作，没有视图嘛！默认的视图是同名字的.rhtml文件，存放在app\views\hello目录下，故there动作缺少一个there.rhtml文件。
    4.创建app\views\hello\there.rhtml文件如下：

<html>
    <head>
        <title>Using Ruby on Railstitle>
    head>
    <body>
        <h1>Welcome to Ruby on Railsh1>
        This is your first Ruby on rails application.
        <br/>
        <br/>
        Using this application, you've been introduced to
        controllers, actions, and views.
        <br/>
        <br/>
        Not bad for a first example!
    body>
html>

    在启动服务器，查看http://localhost:3000/first/there，就能看见网页啦！
    5. 回顾一下，有hello控制器接受request，并找到相应的动作there，动作在转发给视图there.rhtml。
    6. 在视图中，也可以使用Ruby代码。如在there.rhtml中添加<%=2+3%>这样的代码，就会显示5；甚至可以添加<%3.times do%>Yes!
<%end%>这样的执行命令。

4.3 将数据从动作传送给视图
    1. 在there代码块中，修改为

def there
@time_now = Time.now
end

2. there.rhtml中添加如下一段代码：

The time is now <%=@time_now%>.

    3.再次查看http://localhost:3000/hello/there，@time_now的值已经显示在页面上了。

4.4 转义敏感文本
    对于<、>、@、&等文本，在html代码中需要使用特殊的符号代替才能正确显示出来。在Rails中，可使用h方法对其转义，如<%=h("I say that here。

4.5 添加第二个动作
    1.根据前面说的，那么只要添加n个动作，就能处理不同的事情了。如创建一个Goto的控制器：

class GotoController < ApplicationController
def work
end

def lunch
end
end

work.rhtml:

<html>
    <head>
        <title>Using Two Viewstitle>
    head>
    <body>
        <h1>Working With Two Viewsh1>
        This is your first Ruby on rails application.
        <br/>
        <br/>
        <h1>Get back to work!<h1>
        <br/>
        <br/>
        This is an active view in a ruby on Rails appliaction.
    body>
html>

lunch.rhtml

<html>
    <head>
        <title>Using Two Viewstitle>
    head>
    <body>
        <h1>Working With Two Viewsh1>
        This is your first Ruby on rails application.
        <br/>
        <br/>
        <h1>Lunch Time!<h1>
        <br/>
        <br/>
        This is an active view in a ruby on Rails appliaction.
    body>
html>

分别访问http://localhost:3000/goto/work和http://localhost:3000/goto/lunch。
2.现在我们将work这个动作改成如下：

def work
    if Time.now.hour == 12
        render(:action => :lunch)
    end
end

这样当12点的时候，访问http://localhost:3000/goto/work就会出现lunch.rhtml的页面了。通过render可以选择呈现的页面。
3.实际上，render还可以直接调用模板，如：

def work
    if Time.now.hour == 20
        render(:action => 'd:\rubydev\first\app\views\goto\lunch.rhtml')
    end
end

Brian 2009-01-09 20:44 发表评论

笔记三. 类和对象

Brian — Wed, 07 Jan 2009 13:01:00 GMT

3.1 类的基本写法
我们直接看代码，比较容易说明：

1class Animal
2    attr_reader :color
3    attr_writer :color
4
5    def initialize(color)
6        @color = color
7    end
8
9end
10
11animal = Animal.new("red")
12puts "The new animal is " + animal.color
13animal.color = "blue"
14puts "The new animal is " + animal.color

上述代码，有程序经验的人基本就能了解大概了。第一行class Aminal是申明了一个叫做Animal的类。这个类有一个initialize的方法，实际上这个方法就是一个构造器，11行代码中的new一个实例，实际上调用的就是initialize方法。请注意这个构造器有一个参数，根据实际情况，可以没有参数或者多个参数。在构造器中，也就是第6行，@color = color，@color叫做实例对象，一个实例就有一个这样的对象，用于保存实例数据。第2，3行建立了一个color的属性，这个属性可以访问@color实例对象，从代码解释来看，这个color对象可读可写，所以在代码12，13行分别对color属性进行了读写。实际上，对于可读可写的属性，只需要使用attr_accessor即可。故代码的第2，3行可合并成attr_accessor :color即可。

3.2 类的继承
Ruby中类的继承表示为<，如下面的代码：

class Animal
    def initialize(color)
        @color = color
    end

    def get_color
        return @color
    end
end

class Dog < Animal
    def initialize(color, sound)
        super(color)
        @sound = sound
    end

    def get_sound
        return @sound
    end
end

dog = Dog.new("brown","Bark")
puts "The new dog is " + dog.get_color
puts "The new dog is " + dog.get_sound

    上述代码表示了Dog继承了Animal类，并在构造器中使用了Ruby内置的super方法。

3.3 理解Ruby中的对象访问
    公共方法(publilc method)----可以在代码的任何地方调用这类方法。没有任何限制。也是Ruby默认的访问级别。
    受保护方法(protected method)----只能在定义这些方法的类的对象内部或是从这个类派生出来的类的对象内部调用这类的方法，也就是说只有“家族成员”才能访问。
    私有方法(private method)----只能在当前对象内部调用这类方法。这是所有方法中限制最严格的。

1class Animal
2    def initialize(color)
3        @color = color
4    end
5
6    public
7    def get_color
8        return @color
9    end
10
11    protected
12    def get_feet
13        return four
14    end
15
16    def get_head
17        return one
18    end
19
20    private
21    def get_eyes
22        return two
23    end
24
25end

上述代码中，从第6行开始声明是public访问修饰符，说明从第6行一下都是public访问级别，直到碰到下一个访问修饰符，即第11行的protected。故可得知，get_feet和get_head方法是protected，而get_eyes则是private的。

3.4 重写方法
Ruby中也可重写方法，即派生类重新定义方法。如：

3.5 创建类变量
在变量名之前加@可以创建实例变量，加@@则就可以创建类变量。类的所有实例都共享一个类变量。通过下面代码可以学习什么是类变量：

class Animal
    @@number_animals = 0

    def initialize(color)
        @color = color
        @@number_animals += 1
    end

    def get_number
        return @@number_animals
    end

end

cat = Animal.new("red")
puts cat.get_number
dog = Animal.new("blue")
puts dog.get_number

3.6 声明类方法
声明类方法可以不用实例化类而直接访问类方法。类方法的声明只要类名+.+方法名即可。如：

class Mathematics
    def Mathematics.add(operand_one, operand_two)
        return operand_one + operand_two
    end
end

puts "1 + 2 = " + Mathematics.add(1,2).to_s

3.7 创建模块
当你使用大量类的时候，可能想将这些类分组成模块。这样就能方便使用大量的类。创建模块要使用module关键字。
Mathematics.rb

module Mathematics
    def Mathematics.add(operand_one, operand_two)
        return operand_one + operand_two
    end
end

Sentence.rb

module Sentence
    def Sentence.add(operand_one, operand_two)
        return operand_one + " " + operand_two
    end
end

usemodules.rb

include 'Mathematics.rb'
include 'Sentence.rb'

puts "2 + 3 = " + Mathematics.add(2,3).to_s

    上述示例中，Mathematics模块的add方法是两个数相加，Sentence模块的add方法是两个单词用单词连接。add方法看上去很像类方法，但实际和类不同，在Ruby中不能使用模块创建实例(也就是对象)。看usemodules的调用方法。
    除了使用include，还可使用require更简洁，如: require 'mathematics'。
    当然类也可以存储进模块中，如：

module Mathematics
    class Adder
        def Adder.add(operand_one, operand_two)
            return operand_one + operand_two
        end
    end
end

puts "2 + 3 = " + Mathematics::Adder.add(2,3).to_s

注意，需要使用范围解析操作符(::)访问模块中的类方法。

3.8 创建混合插入

module Adder
    def add(operand_one, operand_two)
        return operand_one + operand_two
    end
end

module Subtracter
    def subtract(operand_one, operand_two)
        return operand_one - operand_two
    end
end

class Calculator
    include Adder
    include Subtracter
end

calculator = Calculator.new()

puts "2 + 3 = " + calculator.add(2,3).to_s

Brian 2009-01-07 21:01 发表评论

笔记二. 条件、循环、方法和块

Brian — Tue, 06 Jan 2009 14:20:00 GMT

摘要: 2.1 条件语句 Ruby中的条件语句中的关键字为if，else，elsif(注意不是elseif)，unless和case语句。语法很简单，看下面两段代码就能学会了。 temperature = 76 if temperature > 65 && ... 阅读全文

Brian 2009-01-06 22:20 发表评论

笔记一. Ruby简介

Brian — Tue, 06 Jan 2009 07:49:00 GMT

1.1 安装Ruby和Rails
      从http://rubyinstaller.rubyforge.org下载最新的Ruby安装包，并单击安装包就搞定了。然后在命令行模式下输入gem install rails --remote网络安装Rails。至于使用--include-dependencies或本地安装，可查看相关资料。

1.2 创建第一个Web应用程序
        1. 先设置工作目录为d:\rubydev目录,并将第一个Web应用程序命名为hello，则输入命令行rails hello。

        2. 进入hello目录，使用ruby script/gengerate controller App新建一个名为App的控制器。

        3. .rb就是Ruby文件。打开app_controller.rb文件，可以看见：
            class AppController < ApplicationController
            end
            这个控制器派生自ApplicationController基类。
        4.在app_controller.rb中创建动作，修改如下：

class AppController < ApplicationController
def greeting
End
end

5.在ruby\hello\app\views\app\中创建greeting.rhtml文件，如下：

<html>
    <head>
        <title>Ruby on Railstitle>
    head>
    <body>
        <h1>Yes it's workingh1>
    body>
html>

    6.使用ruby script/server启动内置服务器，查看http://localhost:3000/app/greeting，观看效果。

1.3 初识Ruby
    1. 使用puts可输出字符串，并带有换行符。如puts "Hello from Ruby"
    2. 注释符为#。如puts "Hello from Ruby" #Display the text!
    3. 使用交付工具irb，可将Ruby切换为交互性运行模式。

1.4 学习Ruby文档
    使用ri工具，并加上所需要帮助内容的关键字。如ri puts
    不过还是上www.ruby-doc.org方便。

1.5 在Ruby中处理数字
    Ruby对于数字是自动处理的，且没有限制大小。更变态的是可以用下划线分割，如12_234_345，就是12234345。0b开头的为两进制数，0开头为八进制数，0x开头为十六进制数。实际上，Ruby是把数字保存为不同类型的，如整数一般为Fixnum类型，大的为Bignum类型，小数为Float类型。只不过Ruby会自动转换，无需程序员关心而已。

puts 12345
puts 3.1415
puts 31415.0e-4
puts 12_345_678_654_321
puts 0xddff
puts 0b1111
puts 0355

1.6 在Ruby中处理字符串
    可以将字符串放在一对单引号或双引号中，甚至单双引号可以混用。只要配对出现就可以了。但不可双引号中出现双引号，或单引号中出现单引号，这样Ruby无法判断结尾。同时也可使用\作为转义符。如"I said \"Hello\""。
    使用%q(单引号)或%Q(双引号)也可以，但必须配合一个字符。如%Q/Hello World/。甚至可以省略Q，如%/Hello World/。
    可以使用+符号来连接字符串。

puts "Hello"
puts "Hello " + "there"
puts 'Nice to see you.'
puts %Q/How are you./
puts %Q!Fine, and you?!
puts %q!I'm also fine,thanks.!
puts "I have to say, 'I am well.'"
puts "I'll also say, \"Things are fine.\""

    print方法和puts方法相同，都是输出字符串。区别在于print方法不会自动转到下一行。需要使用换行符\n。

1.7 变量的赋值。
    Ruby中变量赋值格式如temperature = 34。变量名的命名要求为：以小写字母(a-z)或下划线(_)开始，后面可以跟任意数量的命名字符。命名字符可以是小写字母，大写字母，数字或下划线。但需避免保留字。Ruby保留字如下：
                _FILE_                def                    in                        self
                _LINE_               defined?            module                super
                BEGIN                do                     next                     then
                END                    else                   nil                        true
                alias                     elsif                   not                       undef
                and                      end                   or                         unless
                begin                    ensure              redo                      until
                break                   false                 rescue                    when
                case                     for                   retry                        while
                class                    if                      return                      yield

1.8 创建常量
    Ruby中以大写字母开头的被认为是常量，Ruby也凭这个判断是否为常量。一般习惯上都全部用大写来表示常量。在Ruby中，常量是允许通过赋值方式来改变常量的值的：
        CONST = 1
        CONST = 2
     但每次改变常量都会收到一个警告：constants.rb:2: warning: already initialized constant CONST

1.9 在双引号字符串中内插变量
    比较以下代码的运行结果就知道啥意思了

temperature = 36
puts "The temperature is " + String(temperature) + "."
puts "The temperature is #{temperature}."
temperature = temperature + 5
puts "The temperature is #{temperature}."

1.10 从命令行读取文本
内置的gets方法可以从命令行读取用户的输入，并在默认情况下把读入的文本赋值给预定义的变量$_。但gets方法会保留用户输入的字符串末尾所加的终止换行符。所以需要内置方法chomp方法，改方法会去除字符串变量$_后面的换行符。但chomp方法只会去除$_变量的换行符。

print "Please enter the temperature:"
gets
chomp
puts "The temperature is #{$_}."

gets方法能把输入值赋予任何一变量，但chomp只能去除$_变量的换行符。

print "Please enter the temperature:"
temperature = gets
$_ = temperature
chomp
temperature = $_
puts "The temperature is #{$_}."

1.11 在Ruby中创建符号
符号以冒号(:)开头，如:temperature。

1.12 Ruby中的操作符

操作符	描述
[]	数组引用
[]=	数组元素集
**	指数运算
!	去反
~	取补
+	一元加
-	相减
*	相乘
/	相除
%	取模
+	相加
-	相减
>>	右移
<<	左移
&	逻辑与
^	逻辑异或
\|	逻辑或
比较操作符
<=	小于等于
<	小于
>	大于
>=	大于等于
相等和模式匹配操作符
<=>	小于，等于，大于
==	等于
===	在case语句的when子句中测试相等
!=	不等于
=~	正则表达式模式匹配
&&	逻辑与
\|\|	逻辑或
..	含最大值的范围
…	不含最大值的范围
?	三重条件
:	否则
赋值
=	简单赋值
%=	取模并赋值
/=	相除并赋值
-=	相减并赋值
+=	相加并赋值
*=	相乘并赋值
**=	指数运算并赋值
defined?	如果符号已定义，则为真
not	逻辑非
and	逻辑组合
or	逻辑组合
语句修饰符
if
unless
while
until
begin/end	块表达式

1.13 操作符的优先级
    上面表的排列就是按照优先级排列的。

1.14 使用数组
    1. 操作符[]可以创建一个数组。
    2.数组第一个索引值为0，而不是1。
    3.数组中可存放不同类型的数值，内置方法length可得到数组个数。

array = ["Hello" , "there", "sweetie", 1, 2, 3]
puts array[0]
puts array[1]
puts array[2]
puts array.length
array2 = Array.new
puts array2.length
array2[0] = "Banana"
array2[2] = "fish"
puts array2[0] + " " + array2[2]
puts array2.length

上述代码中，使用Array.new来创建了一个新的数组，长度为0。当给数组一个元素赋值时，如果这个元素不存在，Ruby会自动创建这个元素。且放置的元素不一定连续，如代码中给0元素赋值后，直接给2元素赋值。同时，数组中索引使用负数，这是索引会从数组的最后一个开始往前基数。在代码中，array[-1]就是3，array[-2]为2，以此类推。

1.15 使用两个数组索引
Ruby中可以通过两个数组索引来引用数组中的元素，第一个索引值代表开始的位置，第二个值代表元素的个数。所以第一个索引成为“起点”，第二个索引成为“元素个数”：array[start, count]。

array = ["Hello" , "there", "sweetie", 1, 2, 3]
array[2,1] = "pal"
puts array
array = ["Hello" , "there", "sweetie", 1, 2, 3]
array[3,0] = "pie"
puts array
array = ["Now" , "is", 1, 2, 3]
array[2,0] = ["the", "time"]
puts array
array = ["Hello" , "there", "sweetie", 1, 2, 3]
array2 = array[3,3]
puts array2

    示例中，7，8，9行实现了插入数组的功能；10，11，12行实现了提取子数组的功能。

1.16 散列表
    Ruby中创建散列表使用大括号{}，如：money_i_am_owed={"Dan"=>"$1,000,000","Derek"=>"$500,000"}。获取散列表值如puts monoey_i_am_owed["Dan"]。

1.17 使用范围
    用..来创建。如1..4则创建了1，2，3，4范围，可使用to_a内置方法把范围转换成数组。但1...4则会忽略最后一个元素，为1,2,3范围。同时，需要提醒的是，范围的创建是递增形式的，如(1..10).to_a是正确的，但(10..1).to_a也正确，但只能得到空数组。

rang=1..5
puts rang.to_a
rang=15
puts rang.to_a
rang="alpha".."alphe"
puts rang.to_a
puts (1..10).to_a
puts (10..1).to_a

Brian 2009-01-06 15:49 发表评论