博客

Ruby 对待文件与 I/O 操作也是面向对象的。

Ruby 的 I/O 系统

IO 类处理所有的输入与输出流。

IO 类

IO 对象表示可读可写的到磁盘文件，键盘，屏幕或设备的连接。

程序启动以后会自动设置 STDERR，STDIN，STDOUT 这些常量。STD 表示 Standard，ERR 是 Error，IN 是 Input，OUT 是 Output。

标准的输入，输出，还有错误流都封装到了 IO 的实例里面。做个实验：

>> STDERR.class
=> IO
>> STDERR.puts("problem!")
problem!
=> nil
>> STDERR.write("problem!\n")
problem!
=> 9

STDERR 是一个 IO 对象。如果一个 IO 对象开放写入，你可以在它上面调用 puts，你想 puts 的东西会写入到 IO 对象的输出流里。IO 对象还有 print 与 write 方法。 write 到 IO 对象的东西不会自动添加换行符，返回的值是写入的字节数。

Ruby 正则表达式的字面构造器：

//

试一下：

>> //.class
=> Regexp

模式匹配有两个部分组成，一个正则表达式（regexp），还有一个字符串。正则表达式预测字符串，字符串要么满足预测，要么不满足。

看看是不是匹配可以使用 match 方法。做个实验：

>> puts "匹配！" if /abc/.match("the alphabet starts with abc.")
匹配！
=> nil
>> puts "匹配！" if "the alphabet starts with abc.".match(/abc/)
匹配！
=> nil

除了 match 方法，还有个模式匹配操作符 =~ ，把它放在字符串与正则表达式的中间用：

掌握基础

我多想能跳过基础，跳过那些看起来没有什么意义的东西，我看不出它们跟我想要的产品之间有任何的关联。我不想浪费力气，我多想能直接去实现自己的想法，我失败了，我猜如果你像我一样，也可能会失败。不管你有多看不起 “基础” 这两个字，你也永远不能摆脱它，所有的一切都是从这里开始的。

挂档起步

比起开车起步，作为一名自由职业者，软件工程师，互联网企业的创业家的起步步骤要简单一些。HTML — CSS — JavaScript — PHP/Ruby/Python/Go/Swift。困难的工作已经被别人做了，我们只是去利用一下这些东西，又有何难。看这篇文字的人的智力一定比写这篇文字的那个人要高很多。要做的也只是学几个单词，理解几个概念，了解一些规则而已。

快速试验

有了一个想法，先别花一年或更长时间才能测试并得到反馈，最多也不能超过半年，要用最简单的产品快速的得到反馈的结果（从《精益创业》学来的）。Drupal，WordPress，在早期都能很好的帮助咱们，去实现一些比较简单的想法，更重要的是快速的试验想法是否可行。可能一两个月就可以让你的想法在线上测试了。

想要枚举的 Class 就得有一个 each 方法，它的工作就是 yield 项目给代码块，每次一个。

each 做的事在不同的类上可能不太一样，比如在数组上，each 会 yield 第一个项目，然后是第二个，第三个 ...  在 hash 里，yield 的是 key/value 作为两个元素的数组。在 file 处理上，每次会 yield 一行内容。range 迭代会先看一下有没有可能迭代，然后假装它是一个数组。在自己的类里定义了 each 方法，它的意思是你自己定义的，只要它 yield 点东西就行。

先写个类，理解一下 Enumerable 是怎么回事。Rainbow 彩虹，每次 yield 一种颜色：

class Rainbow
  include Enumerable

  def each
    yield 'red'
    yield 'orange'
    yield 'yellow'
    yield 'green'
    yield 'blue'
    yield 'indigo'
    yield 'violet'
  end
end

数组（array），散列（hash）。array 里的项目有顺序，你可以用索引号得到对应的项目。hash 里的项目是成对的，一对里有个 key 还有个对应的 value。得到项目的 value 可以使用项目的 key 。

任何的 Ruby 对象都可以作为 hash 的 key 或者 value ，不过注意 key 在 hash 里一定是唯一的。hash 在其它的语言上也叫 dictionaries 或者 associative arrays  。

array 与 hash 很像。在某种意义上 array 就是 hash，只不过它的 key 是连续的整数。hash 有某种意义上也是 array，只不过索引可以是任何东西。

做个实验：

array = ["ruby", "diamond", "emerald"]
hash = { 0 => "ruby", 1 => "diamond", 2 => "emerald" }
puts array[0] # ruby
puts hash[0] # ruby

再做个实验：

2016年9月11日 下午6:46 **

字符串

String 与 Symbol 这两个类提供了表示文字与处理文字的功能。这两个类之间很不同。

字符串表示

一个字符串一般用一组引号包装：

"这就是一个字符串"

单引号也行：

'我也是个字符串'

使用字符插值的时候得用双引号：

puts "二加二等于 #{2 + 2}"
puts '二加二等于 #{2 + 2}'

输出的内容是：

二加二等于 4
二加二等于 #{2 + 2}

单引与双引在 escape 时的区别：

2016年9月10日 下午4:17 ***

Ruby 的字面构造器

Ruby 大部分的内置类可以使用 new 来实例化：

str = String.new
arr = Array.new

有些类不能使用 new 来实例化，比如 Integer 类。有些内置类可以使用字面构造器，就是不需要使用 new ，可以使用一种特别的形式来创建类的实例。

跟朋友吹牛：“我经常工作到凌晨两三点”，忽悠客户：“这个项目花了我三个月的时间”。经常工作到凌晨说明的只是你比较喜欢在晚上工作。做项目花了三个月时间，如果我是客户，我会想，你是每天两小时，持续了三个月，还是每天八小时持续了三个月。你是怎么知道自己到底在某件事情上花了多长时间？不能胡诌，要用一个简单的科学的方法，就是用你的手表掐算时间，当然更好的方法是使用时间跟踪的软件。

我也是最近才使用了时间跟踪，因为我想记录未来 30 天的工作与学习的过程，看一下到底花了多久学会一门语言跟框架。Toggl 是我用的跟踪软件，跨平台，简单易用。在框框里输入你想干的事，给事情选择个对应的项目，也可以打上几个标签，就可以开始跟踪了，在你的手机，电脑上都可以看到跟踪的状态。

我觉得时间跟踪可以作为一种工作与学习的方法。使用这种方法以后，我很少出现脑袋要分裂的状态，以前如果我经常在两三件事情上来回切换，过一阵脑袋就像是要裂开一样，疲惫，无法再继续学习或工作。

时间跟踪要求你，先做一个简短的计划，这个任务计划应该在秒级单位时间完成。然后把你要做的事情交给跟踪软件，开始你的任务，这个过程有点像是一种强制手段，迫使你不能干其它的事情。停下任务，就停止跟踪时间，稍后可以继续这个任务。

2016年9月8日  下午7:12 ***

之前我们见过方法的调用，它会让程序从调用方法的地方跳到方法的定义主体那里。程序并不是按直线运行的，执行的顺序会受到一些规则还有一些被称为控制流的程序设计结构的影响。

Ruby 的控制流有下面这些：

• 条件执行（Conditional execution）— 根据表达式的真实性执行。
• 循环（Looping）— 一块儿重复执行的代码。
• 迭代（Iteration）— 调用方法的时候给它提供一块儿代码，方法在它执行的时候可以多次调用这块代码。
• 异常（Exceptions）— 处理异常情况。

按条件执行代码

Ruby 提供了一些基于条件控制程序流的方法。有两大类，if 还有 case 。

if 跟它的朋友们

if 用起来像这样：

if condition
  # condition 如果是 true 就执行这里的代码
end

if 可以嵌套使用：

2016年9月7日 下午5:37 ***

有些东西在任何时间任何地方表示的意思是不变的，比如整数，你看到的就是它表示的东西。关键词也一样，你不能使用 def，class 这些关键词作为变量名，所以当你看到它们的时候，你可以很容易知道它们是做什么的。不过还有很多东西的意思取决于它们所处的情境，也就是它们在不同的时间不同的地方的意思可能是会有变化的。

self 表示的是当前或者默认的对象，在程序运行的时候每次它都会表示一个特定的对象。永远都只会有一个 self ，但是它表示的东西是会变的。

作用域（scope）的规则决定了变量的可见性。你要知道所在的地方受哪个作用域的影响，这样你才能明白哪些变量表示的是什么，不致于把它们跟在其它的作用域的同名变量混淆。

知道当前是在哪个作用域，了解 self 表示的对象是谁，这样你才能明白到底发生了什么，才可以快速的分析遇到的问题。

下午 5:54 ***

self

下午6:07 ***

使用关键词 self 可以得到当前对象。在程序运行中，有且只有一个 self 。成为 self 有一些特权，一会儿我们会看到。永远都只会有一个当前对象或者叫 self 。是谁在哪里会成为 self 是有一些规则的。