skpark1987

[Elixir 基础] 复合类型: Tuple

skpark1987 — Mon, 18 Sep 2017 23:48:55 +0800

最近在学习 Elixir 开发，因为它是面向函数的编程语言，像我这种一直做面向对象开发的人来说很多东西很难理解。因此我打算写一系列基础篇的文章，既巩固自己的知识，也希望对其他学习该技术的人有帮助。

往期回顾
【Elixir 基础】复合类型：List

我们会以定义，常用的操作符，方法，性能的顺序来进行学习。

定义

Elixir 中的 Tuple 是一个有序集合，它既可以包含任意类型的元素，又可以包含不同的类型。使用大括号进行定义

iex(3)> {1, :two, "three"}
{1, :two, "three"}

tuple 在内存中是使用连续的内存块进行保存，它意味着访问某一个元素是固定消耗，不会随着 tuple 的大小而改变。

iex(4)> tuple = {1, :two, "three"}
{1, :two, "three"}
iex(5)> elem(tuple, 0)
1
iex(6)> elem(tuple, 2)
"three"

因为 tuple 是使用连续的内存区域进行保存，所以修改 tuple 中的某个元素的时候我们需要对整个代码块进行复制，所以数据量大的时候会相当消耗内存。在 Elixir 中 tuple 一般不会当做集合来使用，而是当做一个容器包含多个值。比如调用方法的时候返回{:ok, value} 和 {:error, reason}

{:ok, ["tribe", "tribe.ex", "tribe_web", "tribe_web.ex", "tribe_web_admin.ex"]}
iex(6)> File.ls("aaa")
{:error, :enoent}

常用的方法

iex(7)> tuple = {1, "abc", :hello, true}
{1, "abc", :hello, true}
# 访问元素
iex(8)> elem(tuple, 1)
"abc"
# 更新元素
iex(9)> put_elem(tuple, 1, "def")
{1, "def", :hello, true}
# tuple大小
iex(10)> tuple_size(tuple)
4
# 尾部追加
iex(2)> Tuple.append(tuple, :world)
{1, "abc", :hello, true, :world}
# 删除指定下标的元素
iex(4)> Tuple.delete_at(tuple, 3)
{1, "abc", :hello}
# 插入元素(注意是插入，不会对已有的值进行更新)
iex(5)> Tuple.insert_at(tuple, 1, 25)
{1, 25, "abc", :hello, true}
# 用指定的元素和大小来创建tuple
iex(6)> Tuple.duplicate("hello", 5)
{"hello", "hello", "hello", "hello", "hello"}

性能

在前面的 List 文章里我们对比过头部追加和尾部追加时候的性能差异，这次我们看看当使用 tuple 的时候跟 list 有哪些的不同。

defmodule Recursion do
  def prepend_elem(tuple, elem, n) when n <= 1 do
    Tuple.insert_at(tuple, 0, elem)
  end

  def prepend_elem(tuple, elem, n) do
    tuple = Tuple.insert_at(tuple, 0, elem)
    prepend_elem(tuple, elem, n - 1)
  end

  def append_elem(tuple, elem, n) when n <= 1 do
    Tuple.insert_at(tuple, tuple_size(tuple), elem)
  end

  def append_elem(tuple, elem, n) do
    tuple = Tuple.insert_at(tuple, tuple_size(tuple), elem)
    append_elem(tuple, elem, n - 1)
  end
end
IO.puts "start prepend"
prepend_start_time = Time.utc_now |> Time.to_string
Recursion.prepend_elem({}, :a, 1_00_000)
prepend_end_time = Time.utc_now |> Time.to_string
IO.puts "start at #{prepend_start_time}" 
IO.puts "end at #{prepend_end_time}"
IO.puts "------------------------"
IO.puts "start append"
append_start_time = Time.utc_now |> Time.to_string
Recursion.append_elem({}, :b, 100000)
append_end_time = Time.utc_now |> Time.to_string
IO.puts "start at #{append_start_time}" 
IO.puts "end at #{append_end_time}"
tuple_10000 = Tuple.duplicate(:a, 10000)
tuple_1000000 = Tuple.duplicate(:a, 1000000)
IO.puts "------------------------"
IO.puts "start get element"
tuple10000_start_time = Time.utc_now |> Time.to_string
elem(tuple_10000, 5000)
tuple10000_end_time = Time.utc_now |> Time.to_string
IO.puts "access tuple(10000) at #{tuple10000_start_time}" 
IO.puts "end tuple(10000) at #{tuple10000_end_time}"
tuple1000000_start_time = Time.utc_now |> Time.to_string
elem(tuple_1000000, 500000)
tuple1000000_end_time = Time.utc_now |> Time.to_string
IO.puts "access tuple(1000000) at #{tuple1000000_start_time}" 
IO.puts "end tuple(1000000) at #{tuple1000000_end_time}"

start prepend
start at 15:41:26.662224
end at 15:41:35.553280
------------------------
start append
start at 15:41:35.553460
end at 15:41:44.633456
------------------------
start get element
access tuple(10000) at 15:41:44.643669
end tuple(10000) at 15:41:44.643698
access tuple(1000000) at 15:41:44.643723
end tuple(1000000) at 15:41:44.643729

我们首先测试了当追加 10 万条元素的时候，头部追加和尾部追加的性能。结果发现性能基本相同，不像 List 有很大的性能差异性。后来又测试了不同的数据量的时候的访问的性能，结果也是一样，跟上面提的访问某一个元素是固定消耗的观点相吻合。

[Elixir 基础] 复合类型: List

skpark1987 — Thu, 14 Sep 2017 22:57:08 +0800

最近在学习 Elixir 开发，因为它是面向函数的编程语言，像我这种一直做面向对象开发的人来说很多东西很难理解。因此我打算写一系列基础篇的文章，既巩固自己的知识，也希望对其他学习该技术的人有帮助。

我们会以定义，常用的操作符，方法，性能的顺序来进行学习。

定义

Elixir 中的 List 是使用中括号来表示的。Elixir 中的 List 是一个高性能的链表，它意味着 List 内部是[头部, 尾部]来组成的

iex(27)> [1, 2, true, 3]
iex(28)> [head | tail] = [1, 2, 3]
iex(29)> head
1
iex(30)> tail
[2, 3]

注意，大部分情况下 head 是某一个元素，而 tail 是包含除了第一个元素的其他元素的数组。因为内部是链表的方式实现的，在头部添加某个元素是很快速的（恒定时间），而添加到尾部所消耗的时间是随着 List 的大小而增加。稍后我们会演示用两种方式追加时候的性能。

常用的操作符

# 添加元素
[1, 2] ++ [3] # [1, 2, 3]
# 删除元素
[1, 2, 3, 4] -- [3, 2] # [1, 4]
# 进行比较
[3, 2] === [3, 2] # true

常用的方法

基本上看List 模块和Enum 模块就能了解大部分方法了，下面列出常用的几个。

# 获取头部元素
iex(81)> hd [1,2,3]
1
# 获取尾部数组
iex(82)> tl [1,2,3]
[2, 3]
# 获取列表长度
iex(83)> length [1,2,3]
3
# 遍历元素
iex(84)> Enum.each [1,2,3], fn(x) ->
...(84)>   IO.puts x
...(84)> end
1
2
3
# 根据下标进行访问
iex(86)> Enum.fetch([1, 2, 3], 2)
{:ok, 3}
# 删除某个元素
iex(106)> List.delete([1,2,3,4,"a"], "a")
[1, 2, 3, 4] #不保证肯定删除（找到了才删，没找到返回原来的列表）
# 删除指定下标的元素
iex(110)> List.delete_at([1,2,3,4,"a"], 4)
[1, 2, 3, 4] #不保证肯定删除（找到了才删，没找到返回原来的列表）
# 在指定的位置插入新的元素
iex(112)> List.insert_at([1,2,3,4,"a"], 4, 5)
[1, 2, 3, 4, 5, "a"]
# 删除重复元素
iex(88)> Enum.uniq([1, 2, 3, 3, 2, 1])
[1, 2, 3, 2, 1]
# 数组元素进行连接
iex(90)> Enum.join([1, 2, 3])
"123"
iex(91)> Enum.join([1, 2, 3], " = ")
"1 = 2 = 3"
# 随机获取某一个元素
iex(92)> Enum.random [1,2,3,4,5]
1
iex(93)> Enum.random [1,2,3,4,5]
3
# 顺序打乱
iex(94)> Enum.shuffle [1,2,3,4,5]
[4, 5, 3, 2, 1]
# 进行排序
iex(100)> Enum.shuffle([1,2,3,4,5]) |> Enum.sort
[1, 2, 3, 4, 5]
# 从头部获取n个元素
iex(101)> Enum.take([1,2,3,4,5], 3)
[1, 2, 3]
# 随机获取n个元素
iex(102)> Enum.take_random([1,2,3,4,5], 3)
[5, 1, 4]
# 对数组里的数字进行求和
iex(105)> Enum.sum 1..10
55

性能

下面的程序为在头部追加和尾部追加时候的性能对比

defmodule Recursion do
  def prepend_elem(list, elem, n) when n <= 1 do
    list = elem ++ list
  end

  def prepend_elem(list, elem, n) do
    list = elem ++ list
    prepend_elem(list, elem, n - 1)
  end

  def append_elem(list, elem, n) when n <= 1 do
    list = list ++ elem
  end

  def append_elem(list, elem, n) do
    list = list ++ elem
    append_elem(list, elem, n - 1)
  end
end
IO.puts "start prepend"
prepend_start_time = Time.utc_now |> Time.to_string
list = Recursion.prepend_elem([], [1], 100000)
prepend_end_time = Time.utc_now |> Time.to_string
IO.puts "start at #{prepend_start_time}" 
IO.puts "end at #{prepend_end_time}"
IO.puts "------------------------"
IO.puts "start append"
append_start_time = Time.utc_now |> Time.to_string
list = Recursion.append_elem([], [1], 100000)
append_end_time = Time.utc_now |> Time.to_string
IO.puts "start at #{append_start_time}" 
IO.puts "end at #{append_end_time}"

start prepend
start at 15:10:24.463439
end at 15:10:24.474485
------------------------
start append
start at 15:10:24.483897
end at 15:10:48.547505

结论：头部追加 (prepend)10 万次：10 毫秒。尾部追加 (append)10 万次：24 秒（元素越多越慢），2400 倍

在 Phoenix 中使用 UIKit 和 SCSS

skpark1987 — Wed, 13 Sep 2017 22:24:21 +0800

通过这篇文章，我们学习如何在 Phoenix(当前版本是 1.3) 中安装 UIKit3。

预备知识

显然你的电脑中应该安装Elixir和Phoenix。你还需要安装NPM，通过它我们会安装Brunch及其它的一些依赖库。

安装

先新建一个 Phoenix 工程，

mix phx.new phx_uikit

当安装依赖库的时候注意最后一行

* running cd assets && npm install && node node_modules/brunch/bin/brunch build

它将会执行npm install，在 assets 目录中安装brunch构建工具因此下一步进入到assets目录后，安装相关的依赖库

cd phx_uikit/assets
npm install --save-dev sass-brunch
npm install --save uikit jquery

我们将会安装sass-brunch来编译 SCSS/SASS，我们还将安装uikit及jQuery(因为 uikit 需要它)。 ###配置我们安装好了依赖库，现在做一下简单的配置。所有的配置代码都是在assets/brunch-config.js中进行。把下面的代码拷贝到该文件的 plugins 对象里：

sass: {
  options: {
    includePaths: ["node_modules/uikit/src/scss"]
  }
}

下一步我们需要添加 uikit 的 JavaScript 库到 app 中。我们仅需要添加下面的代码到 npm 对象：

globals: {
  $: "jquery",
  uikit: "uikit",
  icons: "uikit/dist/js/uikit-icons"
}

这一段会告诉 brunch 我们将使用 $ 来全局使用 jQuery，用 uikit 来使用 uikit。我们还会使用 uikit 的图标。因此添加下面的代码到 app.js 。

uikit.use(icons);

导入

为了使用 UIKit 所提供的 SCSS 文件，我们需要导入 SCSS 到我们到 main SCSS 文件。首先我们重命名 app.css 为 app.scss，并且删除 phoenix.css。然后添加下面的代码到 app.scss 中。

@import "variables-theme";
@import "mixins-theme";
@import "uikit-theme";

这将会导入 uikit SCSS 到我们的工程当中。

测试

我们仅需要添加下面的代码到app.html.eex中来进行测试。

<div class="uk-alert-danger" uk-alert>
  <a class="uk-alert-close" uk-close></a>
  <h3>Notice</h3>
  <p>This is a paragraph</p>
</div>

启动mix phx.server查看结果。

原文链接

github 地址

View 当中的 CoffeeScript 的问题

skpark1987 — Thu, 27 Apr 2017 13:48:27 +0800

当前场景是，当我点击画面中的编辑链接时会调用edit.js.erb执行相关处理，当我把该处理文件重命名为edit.js.coffee时（也就是使用 coffeescript），相同的内容无法执行，也不会输出任何错误 log

// 环境   ruby: 2.4.0
//        rails: 5.0.2
// index，用的模板是slim
= link_to note.title, edit_note_path(note), remote: true

// controller
def edit
    @note = Note.find(params[:id])
    respond_to do |format|
       format.html
       format.js {render layout: false}
    end
end

// edit.js.erb
note = <%= @note.to_json.to_s.html_safe %>;
title = note['title']
action_path = "<%= note_path(@note) %>";
form_template = `
<form accept-charset="UTF-8" action="${action_path}" method="PUT">
  <input name="_method" type="hidden" value="put" />
  <input name="utf8" type="hidden" value="&#x2713;" />
  <input name="authenticity_token" type="hidden" value="<%= form_authenticity_token %>" />
  <div class="field">
    <label for="note_title">Title</label>
    <input type="text" name="note[title]" id="note_title" value="${note['title']}"/>
  </div>
  <div class="field">
    <label for="note_content">Content</label>
    <textarea name="note[content]" id="note_content">${note['content']}</textarea>
  </div>
  <div class="field">
    <input type="submit" name="commit" value="Create" class="btn btn-primary" data-disable-with="Create">
  </div>
</form>
`
$("#note_form").html(form_template);

能帮我看看，代码有什么问题吗。

Rails 常用断言方法整理

skpark1987 — Sun, 19 Jul 2015 02:25:12 +0800

assert assert_not assert_empty(obj, msg=nil) assert_equal(exp, act, msg=nil): 使用==进行判断 assert_same(exp, act, msg=nil): 使用 equal? assert_match(matcher, obj, msg=nil): 匹配正则表达式 exp =~ act assert_template(options = {}, message = nil)

# new模板
assert_template "new"
# 绝对路径的模板
assert_template %r{\Aadmin/posts/new\Z}
# 指定layout键
assert_template layout: 'admin'
assert_template layout: 'layouts/admin'
# _customer布局被渲染两次
assert_template partial: '_customer', count: 2
# 一个文件被渲染
assert_template file: "README.rdoc"

assert_difference(expression, difference=1, message=nil, &block)

#assert_difference ‘Article.count’ do
#assert_difference [ ‘Article.count’, ‘Post.count’ ], 2 do
#assert_difference ->{ Article.count }, 2 do
assert_difference [->{ Article.count }, ->{ Post.count }], 2 do
    post :create, article: {…}
end

assert_no_difference(expression, message=nil, &block) assert_redirected_to(options={}, message=nil)

# 指定controller及action
assert_redirected_to controller: "weblog", action: "index"
# 指定url
assert_redirected_to login_url
# @customer对象的show页面
assert_redirected_to @customer
# 满足正则表达式
assert_redirected_to %r(\Ahttp://example.org)

assert_response 指定 response 为下列中的一个 :success - Status code was in the 200-299 range :redirect - Status code was in the 300-399 range :missing - Status code was 404 :error - Status code was in the 500-599 range *assert_select(*args, &block) *

# 两个ol列表，里面包含4个li
assert_select "ol" do |elements|
  elements.each do |element|
    assert_select element, "li", 4
  end
end
assert_select "ol" do
  assert_select "li", 8
end

相等性测试结构：assert_select "元素选择器", 判断参数判断参数有以下的可能性 true 至少有一个元素 false 没有相应的元素 String/Regexp 至少有一个元素的文本内容与正则/字符串相匹配 Integer 有指定个数的元素 Range 存在范围内个数的元素当执行多个相等性测试的时候，可以使用以下 hash 键 :text 筛选指定文本内容的元素 (字符串/正则) :html 筛选指定 HTML 内容的元素 (字符串/正则) :count 元素的个数与指定个数一致时返回 true :minimum 选择的元素的最小个数 :maximum 选择的元素的最大个数

# 至少有一个form元素
assert_select "form"
# form元素包含四个input元素
assert_select "form input", 4
# title为welcome
assert_select "title", "Welcome"
# title为Welcome，并且只有一个title元素
assert_select "title", {count: 1, text: "Welcome"},
    "Wrong title or more than one title element"
# 页面没有form元素
assert_select "form", false, "This page must contain no forms"
# 测试HTML元素及类结构
assert_select "body div.header ul.menu"
# 用正则判断指定li元素的ID是否符合要求
assert_select "ol>li#?", /item-\d+/
# form元素内的所有input元素的name有值
assert_select "form input" do
  assert_select "[name=?]", /.+/  # Not empty
end

基础理解 class_eval 和 instance_eval

skpark1987 — Mon, 25 May 2015 19:42:58 +0800

原文链接：Understanding class_eval and instance_eval 比起别的方法，这个两个方法更加让人困惑，尤其是他们的解释。它们是 class_eval 和 instance_eval。名字很相似，但行为有悖常理。

使用ClassName.instance_eval方法可以定义一个类方法
使用ClassName.class_eval可以定义一个实例方法。为了明白这个定义的原因，我们举个例子。 ```ruby class MyClass def initialize(num) @num = num end end

a = MyClass.new(1) b = MyClass.new(2)

继续学习下一步之前，要记住Ruby中任何东西都是对象。这意味着类也是一个对象。当你定义MyClass，Ruby会创建名字叫 MyClass 的全局变量， 它是一个类对象。当你使用MyClass.new时，它会给你MyClass的一个实例。你平常使用的实际对象都是实例。一个类拥有多个实例。因此我们拥有两个相同类名的实例对象。当然，目前为止它还不是很有用，因为它没做任何的工作。我们无法访问 @num 变量，因为我们还没定义 getter 和 setter方法。
```ruby
irb> a.num
NoMethodError: undefined method `num' for #<MyClass:0x007fba5c02c858 @num="1">

让我们更加清楚地了解 instance_eval。使用它我们能做什么？我们可以像正在访问某个对象的内部方法一样运行代码。意思是我们可以访问实例变量及 private 方法。为了取出@num的值，让我们评估一下 MyClass 实例。

irb> a.instance_eval { @num }
=> 1
irb> b.instance_eval { @num }
=> 2

这个执行的很好，但当做很多事的时候有些不方便，让我们定义一个方法，简化操作。

irb> a.instance_eval do
irb>   def num
irb>     @num
irb>   end
irb> end
=> nil
irb> a.num
=> 1
irb> b.num
NoMethodError: undefined method `num' for #<MyClass:0x007fba5c08e5f8 @num="2">

我们使用了 instance_eval，它只能在某个对象的内部进行评估。我们定义了一个方法，但是它只对应于特定的对象 a。我们如何定义一个可以被类的所有对象共享的方法呢？获取我们需要在类对象中定义一个方法。

irb> MyClass.instance_eval do
irb>   def num
irb>     @num
irb>   end
irb> end
=> nil
irb> b.num
NoMethodError: undefined method `num' for #<MyClass:0x007fba5c08e5f8 @num="2">

很不幸运，它也不好用。到底发生了什么？我们在类中做了跟之前的例子一样的操作。我们在类中定义了一个方法，但它不意味着该类的对象可以把方法继承下来，而是我们在类中定义了类似于 def self.num的方法，它跟 Java 中的静态方法很像。这个方法必须以 MyClass.num 的方式进行激活，所以它无法被实例方法调用：

irb> MyClass.num
=> nil

在这里我们会获得 nil。因为在 MyClass 对象中没有@num变量。未定义的变量会有默认值 nil。好吧，那正确的解决方式是什么呢？答案为 class_eval：

irb> MyClass.class_eval do
irb>   def num
irb>     @num
irb>   end
irb> end
=> nil
irb> b.num
=> 2

Yes! 成功了。我们给类定义了方法，而不是类对象，并且该方法可以被所有的类对象所使用。注意我们是在 MyClass 中调用了class_eval，而不是类对象。在实例中无法调用class_eval因为class_eval不是实例方法，只有像 MyClass 这样的类才能使用。但是你可以通过调用 class 方法获取该实例的 Class。

irb> a.class_eval
NoMethodError: undefined method `class_eval' for #<MyClass:0x007fba5c02c858 @num="1">
irb> a.class.class_eval {}
=> nil

需要注意的是上例中使用 class_eval 定义的方法其实跟下例有一样的效果。

class MyClass
  def num
    @num
  end
end

元编程进一步理解 metaclass

skpark1987 — Fri, 22 May 2015 19:58:10 +0800

原文链接：Seeing Metaclasses Clearly 如果你刚开始使用元编程，并且想要使用它的话，下面的四个方法或许会给你一些帮助。

class Object
   # 扩展Object类，添加metaclass方法，返回meta-class
   def metaclass; class << self; self; end; end
   def meta_eval &blk; metaclass.instance_eval &blk; end

   # 添加方法到meta-class
   def meta_def name, &blk
     meta_eval { define_method name, &blk }
   end

   # 类里创建实例方法
   def class_def name, &blk
     class_eval { define_method name, &blk }
   end
 end

我将把这些文件保存到 metaid.rb的文件，为了使用 metaclass 更方便，我准备创建一个库。让我们开始讨论 metaclass 吧，我建议你最好在电脑里也保存一份metaid.rb。花点时间把这篇文章里的代码都执行一遍，你会发现对元编程的理解更加深刻了。

关于 Class

好吧，什么是 Class? 让我们创建一个简单的对象了解一下。

class MailTruck  #Truck意思是卡车
  attr_accessor :driver, :route
  def initialize( driver, route )
    @driver, @route = driver, route
  end
end

m = MailTruck.new( "Harold", ['12 Corrigan Way', '23 Antler Ave'] ) 
#=> <MailTruck:0x007fda0094ebc0 @driver="Harold", @route=["12 Corrigan Way", "23 Antler Ave"]> 
m.class
#=> MailTruck

对象是保存变量的存储器。MailTruck 是一个对象，当实例化后，会有@driver和@route变量。当然它也可以持有其他任何类型的变量。

m.instance_variable_set( "@speed", 45 )
m.driver
#=> Harold
m.instance_variables
#=> [:@driver, :@route, :@speed]

好吧，@driver实例变量有一个访问控制器。当 Ruby 在 MailTruck 类的定义中看到attr_accessor :driver的时候，你可以获取Reader和Writer方法。方法 driver以及 driver= 。这些方法保存在类中。因此实例变量保存在对象里而访问控制方法（Reader 和 Writer）保存在类定义里。他们是两个完全不同的地方。 这是一个很重要的知识：对象不会保存方法，只有类才能保存

类是对象

好吧，但是类是对象，不是吗？我的意思是 Ruby 中的任何东西都是对象，因此类和对象都是对象才对。是什么东西导致他们一样？当然，类是对象。你可以在类中运行所有在该类的对象里可以运行的方法。运行下例，他们都会有 ID 及符号表。

m.object_id
MailTruck.object_id

但是我之前告诉过你：类保存方法。他们是不同的。现在我知道你已经有些糊涂了，“如果类是对象，对象的创建是基于类，这样的话不是导致无线循环了吗？” 不，没有。这点我不是很愿意跟你说，但是类不是真正的对象。从 Ruby 的源代码，我们看到：

struct RObject {
   struct RBasic basic;
   struct st_table *iv_tbl;
 };

struct RClass {
  struct RBasic basic;
  struct st_table *iv_tbl;
  struct st_table *m_tbl;
  VALUE super;
};

注意！一个类它含有 m_tbl(一个符号表用来保存方法) 和一个父类 (指向父类)。但是让我考考你。作为 Ruby 程序员，一个类是一个对象。因为它满足两个重要的条件：你可以在类中保存实力变量及它可以从它是从 Object 类而来。就这么简单。

o = Object.new
#=> <Object:0x007fda0185f2b8>
o.class
#=> Object
Class.superclass.superclass
#=> Object
Object.class
#=> Class
Object.superclass
#=> BasicObject

Object 类处于很顶层的类当只有在其他地方找不到方法时才会加入进来。

Metaclass 到底是什么

我们可以假设metaclass为“一个可以定义 class 的 class”。尽管这个定义在 Ruby 中不怎么行得通。“一个可以定义 class 的 class”，其实就是一个类。

class Class
  def attr_abort( *args )
    abort "Please no more attributes today."
  end
end

class MyNewClass
  attr_abort :id, :diagram, :telegram
end

会打印“Please no more attributes today.”。attr_abort 方法可以在定义中被使用。你常常在 Ruby 中定义，再定义类。它不是 meta，它仅仅是代码中的一部分。类持有方法。你还觉得它复杂吗？既然之前的定义不再有效了，我认为 Ruby 的metaclass可以被理解为“一个类，通过这个类对象可以重新定义自己”。

对象是否需要 metaclass

对象是无法持有方法的。大部分对象没必要保存方法。但是有些时候你希望一个对象能够保存一些方法。你没法做到这些。但 Matz 提供给我们 metaclass，它足够有些可以实现这些功能。在 YAML库中，当一个对象输出时你可以自定义属性。

require 'yaml'
class << m
  def to_yaml_properties
    ['@driver', '@route']
  end
end

YAML::dump m
#=> --- !ruby/object:MailTruck
#=> driver: Harold
#=> route:
#=>   - 12 Corrigan Way
#=>   - 23 Antler Ave

当你想要在不影响其他对象的前提下 dump 某个对象为指定的 YAML 风格时这是很方便的。上例中，只有 m 变量中的对象才会以属性的顺序进行输出。 MailTruck 类的其他对象还是按照 YAML 库所选择的顺序进行输出。有时候我们想要以指定的格式格式显示字符串而不更改 String 类 (如果更改 String 类，会影响你的所有代码)。因此 m 变量中的对象拥有它自己的to_yaml_properties 方法。它保存在 metaclass。metaclass 为对象保存方法并且在继承链中紧挨着对象。我们还可以用以下几种方式添加to_yaml_properties**方法。

def m.to_yaml_properties
  ['@driver', '@route']
end

如果你载入这篇文章的头部提供的metaid.rb代码的话，试试以下代码：

m.metaclass
#=> #<Class:#<MailTruck:0x81cfb94>>
m.metaclass.class
#=> Class
m.metaclass.superclass
#=> #<Class:MailTruck>
m.metaclass.instance_methods
#=> [..., "to_yaml_properties", ...]
m.singleton_methods
#=> ["to_yaml_properties"]

当你使用 ** class << m ** 语法的时候，你正在打开metaclass。Ruby 会调用这些虚拟类 (virtual class)。注意 m.metaclass的结果。一个类附加到一个对象：

#=> #<Class:#<MailTruck:0x81cfb94>>

当一个对象在附加的 metaclass 中找到方法时，这些方法被引用为对象的单数方法 (singleton method，中文名称自己理解就行，好像没有标准翻译) 而不是类的 metaclass 的实例方法。并且因为只有一个 metaclass 附加到对象，它被称呼为单数方法。当你使用 metaclass 的方法时，很容易找到 metaclass。一般，你可以使用 ** class << self; self; end **来获取 metaclass。但这个更加简单。 metaclass 是否需要 metaclass？

m.metaclass.metaclass
#=> #<Class:#<Class:#<MailTruck:0x81cfb94>>>
m.metaclass.metaclass.metaclass
#=> #<Class:#<Class:#<Class:#<MailTruck:0x81cfb94>>>>

试试这些我们创建的无聊的方法。那么我们是否该使用 metaclass 的 metaclass? 好吧，我们使用普通的 metaclass 做同样的事情。一个普通的 metaclass 可以持有某个对象的方法。因此 metaclass 的 metaclasss 持有该 metaclass 的方法？当然，它就是一个对象！问题是 metaclass 的 metaclass 对于我们来说不是很有用。只有你想深入了解的时候才会使用到它，我们不在这里花太多时间。

m.meta_eval do
  self.meta_eval do
    self.meta_eval do
      def ribbit; "*ribbit*"; end
    end
  end
end

m.metaclass.metaclass.metaclass.singleton_methods
#=> ["class_def", "metaclass", "constants", "meta_def",
     "attr_test", "nesting", "ribbit"]

metaclass 只有当做单层使用的时候才有用。你想给某个对象一些方法。或，你也可以指定的类拥有 metaclass。除了这些你也可以保存方法到隐蔽的 metaclass，隐蔽到无人可以获取它。或许某一天你会这么做。谁知道呢。有一个很重要的点：metaclass。是的，当你给某个对象创建 metaclass 的时候，在对象的继承链响应之前，截掉方法的调用。但是它不意味着继承受到进一步 metaclass 的影响。当你创建 metaclass 的 metaclass 时，对对象最开始引用的 metaclass 没有任何影响。我重申之前声明的类及基于类的创建。

类是对象。这意味着它可以持有变量。
metaclass 可以持有实例方法。当它被添加到对象时，这些方法会变成单数方法。这些方法会截掉方法的调用。你之前是否在类中使用过实例变量？不是类方法，而是类本身。 ruby class MailTruck @trucks = [] def MailTruck.add( truck ) @trucks << truck end end 为什么不直接使用类变量 ruby class MailTruck @@trucks = [] def MailTruck.add( truck ) @@trucks << truck end end 他们工作的完全一样，我的意思是没关系，不是吗？下面有两个原因你需要使用类变量而不是实例变量：
类变量有两个@@符号，易于辨认
类变量在需要的时候可以被实例方法引用。 ruby class MailTruck @@trucks = [] def MailTruck.add( truck ) @@trucks << truck end def say_hi puts "Hi, I'm one of #{@@trucks.length} trucks!" end end 但是下面的无法执行 ruby class MailTruck @trucks = [] def MailTruck.add( truck ) @trucks << truck end def say_hi puts "Hi, I'm one of #{@trucks.length} trucks!" #在这里@trucks为nil end end 那么实例变量有什么好呢？多浪费空间！我再也不使用了！(是的，当碰到上面的情形时使用类变量) 让我再指出上例中有 metaclass 出现，因为每个类方法都保存在 metaclass 中。你也可以使用self: ruby class MailTruck def self.add( truck ) @@trucks << truck end end 或 singleton 语法 ruby class MailTruck class << self def add( truck ) @@trucks << truck end end end ruby class MailTruck def self.company( name ) meta_def :company do; name; end end end 上面的代码很简单，但很实用。一个新的 company 类方法添加到了 MailTruck，该类方法可以被使用在类定义中。 ruby class HappyTruck < MailTruck company "Happy's -- We Bring the Mail, and That's It!" end 好吧，上面的代码执行了 HappyTruck 的 company 方法，参数为它的口号。在这里 meta_def都做了什么？ meta 的威力在这里显现出来了。 meta_def添加了一个叫 company 的方法到 metaclass 中。这里的奇妙之处为该方法时添加到了派生类HappyTruck，而不是MailTruck 这个看起来很简答，但很有用。你可以很简单的写出类方法，实现添加类方法到派生类。

基础 Ruby 中 Include, Extend, Load, Require 的使用区别

skpark1987 — Fri, 22 May 2015 19:23:22 +0800

原文链接: Ruby Require VS Load VS Include VS Extend

Include

如下例当你 Include 一个模块到某个类时，相当于把模块中定义的方法插入到类中。它允许使用 mixin。它用来 DRY 你的代码，避免重复。例如，当你有多个类时，需要相同的函数时，可以把函数定义到 module 中，进行 include。下例假设模块 Log 和类 TestClass 在相同的.rb 文件。如果它们存在于多个文件，则需要使用 load 或 require 导入文件。

module Log 
  def class_type
    "This class is of type: #{self.class}"
  end
end

class TestClass 
  include Log 
end

tc = TestClass.new.class_type
puts tc #This class is of type: TestClass

Extend

当你使用 Extend 来替换 Include 的时候，你会添加模块里的方法为类方法，而不是实例方法。详细请看例子：

module Log
  def class_type
    "This class is of type: #{self.class}"
  end
end

class TestClass
  extend Log
  # ...
end

tc = TestClass.class_type
puts tc  # This class is of type: TestClass

当你在类中使用 Extend 来代替 Include, 如果你实例化 TestClass 并调用 class_type 方法时，你将会得到 NoMethodError。再一次强调，使用 Extend 时方法是类方法。

Require

Require 方法允许你载入一个库并且会阻止你加载多次。当你使用 require 重复加载同一个 library 时，require 方法将会返回 false。当你要载入的库在不同的文件时才能使用 require 方法。下例将演示 require 的使用方式。

文件 test_library.rb 和 test_require.rb 在同一个目录下。

# test_library.rb
puts " load this libary "

# test_require.rb
puts (require './test_library')
puts (require './test_library')
puts (require './test_library')
# 结果为
#  load this libary 
# true
# false
# false

Load

Load 方法基本和 require 方法功能一致，但它不会跟踪要导入的库是否已被加载。因此当重复使用 load 方法时，也会载入多次。大部分情况你都会使用 require 来代替 load。但当你需要每次都要加载时候你才会使用 load, 例如模块的状态会频繁地变化，你会使用 load 进行加载，获取最新的状态。

puts load "./test_library.rb"  #在这里不能省略 .rb, require可以省略
puts load "./test_library.rb" 
puts load "./test_library.rb" 
#结果
# load this libary
#true
# load this libary
#true
# load this libary
#true

元编程基础方法整理

skpark1987 — Thu, 21 May 2015 21:29:40 +0800

eval

eval 是 Object 中的 private 方法。但是你可以通过发送名称到 public 方法的方式更改它的 visibility。

class Object
  public :eval
end
print( "Enter the name of a string method (e.g. reverse or upcase): " )
# user enters: upcase
methodName = gets().chomp()
exp2 = "'Hello world'."<< methodName
puts( eval( exp2 ) ) #=> HELLO WORLD
puts( "#{exp2}" ) #=> "Hello world".upcase
puts( "#{eval(exp2)}" ) #=> HELLO WORLD

eval 可以 evaluate 多行字符串，使能够执行字符串中的整个程序。

eval( 'def aMethod( x )
    return( x * 2 )
  end
  num = 100
  puts( "这是计算后的结果:" )
  puts( aMethod( num ))' )

instance_eval

instance_eval 可以被具体的对象调用，提供了对该对象实例变量的访问。

class MyClass
  def initialize
    @aVar = "Hello world"
  end
end
ob = MyClass.new
p( ob.instance_eval { @aVar } ) #=> "Hello world"
p( ob.instance_eval( "@aVar" ) ) #=> "Hello world"
p( ob.eval( "@aVar" ) ) # 错误，你需要更改eval方法为public

class_eval(module_eval)

功能跟 instance_eval 类似，但是它是执行在 class 或 module 中，它们俩可以互换着使用。

module X
end
class Y
  @@x = 10
  include X
end
X::module_eval{ define_method(:xyz){ puts("hello" ) } }  # 在模块中定义xyz方法
Y::class_eval{ define_method(:abc){ puts("hello, hello" ) } } # 在类中定义abc方法
y = Y.new # 现在Y有abc和xyz方法

操作变量

类变量

class_variable_set( aSymbol, aValue )
class_variable_get( aSymbol )
class_variables # return class variable array

实例变量

instance_variable_set( aSymbol, aValue )
instance_variable_get( aSymbol )

常量

const_set( aSymbol, aValue )
const_get( aSymbol )
constants

动态创建实例

class X
  def y
    puts( "ymethod" )
  end
end
print( "请输入类名: ") #输入: X
cname = gets().chomp
ob = Object.const_get(cname).new #执行 X.new 方法
p( ob )
print( "请输入要执行的方法: " ) #<= 输入: y
mname = gets().chomp
ob.method(mname).call

动态创建类

puts("请输入咬创建的类的名称? ")
className = gets.strip().capitalize()
Object.const_set(className,Class.new) #使用set方法，创建类
puts("我会给它创建一个叫myname的方法" )
className = Object.const_get(className)
className::module_eval{ define_method(:myname){
  puts("我的类的名称为 '#{self.class}'" ) }
}
x = className.new
x.myname

BINDINGS

eval 方法有一个可选的 binding 参数，如果提供的话，将会在指定的上下文执行 evaluation。类似于 JS 中的 apply，call 方法的第一个参数。

def getBinding(str)
  return binding()
end
str = "hello"
puts( eval( "str + ' Fred'" ) ) #没指定Binding，因此str为当前环境下的str变量。=> "hello Fred"
puts( eval( "str + ' Fred'", getBinding("bye") ) ) #指定了Binding，因此在getBinding上下文中寻找str变量。=> "bye Fred"

class MyClass
  @@x = " x"
  def initialize(s)
    @mystr = s
  end
  def getBinding
    return binding()
  end
end
class MyOtherClass
  @@x = " y"
  def initialize(s)
    @mystr = s
  end
  def getBinding
    return binding()
  end
end
@mystr = self.inspect
#@@x = " some other value"  注意加这句后的区别。
ob1 = MyClass.new("ob1 string")
ob2 = MyClass.new("ob2 string")
ob3 = MyOtherClass.new("ob3 string")
puts(eval("@mystr << @@x", ob1.getBinding)) #=> ob1 string x
puts(eval("@mystr << @@x", ob2.getBinding)) #=> ob2 string x
puts(eval("@mystr << @@x", ob3.getBinding)) #=> ob3 string y

send

可以通过使用 send 方法，调用指定:symbol 名称的方法。

class MyString < String
  def initialize( aStr )
    super aStr
  end
  def show
    puts self
  end
  def rev
    puts self.reverse
  end
end
print("输入你的名字: ") #<= 输入: Fred
name = MyString.new( gets() )
print("输入方法名: " ) #<= 输入: rev
methodname = gets().chomp.to_sym
puts( name.send(methodname) ) #=> derF

##动态创建/删除方法

#创建方法
def addMethod( m, &block )
  self.class.send( :define_method, m , &block )
end
#删除方法
class String
  remove_method( :reverse )
end

如果同样的名称的方法在祖先类中已定义，则祖先类中的方法不会被删除。

class Y
  def somemethod
    puts("Y的方法")
  end
end
class Z < Y
  def somemethod
    puts("Z的方法")
  end
end
zob = Z.new
zob.somemethod #=> “Z的方法”
class Z
  remove_method( :somemethod )
end
zob.somemethod #=> “Y的方法”

undef_method

防止调用某方法，不管该方法是否已被定义。

zob = Z.new
zob.somemethod #=> “Z的方法”
class Z
  undef_method( :somemethod )
end
zob.somemethod #=> "undefined method‟ error

method_missing

捕捉不存在的方法

def method_missing( methodname )
 puts( "Sorry, #{methodname} does not exist" )
end
xxx #=> Sorry, xxx does not exist

RMagick undefined method `include' for

skpark1987 — Sun, 12 Apr 2015 21:57:03 +0800

开发环境 ruby 2.1.5p273 (2014-11-13 revision 48405) [x86_64-darwin14.0] Rails 4.2.0 外部插件 ImageMagick: 6.9.0-1 Q16 x86_64 RMagick: 2.14.0

我想使用 Rmagick 对图片进行处理，并且已经部署好 ImageMagick 环境。使用的方式为 brew install imagemagick gem install rmagick 并且编辑了 Gemfile 添加了 gem 'rmagick', '2.14.0' 记录

我的代码为

require 'RMagick'
include Magick   #这一行报错
=begin
错误信息为：NoMethodError in GalleriesController#ajax_getGalleryMiddleImage
undefined method `include' for #<GalleriesController:0x007f82e694bbd0>
=end

有人了解这个错误吗？实在不清楚为啥基本的 inlucde 都会报错，我也谷歌搜索过，可能错误比较特殊，没找到相同的。

skpark1987

[Elixir 基础] 复合类型: Tuple

定义

常用的方法

性能

[Elixir 基础] 复合类型: List

定义

常用的操作符

常用的方法

性能

在 Phoenix 中使用 UIKit 和 SCSS

预备知识

安装

导入

测试

View 当中的 CoffeeScript 的问题

Rails 常用断言方法整理

基础 理解 class_eval 和 instance_eval

元编程 进一步理解 metaclass

关于 Class

类是对象

Metaclass 到底是什么

对象是否需要 metaclass

基础 Ruby 中 Include, Extend, Load, Require 的使用区别

Include

Extend

Require

Load

元编程 基础方法整理

eval

instance_eval

class_eval(module_eval)

操作变量

类变量

实例变量

常量

动态创建实例

动态创建类

BINDINGS

send

undef_method

method_missing

RMagick undefined method `include' for

基础理解 class_eval 和 instance_eval

元编程进一步理解 metaclass

元编程基础方法整理