Flash AS 基理殿堂

[AS3 狂想曲] SWF 间双向通信 [FL 车在臣]

FL车在臣 — Fri, 13 Nov 2009 09:07:59 GMT+8

演示文件源码下载：http://kerryas.googlecode.com/files/swfs_communication.rar

假设有一个主 SWf 名为 main.swf 加载一个名为 game.swf 的游戏模块：
1. main 里面使用 Loader 将 game.swf 加载进来；
2. 在 game 中定义 public function moveBall(speed:Number) 方法，用于开始游戏;
3. 在 main 里面使用类似 loader["content"].moveBall(speed) 的语句调用 game.swf 里面的方法；
4. game.swf 与 main.swf 通信的方法，可以使用 dispatchEvent 方法与 main.swf 通信，也可以继续使用上述方法。

下面请看示例：
1. 首先创建被调用的 game.swf：
package {
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.system.Security;

    public class Game extends Sprite {
        private var ball:Sprite;
        private var speed:Number;

        public function Game() {
            // 在 Flash IDE 中执行 Debug
            Security.allowInsecureDomain("*");

            if (stage) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }

        private function init(e:Event = null):void {
            removeEventListener(Event.ADDED_TO_STAGE, init);
            ball = new Sprite();
            ball.graphics.beginFill(0xFF0000);
            ball.graphics.drawCircle(0, 0, 50);
            ball.graphics.endFill();
            addChild(ball);
            ball.x = 50;
            ball.y = stage.stageHeight / 2;
        }

        public function moveBall(speed:Number):void {
            this.speed = speed;
            addEventListener(Event.ENTER_FRAME, onGameLoop);
        }

        private function onGameLoop(e:Event):void {
            ball.x += speed;
        }

        public function stopMove():void {
            removeEventListener(Event.ENTER_FRAME, onGameLoop);
        }
    }
}
在这个类里创建了一个小球实例 ball，还提供了两个公开的方法 moveBall(speed) 和 stopMove()，用于控制小球的运动与停止。最后，编译该文件将生成好的 game.swf 放到应用服务器的根目录上（http://localhost/game.swf）。

2. 下面创建主程序，调用 game.swf 并与其通信
package {
    import flash.display.Loader;
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.net.URLRequest;
    import flash.system.Security;

    public class Main extends Sprite {
        private var loader:Loader;

        public function Main() {
            if (stage) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }

        private function init(e:Event = null):void {
            removeEventListener(Event.ADDED_TO_STAGE, init);

            // 允许访问变量、对象、属性、方法等
            Security.allowDomain("*");

            loader = new Loader();
            addChild(loader);

            // 加载 http://localhost/game.swf 后面的参数用于防止缓存
            loader.load(new URLRequest("http://localhost/game.swf?" + new Date().time));
            loader.contentLoaderInfo.addEventListener(Event.INIT, onLoadComplete);
        }

        private function onLoadComplete(e:Event):void {
            // 调用 game.swf 中的 moveBall(speed) 方法
            loader["content"].moveBall(5);

            // 点击舞台后调用 game.swf 中的 stopMove() 方法
            stage.addEventListener(MouseEvent.CLICK, onClickStageHandler);
        }

        private function onClickStageHandler(e:MouseEvent):void {
            loader["content"].stopMove();
        }

    }
}
主程序中先将 game.swf 加载进来，然后调用 game.swf 中的 moveBall(speed) 方法，并侦听在舞台发生点击事件后调用 game.swf 中的 stopMove() 方法。

3. game.swf 与 main.swf 通信方法：
调用的方法可以和 main.swf 调用 game.swf 一样，也可以使用事件调度，下面是事件驱动方法：
（1）定义 GameEvent.as 事件
package {
    import flash.events.Event;

    public class GameEvent extends Event {
        public static const GAME_START:String = "game_start";
        public static const GAME_OVER:String = "game_over"

        public var score:uint;

        public function GameEvent(type:String, score:uint = 0) {
            this.score = score;
            super(type);
        }

    }
}

（2）在 Game 中当调用 moveBall(speed) 方法时分发 GameEvent.GAME_START 事件：
dispatchEvent(new GameEvent(GameEvent.GAME_START));
在 Game 中当调用 stopMove() 方法时分发 GameEvent.GAME_OVER 事件：
dispatchEvent(new GameEvent(GameEvent.GAME_OVER, ball.x)); // 将小球的 x 坐标作为 GameEvent 的参数发出

（3）在 Main 中侦听这两个事件（当 game.swf 被加载进来后）：
loader["content"].addEventListener(GameEvent.GAME_START, onGameStartHandler);
loader["content"].addEventListener(GameEvent.GAME_OVER, onGameOverHandler);

private function onClickStageHandler(e:MouseEvent):void {
    loader["content"].stopMove();
}

private function onGameOverHandler(e:Object):void {
    trace(e.score);
}

private function onGameStartHandler(e:Object):void {
    trace(e.score);
}

请注意处理事件的类型不是 GameEvent 而是 Object，理论上应该是 GameEvent ，但是如果这样声明的话会出现“强制转换类型失败”，因此只能用 Object 来替代。

[KerryLib] KerryLib v0.2 更新内容 [FL车在臣]

FL车在臣 — Sun, 13 Sep 2009 13:32:15 GMT+8

SVN Checkout or Update：http://kerryas.googlecode.com/svn/trunk/KerryLib

版本 0.2 更新内容
com.kerry.effect
    -- Earthquake
    -- PerlinDistort
    -- Rippler
    -- StaticReflection
com.kerry.util
    -- ArrayUtil
    -- ClassUtil
    -- MathUtil
    -- ObjectUtil
    -- StringUtil

■ com.kerry.effect#Earthquake.as
package com.kerry.effect {
    import flash.display.DisplayObject;
    import flash.events.TimerEvent;
    import flash.utils.Timer;


    public class Earthquake {
        private var source:DisplayObject;
        private var originalX:Number;
        private var originalY:Number;

        private var timer:Timer;
        private var intensity:Number


        public function Earthquake(source:DisplayObject) {
            this.source = source;
        }


        public function quake(intensity:Number = 10, times:uint = 5, intervalSeconds:Number = 0.05):void {
            this.intensity = intensity;
            originalX = source.x;
            originalY = source.y;

            timer = new Timer(intervalSeconds * 1000, times);
            timer.addEventListener(TimerEvent.TIMER, onQuake);
            timer.addEventListener(TimerEvent.TIMER_COMPLETE, rest);
            timer.start();
        }


        private function onQuake( event:TimerEvent ): void {
            source.x = originalX + Math.random() * intensity;
            source.y = originalY + Math.random() * intensity;
        }


        private function rest(e:TimerEvent): void {
            source.x = originalX;
            source.y = originalY;
        }

    }
}

■ com.kerry.effect#PerlinDistort.as
package com.kerry.effect {
    import flash.display.BitmapData;
    import flash.geom.Point;
    import flash.filters.DisplacementMapFilter;
    import flash.display.Sprite;
    import flash.display.DisplayObject;
    import flash.display.Bitmap;
    import flash.events.Event;

    public class PerlinDistort {
        private var perlinOffset:Array;
        private var randCount:Number;

        private var source:DisplayObject;
        private var bmp:BitmapData;
        private var dmf:DisplacementMapFilter;


        public function PerlinDistort(source:DisplayObject, scaleX:Number, scaleY:Number) {
            this.source = source;
            randCount = Math.random() * 25;
            perlinOffset = new Array(new Point(55, 34), new Point(20, 33));

            bmp = new BitmapData(source.width + 100, source.height + 100, false);
            bmp.draw(source);
            dmf = new DisplacementMapFilter(bmp, new Point(0, 0), 1, 1, scaleX, scaleY, "color", 0xFFFFFF, 0);
            source.addEventListener(Event.ENTER_FRAME, noiseOn);
        }

        private function noiseOn(e:Event):void {
            perlinOffset[0].y -= 8;
            perlinOffset[0].x -= 5;
            perlinOffset[1].x += 8;
            perlinOffset[1].y += 5;
            bmp.perlinNoise(100, 100, 3, randCount, false, true, 1, true, perlinOffset);
            source.filters = [dmf];
        }


        public function removeNoise():void {
            source.removeEventListener(Event.ENTER_FRAME, noiseOn);
            source.filters = [];
        }
    }
}

■ com.kerry.effect#Rippler.as
package com.kerry.effect {
    import flash.display.BitmapData;
    import flash.display.BitmapDataChannel;
    import flash.display.BlendMode;
    import flash.display.DisplayObject;
    import flash.events.Event;
    import flash.filters.ConvolutionFilter;
    import flash.filters.DisplacementMapFilter;
    import flash.geom.ColorTransform;
    import flash.geom.Matrix;
    import flash.geom.Point;
    import flash.geom.Rectangle;


    public class Rippler {
        private var source:DisplayObject;

        private var buffer1:BitmapData;
        private var buffer2:BitmapData;
        private var defData:BitmapData;

        private var fullRect:Rectangle;
        private var drawRect:Rectangle;
        private var origin:Point = new Point();

        private var filter:DisplacementMapFilter;
        private var expandFilter:ConvolutionFilter;
        private var colourTransform:ColorTransform;

        private var matrix:Matrix;
        private var scaleInv:Number;


        public function Rippler(source:DisplayObject, strength:Number, scale:Number = 2) {
            var correctedScaleX : Number;
            var correctedScaleY : Number;

            this.source = source;
            scaleInv = 1 / scale;

            buffer1 = new BitmapData(source.width * scaleInv, source.height * scaleInv, false, 0x000000);
            buffer2 = new BitmapData(buffer1.width, buffer1.height, false, 0x000000);
            defData = new BitmapData(source.width, source.height);

            correctedScaleX = defData.width / buffer1.width;
            correctedScaleY = defData.height / buffer1.height;

            fullRect = new Rectangle(0, 0, buffer1.width, buffer1.height);
            drawRect = new Rectangle();

            filter = new DisplacementMapFilter(buffer1, origin, BitmapDataChannel.BLUE, BitmapDataChannel.BLUE, strength, strength, "wrap");
            source.filters = [filter];

            source.addEventListener(Event.ENTER_FRAME, handleEnterFrame);
            expandFilter = new ConvolutionFilter(3, 3, [0.5, 1, 0.5, 1, 0, 1, 0.5, 1, 0.5], 3);
            colourTransform = new ColorTransform(1, 1, 1, 1, 127, 127, 127);
            matrix = new Matrix(correctedScaleX, 0, 0, correctedScaleY);
        }


        public function drawRipple(x:int, y:int, size:int, alpha:Number):void {
            var half : int = size >> 1;
            var intensity : int = (alpha * 0xff & 0xff) * alpha;

            drawRect.x = ( -half + x) * scaleInv;
            drawRect.y = ( -half + y) * scaleInv;
            drawRect.width = drawRect.height = size * scaleInv;
            buffer1.fillRect(drawRect, intensity);
        }


        public function getRippleImage():BitmapData {
            return defData;
        }


        public function destroy():void {
            buffer1.dispose();
            buffer2.dispose();
            defData.dispose();
            source.removeEventListener(Event.ENTER_FRAME, handleEnterFrame);
        }


        private function handleEnterFrame(e:Event):void {
            var temp:BitmapData = buffer2.clone();
            buffer2.applyFilter(buffer1, fullRect, origin, expandFilter);
            buffer2.draw(temp, null, null, BlendMode.SUBTRACT, null, false);
            defData.draw(buffer2, matrix, colourTransform, null, null, true);
            filter.mapBitmap = defData;
            source.filters = [filter];
            temp.dispose();
            switchBuffers();
        }


        private function switchBuffers():void {
            var temp:BitmapData;
            temp = buffer1;
            buffer1 = buffer2;
            buffer2 = temp;
        }
    }

}

■ com.kerry.effect#StaticReflection.as
package com.kerry.effect {
    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import flash.display.DisplayObject;
    import flash.display.GradientType;
    import flash.display.Sprite;
    import flash.geom.Matrix;


    public class StaticReflection extends Sprite {
        private var source:DisplayObject;
        private var bitmap:Bitmap;

        public function StaticReflection(source:DisplayObject) {
            this.source = source;

            var w:Number = source.width;
            var h:Number = source.height;

            var colors:Array = [0xFF0000, 0x0000FF];
            var alphas:Array = [0.4, 0];
            var ratios:Array = [0, 0xFF];

            var matrix:Matrix = new Matrix();
            matrix.createGradientBox(w, h, Math.PI / 2, 0, 0);

            var bmd:BitmapData = new BitmapData(w, h, true, 0x00000000);
            bitmap = new Bitmap(bmd);
            bmd.draw(source);
            addChild(bitmap);

            bitmap.scaleY = -1;
            bitmap.y = bitmap.height;
            bitmap.cacheAsBitmap = true;

            var mark:Sprite = new Sprite();
            mark.graphics.beginGradientFill(GradientType.LINEAR, colors, alphas, ratios, matrix);
            mark.graphics.drawRect(0, 0, w, h);
            addChild(mark);
            mark.cacheAsBitmap = true;

            bitmap.mask = mark;
        }

    }
}

■ com.kerry.util#ArrayUtil.as
package com.kerry.util {

    public class ArrayUtil {

        public static function arrayContainsValue(arr:Array, value:Object):Boolean {
            return (arr.indexOf(value) != -1);
        }


        public static function remov_rueFromArray(arr:Array, value:Object):void {
            var len:uint = arr.length;

            for (var i:Number = len; i > -1; i--) {
                if (arr[i] === value) {
                    arr.splice(i, 1);
                }
            }
        }


        public static function copyArray(arr:Array):Array {
            return arr.slice();
        }


        public static function arraysAreEqual(arr1:Array, arr2:Array):Boolean {
            if (arr1.length != arr2.length) {
                return false;
            }

            var len:Number = arr1.length;

            for (var i:Number = 0; i < len; i++) {
                if (arr1[i] !== arr2[i]) {
                    return false;
                }
            }
            return true;
        }


        public static function shuffle(source:Array):Array {
            if( source == null ) return null;
            return source.sort( function( ...arguments : Array ) : int { return Math.round( Math.random() * 2 ) - 1; } );
        }

    }
}

■ com.kerry.util#ClassUtil.as
package com.kerry.util {
    import flash.utils.describeType;
    import flash.utils.getDefinitionByName;

    public class ClassUtil {

        public static function getInstance(Clazz:Class, ...arguments:Array):Object {
            var xml:XML = describeType(Clazz);
            if(xml.hasOwnProperty("factory")) xml = new XML( xml.child( "factory" ));
            var constructorArgumentsLength:uint = xml.child( "constructor" ).child( "parameter" ).length();

            switch(constructorArgumentsLength) {
                case 0: return new Clazz();
                case 1: return new Clazz(arguments[0]);
                case 2: return new Clazz(arguments[0], arguments[1]);
                case 3: return new Clazz(arguments[0], arguments[1], arguments[2]);
                // ... case 21
            }
            return null;
        }

    }
}

■ com.kerry.util#MathUtil.as
package com.kerry.util {


    public class MathUtil    {

        public static function radianToDegree (radian:Number):Number {
            return radian * 180 / Math.PI;
        }


        public static function degreeToRadian(degree:Number):Number {
            return degree / 180 * Math.PI;
        }


        public static function pythagoras(s1:Number , s2:Number, searchHypotenuse:Boolean = false):Number {
            if (searchHypotenuse) return Math.sqrt( s1 * s1 + s2 * s2 );
            var hypo:Number = Math.max( s1 , s2 );
            var side:Number = Math.min( s1 , s2 );
            return Math.sqrt(hypo * hypo - side * side);
        }


        public static function distance(p1X:Number, p1Y:Number, p2X:Number, p2Y:Number):Number {
            var dx:Number = p1X - p2X;
            var dy:Number = p1Y - p2Y;
            return Math.sqrt(dx * dx + dy * dy);
        }

    }
}

■ com.kerry.util#ObjectUtil.as
package com.kerry.util {
    import flash.utils.ByteArray;
    import flash.utils.describeType;


    public class ObjectUtil    {


        public static function copyProperties(fromObject:Object, toObject:Object):void {
            var isDynamicObject:Boolean = isDynamic(toObject);
            for (var prop:String in fromObject) {
                if (isDynamicObject || toObject.hasOwnProperty(prop)) toObject[prop] = fromObject[prop];
            }
        }


        public static function copy (obj:Object):Object {
            var buffer:ByteArray = new ByteArray();
            buffer.writeObject(obj);
            buffer.position = 0;
            return buffer.readObject();
        }


        public static function isDynamic(obj:Object):Boolean {
            var xml:XML = describeType(obj);
            return xml.@isDynamic == "true";
        }

    }
}

■ com.kerry.util#StringUtil.as
package com.kerry.util {


    public class StringUtil {

        public static function trim(input:String):String {
            return StringUtil.ltrim(StringUtil.rtrim(input));
        }


        public static function ltrim(input:String):String {
            var size:Number = input.length;
            for (var i:Number = 0; i < size; i++) {
                if (input.charCodeAt(i) > 32) {
                    return input.substring(i);
                }
            }
            return "";
        }


        public static function rtrim(input:String):String {
            var size:Number = input.length;
            for (var i:Number = size; i > 0; i--) {
                if (input.charCodeAt(i - 1) > 32) {
                    return input.substring(0, i);
                }
            }
            return "";
        }


        public static function stringHasValue(s:String):Boolean {
            return (s != null && s.length > 0);
        }


        public static function isEmail(s:String):Boolean {
            return /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,6}$/i.test( s );
        }


        public static function isWhitespace(s:String):Boolean {
            switch(s) {
                case " ":
                case "\t":
                case "\r" :
                case "\n" :
                case "\f" :
                return true;
            }
            return false;
        }

    }
}

KerryLib v0.2 部分 demo 程序效果：
com.kerry.effect.Rippler 及 com.kerry.effect.StaticReflection 结合
=> StaticReflectionWithRipplerDemo

[视频教程] Flash AS 3.0 项目开发实践 [FL车在臣]

FL车在臣 — Tue, 08 Sep 2009 14:34:51 GMT+8

1. 内容介绍及 FlashDevelop 安装使用

2. Flash 与后台（Java, PHP, Rails）通信及 HttpWatch 使用

3. Json 数据交换、AS3corelib 以及 Alcon 调试工具

4. AMFPHP、KerryLib 及 swfobject.js

演示文件源码下载：http://kerryas.googlecode.com/files/flashas3_develop.rar

内容介绍

1. FlashDevelop：Flash 项目开发必备环境

2. Flash 与后台：Java, PHP, Rails 通信技术

3. HttpWatch：网页数据分析工具

4. JSON：轻量级的数据交换格式

5. As3corelib：Adobe 官方出品的 AS3 函数库

6. Alcon：调试工具

7. AMFPHP：让 Flash 与 PHP 无缝通信

8. KerryLib：FL车在臣 AS3 开源项目

9. SWFObject：基于 Javascript 的 Flash 媒体版本检测与嵌入模块

1.1 FlashDevelop 安装
安装准备：
Microsoft .Net Framework2（运行环境）
JRE 1.6+ （ Flex SDK 必须的必备条件）
FlexSDK（FD 进行调试编译的基础）

下载安装 FD：www.flashdevelop.org

1.2 FlashDevelop 开发环境配置
●设置 Flex SDK Location 到 Flex SDK 的根目录（Tools->Program Settings-> AS3Context）

●设置 Path To Flash IDE 到 Flash 安装根目录（ Tools->Program Settings-> ASCompletion ）

●设置 Flash View 到 [Flex SDK]/ runtimes\player\10\win\FlashPlayer.exe

●设置 Contextual Generator 快捷键 Ctrl + 1

●插件的安装（放置在 [FlashDevelop]/Plugins 目录）例如： fdbplugin 一款 FD 的 Debug 插件

1.3 FlashDevelop 工程创建及设置

●Flash IDE 工程与 AS3 工程
●Project Classpaths 与 Global Classpaths
●运行平台（flash player 9/10）Output-> Plantform

1.4 FlashDevelop 创建 asDoc 文档

●Flash Tools -> Documentation Generator
Page Title：设置页面标题
Output directory：设置文档输出的路径
Classpaths：设置生成文档的源文件路径
Excude classes：设置要排除在外的类
Settings -> ASDoc location：设置为 [Flex SDK]/bin

2.1 Flash 与后台通信

var request:URLRequest = new URLRequest("http://localhost:8080/hello_flash/servlet/hello");
request.method = "post";

var vars:URLVariables = new URLVariables();
vars.name = "kerry";
vars.pass = "123456";
request.data = vars;

var loader:URLLoader = new URLLoader();
loader.load(request);
loader.addEventListener(Event.COMPLETE, onLoadComplete);

private function onLoadComplete(e:Event):void {
trace(e.target.data);
}

2.2 Flash 与 Java
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();

String username = request.getParameter("name");
String password = request.getParameter("pass");

out.println("hello from java: " + username +" "+ password);
out.flush();
out.close();
}

2.3 Flash 与 PHP
$username = $_POST['name'];
$password = $_POST['pass'];
echo "hello from php : ".$username." ".$password;
?>

2.4 Flash 与 Rails
●F:\rails_project>rails -d mysql hello_flash

●修改 database.yml 并创建 hello_flash 数据库

●ruby script/generate controller hello sayHello

●启动 WEBrick 服务器：ruby script/server

修改 app/controllers/hello_controller.rb
class HelloController < ApplicationController
def sayHello
username = params['name'];
password = params['pass'];
render :text => "hello from rails:#{username} #{password}"
end
end

3. HttpWatch 观察请求与响应

●HttpWatch最主要的功能就是对通过浏览器发送的http 请求进行监控和分析，当你在浏览器的地址栏上请求一个 URL 或者提交一份表单时，HttpWatch帮你分析 http 请求的 head 信息，访问页面的 cookie 信息，Get 和 Post 的详细数据包分析。
●在 IE 下使用 Shift + F2 调出 HttpWatch 工具栏
●使用 Record 记录请求与响应数据

4. JSON — 轻量级数据交换格式
XML 与 JSON 实例比较：假设有一个用户数据包括：用户名，年龄，email 地址（工作和家庭）。
用 XML 表示如下：

张三
30

kelly@seankelly.biz

kelly@seankelly.tv

用 JSON 表示如下：
{
"name":"张三",
"age":30,
"emailaddrs": [
{"type": "work", "value": "kelly@seankelly.biz"},
{"type": "home", "value": "kelly@seankelly.tv"}
]
}
与XML一样，JSON也是基于文本的，且它们都使用Unicode编码，同样具有可读性。XML比较适合于标记文档，而 JSON 却更适合于时行数据交换处理。

5.1 as3corelib — AS3开源库
As3corelib是Adobe官方出品的ActionScript 3 函数库，这个库包括了MD5、SHA1、SHA224、SHA256加密，PNG、JPG编码，JSON序列化等强大功能。
地址：http://code.google.com/p/as3corelib/

5.2 as3corelib — JSON 类范例
var person:Object = new Object();
person.name = "张三";
person.age = 30;

person.emailaddrs = new Array();

var email1:Object = new Object();
email1.type = "work";
email1.value = "kerry@work.com";

var email2:Object = new Object();
email2.type = "home";
email2.value = "kerry@home.com";
person.emailaddrs.push(email1, email2);

var jsonStr:String = JSON.encode(person);
trace(jsonStr);

var resultPerson:Object = JSON.decode(jsonStr);
trace(resultPerson.age);// 30

6.1 Alcon — 轻量级调试工具
Alcon 简介：为 AS 开发人员提供简单直接、方便、快捷的程序调试方法和监视器。

App Monitor：用于监视应用程序的帧频，帧的渲染时间以及内存消耗情况：
Debug.monitor(stage, 1000);
Debug.mark(0xFF0000);

6.2 Alcon 快速开始
将 Alcon 的源码加入到类路径，调试程序
import com.hexagonstar.util.debug.Debug;

Debug.trace(“hello”);// 打印字符串

Debug.traceObj(obj); // 打印对象

Debug.inspect(obj); // 观察对象

Debug.hexDump(obj); // 打印十六进制信息

Debug.delimiter(); // 打印分割线

Debug.timerStart("循环开始");
for (var i:int = 0; i < 1000000; i++) {}
Debug.timerStopToString();

7.1 AMFPHP 简介
● AMFPHP 是 Action Message Format（AMF）的一个开源 PHP 实现。用于在 PHP 与 Flash 无缝交换数据，不需要手动进行序列化。AMF 是基于二进制的数据传输格式，数据体积小、效率高，尤其是大数据量的传输。

● 运行环境
Apache2.2 + PHP5 + MySQL5

● 下载安装：http://www.amfphp.org/

7.2 AMFPHP 使用规范
一、PHP后台采用AMFPHP框架进行编码，数据通信格式为AMF3。调试方法：NetDebug::trace()。
AMFPHP采用创建类的方式对业务逻辑进行封装。创建类时，以其所处理的逻辑不同进行划分。

二、在AMFPHP框架中输出中文需要加入在gateway.php中加入：
$gateway->setCharsetHandler( "iconv", "utf-8", "utf-8" );

三、数据封装方式：
1.返回数组：
$user = array('name'=>'kerry','sex'=>'male','age'=>23);

2.返回对象：
$user -> name = 'kerry';
$user -> sex = 'male';
$user -> age = 23;

四、代码编写时，需要写明方法注释及参数定义（@param），以便提高代码的可维护性：
function getUserInfo($id, $name) {…}

7.3 AMFPHP 后台接口示例
class User {

  function getUserInfo($uid) {
   $conn = mysql_connect("localhost", "root", "");
   mysql_select_db("test");
   mysql_query("set names utf8");
   $sql = "select name,age from user where id = {$uid}";
   $users = mysql_query($sql);

   $result = array();
   while ($row = mysql_fetch_assoc($users)) {
    array_push($result, $row);
   }

   mysql_free_result($users);
   mysql_close($conn);
   return $result;
  }
}
?>

7.4 Connection —后台调用类
package {
import flash.net.NetConnection;
import flash.net.Responder;

public class Connection {
  private var gateway:NetConnection;
  public static var instance:Connection;

  public function Connection(gatePath:String) {
   instance = this;
   gateway = new NetConnection();
   gateway.connect(gatePath);
  }

  private function getResponder(result:Function):Responder {
   return new Responder(result, onFault);
  }

  private function onFault(info:Object):void {
   trace(info.description);
  }

  public function getUserInfo(callBack:Function, uid:uint):void {
   gateway.call("User.getUserInfo", getResponder(callBack), uid);
  }

}
}

7.5 调用后台及处理结果
前台调用
new Connection("http://localhost/flash_hello/amfphp/gateway.php");
Connection.instance.getUserInfo(getUserInfoSuccess, 1);

private function getUserInfoSuccess(result:Object):void {
var user:Object = result[0] as Object;
trace("user name: " + user.name);
trace("user age: " + user.age);
}

输出结果
user name: 张三
user age: 16

8. KerryLib AS3 开源类库
安装 SVN 客户端 —— TortoiseSVN： http://tortoisesvn.net/downloads
SVN Checkout： http://kerryas.googlecode.com/svn/trunk/KerryLib

9.1 SWFObject.js
SWFObject是一个用于在 HTML 中方面插入 Adobe Flash 媒体资源（*.swf文件）的独立、敏捷的JavaScript 模块。该模块中的 JavaScript 脚本能够自动检测 PC、Mac 机器上各种主流浏览器对 Flash 插件的支持情况。它使得插入 Flash 媒体资源尽量简捷、安全。而且它是非常符合搜索引擎优化的原则的。此外，它能够避免您的 HTML、XHTML 中出现 object、embed 等非标准标签，从而符合更加标准。
下载地址（版本 2.2）：http://code.google.com/p/swfobject/

9.2 SWFObject 将 Flash 嵌入网页

hello_flash

9.3 在 Flash 中接收页面参数
var textField:TextField = new TextField();
textField.width = stage.stageWidth;
addChild(textField);

var gateway_path:String = stage.loaderInfo.parameters.gateway_path;

textField.text = gateway_path ? gateway_path : "no values";

KerryLib AS3 开源项目启动 [FL车在臣]

FL车在臣 — Sun, 30 Aug 2009 11:46:02 GMT+8

KerryLib 是基于 ActionScript 3 的开源项目，内容涉及功能代码类、特殊效果类、工具类、组件类等（内附 API 文档及使用示例 demo），作者 FL 车在臣。

KerryLib （源码及演示程序）svn 地址：http://kerryas.googlecode.com/svn/trunk/KerryLib

KerryLib v0.1 更新内容

com.kerry.effect

-- Light

-- PowerFilters

com.kerry.page

-- PageSwitch

com.kerry.util

-- DateUtil

KerryLib v0.1 部分 demo 程序效果：

com.kerry.effect.Light => LightDemo.thunderStorm

com.kerry.effect.PowerFilters

[RoR] Ruby for Rails 最佳实践ⅩⅥ[FL车在臣]

FL车在臣 — Thu, 27 Aug 2009 16:46:00 GMT+8

第十六章改进控制器和视图

第2版的 R4RMusic 的控制器动作及相应模版总结

控制器	描述	动作方法名	主模板
Customer	登录注销注册一个新帐号给购物车添加一个版本查看购物车结帐（购买完毕）	login logout signup add_to_cart view_cart check_out	main/welcome.rhtml main/welcome.rhtml main/welcome.rhtml customer/view_cart.rhtml customer/view_cart.rhtml customer/check_out.rhtml
Main	欢迎访问者显示给定时代的所有作品	welcome show_period	main/welcome.rhtml main/show_period.rhtml
Composer	显示某作曲者作品的所有版本	show	composer/show.rhtml
Edition	显示版本的详细出版信息	show	edition/show.rhtml
Instrument	显示给定乐器的所有作品	show	instrument/show.rhtml
Work	显示给定作品的所有版本	show	work/show.rhtml

R4RMusic 最终版下载：http://kerryas.googlecode.com/files/r4rmusic.rar

一、为视图模板定义辅助方法

1. 组织和访问定制的辅助方法

在 app/helper 目录下是对于每个控制器的辅助文件 controller_helper.rb，例如，composer_helper.rb 包含下面内容

module ComposerHelper

end

把方法定义到辅助文件中可以有助于减少重复代码，可以编写一个自动产生链接的辅助方法

module ComposerHelper

def link_to_composer(composer)

link_to (composer.whole_name,

:controller => "composer",

:action => "show",

:id => composer.id)

end

下面是如何在模版中使用这个新的 link_to_composer 方法的例子

<% @composers.each do |composer| %>

<%= link_to_composer(composer) %>

<% end %>

使用其它辅助文件中的方法

方法一：在辅助方法的控制器中，将该方法声明为 helper，例如

class MainController < ApplicationController

helper :composer

# etc.

end

方法二：把辅助文件放到通用的辅助文件 application_helper.rb 中，这样对于所有的控制器和模版来说这些方法都是可见的。

2. 为 R4RMusic 定制的辅助方法

方法

定义于

通过 helper 包含到这些控制器中

link_to_composer

link_to_work

link_to_edition

link_to_edition_title

link_to_instrument

two_dec

composer_helper.rb

work_helper.rb

edition_helper.rb

instrument_helper.rb

application_helper.rb

customer, edition, main

composer, customer, edition, instrument, main

customer, work

composer, instrument

main

可被所有控制器访问

下面是前五个辅助方法的定义：

def link_to_composer(composer)

link_to(composer.whole_name,

:controller => "composer",

:action => "show",

:id => composer.id)

end

def link_to_edition(edition)

link_to edition.description,

:controller => "edition",

:action => "show",

:id => edition.id

end

def link_to_edition_title(edition)

link_to edition.nice_title,

:controller => "edition",

:action => "show",

:id => edition.id

end

def link_to_work(work)

link_to(work.nice_title,

:controller => "work",

:action => "show",

:id => work.id)

end

def link_to_instrument(instrument)

link_to instrument.name,

:controller => "instrument",

:action => "show",

:id => instrument.id

end

第六个辅助方法将一个浮点数转换为一个包含两个十进制小数的字符串

module ApplicationHelper

def two_dec(n)

sprintf("%.2f", n)

end

二、编码和部署部分视图模板

1. 剖析主模板

首先查看 composer/show.html.erb 模板文件

<% @page_title = "Editions of works by #{@composer.whole_name}" %>

<%= @page_title %>

Click on any edition to see details.

<%= render :partial => "editions" %>

其中 render 方法检查部分模版名字，在它前面添加一下划线，在它后面添加一个 .html.erb 后缀，下面是 composer/_editions.html.erb

<% @composer.editions.map do |edition| %>

<%= link_to_edition_title(edition) %>

(<%= edition.publisher.name %>, <%= edition.year %>)

<% end %>

2. 在欢迎视图模板中使用部分模版

（1）生成作曲者链接清单

创建作曲者链接清单 composer/_list.html.erb

<% @composers.each do |composer| %>

<%= link_to_composer(composer) %>

<% end %>

将下面这一行放到主模板 main/welcome.html.erb 中

<%= render :partial => "composer/list" %>

（2）生成乐器链接清单

部分模版 instrument/_list.html.erb

<% @instruments.each do |instrument|%>

<%= link_to_instrument(instrument) %>

<% end %>

创建 instrument 控制器：

F:\ruby_project\R4Rmusic>ruby script/generate controller instrument show

完成 instrument_controller.rb 文件：

class InstrumentController < ApplicationController

helper :work, :edition

def show

@instrument = Instrument.find(params[:id])

end

（3）生成音乐时代的链接清单

产生音乐时代的链接清单 main/_period_list.html.erb

<% @periods.each do |period| %>

<%= link_to period,

                           :controller => "main",

                           :action     => "show_period",

                           :id         => period %>

                   <% end %>

我们也需要为在 welcome 模板中加入部分模板

<%= render :partial => "period_list" %>

（4）完整的欢迎模板（views/main/welcome.html.erb）

<% if @c %>

Welcome, <%= @c.first_name %>.

<% end %>

Browse works by...

...Period	...Composer	...Instrument
<%= render :partial => "period_list" %>	<%= render :partial => "composer/list" %>	<%= render :partial => "instrument/list" %>

...Period

...Composer

...Instrument

<%= render :partial => "period_list" %>

<%= render :partial => "composer/list" %>

<%= render :partial => "instrument/list" %>

<% if @c %>

<%= render :partial => "favorites" %>

<% else %>

Log in or create an account

Log in to your account	Sign up for an account
<%= render :partial => "customer/login" %>	<%= render :partial => "customer/signup" %>

<% end %>

三、更新主控制器

Welcome 动作新面孔（main_controller.rb）：

class MainController < ApplicationController

helper :work, :composer, :instrument

def welcome

@composers = Composer.find(:all).sort_by do |composer|

[composer.last_name, composer.first_name, composer.middle_name]

end

@periods = Work.all_periods

@instruments = Instrument.find(:all, :order => "name ASC" )

end

def show_period

@period = params[:id]

works = Work.find(:all).select do |work|

(work.period == @period) || (work.century == @period)

end

@editions = Edition.of_works(works)

end

四、加入顾客注册的登录动作

1. 登录和注册部分模板

（1）注册模板 customer/_signup.html.erb

<% form_tag :controller => "customer",

:action => "signup" do %>

First name: <%= text_field "customer", "first_name" %>

Last name: <%= text_field "customer", "last_name" %>

User name: <%= text_field "customer", "nick" %>

Password: <%= password_field "customer", "password" %>

Email address: <%= text_field "customer", "email" %>

<% end %>

（2）登录模板 customer/_login.html.erb

<% form_tag :controller => "customer",

:action => "login" do %>

User name: <%= text_field "customer", "nick" %>

Password: <%= password_field "customer", "password" %>

<% end %>

2. 登录和保存会话状态

def login

pw,nick = params[:customer].values_at(*%w{password nick})

c = Customer.find_by_nick(nick)

if c && Digest::SHA1.hexdigest(pw) == c.password

@session['customer'] = c.id

redirect_to :controller => "main", :action => "welcome"

else

report_error("Invalid login")

end

3. 用 before_filter 看守动作（ApplicationController.rb）

class ApplicationController < ActionController::Base

layout("base")

before_filter :get_customer

def get_customer

if session['customer']

@c = Customer.find(session['customer'])

end

如果 session 中已经保存了用户的 ID ，那么数据库中可以查找出该对象则 @c 不为空，否则 @c 为空那么，主界面中显示提示用户登录：

<% if @c %>

<%= render :partial => "favorites" %>

<% else %>

Log in or create an account

# display of login and signup forms handled here

<% end %>

我们还希望过滤器能在顾客没有登录的情况下拦截请求动作（CustomerController.rb）

before_filter :authorize, :except => ["signup","login"]

def authorize

return true if @c

report_error("Unauthorized access; password required")

end

其中 report_error 是一个自制的、通过错误报告方法，被定义在 application.rb 中

class ApplicationController < ActionController::Base

# prior code here, then:

private

def report_error(message)

@message = message

render("main/error")

return false

end

该方法把传入的消息赋值给 @message 实例变量，呈现在 app/views/main/error.html.erb

4. 实现注册功能（CustomerController.rb）

def signup

c = Customer.new(params[:customer])

c.password = Digest::SHA1.hexdigest(c.password)

c.save

session['customer'] = c.id

redirect_to :controller => "main", :action => "welcome"

end

使用 before_filter 技术，进行表单数据的验证，创建一个 new_customer 的过滤器，仅让它在 signup 动作之前作为过滤器执行

before_filter :new_customer, :only => ["signup"]

def new_customer

applicant = params[:customer]

if Customer.find_by_nick(applicant['nick'])

report_error("Nick already in use. Please choose another.")

elsif Customer.find_by_email(applicant['email'])

report_error("Account already exists for that email address")

end

5. 编写顾客注销脚本（在 app/view/layout/base.html.erb 中加入注销按钮，加在 body 中）

<% if @c %>

<% end %>

<%= link_to "Home",

:controller => "main",

:action => "welcome" %>

<%= link_to "View cart",

:controller => "customer",

:action => "view_cart" %>

<%= link_to "Log out",

:controller => "customer",

:action => "logout" %>

五、处理顾客订单

首先为 app/controllers/customer_controller.rb 添加一个动作

def view_cart

end

然后实现 view_cart.html.erb 视图

<% @page_title = "Shopping cart for #{@c.nick}" %>

<%= render :partial => "cart" %>

以下是购物车视图的 customer/_cart.html.erb 部分模板

<% @c.editions_on_order.each do |edition| %>

<% count = @c.copies_of(edition) %>

<% end %>

Title Composer Publisher Price Copies Subtotal

<%= link_to_edition_title(edition) %>

Title	Composer	Publisher	Price	Copies	Subtotal
<%= link_to_edition_title(edition) %>	<% edition.composers.each do \|composer\| %> <%= link_to_composer(composer) %> <% end %>	<%= edition.publisher.name %>	<%= two_dec(edition.price) %>	<%= count %>	<%= two_dec(edition.price * count) %>
TOTAL	<%= two_dec(@c.balance) %>

<% edition.composers.each do |composer| %>

<%= link_to_composer(composer) %>

<% end %>

<%= edition.publisher.name %>

<%= two_dec(edition.price) %>

<%= count %>

<%= two_dec(edition.price * count) %>

TOTAL <%= two_dec(@c.balance) %>

<%= link_to("Complete purchases",

:controller => "customer",

:action => "check_out") %>

2. 查看和购买一个版本

查看版本的主模板，edition/show.html.erb

<% @page_title = @edition.nice_title %>

<%= @page_title %>

<%= render :partial => "details" %>

查看版本的部分模板，edition/_details.html.erb 部分模板

Edition: <%= @edition.description %>

Publisher: <%= @edition.publisher.name %>

Year: <%= @edition.year %>

Price: <%= two_dec(@edition.price) %>

<% if @c %>

<%= link_to "Add to cart",

              :controller => "customer",

              :action     => "add_to_cart",

              :id         => @edition.id %>

<% end %>

Thanks for your order, <%= @c.first_name %>!

六、通过动态代码使页面人性化

1. 从排名到喜好

在 app/models/customer.rb 中定义

def rank(list)

list.uniq.sort_by do |a|

list.select {|b| a == b }.size

end.reverse

end

def composer_rankings

rank(edition_history.map {|ed| ed.composers }.flatten)

end

def instrument_rankings

rank(work_history.map {|work| work.instruments }.flatten)

end

def favorites(thing,options)

limit = options[:count]

rankings = send("#{thing}_rankings")

return rankings[0,limit].compact

end

其中 favorites 方法根据 thing 参数动态选择用户喜好，给定的 count 选择数组相应的条目。如果该值比排名方法返回的数组 size 要大，那么用 nil 进行填充，最后 compact 将删除这些 nil。

2. 实际使用中的 favorites 特性

最后让我们来实现 main/_favorites.html.erb 部分模板

Your favorites

<% fav_composers = @c.favorites :composer,

:count => 3 %>

<% fav_instruments = @c.favorites :instrument,

:count => 3 %>

<% fav_composers.each do |composer| %>

<%= link_to_composer(composer) %>

<% end %>

<% fav_instruments.each do |instrument| %>

<%= link_to_instrument(instrument) %>

<% end %>

至此 Ruby For Rails 最佳实践系列教程全部结束，欢迎广大 RoR 学习和爱好者多提宝贵意见！

---- FL车在臣

[RoR] Ruby for Rails 最佳实践ⅩⅤ[FL车在臣]

FL车在臣 — Thu, 27 Aug 2009 16:41:36 GMT+8

第十五章通过编程改进 ActiveRecord 模型

一、软模型改进与硬模型改进

1. 当在 ActiveRecord 模型类中编写一个新方法时，可以把方法区分为：被动方法（即那些仅仅获取数据并返回数据的方法）和主动方法（即那些生成新的数据结构的方法）

class Composer < ActiveRecord::Base

has_many :works

# 软改进

def editions

works.map {|work| work.editions }.flatten.uniq

end

# 硬改进

def whole_name

first_name + " " +

(if middle_name then middle_name + " " else "" end) +

last_name

end

2. 软模型改进与硬模型改进：本质区别

本质区别在于：软改进描述给 ActiveRecord 提供辅助；硬改进涉及产生新的数据。

二、模型的软编程改进

1. 通过软改进细化 Work 模型

（1）哪些发行商发行过该作品的版本

def publishers

editions.map {|e| e.publisher}.uniq

end

（2）该作品来自哪个国家

def country

composer.country

end

（3）哪些顾客订购过该作品

def ordered_by

editions.orders.map {|o| o.customer }.uniq

end

（4）该作品的基调是什么

def key

kee

end

2. 为顾客的业务建模

（1）该顾客有哪些未完成的订单

def open_orders

orders.find(:all, :conditions => "status = 'open'")

end

（2）该顾客当前订单中包含哪些版本

def editions_on_order

open_orders.map {|order| order.edition }.uniq

end

（3）该顾客曾经订购过哪些版本

def edition_history

orders.map {|order| order.edition }.uniq

end

（4）该顾客当前订单中包含哪些作品

def works_on_order

editions_on_order.map {|edition| edition.works }.flatten.uniq

end

（5）该顾客曾经订购过哪些作品

def work_history

edition_history.map {|edition| edition.works }.flatten.uniq

end

3. 改进 composer

（1）该作曲者的作品出现在哪些版本中

def editions

works.map {|work| work.editions }.flatten.uniq

end

（2）哪些发行商发行过包含该作曲者作品的版本

def publishers

editions.map{|edition| edition.publisher }.uniq

end

4. 对比软改进过程中的 Ruby 和 SQL

最高效、最快速的数据库记录提取方式是 SQL 代码。ActiveRecord 做的很多工作就是私底下将你的 Ruby 代码翻译为 SQL 语句，然后使用这些语句查询数据库。

为了提高执行速度，ActiveRecord 允许任何时候都可以使用 SQL。可是这样就失去了良好的 Ruby 外观，却获得了效率。

作为对比 Ruby/SQL 的例子，我们来看一下 Composer#editions 方法：

def editions

works.map {|work| work.editions }.flatten.uniq

end

该方法首先调用 works，无条件地搜集该作曲者的所有作品。调用 works 方法之后，ActiveRecord 的任务就完成了；该方法也是唯一的一个数据库查询，返回该作曲者的所有作品。剩下的都是纯 Ruby 代码：获取作品的所有版本（使用map），这些信息被存放在一个数组的数组中，然后使用 flatten 和 uniq 对该数组进行处理。最后，得到一个新数组。

下面是实现 editions 方法的另一种方式，使用 SQL 语句

def editions

Edition.find_by_sql("SELECT edition_id from editions_works

LEFT JOIN works ON editions_works.work_id = works.id

LEFT JOIN composers ON works.composer_id = composers.id

WHERE (composers.id = #{id})")

end

Ruby 程序员在使用 Ruby 编写程序时，知道它不是特别快的语言；在碰到严重的性能瓶颈时，他们把程序的某些部分编写为 C 扩展。而在 Rails 应用开发中，SQL 也扮演着类似的角色。

三、硬模型改进

1. 美化字符串属性（Work 类）

（1）调整作品的各乐器名的格式

def nice_instruments

instrs = instruments.map {|inst| inst.name }

ordered = %w{ flute oboe violin viola cello piano orchestra }

instrs = instrs.sort_by {|i| ordered.index(i) || 0 }

case instrs.size

when 0

nil

when 1

instrs[0]

when 2

instrs.join(" and ")

else

instrs[0...-2].join(", ") + ", and " + instrs[-1]

end

代码中使用了 %w{…} 构造一个字符串数组，用于存放规范的乐器名顺序

ordered = %w{ flute oboe violin viola cello piano orchestra }

接着，根据 ordered 数组中各个乐器的出现顺序（乐器名在数组中的索引序号）对 instrs 排序，如果出现不存在的乐器名，则它将出现在排序结果的最后面

instrs = instrs.sort_by {|i| ordered.index(i) || 0 }

（2）调整作品号的格式

def nice_opus

if /^\d/.match(opus)

"op. #{opus}"

else

opus

end

（3）美化的作品标题

def nice_title

t,k,o,i = title, key, nice_opus, nice_instruments

"#{t} #{"in #{k}" if k}#{", #{o}" if o}#{", for #{i}" if i}"

end

（4）美化的版本标题（Edition.rb）

def nice_title

(title || works[0].nice_title) +

" (#{publisher.name}, #{year})"

end

2. 计算作品的年代（Work 类）

（1）作品出自哪个世纪

def century

c = (year - 1).to_s[0,2].succ

c += case c

when "21" then "st"

else "th"

end

c + " century"

end

（2）作品的更富描述性的时代信息

在 Work 类中定义一个常量

PERIODS = { [1650..1750, %w{ EN DE FR IT ES NL}] => "Baroque",

[1751..1810, %w{ EN IT DE NL }] => "Classical",

[1751..1830, %w{ FR }] => "Classical",

[1837..1901, %w{ EN }] => "Victorian",

[1820..1897, %w{ DE FR }] => "Romantic" }

然后加入该方法

def period

pkey = PERIODS.keys.find do |yrange, countries|

yrange.include?(year) && countries.include?(country)

end

PERIODS[pkey] || century

end

3. 剩余的顾客业务（Customer 类）

（1）顾客喜好排名

def rank(list)

list.uniq.sort_by do |a|

list.select {|b| a == b }.size

end.reverse

end

def composer_rankings

rank(edition_history.map {|ed| ed.composers }.flatten)

end

def instrument_rankings

rank(work_history.map {|work| work.instruments }.flatten)

end

（2）计算订购的副本的数目

def copies_of(edition)

orders.find(:all, :conditions => "edition_id = #{edition.id}").size

end

（3）未偿余额

方法一：

def balance

acc = 0

open_orders.each do |order|

acc += order.edition.price

end

"%.2f" % acc

end

方法二（递增的累计计算可以使用 inject 方法自动完成）：

def balance

"%.2f" % open_orders.inject(0) do |acc,order|

acc + order.edition.price

end

（4）顾客结帐

方法一：

def check_out

orders.each do |order|

order.status = "paid"

order.update

end

方法二：

def check_out

orders.each do |order|

order.update_attribute(:status, "paid")

end

四、用类方法扩展模型功能

1. 确定一组作品的所有版本（app/models/edition.rb）

def Edition.of_works(works)

works.map {|work| work.editions }.flatten.uniq

end

2. 获取库存作品的所有时代（app/models/work.rb）

def Work.all_periods

find(:all).map {|c| c.period }.flatten.uniq.sort

end

3. 确定作品的销售排名（app/models/work.rb）

def Work.sales_rankings

r = Hash.new(0)

find(:all).each do |work|

work.editions.each do |ed|

r[work.id] += ed.orders.size

end

散列是无序的，要使用这个散列，还需要对它进行排序：

rankings = Work.sales_rankings

r_sorted = rankings.sort_by {|key,value| value }

4. 确定作曲者的销售排名（app/models/composer.rb）

def Composer.sales_rankings

r = Hash.new(0)

Work.sales_rankings.map do |work,sales|

r[work.composer.id] += sales

end

[RoR] Ruby for Rails 最佳实践ⅩⅣ[FL车在臣]

FL车在臣 — Thu, 27 Aug 2009 16:37:04 GMT+8

第四部分结合 Ruby 和 Rails

第十四章再次为 R4RMusic 应用领域建模

一、跟踪 ActiveRecord 模型实例的功能

1. 模型实例功能概览：Rails 模型实例的功能来源于四个地方

■ 通过实例所属的类继承，该实例可以调用所属类的父类（即 ActiveRecord::Base 或该类的另外一个后代）的实例方法。

■ 根据相关的数据库表的字段名自动生成的读写方法（accessor）和其它方法。举例来说，由于数据库表 composers 中有 title 字段，所以 Composer 的对象具有 title 和 title= 方法。

■ 在使用关联指令时，半自动生成的读写方法和其它方法。例如，在 Work 类中的 has_one: composer。

■ 通过编程添加的任意多个实例方法，它们根据需要被添加到模型定义文件中。

2. 继承的和自动获得的 ActiveRecord 模型实例行为

（1）ActiveRecord 对象的两种存在方式

ActiveRecord 和典型的 Ruby 对象之间是有差别的，ActiveRecord 对象有两种存在方式：一方面，它是一个 Ruby 类。另一方面，它是一个句柄，可以用它来直接操作数据库记录。

ActiveRecord 的类方法和实例方法，以及它们与对象和数据库记录的存在状态之间的关系

	new	create (new+save)	find	save	update	delete (find+destroy)	destroy
方法调用前：
Ruby 对象存在吗？	不存在	不存在	不存在	存在	存在	不存在	存在
数据库记录存在吗？	不存在	不存在	存在	存在	存在	存在	存在
方法调用后：
Ruby 对象存在吗？	存在	存在	存在	存在	存在	存在冻结	存在冻结
数据库记录存在吗？	不存在	存在	存在	存在	存在	不存在	不存在

■ 方法被调用前没有对象存在的方法是类方法（可以根据没有对象实例调用它们来判断）。

■ 冻结意味着已经通过 Ruby 的 freeze 方法将对象实例冻结。这保证对象不会再被改变，不能再给它的实例变量赋值。在销毁一个 ActiveRecord 对象后，它会被冻结。尽管可以从数据库中彻底删除记录，但是 Ruby 中没有相应的可以彻底地删除对象的操作。因此，冻结它就是最好的指示它的生命期已经结束的方法。

■ update、delete 和 destroy 各自有一个以 _all 结尾的变体（update_all 等），它们对数据库中所有已存的记录或相应的 Ruby 实例执行给定的操作。

（2）根据数据库中的字段名自动生成的方法

ActiveRecord 将数据库的结构和名字都映射到 Ruby 中，将表名映射为类名，字段名映射为实例方法。Rails 是一个对象关系映射系统（ORM，Object/Relational Mapping）。

3. 通过关联半自动获得的行为

关联准确生动地描述了 Rails 实体模型之间的“有”和“属于”关系。如 Composer 类中包含 has_many :works，以及 Work 类中包含 belongs_to :composer。

我们没有定义 has_many 方法，所以它肯定是父类 ActiveRecord::Base 的类方法，其它的关联和有 belongs_to、has_one 和 has_and_belongs_to_many。

二、改进领域模型

1. 从 Edition 模型中抽取出 Publisher 模型，并设置发行商和版本之间的关系

F:\ruby_project\R4Rmusic>ruby script/generate model publisher

修改 app/models/publisher.rb 文件

class Publisher < ActiveRecord::Base

has_many :editions

end

创建 publishers 数据表结构

CREATE TABLE publishers (

id INT(11) NOT NULL AUTO_INCREMENT,

name VARCHAR(60),

city VARCHAR(30),

country CHAR(2),

PRIMARY KEY (id)

);

改变后的 editions 表以及新生成的 publishers 表

2. instruments 模型和多对多关系

（1）我们要支持按照乐器分类来浏览乐谱，因此单独创建一个乐器的数据表

F:\ruby_project\R4Rmusic>ruby script/generate model instrument

instruments 模型有两个属性：name（乐器名，如小提琴）和 family（乐器族，如弦乐）

CREATE TABLE instruments (

id INT(11) NOT NULL AUTO_INCREMENT,

name VARCHAR(20),

family VARCHAR(15),

PRIMARY KEY (id)

);

乐器和音乐之间是多对多关系：一件作品可以被多个乐器演奏，一个乐器可以演奏多个作品。

实现多对多关系，首先要为 Rails 提供一个记录乐器和作品关系的表，并遵循 Rails 标准为这张表命名：instruments_works。它有两个字段：一个是针对特定乐器ID字段，另一个是针对特定作品的ID字段

CREATE TABLE instruments_works (

instrument_id int(11),

work_id int(11)

);

（2）使用 has_and_belongs_to_many 关联

修改 app/models/instrument.rb 中的关联指令

class Instrument < ActiveRecord::Base

has_and_belongs_to_many :works

end

添加 app/models/work.rb 中的关联指令

class Work < ActiveRecord::Base

has_and_belongs_to_many :instruments

end

（3）instrument 模型对 work 模型的影响

需要给 Work 模型添加基调（key）属性，但是 key 是 SQL 的关键字，所以改名为 kee。

还需要增加一个作品编号（opus）字段，现在 works 表的 SQL 如下

CREATE TABLE works (

id INT(11) NOT NULL AUTO_INCREMENT,

composer_id INT(11),

title VARCHAR(100),

year INT(4),

kee CHAR(9),

opus VARCHAR(20),

PRIMARY KEY (id)

);

（4）editions 到 works 的多对多映射

一件作品可以出现在多个版本中，一个版本可以包含多件作品。首先把 work_id 从 editions 表中删除，然后增加一个用于保存 works 和 editions 关系的表

CREATE TABLE editions_works (

edition_id int(11),

work_id int(11)

);

修改 ActiveRecord，修改 edition.rb 中的 belongs_to :work

has_and_belongs_to_many :works

在 work.rb 中加入下面代码（:order 告诉 ActiveRecord 把返回的版本按年份升序排序）

has_and_belongs_to_many :editions,

:order => "year ASC"

3. 创建顾客和订单模型

（1）我们将让顾客做下面这些事：

■ 注册

■ 登录

■ 选择商品并将其放入购物车中

■ 结帐（购买商品）

在 Rails 方面，需要为 customer 模型生成模型和控制器

F:\ruby_project\R4Rmusic>ruby script/generate model customer

F:\ruby_project\R4Rmusic>ruby script/generate controller customer

在数据库方面，创建顾客模型的 SQL 表结构

CREATE TABLE customers (

id INT(11) NOT NULL AUTO_INCREMENT,

first_name VARCHAR(30),

last_name VARCHAR(30),

nick VARCHAR(15),

password VARCHAR(40),

email VARCHAR(50),

PRIMARY KEY (id)

);

（2）创建定单模型

F:\ruby_project\R4Rmusic>ruby script/generate model order

为记录订单时间，orders 表有一个名为 created_at 字段。该字段名在 Rails 中是一个特殊的字段名：在保存 Order 对象时，Rails 自动将保存操作发生的时间和日期。Order 模型中还包含一个 status 字段，如果订单已经付过款，该字段设置为“paid”，如果订单商品已经发出，则设置为“shipped”

CREATE TABLE orders (

id INT(11) NOT NULL AUTO_INCREMENT,

edition_id INT(11),

customer_id INT(11),

status CHAR(4),

created_at DATETIME,

PRIMARY KEY (id)

);

（3）建立 orders 与 customers 和 editions 的关联

修改 app/models/orders.rb 文件

class Order < ActiveRecord::Base

belongs_to :customer

belongs_to :edition

end

修改 app/models/customer.rb 文件，并创建依赖关系：如果顾客记录不存在，那么他的订单也随之删除，一旦所属的记录被删除，这些无主记录就没有用了。

class Customer < ActiveRecord::Base

has_many :orders,

:dependent => true,

:order => "created_at ASC"

end

最后在 edition 模型中，也要为 orders 添加一个关联

class Edition < ActiveRecord::Base

has_many :orders

end

4. 为订单设置默认状态

在 Order 类中定义 before_create 方法，在每次保存新模型实例时，自动调用该方法

def before_create

self.status = "open"

end

5. 图示新的领域模型

[RoR] Ruby for Rails 最佳实践ⅩⅢ[FL车在臣]

FL车在臣 — Thu, 27 Aug 2009 16:32:47 GMT+8

第十三章 Ruby 动态特性

一、单例类的位置和角色

1. 单例方法在何处定义

对象的单例方法定义在对象单例类中。每个对象实际上有两个类：

■ 多个对象实例共享的类

■ 单例类

可以将某个对象的单例类看作是它独有的方法保护区，仅属于该对象，其它对象不能分享

obj = Object.new

def obj.talk

puts "Hi!"

end

obj.talk

2. 直接检查和修改单例类

单例类是匿名的，可以使用 class 关键字的一个特殊形式来完成，class 后面跟一个常量

class C

# method and constant definitions here

end

使用以下面特殊记法来打开单例类的定义体

str = "I am a string"

class << str

def twice

self + " " + self

end

puts str.twice

或者可以这样定义

def str.twice

self + " " + self

end

使用 class << 定义类方法

class Ticket

class << self

def most_expensive(tickets)

# etc.

4. 方法查找路径上的单例类

（1）方法查找的顺序（包含单例类）

（2）可以在单例类中混含模块

class C

end

module M

def talk

puts "Hello."

end

obj = C.new

class << obj

include M

end

obj.talk

第二种方法是使用 extend 进行扩展

obj = C.new

obj.extend(M)

obj.talk

（3）在单例类中混含模块与在对象所属类中混含模块

class C

def talk

puts "Hi from original class!"

end

module M

def talk

puts "Hello from module!"

end

c = C.new

c.talk # 输出：Hi from original class!

class << c

include M

end

c.talk # 输出：Hello from module!

通过使用 ancestors 方法，可以清楚地看到任意类或模块的继承／混含层级结构

c = C.new

class << c

include M

p ancestors

end

输出结果为

[M, C, Object, Kernel]

5. 更深入地学习类方法

class C

end

def C.a_class_method

puts "Singleton method defined on C"

end

class D < C

end

D.a_class_method # 输出：Singleton method defined on C

二、方法族

1. 执行字符串

>> ("2+2")

=> 4

编写一个可以让别人在运行时键入其方法名的方法

print "Method name: "

m = gets.chomp

("def #{m}; puts 'Hi!'; end")

(m)

的危险性：从来没有用过、将来也不打算使用的有经验的、专家级的 Ruby 程序员并不少见。

2. instance_：该方法将 self 变为 instance_ 调用的接收者

p self # 输出：main

a = []

a.instance_ { p self } # 输出：[]

instance_ 常用于访问其它对象的私有数据——特别是实例变量

class C

def initialize

@x = 1

end

c = C.new

c.instance_ { puts @x }

3. 最有用的族方法：class_

（1）class_ （即module_）可以进入类定义体中

C = Class.new

C.class_ do

def some_method

puts "Created in class_"

end

c = C.new

c.some_method

（2）将外围作用的局部变量提供给 class_ 代码块

>> var = "initialized variable"

=> "initialized variable"

>> class C

>> puts var

>> end

NameError: undefined local variable or method `var' for C:Class

from (irb):3

>> C.class_ { puts var }

initialized variable

（3）如果想把外部作用域的变量硬塞到实例方法中，可以使用另外一种技术来生成方法

>> C.class_ { define_method("talk") { puts var } }

=> #

三、可调对象

1. Proc 对象

（1）用一个代码块来实例化 Proc 类，可以产生一个 Proc 对象

pr = Proc.new { puts "Inside a Proc's block" }

执行该代码块（Proc 对象）需要显式地调用

pr.call # 输出：Inside a Proc's block

2. 作为闭包的 Proc 对象

def call_some_proc(pr)

a = "irrelevant 'a' in method scope"

puts a

pr.call

end

a = "'a' to be used in Proc block"

pr = Proc.new { puts a }

pr.call

call_some_proc(pr)

输出结果（Proc 对象随身携带了它的上下文，称为闭包）

'a' to be used in Proc block

irrelevant 'a' in method scope

'a' to be used in Proc block

3. Proc 对象的参数

（1）传递和接收参数

pr = Proc.new {|x| puts "Called with argument #{x}" }

pr.call(100) # 输出: Called with argument 100

（2）多个参数的调用

>> pr = Proc.new {|x,y,z| p x,y,z }

=> #

>> pr.call(1,2)

nil

>> pr.call(1,2,3,4)

（3）使用星号操作符（*）将所有的参数合并为一个参数（参数变量 x 被设置为一个数组）

pr = Proc.new {|*x| p x }

pr.call

pr.call(1)

pr.call(1,2)

这段代码的输出

[]

[1]

[1, 2]

让 Proc 对象接受多个参数，而且最后一个参数具有合并多个参数的能力

pr = Proc.new {|x,*y| p x, y }

pr.call(1,2,3)

输出为

[2, 3]

4. 用 lambda 关键字生成匿名函数

（1）lambda 关键字可以用来生成匿名函数，然后可以给它发送“call”消息执行函数

>> lam = lambda { puts "A lambda!" }

=> #

>> lam.call

A lambda!

正如我们所看到的，lambda 不是 Lambda 类的对象，它们是 Proc 类的对象

>> lam.class

=> Proc

和所有的 Proc 对象一样，lambda 都是闭包。

（2）lambda 和 Proc 对象的差别与 return 关键字有关

def return_test

l = lambda { return }

l.call

puts "Still here!"

p = Proc.new { return }

p.call # 跳出方法体

puts "You won't see this message!"

end

return_test

此例可见，lambda 中的 return 从 lambda 返回，而 Proc 中的 return 从外围方法返回

5. 再论代码块

可以在方法中将代码块转换成 Proc 对象，通过一个变量捕获代码块，该变量是方法参数列表中的一个参数变量，它的名字必须以 & 开头

def grab_block(&block)

block.call

end

grab_block { puts "This block will end up in the variable 'block'" }

&block 变量必须是参数列表中的最后一项

def grab_block(x,y,*z,&block)

可以反过来将 Proc 对象或 lambda 转换为一个代码块，使用 & 可以达到此目的

lam = lambda { puts "This lambda will serve as a code block" }

grab_block &lam

下面是另一种方式

grab_block &lambda { puts "This lambda will serve as a code block" }

6. 作为对象的方法

通过 method 方法，并以方法名作为参数，就可以得到一个方法对象

class C

def talk

puts "Method-grabbing test! self is #{self}."

end

c = C.new

meth = c.method(:talk)

调用它自己

meth.call # 输出：Method-grabbing test! self is #

可以将方法和它所绑定的对象解绑定(unbind)，然后再将它绑定到另一个对象上（bind）

class D < C

end

d = D.new

unbound = meth.unbind

unbound.bind(d).call

如果想直接得到解绑定的方法对象，而本想通过已绑定的方法使用 unbind 来得到方法对象，则可以使用 instance_method 方法

unbound = C.instance_method(:talk)

绑定和解绑定技术的使用范例

class A

def a_method

puts "Definition in class A"

end

class B < A

def a_method

puts "Definition in class B (subclass of A)"

end

class C < B

end

c = C.new

c.a_method # 输出：Definition in class B (subclass of A)

默认情况下，实例会执行它在方法查找路径上找到的第一个匹配的方法；

有没有办法让最底层的类实例，在接收到消息“a_method”时执行该方法

A.instance_method(:a_method).bind(c).call # 输出：Definition in class A

可以将此行为放在类 C 的一个方法中

class C

def call_original

A.instance_method(:a_method).bind(self).call

end

四、回调方法和钩子方法

1. 用 method_missing 拦截不能识别的消息

method 是一张安全网：提供了拦截不可响应的消息并对其进行适当处理的办法

class C

def method_missing(m)

puts "There's no method called #{m} here -- please try again."

end

C.new.anything

2. 用 Module#included 捕捉混含操作

module M

def self.included(c)

puts "I have just been mixed into #{c}."

end

class C

include M

end

当 M 被混含到 C 中时，消息“I have just been mixed into C.”

3. 用 Class#inherited 拦截继承

class C

def self.inherited(subclass)

puts "#{self} just got subclassed by #{subclass}"

end

class D < C

end

当 D 继承 C 时自动触发对 inherited 的调用，因此该代码产生下面的输出

C just got subclassed by D

4. 用 Module#const_missing 拦截引用不可识别的常量

class C

def self.const_missing(const)

puts "#{const} is undefined—setting it to 1."

const_set(const,1) ＃如果常量不存在，则将它设置为系统常量

end

puts C::A

a is undefined—setting it to 1.

五、覆盖和增加核心功能

Ruby 最强大的特性之一是可以修改和增强语言核心功能。可以像打开你自己的类那样，很容易地打开和修改核心类。可以按照自己的意愿为它添加方法或覆盖旧的方法。

但是，当你在自己的程序中对 Ruby 核心做出改变时，必须非常非常小心，。如果编写提供给别人使用的代码库，而库中包含了改变核心类和对象的代码，那么对每个使用你的代码人来说，你修改了游戏规则。

[RoR] Ruby for Rails 最佳实践Ⅻ[FL车在臣]

FL车在臣 — Thu, 27 Aug 2009 16:27:07 GMT+8

第十二章正则表达式和基于它的字符串操作

一、什么是正则表达式

正则表达式可用于：在字符串中扫描某个模式的多次出现，进行字符串替换操作，基于匹配分界符将一个字符串分割为多个子字符串。

二、编写正则表达式

1. 正则表达式的字面构造方法

（1）字面构造方法就是一对正斜杠：//

（2）可以从两个方向使用 match：正则表达式对象和字符串对象都可以响应 match方法

puts "Match!" if /abc/.match("The alphabet starts with abc.")

puts "Match!" if "The alphabet starts with abc.".match(/abc/)

Ruby 还提供了模式匹配操作符 =~（等号加波浪号）

puts "Match!" if /abc/ =~ "The alphabet starts with abc."

puts "Match!" if "The alphabet starts with abc." =~ /abc/

（3）match 与 =~ 的主要不同之处在于匹配时的返回值不同：

=~ 返回匹配开始处的字符在字符串中的数值索引，而 match 返回 MatchData 类的实例

>> "The alphabet starts with abc" =~ /abc/

=> 25

>> /abc/.match("The alphabet starts with abc.")

=> #

2. 构造一个模式

（1）可以来构造正则表达式的组件包括以下几个：

■ 字面字符，表示“与该字符匹配”

■ 圆点通配符（.），表示“与任意一个字符匹配”

■ 字符类，表示“与这些字符中的某一个匹配”

（2）特殊字符

对于有特殊意义的字符来说，要匹配这些特殊字符本身，需要使用反斜杠（\）来对它们进行转义：^, $, ? , ., /, \, [, ], {, }, (, ), +, *

（3）通配字符.（圆点）：匹配除换行以外的任意一个的字符

（4）字符集：/[dr]ejected/ 匹配 d 或 r，其后接 ejected

在字符集中可以插入字符范围：/[a-z]/

为了与一个十六进制数字匹配，需要在字符集中使用多个字符范围：/[A-Fa-f0-9]/

非十六进制数字匹配的字符集，使用补集：/[^A-Fa-f0-9]/

（5）常见字符集的特殊转义序列

\d 与任何数字相匹配

\w 与任何数字、字母或下划线相匹配

\s 与任何空白字符（空格、制表符、换行符）相匹配

这些预定义字符集每一个都有一个补集

\D 与任何一个非数字相匹配

\W 与任何数字、字母或下划线之外的任何一个相匹配

\S 与任何一个非空白字符相匹配

三、关于匹配和 MatchData 的更多内容

1. 正则表达式构造的最重要技术之一是使用小括号来指定“捕获”，为了对字符串的某部分做些处理，捕获记法可以分离出与特定的子模式匹配的字符串并保存

str = "Peel,Emma,Mrs.,talented amateur"

/([A-Za-z]+),[A-Za-z]+,(Mrs?\.)/.match(str)

puts $1 # 输出：Peel

puts $2 # 输出：Mrs.

Ruby 自动填写了这些变量为全局变量，它们以数字作为名字：$1, $2 等等。

2. 匹配成功和匹配失败

（1）匹配一个电话号码并查询作为结果的 MatchData 对象

string = "My phone number is (123) 555-1234."

phone_re = /$(\d{3})$\s+(\d{3})-(\d{4})/

m = phone_re.match(string)

unless m

puts "There was no match--sorry."

exit

end

print "The whole string we started with: "

puts m.string

print "The entire part of the string that matched: "

puts m[0]

puts "The three captures: "

3.times do |index|

puts "Capture ##{index + 1}: #{m.captures[index]}"

end

puts "Here's another way to get at the first capture:"

print "Capture #1: "

puts m[1]

下面是代码输出结果

The whole string we started with: My phone number is (123) 555-1234.

The entire part of the string that matched: (123) 555-1234

The three captures:

Capture #1: 123

Capture #2: 555

Capture #3: 1234

Here's another way to get at the first capture:

Capture #1: 123

（2）获取子匹配的两种方法

从 MatchData 对象中获取子匹配的一种方式是直接索引对象，就像数组那样

完整匹配：m[0]

第一个捕获：m[1]

第二个捕获：m[2]

从 1 开始的这些索引值对应于包含捕获的子字符串的全局变量 $n 中的 n。

MathData 对象还有一个名为 captures 的方法，并且以下等式成立

m[1] == m.captures[0]

m[2] == m.captures[1]

（3）MatchData 的其它信息（电话号码匹配操作的补充代码）

print "The part of the string before the part that matched was:"

puts m.pre_match

print "The part of the string after the part that matched was:"

puts m.post_match

print "The second capture began at character "

puts m.begin(2)

print "The third capture ended at character "

puts m.end(3)

这段代码的输出如下

The string up to the part that matched was: My phone number is

The string after the part that matched was: .

The second capture began at character 25

The third capture ended at character 33

四、更多正则表达式技术

1. 量词和贪婪性

（1）表示“0个或1个”的特殊字符：问号（?）

/Mrs?\.?/ 它将匹配 ”Mr”, “Mrs”, “Mr.”, “Mrs.”

（2）表示“0个或多个”的特殊字符：星号（*）

< /p>

要匹配 HTML 文档中的闭标签

：/<\s*\/\s*p\s*>/

（3）表示“1个或多个”的特殊字符：加号（+）

/\d+/ 匹配一个或多个连续的数字构成的任意序列

（4）贪婪量词和不贪婪量词

量词 * （0个或多个）和 + （1个或多个）是贪婪的：它们会匹配尽可能多的字符

string = "abc!def!ghi!"

match = /.+!/.match(string)

puts match[0] # 输出：abc!def!ghi!

可以通过在后面放置一个问号，使它们成为不贪婪量词

string = "abc!def!ghi!"

match = /.+?!/.match(string)

puts match[0] # 输出：abc!

（5）特定次数的重复

通过将一个数放在大括号 {} 中来达到此目的

/\d{3}-\d{4}/ 将匹配 555-1212

也可以指定一个范围，如 1～10个连续数字的任意字符

/\d{1,10}/

如果要匹配“三次或更多的数字”可以使用

/\d{3,}/

匹配五次连续出现“一个大写字母和一个数字”的模式

/([A-Z]\d){5}/

2. 锚和前视断言

（1）最常见的锚是行首（^）和行尾（$）

要确定哪些行是注释行，可以使用下面的正则表达式：/^\s*#/

（2）正则表达式的锚

记法

描述

示例

匹配的字符串示例

行首

行尾

字符串的开始

字符串的结尾

字符串的结尾（不含换行）

单词边界

/^\s*#/

/\.$/

/\AFour score/

/from the arth.\z/

/from the arth.\Z/

/\b\w+\b/

“ # A Ruby comment line”

“one\ntwo\nthree.\nfour”

“Four score”

“from the earth.”

“from the earth\n”

“!!!word***”(匹配 word )

（3）前视断言

假设要匹配一个数的序列，该序列以一个圆点结束。但是并不想把这个圆点本身作为匹配的一部分。实现该功能可以使用前视断言

str = "123 456. 789"

m = /\d+(?=\.)/.match(str)

现在 m[0] 是 “456”：字符串中其后面紧跟着一个圆点的那个数序列。

下面是对其中一些术语的解释：

■ 零宽度（zero-width）：该断言不会消耗字符串的任何字符。如果是模式继续的话，还可以对圆点进行匹配。

■ 肯定的（positive）意味着想要规定圆点存在（?=…），否定的前视断言（?!...）。

■ 前视断言（lookahead assertion）表示想要知道下一个指定的是什么，但并不匹配。

3. 修饰语：在正则表达式最后加入一个字母：/abc/i

修饰语 i 使该正则表达式的匹配操作是大小写不敏感的。

修饰语 m 使圆点通配符可以与任何字符相匹配，包括换行符。

str = "This (including\nwhat's in parens\n) takes up three lines."

m = /$.*?$/m.match(str)

匹配结果为

(including

what's in parens

)

4. 字符串与正则表达式之间的转换

>> str = "def"

=> "def"

>> /abc#{str}/

=> /abcdef/

在把字符串放入正则表达式之前，可以转义字符串中的特殊字符

>> Regexp.escape("a.c")

=> "a\.c"

>> Regexp.escape("^abc")

=> "\^abc"

将正则表达式转换成字符串：str = /abc/.inspect

五、使用正则表达式的常见方法

1. 要从一个字符串数组中找出所有至少有10个字符而且其中至少有一个数字的字符串：

array.find_all {|e| e.size > 10 and /\d/.match(e) }

2. String#scan

scan 方法扫描一个字符串，重复地进行测试以寻找指定模式的各个匹配，结果返回到一个数组中

>> "testing 1 2 3 testing 4 5 6".scan(/\d/)

=> ["1", "2", "3", "4", "5", "6"]

如果在传递给 scan 的正则表达式中使用了小括号分组，它会返回一个数组的数组

>> str = "Leopold Auer was the teacher of Jascha Heifetz."

=> "Leopold Auer was the teacher of Jascha Heifetz."

>> violinists = str.scan(/([A-Z]\w+)\s+([A-Z]\w+)/)

=> [["Leopold", "Auer"], ["Jascha", "Heifetz"]]

3. String#split

split 方法会将一个字符串分割为几个子字符串

line = "first_name=david;last_name=black;country=usa"

record = line.split(/=|;/)

4. sub/sub! 和 gsub/gsub!

gsub（全局替代）：会遍历整个字符串进行修改；

sub：最多只进行一次替代；

（1）sub 接受两个参数，一个正则表达式（或者字符串）和一个替代字符串

>> "typigraphical error".sub(/i/,"o")

=> "typographical error"

可以使用代码块来取代替代字符串参数

>> "capitalize the first vowel".sub(/[aeiou]/) {|s| s.upcase }

=> "cApitalize the first vowel"

（2）gsub ，与 sub 类似，只要字符串的剩余部分还能够与模式匹配就会继续替代

>> "capitalize every word".gsub(/\b\w/) {|s| s.upcase }

=> "Capitalize Every Word"

（3）在替代字符串中使用子匹配

要修正小写字母后面跟着大写字母这样的错误，可以这样做：

>> "aDvid".sub(/([a-z])([A-Z])/, '\2\1')

=> "David"

如果想将字符串的每一个单词都重复一遍，可以这样写

>> "double every word".gsub(/\b(\w+)/, '\1 \1')

=> "double double every every word word"

5. grep：直接基于正则表达式参数进行选择操作

>> ["USA", "UK", "France", "Germany"].grep(/[a-z]/)

=> ["France", "Germany"]

实际上可以使用 select 完成同样的事

["USA", "UK", "France", "Germany"].select {|c| /[a-z]/.match(c) }

选择一些国家后，将它们转换成大写并放到一个数组中返回

>> ["USA", "UK", "France", "Germany"].grep(/[a-z]/) {|c| c.upcase }

=> ["FRANCE", "GERMANY"]

[RoR] Ruby for Rails 最佳实践Ⅺ[FL车在臣]

FL车在臣 — Tue, 25 Aug 2009 10:59:02 GMT+8

第十一章集合、容器和可枚举性

一、数组和散列的比较

数组是有序的对象集合，有序意味着可以基于连续的数字索引从集合中选择对象。

散列是无序的集合，这意味着不能说第一／第二个或第N个元素是什么。散列将对象以成对的方法存储起来，每一对有一个键和一个值，通过键来索引值。散列在其它语言中有时也叫字典或联合数组。

二、使用数组

1. 创建一个新数组

a = Array.new

a = []

a = [1,2,"three",4, [] ]

用 Array.new 的好处是，允许指定数组的大小，并可对其内容进行初始化

>> Array.new(3)

=> [nil, nil, nil]

>> Array.new(3,"abc")

=> ["abc", "abc", "abc"]

甚至可以为 Array.new 提供代码块

>> n = 0

=> 0

>> Array.new(3) { n += 1; n * 10 }

=> [10, 20, 30]

2. 插入、检索和删除数组元素

（1）一次读写多个数组元素

>> a = ["red","orange","yellow","purple","gray","indigo","violet"]

=> ["red", "orange", "yellow", "purple", "gray", "indigo", "violet"]

>> a[3,2]

=> ["purple", "gray"]

>> a[3,2] = "green", "blue"

=> ["green", "blue"]

>> a

=> ["red", "orange", "yellow", "green", "blue", "indigo", "violet"]

（2）对数组头或尾进行操作的特殊方法

使用 unshift 给数组头部添加一个对象

a = [1,2,3,4]

a.unshift(0) # 结果：[0,1,2,3,4]

使用 push （或 << 方法）给数组屋部添加一个对象

a = [1,2,3,4]

a << 5 # 结果：[1,2,3,4,5]

a.push(6,7,8) # 结果：[1,2,3,4,5,6,7,8]

使用 shift 和 pop 从数组的头和尾删除一个对象

a = [1,2,3,4,5]

print "The original array: "

p a

popped = a.pop

print "The popped item: "

puts popped

print "The new state of the array: "

p a

shifted = a.shift

print "The shifted item: "

puts shifted

print "The new state of the array: "

p a

输出结果如下

The original array: [1, 2, 3, 4, 5]

The popped item: 5

The new state of the array: [1, 2, 3, 4]

The shifted item: 1

The new state of the array: [2, 3, 4]

3. 合并数组

（1）使用 concat 方法，合并多个数组，并且永久性地改变了接收者的内容

[1,2,3].concat([4,5,6])

（2）另一种方法是使用 + 方法进行合并，不改变接收者的内容

[1,2,3] + [4,5,6]

（3）使用 replace 替换数组

>> a = [1,2,3]

=> [1, 2, 3]

>> a.replace([4,5,6])

=> [4, 5, 6]

>> a

=> [4, 5, 6]

此方法与重新赋值是不一样的，在于变量的引用不同

（4）使用 zip 并行遍历两个数组，产生一个新的数组

>> [1,2,3].zip([4,5,6])

=> [[1, 4], [2, 5], [3, 6]]

4. 数组转换

（1）使用 flatten 进行数组的平坦化

>> [1,2,[3,4,[5,6],7],[[[8,9]]]].flatten

=> [1, 2, 3, 4, 5, 6, 7, 8, 9]

（2）使用 reverse 方法反转数组内容（也有一个感叹号版本）

>>[1,2,3,4].reverse

=> [4, 3, 2, 1]

（3）使用 join 方法把数组转换成字符串

>> ["abc", "def", 123].join(", ")

=> "abc, def, 123"

（4）使用 uniq 对数组进行唯一化处理，删除原来数组中重复的元素

>> [1,2,3,1,4,3,5,1].uniq

=> [1, 2, 3, 4, 5]

5. 数组迭代、过滤及查询

（1）数组迭代

[1,2,3,4,5].each {|x| puts x * 10 }

使用 each 方法的变体 each_with_index，在遍历时每次通过匿名调用给代码块传递两个值：当前数组元素及其数组索引（从0开始）

["a","b","c"].each_with_index {|x,i| puts "element #{i} is #{x}" }

输出如下

element 0 is a

element 1 is b

element 2 is c

（2）数组过滤

使用 find 方法，返回第一个满足代码块条件的元素

>> [1,2,3,4,5,6,7,8,9,10].find {|n| n > 5 }

=> 6

使用 find_all （或 select）方法，返回所有满足代码块条件的元素

>> a = [1,2,3,4,5,6,7,8,9,10]

=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>> a.find_all {|item| item > 5 }

=> [6, 7, 8, 9, 10]

>> a.find_all {|item| item > 100 }

=> []

使用 reject 方法找出不满足代码条件的元素

>> a.reject {|item| item > 5 }

=> [1, 2, 3, 4, 5]

（3）常用的数组查询方法

方法名／调用示例

含义

a.size（同义词：length）

a.empty?

a.include?(item)

a.any? { |item| test }

a.all? { |item| test }

数组中元素的个数

a是空数组返回真；否则为假

数组a包含item时为真；否则为假

有一个元素通过测试就为真；否则为假

所有元素都通过测试就为真；否则为假

三、散列

1. 创建一个新的散列

h = {} 或 Hash.new

创建带有数据的散列使用 [] 方法

Hash["Connecticut" => "CT",

"Delaware" => "DE" ]

2. 插入、检索和删除散列键值对

（1）给散列添加键—值对，键值是唯一的

state_hash["New York"] = "NY"

该语句是下面这条语句的糖衣版本

state_hash.[]=("New York", "NY")

也可以使用相同功能的 store 方法来完成

state_hash.store("New York", "NY")

（2）从散列检索值

conn_abbrev = state_hash["Connecticut"]

另一种方法是使用 fetch 方法

conn_abbrev = state_hash.fetch("Connecticut")

注：fetch 与 [] 方法不同之处：查找一个不存在的键时，fetch 抛出异常而 [] 返回 nil。

还可以在一个操作中使用多个键来检索多个值，需要使用 values_at 方法

two_states = state_hash.values_at("New Jersey","Delaware")

结果为 ["NJ","DE"]

3. 指定和获取默认值

>> h = Hash.new(0)

=> {}

>> h["no such key!"]

=> 0

这种方法可以在第一次用到时，自动添加键

如果不想让不存在的键时自动添加到散列，并设置默认值的话，可以这样

h = Hash.new {|hash,key| hash[key] = 0 }

可以这样来触发

>> h["new key!"]

=> 0

>> h

=> {"new key!"=>0}

4. 合并散列

（1）破坏型操作通过方法 update 进行，如果第二个散列与第一个散列有相同的键，那么第一个散列中的键—值对会被永久性地覆盖

h1 = {"Smith" => "John",

"Jones" => "Jane" }

h2 = {"Smith" => "Jim" }

h1.update(h2)

puts h1["Smith"] # 输出: Jim

（2）要进行非破坏型散列合并，需要使用 merge 方法，merge! 与 update 是同义词

h1 = {"Smith" => "John",

"Jones" => "Jane" }

h2 = {"Smith" => "Jim" }

h3 = h1.merge(h2)

p h1["Smith"] # 输出: John

5. 散列转换

（1）反转散列Hash#invert：交换键和值

>> h = { 1 => "one", 2 => "two" }

=> {1=>"one", 2=>"two"}

>> h.invert

=> {"two"=>2, "one"=>1}

（2）清空散列Hash#clear

>> {1 => "one", 2 => "two" }.clear

=> {}

（3）替代散列的内容 replace

>> { 1 => "one", 2 => "two" }.replace({ 10 => "ten", 20 => "twenty"})

=> {10 => "ten", 20 => "twenty"}

6. 散列的迭代、过滤和查询

（1）一个完整的键—值对通过匿名调用以一个两元素数组的形式传给代码块

{1 => "one", 2 => "two" }.each do |key,value|

puts "The word for #{key} is #{value}."

end

输出结果如下

The word for 1 is one.

The word for 2 is two.

（2）迭代遍历所有的键或值

>> h = {1 => "one", 2 => "two" }

=> {1=>"one", 2=>"two"}

>> h.keys

=> [1, 2]

>> h.values

=> ["one", "two"]

也可以直接对键或值进行迭代

h = {"apple" => "red", "banana" => "yellow", "orange" => "orange" }

h.each_key {|k| puts "The next key is #{k}." }

h.each_value {|v| puts "The next value is #{v}." }

（3）散列的过滤操作

>> { 1 => "one", 2 => "two", 3 => "three" }.select {|k,v| k > 1 }

=> [[2, "two"], [3, "three"]]

或使用 find 方法，返回一个元素或 nil

>> {1 => "un", 2 => "deux", 3 => "trois" }.find {|k,v| k == 3 }

=> [3, "trois"]

还可以对散列进行映射操作

>> { 1 => "one", 2 => "two", 3 => "three" }.map {|k,v| v.upcase }

=> ["ONE", "TWO", "THREE"]

7. 常用的散列查询方法及其含义

方法名／调用示例

含义

h.has_key?(1)

h.include?(1)

h.key?(1)

h.member?(1)

h.has_value?("three")

h.value?("three")

h.empty?

h.size

如果h有键为1，则为真

h.has_key? 的同义词

只要 h 有值为 “three”，就为真

has_value? 的同义词

如果h没有任何键-值对，就为真

h中键-值对个数

8. Ruby 和 Rails 方法调用中的散列

<% def mini_link_to(text, specs)

target = "/#{specs[:controller]}/#{specs[:action]}/#{specs[:id]}"

return "#{text}"

end

<%= mini_link_to "Click here",

:controller => "work",

:action => "show",

:id => 1

将这段代码保存到文件 minilink.erb 中，然后使用 ERb 来运行它

$ erb minilink.erb

ERb会填充模板，结果如下所示：

Click here

四、集合的中心：Enumerable 模块

1. 数组和散列都混含了 Enumerable 模块

class c

include Enumerable

def each

# relevant code here

end

2. 通过 each 获得可枚举性

each 的任务就是通过匿名调用将所有的条目传递给一个给定的代码块，每次只传一个。

find、select、reject、map、any? 和 all? 它们的工作方式都调用方法 each：

class Rainbow

include Enumerable

def each

yield "red"

yield "orange"

yield "yellow"

yield "green"

yield "blue"

yield "indigo"

yield "violet"

end

r = Rainbow.new

y_color = r.find {|color| color[0,1] == 'y' }

puts "First color starting with 'y' is #{y_color}."

可以重写为：

class Rainbow

COLORS = ["red", "orange", "yellow", "green",

"blue", "indigo", "violet"]

def each

COLORS.each {|color| yield color }

end

3. 可枚举的字符串

（1）使用 String#each 进行迭代

s = "This is\na multiline\nstring."

s.each {|e| puts "Next value: #{e}" }

这段代码将一个多行字符串（带显式嵌入的换行符\n）赋值给一个变量，然后对这个字符串进行迭代

Next value: This is

Next value: a multiline

Next value: string.

（2）使用 each_byte 进行字符迭代

"abc".each_byte {|b| puts "Next byte: #{b}" }

输出字符的 ASCII 码，如果想把它们转换成字符，可以调用数值的 chr 方法

"abc".each_byte {|b| puts "Next character: #{b.chr}" }

直接对字符进行迭代，创建 String.each_char 方法

class String

def each_char

each_byte { |b| yield b.chr}

end

五、集合排序

1. 数组排序

>> [3,2,5,4,1].sort

=> [1, 2, 3, 4, 5]

2. 对象数组排序

[ed1,ed2,ed3,ed4,ed5].sort

在 Edition 类中定义<=>方法：

def <=>(other_edition)

self.price <=> other_edition.price

end

3. 在代码块中定义排序顺序

year_sort = [ed1,ed2,ed3,ed4,ed5].sort do |a,b|

a.year <=> b.year

end

使用 sort_by 的简洁排序，和 sort 一样，sort_by 也是 Enumerable 的一个实例方法。它们的主要区别是：必须为 sort_by 提供一个代码块，代码块中只需要说明如何对集合中的单个条目进行处理

>> ["2",1,5,"3",4,"6"].sort_by {|a| a.to_i }

=> [1, "2", "3", 4, 5, "6"]

[RoR] Ruby for Rails 最佳实践Ⅹ[FL车在臣]

FL车在臣 — Tue, 25 Aug 2009 10:57:23 GMT+8

第十章标量对象

一、使用字符串

1. 字符串引用机制概要

记号	单引或双引	示例	输出
'	单引	'You\'ll have to "escape" single quotes.'	You’ll have to “escape” single quotes.
"	双引	"You'll have to \"escape\" double quotes."	You’ll have to “escape” double quotes.
%q	单引	%q{'Single-quoted' example—no escape needed.}	Single-quoted’ example—no escape needed.
%Q	双引	%Q{"Double-quoted" example—no escape needed..}	“Double-quoted” example—no escape needed.

2. 字符串操作

（1）合并两个字符串

str = "a" + "b"

str = "a" << "b"

（2）替换字符串的内容

str = "Hi there."

str.replace("Good-bye.")

（3）改写字符串

方法

示例

结果

capitalize

upcase

downcase

swapcase

strip

lstrip

rstrip

chop

chomp

reverse

"ruby".capitalize

"cobol".upcase

"UNIX".downcase

"rUBY".swapcase

" lose the outer spaces "

" lose the left spaces "

" lose the right spaces "

"remove last character"

"remove training newline\n"

" gnirts eht esrever"

"Ruby"

"COBOL"

"unix"

"Ruby"

"lose the outer spaces"

"lose the left spaces "

" lose the right spaces"

"remove last characte"

"remove trailing newline"

"reverse the string"

注：所有这些方法都有相应的感叹号方法

4. 获取字符串的子字符串

字符串有一对读写方法：[]方法和[]=方法

（1）读方法[]

"abc"[2] # 输出：99

"abc"[2].chr # 输出：c

"abc"[-2].chr # 输出：b

"This is a string"[5,4] # 输出：is a

（2）写方法[]=

>> s = "This is a string."

=> "This is a string."

>> s[-1] = "!"

=> "!"

>> s

=> "This is a string!"

>> s[2,2] = "at"

=> "at"

>> s

=> "That is a string!"

5. 比较字符串

（1）比较两个字符串是否相等，最常用的方法 ==

"a" == "a" # 输出：true

"a" == "b" # 输出：false

另一种方法是 String#eql?，如 "a".eql?("a") # 输出：true

第三种方法是 String#equal?，如 "a".equal?("a") # 输出：false，因为两个字符串不是同一个对象

（2）字符串的比较与顺序

太空船方法/操作符（<=>）返回-1表示右边对象较大，1表示左边对象较大，0表示相等。

“a”比”A”要大，因为顺序是基于 ASCII 码值定义的。

二、符号及其用法

1. 符号是 Ruby 内建的 Symbol 的实例，它们的字面构造器是前导冒号

:book

:"Here's how to make a symbol with spaces in it."

还可以通过对字符串调用 to_sym 方法（也可以用同意词 intern），以编程方式创建符号

>> "a".to_sym

=> :a

>> "Converting string to symbol with intern....".intern

=> :"Converting string to symbol with intern...."

也可以很容易将符号转换成字符串

>> :a.to_s

=> "a"

2. 符号与字符串的关键不同：对于任何给定的文本，只存在一个符号对象

>> :a.equal?(:a)

=> true

>> "a".equal?("a")

=> false

字符串与符号之间的另一个重要不同之处是：符号是不可变的，不能对符号的一部分进行增加、删除或改变。

符号在内存和处理时间上是高效的。相反，字符串具备的各种功能（如字符串变长，改变内容，等等）决定了其维护与处理的开销比较大。常常会见到符号被用作方法的参数，尤其是散列的键。

3. 重新讲解 Rails 风格的方法参数

class Work < ActiveRecord::Base

belongs_to :composer

# etc.

其中 :composer 是一个符号，它是 belongs_to 方法的参数。

<%= link_to "Click here",

:controller => "book",

:action => "show",

:id => book.id %>

这是方法参数散列的一个例子，每一个符号都是散列的键，每一个右侧值都是散列的值。

三、数值对象

1. 在 Ruby 中，数是对象。和其它对象一样，可以给它们发送消息。

n = 98.6

m = n.round

puts m

x = 12

if x.zero?

puts "x is zero"

else

puts "x is not zero"

end

puts "The ASCII character equivalent of 97 is #{97.chr}"

2. 数值类层级结构

3. 常见算术表达式及其求值结果

表达式

结果

评注

1 + 1

10/5

10/3

10.0/3.0

1.2 + 3.4

-12 - -7

10 % 3

3.3333333333

4.6

-5

加法

整数除法

整数除法（无自动浮点数转换）

浮点数除法

浮点数加法

减法

模运算（余数）

4. 非十进制数运算

（1）十六进制数，前导 0x 指示

>> 0x12

=> 18

>> 0x12 + 12

=> 30

（2）八进制数，前导 0 指示

>> 012

=> 10

>> 012 + 12

=> 22

>> 012 + 0x12

=> 28

（3）用 to_i 方法将其它进制数转成十进制

>> "10".to_i(17)

=> 17

>> "12345".to_i(13)

=> 33519

>> "ruby".to_i(35)

=> 1194794

四、时间和日期

1. 时间和日期是通过三个类来操作的：Time、Date 和 DateTime。为了使用它们的全部功能，需要将 date 库或 time 库两者都请求加载到程序中或 irb 会话中

require 'date'

require 'time'

想知道英格兰是如何称呼1705年4月24日的吗？

>> require 'date'

=> true

>> Date.parse("April 24 1705").england.strftime("%B %d %Y")

=> "April 13 1705"

2. 获得系统当前时间

require 'date'

d = Date.today

puts d

2009-08-21

3. 日期对象可以响应 << 和 >> 方法

puts d << 2 # 输出：2009-06-21，两个月前的日期

puts d >> 5 # 输出：2010-01-21，五个月后的日期

4. 获得年、月、日、小时、分钟、秒及微秒

>> t = Time.new

=> Tue Jan 17 17:51:04 PST 2006

>> t.year

=> 2006

>> t.month

=> 1

>> t.day

=> 17

>> t.hour

=> 17

>> t.min

=> 51

>> t.sec

=> 4

>> t.usec

=> 377285

5. UNIX 风格的格式字符串

>> t.strftime("%m-%d-%Y")

=> "01-17-2006"

6. 常见的时间和日期格式说明符

说明符

描述

%b, %B

%a, %A

%H,%I

年份（4位数字）

年份（最后2位数字）

月份名的缩写、月份名的全称

月份（数字）

日子（左边补0）

日子（左边补空格）

星期几的缩写、星期几的全称

小时（24小时进制），小时（12小时进制）

分钟

秒

等价于 %a %b %d %H:%M:%S %Y

等价于 %m/%d/%y

7. 一些时间格式说明符的用法示例

>> t.strftime("Today is %x")

=> "Today is 01/17/06"

>> t.strftime("Otherwise known as %d-%b-%y")

=> "Otherwise known as 17-Jan-06"

>> t.strftime("Or even day %e of %B, %Y.")

=> "Or even day 17 of January, 2006."

>> t.strftime("The time is %H:%m.")

=> "The time is 17:01."

[RoR] Ruby for Rails 最佳实践Ⅸ[FL车在臣]

FL车在臣 — Fri, 21 Aug 2009 11:22:10 GMT+8

第三部分内建类和内建模块

第九章内建类和内建模块基础知识

一、Ruby 的字面构造器

Ruby 有很多内建类，它们中的大多数可以用 new 来实例化

str = String.new

arr = Array.new

有些则不可以，比如，不可以创建 Integer 类的新实例。

此外，有一部分幸运的内建类还有字面构造器，这意味着可以用特别的记法来创建这些类的对象，而不调用 new。比如：对于 String.new 和 Array.new 来说，更常见到的是 “” 和 []

内建类的字面构造器

类	字面构造器	示例
String	引号	"new string" 或 'new string'
Symbol	前导冒号	:symbol 或 :"symbol with spaces"
Array	中括号	[1,2,3,4,5]
Hash	大括号	{"New York" => "NY", "Oregon" => "OR"}
Range	二个或三个圆点	0...10 或 0..9
Regexp	斜杠	/([a-z]+)/

二、反复出现的语法糖衣

有操作符风格的语法糖衣调用记法的方法

分类

名称

定义示例

调用示例

糖衣化记法

算术方法/

操作符

def +(x)

def -(x)

def *(x)

def /(x)

def %(x)

obj.+(x)

obj.-(x)

obj.*(x)

obj./(x)

obj.%(x)

obj + x

obj - x

obj * x

obj / x

obj % x

读/写/添加数据

[]

[]=

def [](x)

def []=(x,y)

def <<(x)

obj.[](x)

obj.[]=(x,y)

obj.<<(x)

obj[x]

obj[x] = y

obj << x

比较方法/

操作符

def ==(x)

def >(x)

def <(x)

def >=(x)

def <=(x)

obj.==(x)

obj.>(x)

obj.<(x)

obj.>=(x)

obj.<=(x)

obj == x

obj > x

obj < x

obj >= x

obj <= x

case 相等操作符

===

def ===(x)

obj.===(x)

obj === x

这类语法糖衣（看起来像操作符其实是方法调用）的广泛使用，揭示了作为一门编程语言的 Ruby 背后的很多哲学思想。

算术方法/操作符的糖衣记法

糖衣记法

Ruby 如何看待

x += 1

x -= 1

x *= 2

x /= 2

x %= 2

x = x + 1

x = x - 1

x = x * 2

x = x / 2

x = x % 2

三、改变或者不改变其接收者的方法

1. 改变接收者的方法的基本知识

（1）不改变接收者的示例，该例中 str 没有改变 capitalize 方法只返回了一个新的字符串

str = "hello"

puts str.capitalize #输出：Hello

puts str # 输出：hello

（2）改变接收者的示例，原 str 字符串发生了变化

str = "hello"

str.replace("goodbye")

puts str # 输出：goodbye

（3）改变对象而不是创建新对象的一个考虑是效率：创建新对象，就内存和处理器的资源来说开销很大。

2. 感叹号 ! 方法

Ruby 允许定义方法名以感叹号结尾的方法。

感叹号在 Ruby 内部没有什么特别的意义，不过根据惯例，感叹号表明一个方法是危险的。

危险的意味着该方法（与和它同名的没有感叹号的方法不同）永久性地改变它的接收者。

这样的方法对包括：用于数组的 sort/sort!，用于字符串的 upcase/upcase! 和 chomp/chomp!，以及用于字符串和数组的 reverse/reverse!。

3. ActiveRecord 对象扩展了改变接收者的行为

composer = Composer.new

composer.first_name = "Johann"

composer.save

composer.update_attribute("last_name","Bach")

第一个改变将新的作曲者的名字设成 Johann，需要一个手动保存的操作才能将新的值保存到数据库中。第二个改变执行了一个 update_attribute 操作，不仅改变了内存中的对象属性，也更新了数据库中的记录，这种改变叫做横向（lateral）改变或元改变（meta-change）。

四、内建和定制的 to_*（转换）方法

1. Ruby 提供了很多内建方法，这些方法可以将一个类的对象转换为另一类的对象，它们的名字以 to_ 开头：to_s（转换成字符串），to_a（转换成数组），to_i（转换成整数）和 to_f（转换成浮点数）

2. to_s 方法

>> "I am already a string!".to_s

=> "I am already a string!"

还可以返回扁平化的字符串

>> ["one", "two", "three", 4, 5, 6].to_s

=> "onetwothree456"

也可以返回关于某个对象的描述性的字符串

>> Object.new.to_s

=> "#"

3. 编写自己的 to_* 方法

class C

def initialize(name)

@name = name

end

def to_s

"A C object named #{@name}"

end

c = C.new("Emma")

puts c

五、再论迭代器

1. each 的返回值是它的接收者，即最初的数组

array = [1,2,3,4,5]

other = array.each {|n| puts "Current element is #{n}" }

这里，other 只是 array 的另一个引用。保存 each 的返回值没有什么意义。

2. map 的返回值是一个新的数组，这个数组由所有匿名调用的操作结果构成

array = [1,2,3,4,5]

other = array.map {|n| n * 10 }

p other

这个新数组就是 map 调用的返回值：[10,20,30,40,50]

六、布尔状态、布尔对象和空对象

表达式

表达式求值结果对象

表达式的布尔值

1+1

true

false

"string"

puts "string"

100 > 50

x = 10

def x; end

true

false

"string"

nil

true

nil

true

false

true

false

true

false

特殊对象 nil

nil 通过 to_s 转换为一个空字符串””；nil的整数表示为0；nil的对象id是4

说 nil 为空是不准确的。可以将 nil 想像成一个存在的对象，它具有一组幸存下来的方法

七、比较两个对象

1. 相等性测试

>> a = Object.new

=> #

>> b = Object.new

=> #

>> a == a

=> true

>> a == b

=> false

>> a.eql?(a)

=> true

>> a.eql?(b)

=> false

>> a.equal?(a)

=> true

>> a.equal?(b)

=> false

2. 比较和 Comparable 模块

（1）混含一个名为 Comparable 的模块（Ruby 提供）

（2）在类中定义一个名为 <=> 的比较方法

比较方法 <=> （太空船操作符或太空船方法），该方法中定义了小于、等于和大于的含义

八、列出对象的方法

1. 列出对象的方法，在 irb 中输入

"I am a String object".methods

对它们进行一下排序

"I am a String object".methods.sort

2. 列出类的方法，而不是实例方法

String.methods.sort

列出 String 类的实例拥有的方法

String.instance_methods

3. 列出对象的单例方法

str = "a plain old string"

"a plain old string"

def str.some_new_method; end

p str.singleton_methods.sort

4. 产生过滤的和有选择的方法列表

如果想了解一个类的实例方法但不包括这个类的祖先类的实例方法，可以传入一个参数

String.instance_methods(false).sort

其它用于列举方法的方法包括以下几个

■ obj.private_methods

■ obj.public_methods

■ obj.protected_methods

■ obj.singleton_methods

[RoR] Ruby for Rails 最佳实践Ⅷ[FL车在臣]

FL车在臣 — Wed, 19 Aug 2009 08:53:14 GMT+8

第八章控制流技术

一、条件代码执行

1. if 关键字及相关构造

if condition

# code here, executed if condition uates to true

end

也可以将整个 if 子句放在一行，为此需要在条件后面插入 then 关键字

if x > 10 then puts x end

也可以使用分号来替代换行

if x > 10; puts x; end

作为 Ruby 一个特殊规则，也可以使用冒号代替 then

if x > 10: puts x; end

2. else：可以在 if 语句中提供一个 else 分支

if condition

# code executed if condition is true

else

# code executed if condition is false

end

3. elsif：使得条件逻辑可以层叠，形成比 if 和 else 更多的层次

if condition1

# code executed if condition1 is true

elsif condition2

# code executed if condition1 is false

# and condition2 is true

elsif condition3

# code executed if neither condition1

# nor condition2 is true, but condition3 is

end

4. unless：有时想使用否定 if 条件：如果某件事不是真的，那么执行给定的代码块

方法一：使用 not 关键字

if not (x == 1)

方法二：使用否定操作符!

if !(x == 1)

方法三：使用 unless

unless x == 1

5. 条件修饰语：可以把条件判断直接放在语句的后面作为修饰语

puts "Big number!" if x > 100

它和下面代码等价

if x > 100

puts "Big number!"

end

也可以使用 unless 来实现

puts "Big number!" unless x <= 100

条件修饰语具有会话的风格。它们不需要使用 end。不能用它们来完成太多的工作（不能带 else 或者 elsif 分支），但是在需要一个简单的条件判断时，它们往往非常合适。

6. case 语句

print "Exit the program? (yes or no): "

answer = gets.chomp

case answer

when "yes"

puts "Good-bye!"

exit

when "no"

puts "OK, we'll continue"

else

puts "That's an unknown answer -- assuming you meant 'no'"

end

when 子句的匹配方法由 ===（三等号操作符）判断，即

if "yes" === answer

puts "Good-bye!"

exit

elsif "no" === answer

puts "OK, we'll continue"

else

puts "That's an unknown answer—assuming you meant 'no'"

end

因此 case/when 逻辑的本质是 object === other_object；而 object === other_object 的本质是 object ===(other_object)。

二、用循环重复动作

1. 用 loop 方法实现无条件循环，下面两段代码是等价的

loop { puts "Looping forever!" }

loop do puts "Looping forever!" end

对循环进行控制（break 停止循环）

n = 1

loop do

n = n + 1

break if n > 9

end

使用 next 在没有完成本次循环的情况下跳到下一次循环

n = 1

loop do

n = n + 1

next unless n == 10

break

end

2. 用 while 和 until 关键字实现条件循环

（1）while：在给定条件为真时循环执行代码

n = 1

while n < 11

puts n

n = n + 1

end

puts "Done!"

也可以把 while 子句放在循环的结束处，这时需要 begin/end 标记循环的头尾

n = 1

begin

puts n

n = n + 1

end while n < 11

puts "Done!"

（2）until：具有和 while 相同的用法，但是逻辑相反

n = 1

until n > 10

puts n

n = n + 1

end

（3）while 和 until 作为修饰语

和 if unless 一样，while 和 until 可以在语句的末尾用作修饰语

n = 1

n = n + 1 until n == 10

puts "We've reached 10!"

3. for/in 循环：基于值列表的循环

celsius = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

for c in celsius

puts c

end

三、代码块、迭代器和 yield 关键字

1. 代码块：由任意多行 Ruby 代码构成，可以用大括号封装

object.method_name {

# code inside block

}

也可以用 do/end 来封装

object.method_name do

# code inside block

end

2. yield 关键字：如果在调用方法时提供了代码块，那么在该方法执行过程中可以将控制转移到该代码块（暂停方法的执行），执行代码块中的代码，最后再返回该方法继续执行

def demo_of_yield

puts "Executing the method body..."

puts "About to yield control to the block..."

yield

puts "Back from the block—finished!"

end

demo_of_yield { puts "> Control has been passed to the block!" }

该代码的输出如下

Executing the method body...

About to yield control to the block...

> Control has been passed to the block!

Back from the block—finished!

3.给代码块传递参数

可以通过 yield 将参数发送到代码

yield(x,y,z)

代码块接受参数的方法，不使用圆括号，而使用一对管道符号（||）

some_method {|a,b,c|

# code here

}

示例如下

def yield_an_arg

puts "Yielding 10!"

yield(10)

end

yield_an_arg {|x| puts "> Code block received this argument: #{x}" }

4. 从代码块返回值

def more_yielding

puts "The code block shall multiply a number by 10."

result = yield(3)

puts "The result of this operation is #{result}."

end

more_yielding {|x| x * 10 }

5. 执行多个迭代

迭代：方法匿名调用代码块的过程

迭代器：任何匿名调用代码块的方法

使用代码块来执行温度转换方法

def temp_chart(temps)

for temp in temps

converted = yield(temp)

puts "#{temp}\t#{converted}"

end

celsiuses = [0,10,20,30,40,50,60,70,80,90,100]

temp_chart(celsiuses) {|cel| cel * 9 / 5 + 32 }

6. Ruby 的代码块机制意味着：可以使用代码块来补足方法中没有完全定义的行为

我们可以使用同样的方法通过另外的方式转换温度：

fahrens = [32,62,92,122,152,182,212]

temp_chart(fahrens) {|fahr| (fahr - 32) * 5 / 9 }

7. 关于 for 的更多内容

for 的本质就是迭代器：for 是调用一个特殊的迭代器 each 的一种可选方式

下面两段代码是等价的

for x in [1,2,3,4,5]

puts x * 10

end

与

[1,2,3,4,5].each {|x| puts x * 10 }

四、错误处理和异常

1. 异常是特殊类型的对象，它是 Exception 类或它的后代类的一个实例，抛出一个异常意味着：停止程序的正常执行，处理碰到的问题或者退出程序

要看看实际中的异常可以试一试：

F:\ruby_project>ruby -e '1./0'

Ruby 抛出一个异常

-e:1:in `/': divided by 0 (ZeroDivisionError)

from -e:1

2. 常见的异常

异常名	常见原因	怎样抛出
RuntimeError	这是 raise 方法抛出的默认异常	raise
NoMethodError	对象收到一个找不到对应方法的消息	a = Object.new a.some_unknown_method_name
NameError	解释器碰到一个不能解析为变量或方法名的标识符	a = some_random_identifier
IOError	读关闭的流（stream），写只读的流，或类似的操作	STDIN.puts("Don't write to STDIN!")
Errno::error	与文件 IO 相关的一族错误	File.open(-12)
TypeError	方法接收到它不能处理的参数	a = 3 + "can't add a string to a number!"
ArgumentError	传递的参数的数目出错	def m(x); end; m(1,2,3,4,5)

3. 用 rescue 块来营救程序异常

print "Enter a number: "

n = gets.to_i

begin

result = 100 / n

rescue

puts "Your number didn't work. Was it zero???"

exit

end

puts "100/#{n} is #{result}."

指定想要营救的异常：rescue ZeroDivisionError

4. 显示抛出异常

可以给 raise 提供第二个参数，作为抛出异常时的消息字符串

def fussy_method(x)

raise ArgumentError, "I need a number under 10" unless x < 10

end

fussy_method(20)

也可以在此例中使用 rescue

begin

fussy_method(20)

rescue ArgumentError

puts "That was not an acceptable number!"

end

5. 重新抛出异常

def reraiser(filename)

file_handle = File.new(filename)

rescue Errno::ENOENT => e

puts "Something's wrong with your filename...."

raise e

end

注意：只要 rescue 子句是方法定义体的最后部分，就不喜欢显示地使用 being/end 分隔符；

方法自己扮演了异常块的 end 角色。

此例涉及的主要新技术是那个奇特的 rescue 行。=>e 构造将异常对象放入变量 e 中。

下面对该方法进行调用

reraiser("some_non_existent_filename")
输出以下内容

Something's wrong with your filename....

reraiser.rb:2:in `initialize': No such file

or directory - some_non_existent_filename

(Errno::ENOENT)

6. 创建异常类：通过从 Exception 或它的后代继承

class MyNewException < Exception

end

raise MyNewException, "some new kind of error has occurred!"

7. 异常及它们在 Rails 框架中的名字

ActiveController 库定义了 UnknownAction, UnknownController, MissingTemplate 等异常，所有这些异常类都继承自中间级别的异常类 ActionControllerError，该类是 Ruby 内建的 StandardError类的子类。

[RoR] Ruby for Rails 最佳实践Ⅶ[FL车在臣]

FL车在臣 — Wed, 19 Aug 2009 08:48:22 GMT+8

第七章默认对象(self)和作用域

一、理解当前对象或默认对象 self

1. 在不同上下文中判定 self

puts "Tol Level"

puts "self is #{self}" #输出 main

class C

puts "Class definition block:"

puts "self is #{self}" #输出 C

def self.x

puts "Class method C.x:"

puts "self is #{self}" #输出 C

end

def m

puts "Instance method C#x:"

puts "self is #{self}" #输出 #

end

2. 在类和模块定义中的 self

class C

puts "Just started class C:"

puts self #输出 C

module M

puts "Nested module C::M:"

puts self #输出 C::M

end

puts "Back in the outer level of C:"

puts self #输出 C

end

3. 单例方法定义和类方法定义中的 self

（1）在执行单例方法时，self 是拥有该方法的对象

obj = Object.new

def obj.show_me

print "I'm an object; "

puts "here's self inside a singleton method of mine:"

puts self

end

obj.show_me

print "And inspecting obj from outside, "

puts "to be sure it's the same object:"

p obj

输出结果

I'm an object; here's self inside a singleton method of mine:

And inspecting obj from outside, to be sure it's the same object:

（2）类方法中的 self 就是类本身，因此

class C

def C.x

puts "Class method of class C"

puts self

end

等同于

class C

def self.x

puts "Class method of class C"

puts self

end

二、确定作用域

1. 全局变量具有全局作用域，全局变量通过变量名前加美元符号（$）来识别

$gvar = "I'm a global!"

class C

def examine_global

puts $gvar

end

C.new.examine_global

2. Ruby 内建全局变量

（1）$0 包含了 Ruby 正在执行的文件的名字

（2）$: 包含了一些目录，在加载一个外部文件时，这些目录构成了 Ruby 搜索路径

（3）$$ 包含了 Ruby 进程的进程ID

3. 全局变量使用范例

class Work

def show_info

puts "Title and composer: #{$title}, #{$composer}"

end

work = Work.new

$composer = "Giuseppe Verdi"

$title = "La Traviata"

work.show_info

3. 局部作用域

class C

a = 5

module M

a = 4

module N

a = 3

class D

a = 2

def show_a

a = 1

puts a

end

puts a #输出 2

end

puts a #输出 3

end

puts a #输出 4

end

puts a #输出 5

end

d = C::M::N::D.new

d.show_a #输出 1

4. 常量的作用域和解析

module M

class C

X = 2

class D

module N

X = 1

end

puts M::C::D::N::X #输出 1

puts M::C::X #输出 2

5. 强制使用绝对常量路径（::）

class Violin

# Violin 中再创建一个 String 类

class String

attr_accessor :pitch

def initialize(pitch)

@pitch = pitch

end

# 如果想调用 Ruby 自带的 String 类，则使用 ::String.new(args)

def history

::String.new(maker + ", " + Date)

end

三、部署访问权限规则

1. 私有方法：Ruby 通过禁止对私有方法使用显式的接收者来获得私有特性，在所有可以省略接收者的场合，调用私有方法是没问题的

class C

private

def sayHello

puts "hello"

end

#或者使用 private :sayHello

end

2. 保护方法：只要默认对象（self）和你想调用的方法所属的对象是同一类的实例，你就可以调用该保护方法

class C

def initialize(n)

@n = n

end

def n

end

def compare(c)

if c.n > n

puts "The other object's n is bigger."

else

puts "The other object's n is the same or smaller."

end

protected :n

end

c1 = C.new(100)

c2 = C.new(101)

c1.compare(c2)

3. 公有方法：默认的访问级别

四、编写和使用顶层方法

1. 预定义的（内建的）顶层方法：如 puts 和 print 都是 Kernel 内建的私有实例方法。

2. 查看所有内建私有实例方法：puts Kernel.private_instance_methods.sort

[RoR] Ruby for Rails 最佳实践Ⅵ[FL车在臣]

FL车在臣 — Wed, 19 Aug 2009 08:42:51 GMT+8

第六章模块和程序组织

一、创建和使用模块的基础知识

1. 除了使用 module 关键字来替代 class 关键字之外，编写模块和编写类很相似

module MyFirstModule

def say_hello

puts "Hello"

end

2. 使用模块

class ModuleTester

include MyFirstModule

end

mt = ModuleTester.new

mt.say_hello

二、封装似栈特性的模块

1. 封装具有似栈性的结构和行为的 Stacklike 模块（保存到 stacklike.rb 文件中）

module Stacklike

attr_reader :stack

def initialize

@stack = Array.new

end

def add_to_stack(obj)

@stack.push(obj)

end

def take_from_stack

@stack.pop

end

2. 将 Stacklike 模块混含到 Stack 类中，使用 Stack 类的实例

require "stacklike"

class Stack

include Stacklike

end

s = Stack.new

s.add_to_stack("item one")

s.add_to_stack("item two")

s.add_to_stack("item three")

puts "Objects currently on the stack:"

puts s.stack

taken = s.take_from_stack

puts "Removed this object:"

puts taken

puts "Now on stack:"

puts s.stack

运行结果

Objects currently on the stack:

item one

item two

item three

Removed this object:

item three

Now on stack:

item one

item two

三、模块、类和方法查找

1. 从对象角度看方法查找

module M

def report

puts "'report' method in module M"

End

end

class C

include M

end

class D < C

end

obj = D.new

obj.report # 输出：'report' method in module M

类 D 的对象实例的方法查找过程图

2. 一条方法查找路径上的两个同名方法

module M

def report

puts "'report' method in module M"

end

class C

include M

def report

puts "'report' method in class C"

end

c = C.new

c.report # 输出：'report' method in class C

3. 混含定义了同名方法的两个模块

module M

def report

puts "'report' method in module M"

end

module N

def report

puts "'report' method in module N"

end

class C

include M

include N

end

c = C.new

c.report # 输出：'report' method in module N

4. 用 super 提升方法查找路径

module M

def report

puts "'report' method in module M"

end

class C

include M

def report

puts "'report' method in class C"

puts "About to trigger the next higher-up report method..."

super

puts "Back from the 'super' call."

end

c = C.new

c.report

输出结果

'report' method in class C

About to trigger the next higher-up report method...

'report' method in module M

Back from the 'super' call.

四、类／模块的设计和命名

1. 使用类还是模块？

（1）模块没有实例。因此实体或事物最好建模为类，而实体或事物的特性最好建模为模块，因此我们倾向于使用名词作为类名，使用形容词作为模块名。

（2）一个类中有一个父类，但它可以混含任意多个模块。如果使用继承，要慎重考虑生成一个合理的父类／子类关系。如果使用一个类唯一的父类关系最后却发现几组特性中只有一个赋予了该类，那么这个关系还是不要用的好。

2. 嵌套的模块和类

模块和类可以相互嵌套

module Tools

class Hammer

要产生定义在 Tools 模块中的 Hammer 类的实例，须用双冒号（::）访问该类

h = Tools::Hammer.new

3. Rails 源代码中样版代码中的模块组织

class Composer < ActiveRecord::Base

end

[RoR] Ruby for Rails 最佳实践Ⅴ[FL车在臣]

FL车在臣 — Wed, 19 Aug 2009 08:37:14 GMT+8

第五章用类组织对象

一、类和实例

1. 第一个类

class Ticket

end

ticket = Ticket.new

2. 实例方法与单例方法

（1）在类中定义、供类的所有实例使用的方法，称为实例方法（Instance methods）

class Ticket

def event

"Can't really be specified yet..."

end

（2）为一个特定的对象定义的方法，称为单例方法（Singleton methods）

class Ticket

end

ticket = Ticket.new

def ticket.price

117.50

end

3. 实例变量：使得单个对象可以记忆状态

class C

def inst_var_init(value)

puts "Setting an instance variable...."

@ivar = value

end

def inst_var_report

puts "Inspecting the value of the instance variable...."

puts @ivar

end

c = C.new

c.inst_var_init("Just some string")

c.inst_var_report

4. 初始化对象状态

class Ticket

def initialize(venue,date)

@venue = venue

@date = date

end

def venue

@venue

end

def date

@date

end

二、设置方法

（1）改变对象状态（定义方法）

class Ticket

def initialize(venue, date)

@venue = venue

@date = date

end

def set_price(amount)

@price = amount

end

def price

@price

end

（2）语法糖衣（Syntactic sugar）

def price=(amount)

@price = amount

end

调用写方法的语法糖衣

ticket.price=(65.00)

可以这样写：

ticket.price = 65.00

三、属性和 attr_* 方法族

1. 产生获取和设置方法 attr_* 方法族的总结

方法名	效果	例子	等价的代码
attr_reader	产生读方法	attr_reader :venue	def venue @venue end
attr_writer	产生写方法	attr_writer :price	def price=(price) @price = price end
attr_accessor	产生读写方法	attr_accessor :price	def price=(price) @price = price end def price @price end
attr	产生读方法和可选的写方法（如果第二个参数为 true）	1. attr :venue 2. attr :price, true	1. 参见 attr_reader 2. 参见 attr_accessor

2.属性访问修饰符的使用

class Ticket

attr_accessor :venue, :date

end

四、类方法和 Class 类

1. 类也是对象：类是唯一具有创建新对象（实例）的能力的一类对象

下面定义一个类方法，找出最贵的入场券

def Ticket.most_expensive(*tickets)

tickets.sort_by {|t| t.price }.last

end

我们可以用该方法找出哪张入场券是最贵的

th = Ticket.new("Town Hall","11/12/13")

cc = Ticket.new("Convention Center","12/13/14/")

fg = Ticket.new("Fairgrounds", "13/14/15/")

th.price = 12.55

cc.price = 10.00

fg.price = 18.00

highest = Ticket.most_expensive(th,cc,fg)

puts "The highest-priced ticket is #{highest.venue}."

2. 类方法的调用方式

Ticket.most_expensive 或 Ticket::most_expensive

五、常量

常量的名字以一个大写字母开头

class Ticket

VENUES = ["Convention Center", "Fairgrounds", "Town Hall"]

end

puts Ticket::VENUES

六、继承

1. 抽象事物和特殊事物之间的关系可以通过继承（inheritance）来表达

class Publication

attr_accessor :publisher

end

class Magazine < Publication

ddattr_accessor :editor

end

2. 继承和 Rails 设计

class ComposerController < ApplicationController

end

class ApplicationController < ActionController::Base

class Composer < ActiveRecord::Base

七、Object 类

Object 类位于继承树的顶部。每一个类都是 Object 的直系后代

class C

end

class D < C

end

puts D.superclass

puts D.superclass.superclass

输出为：

Object

[RoR] Ruby for Rails 最佳实践Ⅳ[FL车在臣]

FL车在臣 — Wed, 19 Aug 2009 08:31:57 GMT+8

第二部分 Ruby 构造块

第四章对象和变量

一、对象

1. 创建类的实例——对象

obj = Object.new

2. 定义对象方法

def obj.talk

puts "I am an object."

puts "(Do you object?)"

end

3. 给对象发送消息

object.message

4. 接受参数的方法

def obj.c2f(c)

c * 9 / 5 + 32

end

# puts obj.c2f(100)

5. 方法的返回值，通常不需要 return（该关键字是可选的）

def obj.c2f(c)

return c * 9 / 5 + 32

end

二、对象固有行为

1. 列出对象的固有方法清单：

p Object.new.methods.sort

["==", "===", "=~", "__id__", "__send__", "class",

"clone", "display", "dup", "eql?", "equal?", "extend",

"freeze", "frozen?", "hash", "id", "inspect",

"instance_", "instance_of?", "instance_variable_get",

"instance_variable_set", "instance_variables", "is_a?",

"kind_of?", "method", "methods", "nil?", "object_id",

"private_methods", "protected_methods", "public_methods",

"respond_to?", "send", "singleton_methods", "taint",

"tainted?", "to_a", "to_s", "type", "untaint"]

2. 用 object_id 方法唯一标识对象

（1）两个变量引用同一对象 object_id 相同

a = Object.new

b = a

puts "a's id is #{a.object_id} and b's id is #{b.object_id}."

（2）两个值相同的字符串对象 object_id 不相同

string_1 = "Hello"

string_2 = "Hello"

puts "string_1's id is #{string_1.object_id}."

puts "string_2's id is #{string_2.object_id}."

3. 用 respond_to? 方法查询对象是否拥有该方法

obj = Object.new

obj.talk

Ruby 会告诉你：

undefined method 'talk' for # (NoMethodError)

使用respond_to?方法可以事先判定对象是否能响应给定的消息。respond_to?常常与条件（if）逻辑一起出现

obj = Object.new

if obj.respond_to?("talk")

obj.talk

else

puts "Sorry, the object doesn't understand the 'talk' message."

end

4. 用 send 方法给对象发送消息

if ticket.respond_to?(request)

puts ticket.send(request)

else

puts "No such information available"

end

5. 必需参数、可选参数以及默认值参数

（1）必需参数

def obj.one_arg(x)

end

obj.one_arg(1,2,3)

结果是：

ArgumentError: wrong number of arguments (3 for 1)

（2）可选参数

def obj.multi_args(*x)

end

（3）混合使用必需参数和可选参数

def two_or_more(a,b,*c)

（5）参数的默认值

def default_args(a,b,c=1)

puts "Values of variables: ",a,b,c

end

（6）参数的顺序

def opt_args(a,b,*x) # 正确

def opt_args(a,*x,b) # 错误

[RoR] Ruby for Rails 最佳实践Ⅲ[FL车在臣]

FL车在臣 — Wed, 19 Aug 2009 08:25:59 GMT+8

第三章了解 Ruby 前提下的 Rails 开发

一、YAML 和实际为编程的配置

YAML （按 UNIX 平台的传统，最初代表 Yet Another Markup Language，现在却代表 YAML Ain’t Markup Language）可以说是一个标记语言，也可以说是一个串行化格式，取决于你看问题的角度。下面是一个简单的例子：一个嵌套的数组结构转变成一个 YAML 表示，然后再由它恢复成一个数组：

require 'yaml'

array = [1, 2, 3, [4, "five", :six]]

puts "Original array:"

puts array.inspect

yarray = array.to_yaml

puts "YAML representation of array: "

puts yarray

thawed = YAML.load(yarray)

puts "Array re-loaded from YAML string: "

p thawed

（此例中，inspect 方法为对象产生一个详细的字符串表示；还有 p 方法，等价于 puts）。

运行这段脚本的输出如下：

Original array:

[1, 2, 3, [4, "five", :six]]

YAML representation of array:

---

- 1

- 2

- 3

- - 4

- five

- :six

Array re-loaded from YAML string:

[1, 2, 3, [4, "five", :six]]

Rails 在几种上下文中使用 YAML，在 database.yml 中会看到如下的块：

development:

adapter: mysql

database: r4rmusic1_development

username: r4r

password: railzrulez

socket: /tmp/mysql.sock

将这些行放到一个文件（如sample.yml）中，然后运行下面命令：

F:\ruby_project>ruby -ryaml -e 'p YAML.load(File.read("sample.rb"))'

{"development" => {"socket"=>"/tmp/mysql.sock",

"username"=>"r4r",

"adapter"=>"mysql",

"password"=>"railzrulez",

"database"=>"r4rmusic1_development"

}

二、给控制器增加功能

通过点击合适的列标题，可以让列表以不同的方式排序（按标题，按作者，按状态）：

def all

@order = params[:order] || "number"

sort_proc = case @order

when "author" then lambda {|r| [r.user.name.downcase, r.number] }

when "status",

"title" then lambda {|r| [r.send(@order).downcase, r.number]}

when "number" then lambda {|r| -r.number }

end

@rcrs = Rcr.find(:all).sort_by &sort_proc

end

变量@order（一个实例变量）设置为CGI变量order的值；如果该CGI变量的值没有设置，则它的默认值是字符串"number"。然后，变量sort_proc（排序过程）被设置为三个可能的lambda表达式（匿名函数）中的一个。选择哪一个lambda表达式取决于@order的值，这个选择是通过一个case语句来执行的。

一旦选定了正确的lambda表达式，所有现存的RCR将根据该lambda表达式的逻辑排序，这个排序需使用ActiveRecord的find方法来获取所有的RCR，以及根据sort_proc中保存的lambda表达式来使用Ruby的sort_by方法过滤这个列表。

如果了解Ruby，则该方法很容易编写。但是一定要了解Ruby！确切地说，需要了解下面这些内容：

case语句；

lambda关键字，用它生成一个匿名函数；

send方法（请注意status和title是怎样一起处理的）；

sort_by方法，需要给它传递一个lambda表达式。

三、部署 Rails 的辅助文件

Rails 对每一个控制器都会自动产生一个辅助文件，可以编写任意多的 Ruby 方法。位于 app\helpers 下。

下面是一个从RCRchive列表排序代码中提取的例子。在RCR的每一个视图中的每一个列标题，都超链接到rcr/all动作。这些链接只在一个方面有区别：order参数的值（“author”、“title”、“number”或“Status”）。这意味着这四个链接使用几乎完全相同的代码。为减少重复，可用一个辅助方法自动产生合适的链接。你所需要做的仅仅是传递给它一个order参数。

该辅助方法定义在文件rcr_helper.rb中，如下所示：

def link_to_order(order)

link_to(order.capitalize,

:controller => "rcr",

:action => "all",

:params => { "order" => order })

end

在视图（app/views/rcr/all.rhtml）中，下面四行产生表的列标题：

<%= link_to_order("number") %>

<%= link_to_order("title") %>

<%= link_to_order("status") %>

<%= link_to_order("author") %>

四、给模型增加功能

1. 实现预定义的回调方法

如果在一个ActiveRecord模型文件中编写一个名为before_create的方法，该方法会在该模型的实例的数据库记录产生之前被执行。

如果description字段有默认的字符串值，那应该更好。如果在数据库记录首次产生的时候，该edition不存在描述信息，让我们给它一个默认值"standard"。

def before_create

self.description = "standard" unless description

end

2. 自由形式的编程的模型改进

假设在一个视图模板中，变量@customer包含一个客户对象，你可以像下面这样显示这个人的名字：

Hello, <%= @customer.title + " " + @customer.first_name + " " +

@customer.middle_initial + ". " +

@customer.last_name" %>

下面让 customer 对象自己产生该名字的友好板本：

class Customer < ActiveRecord::Base

def nice_name

title + " " + first_name + " " +

(if middle_initial then middle_initial + ". " else "" end) +

last_name

end

下面可以在视图中直接调用 @customer 中该实例的方法：

Good morning, <%= @customer.nice_name %>.

[RoR] Ruby for Rails 最佳实践Ⅱ[FL车在臣]

FL车在臣 — Tue, 18 Aug 2009 13:13:20 GMT+8

第二章 Rails 工作原理

一、Rails 的 MVC 框架设计实现概览

MVC 阶段	Rails 子库	目的
模型	ActiveRecord	在关系数据库表和操作数据库记录的Ruby程序代码之间提供接口和绑定。Ruby方法名自动从数据库表的字段名产生，等等
视图	ActionView	一个基于嵌入式Ruby（ERb）的系统，用于定义服务于数据表示的表示模板。对Rails应用的每一次Web连接都导致显示一个视图
控制器	ActionController	在ActiveRecord（数据库接口）和ActionView（表示引擎）之间的数据中介。ActionController提供功能设施，处理和组织来自数据库和Web表单输入的数据，然后它将这些数据递交给ActionView，ActionView将这些数据插入模板并显示

二、图解 Ruby 和 Rails 框架

三、全程开发 Rails 应用，音乐店应用——R4Rmusic（PS：完整版攻略）

Google Code 下载：http://kerryas.googlecode.com/files/R4Rmusic1.rar

1. 生成音乐店的数据库表 SQL 命令

CREATE DATABASE r4rmusic1;

USE r4rmusic1;

DROP TABLE IF EXISTS works;

DROP TABLE IF EXISTS editions;

DROP TABLE IF EXISTS composers;

CREATE TABLE works (

id INT(11) NOT NULL AUTO_INCREMENT,

composer_id INT(11),

title VARCHAR(100),

PRIMARY KEY (id)

);

CREATE TABLE editions (

id INT(11) NOT NULL AUTO_INCREMENT,

work_id INT(11) NOT NULL,

description VARCHAR(30),

publisher VARCHAR(60),

YEAR INT(4),

price FLOAT,

PRIMARY KEY (id)

);

CREATE TABLE composers (

id INT(11) NOT NULL AUTO_INCREMENT,

first_name VARCHAR(25),

last_name VARCHAR(25),

PRIMARY KEY (id)

);

2. 产生音乐店示例库存数据的 SQL 命令

INSERT INTO composers

VALUES (1,"Johannes","Brahms");

INSERT INTO composers

VALUES (2,"Claude","Debussy");

INSERT INTO works

VALUES (1,1,"Sonata for Cello and Piano in F Major");

INSERT INTO works

VALUES (2,2,"String Quartet");

INSERT INTO editions

VALUES (1,1,"Facsimile","D. Black Music House", 1998, 21.95);

INSERT INTO editions

VALUES (2,1,"Urtext","RubyTunes, Inc.", 1977, 23.50);

INSERT INTO editions

VALUES (3,1,"ed. Y.Matsumoto","RubyTunes, Inc.", 2001, 22.95);

INSERT INTO editions

VALUES (4,2,"","D. Black Music House", 1995, 39.95);

INSERT INTO editions

VALUES (5,2,"Reprint of 1894 ed.", "RubyTunes, Inc.", 2003, 35.95);

3. 创建 R4Rmusic1 项目（数据库基于Mysql）

F:\ruby_project>rails -d mysql R4Rmusic1

F:\ruby_project>cd R4Rmusic1

4. 初始设置及测试

（1）配置数据库文件 config/database.yml

development:

adapter: mysql

encoding: utf8

reconnect: false

database: R4Rmusic1

pool: 5

username: root

password:

host: localhost

（2）启动 WEBrick 应用服务器

F:\ruby_project\R4Rmusic1>ruby script\server

=> Booting WEBrick

=> Rails 2.3.3 application starting on http://0.0.0.0:3000

=> Call with -d to detach

=> Ctrl-C to shutdown server

[2009-08-16 14:40:31] INFO WEBrick 1.3.1

[2009-08-16 14:40:31] INFO ruby 1.8.6 (2008-08-11) [i386-mswin32]

[2009-08-16 14:40:31] INFO WEBrick::HTTPServer#start: pid=988 port=3000

（3）测试服务

访问：http://localhost:3000/

点击：About your application’s environment 测试是否列出应用的环境列表，如果是则服务正确，如果出错需要访问log/development.log 查找原因。

5. 创建 Rails 模型文件

F:\ruby_project\R4Rmusic1>ruby script/generate model work

F:\ruby_project\R4Rmusic1>ruby script/generate model edition

F:\ruby_project\R4Rmusic1>ruby script/generate model composer

执行后会在 app/model 目录下生成这三个模型文件：work.rb, edition.rb, composer.rb

将 work.rb 修改如下：

class Work < ActiveRecord::Base

belongs_to :composer

has_many :editions

end

将 edition.rb 修改如下：

class Edition < ActiveRecord::Base

belongs_to :work

end

将 composer.rb 修改如下：

class Composer < ActiveRecord::Base

has_many :works

end

6. 创建访问主界面

（1）创建主界面视图及控制器

F:\ruby_project\R4Rmusic1>ruby script/generate controller main welcome

（2）将 app\controllers\main_controller.rb 修改如下（编写控制器）：

class MainController < ApplicationController

def welcome

#@composers = Composer.find(:all)

@composers = Composer.find(:all).sort_by {|c| [c.last_name, c.first_name]}

end

（3）将 app\views\main\welcome.html.erb 修改如下（编写视图）：

Click on a composer's name

to see all of that composer's works.

<% @composers.each do |composer| %>

<%= link_to "#{composer.first_name} #{composer.last_name}",

                  :controller => "composer",

                  :action     => "show",

                  :id         => composer.id %>

<% end %>

（4）R4RMusic基本布局（在app\views\layouts 中创建base.html.erb）

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<%= @page_title %>

<%= @content_for_layout %>

（5）将默认布局加入到 app\controllers\ application_controller.rb 中

class ApplicationController < ActionController::Base

layout "base"

end

（6）设置应用程序入口文件，在 config/routes.rb 中加入配置：

map.connect '', :controller => "main", :action => "welcome"

（7）删除public/index.html（Rails 应用默认入口），重启 WEBrick 测试。

7. 创建作品、版本及作曲者的控制器

F:\ruby_project\R4Rmusic1>ruby script/generate controller work show

F:\ruby_project\R4Rmusic1>ruby script/generate controller edition show

F:\ruby_project\R4Rmusic1>ruby script/generate controller composer show

修改 app\controllers\work_controller.rb

def show

@work = Work.find(params[:id])

end

修改 app\controllers\edition_controller.rb

def show

@edition = Edition.find(params[:id])

end

修改 app\controllers\composer_controller.rb

def show

@composer = Composer.find(params[:id])

end

8. 创建作品、版本及作曲者的视图

（1）将 app\views\work\show.html.erb

Available editions of

<%= @work.title %> by

<%= "#{@work.composer.first_name} #{@work.composer.last_name}" %>

<% @work.editions.each do |ed| %>

<% end %>

Edition	Publisher
<%= link_to ed.description \|\| "(no descr.)", :controller => "edition", :action => "show", :id => ed.id %>	<%= ed.publisher %>

Edition

Publisher

<%= link_to ed.description || "(no descr.)",

:controller => "edition",

:action => "show",

:id => ed.id %>

<%= ed.publisher %>

（2）将 app\views\edition\show.html.erb

<% @page_title =

"#{@edition.work.title} (#{@edition.description})" %>

Details of <%= @edition.work.title %>

(<%= @edition.description %>),

<%= "#{@edition.work.composer.first_name}

#{@edition.work.composer.last_name}" %>

Publisher	Year	Price
<%= @edition.publisher %>	<%= @edition.year %>	$<%= @edition.price %>

（3）将 app\views\composer\show.html.erb

<% @page_title =

"Works by #{@composer.first_name} #{@composer.last_name}" %>

Click on any work to see all available editions of that work.

<% @composer.works.each do |work| %>

<%= link_to work.title,

                 :controller => "work",

                 :action     => "show",

                 :id         => work.id %>

<% end %>

8. 最后，重新启动 WEBrick 服务器，第一个 R4RMusic 应用完成。

[RoR] Ruby for Rails 最佳实践Ⅰ[FL车在臣]

FL车在臣 — Tue, 18 Aug 2009 10:11:19 GMT+8

下载 Ruby：http://rubyforge.org/frs/?group_id=167

安装 Rails：gem install rails --remote

安装 Mysql 驱动：gem install mysql

第一部分 Ruby/Rails 全景

第一章 Ruby 工作原理

一、编写第一个程序文件：

1. 摄氏—华氏温度转换程序（F:\ruby_project\c2f.rb）

c = 100

f = (c * 9 / 5) + 32

puts "The result is: "

puts f

puts "."

2. 语法错误检查

F:\ruby_project>ruby -cw c2f.rb

Syntax OK

3. 运行程序

F:\ruby_project>ruby c2f.rb

The result is:

212

二、交互式温度转换程序（F:\ruby_project\c2fi.rb）

print "Hello. Please enter a Celsius value: "

c = gets

f = (c.to_i * 9 / 5) + 32

puts "The Fahrenheit equivalent is "

puts f

puts "."

===================================================

缩减代码：

print "Hello. Please enter a Celsius value: "

print "The Fahrenheit equivalent is ", gets.to_i * 9 / 5 + 32, ".\n"

===================================================

F:\ruby_project>ruby c2fi.rb

Hello. Please enter a Celsius value: 100

The Fahrenheit equivalent is 212.

F:\ruby_project>ruby c2fi.rb

Hello. Please enter a Celsius value: 23

The Fahrenheit equivalent is 73.

三、文件输入式温度转换程序（F:\ruby_project\c2fin.rb）

print "Reading Celsius temperature value from data file..."

num = File.read("temp.dat")

c = num.to_i

f = (c * 9 / 5) + 32

puts "The number is " + num

print "Result: "

puts f

四、使用文件输出的温度转换程序（F:\ruby_project\c2fout.rb）

print "Hello. Please enter a Celsius vallue: "

c = gets.to_i

f = (c * 9 / 5) + 32

puts "Saving result to output file 'temp.out'"

fh = File.new("temp.out", "w")

fh.puts f

fh.close

五、一个程序，多个文件

1. 请求加载文件 require：

puts "This is the first (master) program file."

require 'requiree.rb'

puts "And back again to the first file."

2. 加载文件 load：

load 是 require 的近亲。它们的主要区别在于，如果执行下面代码：

require 'requiree.rb'

第二次执行 require 什么都不会发生，而如果执行下面代码：

load 'requiree.rb'

Ruby 会两次读入该文件

六、ruby 解释起的命令行开关

命令行开关	描述	例子
-c	不执行程序，只检查程序语法	ruby -c c2f.rb
-w	在程序执行过程中给出警告信息	ruby -w c2f.rb
-e	执行在命令行中引号内的代码	ruby -e 'puts "code demo!"'
-v	显示Ruby版本信息，在详细模式下执行程序	ruby -v
-l	行模式：如果没有换行则在每一行后输出换行	ruby -l -e 'print "Will jump!"'
-rname	加载指定的扩展	ruby -r profile
--version	显示Ruby版本信息	ruby --version

七、重要的标准 Ruby 工具和应用程序

1. 调试器，Ruby 运行这个例子时加载了 debug 扩展

F:\ruby_project>ruby -r debug c2fi.rb

Debug.rb

Emacs support available.

2. 性能分析

F:\ruby_project>ruby -r profile c2fi.rb

3. ri和RDoc

（1）ri（Ruby 索引）：命令行工具，获取关于Ruby的详细信息，如：

ri require

获取 require 功能的完整的、官方的描述

（2）RDoc（Ruby 文档）：根据注释内容建立索引

4. ERb （Embedded Ruby）：允许将 Ruby 代码嵌入 HTML 文件

（1）ERb 实例（erbdemo.rb）

<% page_title = "Demonstration of ERb" %>

<% salutation = "Dear programmer," %>

<%= page_title %>

<%= salutation %>

This is a bref demonstration of how ERb fills out a template.

（2）F:\ruby_project>erb erbdemo.rb

Demonstration of ERb

Dear programmer,

This is a bref demonstration of how ERb fills out a template.

Flash AS 基理殿堂

[AS3 狂想曲] SWF 间双向通信 [FL 车在臣]

[KerryLib] KerryLib v0.2 更新内容 [FL车在臣]

[视频教程] Flash AS 3.0 项目开发实践 [FL车在臣]

KerryLib AS3 开源项目启动 [FL车在臣]

[RoR] Ruby for Rails 最佳实践ⅩⅥ[FL车在臣]

第十六章 改进控制器和视图

一、为视图模板定义辅助方法

二、编码和部署部分视图模板

<%= @page_title %>

Welcome, <%= @c.first_name %>.

Browse works by...

Log in or create an account

三、更新主控制器

四、加入顾客注册的登录动作

Log in or create an account

五、处理顾客订单

<%= @page_title %>

Contents:

Thanks for your order, <%= @c.first_name %>!

六、通过动态代码使页面人性化

Your favorites

[RoR] Ruby for Rails 最佳实践ⅩⅤ[FL车在臣]

第十五章 通过编程改进 ActiveRecord 模型

一、软模型改进与硬模型改进

二、模型的软编程改进

三、硬模型改进

四、用类方法扩展模型功能

[RoR] Ruby for Rails 最佳实践ⅩⅣ[FL车在臣]

第四部分 结合 Ruby 和 Rails

第十四章 再次为 R4RMusic 应用领域建模

一、跟踪 ActiveRecord 模型实例的功能

二、改进领域模型

[RoR] Ruby for Rails 最佳实践ⅩⅢ[FL车在臣]

第十三章 Ruby 动态特性

一、单例类的位置和角色

二、 方法族

三、可调对象

四、回调方法和钩子方法

五、覆盖和增加核心功能

[RoR] Ruby for Rails 最佳实践Ⅻ[FL车在臣]

第十二章 正则表达式和基于它的字符串操作

一、什么是正则表达式

二、编写正则表达式

三、关于匹配和 MatchData 的更多内容

四、更多正则表达式技术

五、使用正则表达式的常见方法

[RoR] Ruby for Rails 最佳实践Ⅺ[FL车在臣]

第十一章 集合、容器和可枚举性

一、数组和散列的比较

二、使用数组

三、散列

四、集合的中心：Enumerable 模块

五、集合排序

[RoR] Ruby for Rails 最佳实践Ⅹ[FL车在臣]

第十章 标量对象

一、使用字符串

二、符号及其用法

三、数值对象

四、时间和日期

[RoR] Ruby for Rails 最佳实践Ⅸ[FL车在臣]

第三部分 内建类和内建模块

第九章 内建类和内建模块基础知识

一、Ruby 的字面构造器

二、反复出现的语法糖衣

三、改变或者不改变其接收者的方法

四、内建和定制的 to_*（转换）方法

五 、再论迭代器

六、布尔状态、布尔对象和空对象

七、比较两个对象

八、列出对象的方法

[RoR] Ruby for Rails 最佳实践Ⅷ[FL车在臣]

第八章 控制流技术

一、条件代码执行

二、用循环重复动作

三、代码块、迭代器和 yield 关键字

四、错误处理和异常

[RoR] Ruby for Rails 最佳实践Ⅶ[FL车在臣]

第七章 默认对象(self)和作用域

二、确定作用域

第十六章改进控制器和视图

第十五章通过编程改进 ActiveRecord 模型

第四部分结合 Ruby 和 Rails

第十四章再次为 R4RMusic 应用领域建模

二、方法族

第十二章正则表达式和基于它的字符串操作

第十一章集合、容器和可枚举性

第十章标量对象

第三部分内建类和内建模块

第九章内建类和内建模块基础知识

五、再论迭代器

第八章控制流技术

第七章默认对象(self)和作用域

第六章模块和程序组织

第五章用类组织对象

第四章对象和变量

第三章了解 Ruby 前提下的 Rails 开发