[ruby]单例类 singleton class，class_eval vs instance_eval

已于 2022-12-11 11:37:41 修改
阅读量203 收藏
点赞数
分类专栏： ruby 文章标签： ruby c#
于 2021-08-29 01:11:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41037744/article/details/119975726
版权

定义类

  • 类是一个增强的模块，类的知识都可以应用于模块
class A < Array
  def method
    'hello'
  end
end
# A.new.method => 'hello'
  • 同上
A = Class.new(Array) do
  def method
    'hello'
  end
end
# A.new.method => 'hello'

不用class关键字修改类 —— class_eval

def add_method_to(a_class)
# TODO: 在a_class上定义方法m
end
  • 知道类名的话，可以用class打开然后定义，比如a_class类名是A
class A
  def m; 'hello'; end
end

A.new.m => 'hello'
  • 不知道类名用class_eval
def add_methhod_to(a_class)
  a_class.class_eval do 
    def m;  'hello'; end
  end
end

add_method_to A
A.new.m => 'hello'
add_method_to String
'asd'.m => 'hello'

class_eval vs instance_eval

  • 使用def
class Hello end

Hello.instance_eval do 
  def fool_i
    puts "Hello instance_eval foo_i"
  end  
end  
 
Hello.class_eval do
  def foo_c
    puts "Hello class_eval foo_c"
  end  
end  

ls Hello
Hello.methods: foo_i 
Hello#methods: foo_c

instance_eval 代码块中定义的方法变成了 Hello 的类方法，而 class_eval 代码块中定义的方法称为了 Hello 类的实例方法。这里有点绕，跟语义上边理解起来的相反。

  • 使用define_method
Hello.instance_eval do 
  define_method :fool_a do
    puts "Hello define_method instance_eval foo_a"
  end  
end  
 
Hello.class_eval do
  define_method :foo_b do
    puts "Hello define_method class_eval foo_b"
  end  
end  

ls Hello
Hello.methods: 
Hello#methods: foo_b  fool_a

instance_eval和class_eval中使用define_method定义的方法都是Hello的实例方法。

  • 加上singleton_class
Hello.singleton_class.instance_eval do 
  define_method :x do
    puts "Hello define_method instance_eval x"
  end  
end  
 
Hello.singleton_class.class_eval do
  define_method :y do
    puts "Hello define_method class_eval y"
  end  
end  

Hello.singleton_class.instance_eval do
  def h
    puts "Hello singleton_class class_eval def h"
  end  
end  

Hello.singleton_class.class_eval do
  def g
    puts "Hello singleton_class class_eval def g"
  end  
end 

ls Hello
Hello.methods: x y g h
Hello#methods:

加上singleton_class后 instance_eval和class_eval中使用def 和 define_method定义的方法都是Hello的类方法。

  • 总结
    在这里插入图片描述

比如说有个类 G, 调用 class_eval 和 instance_eval 的时候 scope 是 G 这个 Class实例，也就是 self 是 G，所以 define_method 的 receiver 都是 G，所以定义的都是 instance method.

而 def 是在 current class 上定义 instant method，class_eval 中的 current class 自然是 G，instance_eval 中的 current class 是 G 的 singleton_class，所以是 class method.

类变量、类实例变量

  • 类变量可以被子类或者类的实例使用，类实例变量只可以被类本身访问，不能被类的实例或者子类访问。尽量使用类实例变量，不适用类变量
class A
  @v = 1 # 类实例变量
  @@v = 11 # 类变量
  def self.read
  	p @v
  	p @@v
  end
  def read
    p @v
    p @@v
  end
end

A.read => 1  11 
A.new.read => nil  11

类宏

class A
  attr_accessor :my_attribute
end

obj = A.new
obj.my_attribute = 'x'
obj.my_attribute => 'x'
  • 上面attr_accessor的本质是定义了两个普通的方法
class A
  def my_attribute=(value)
    @my_attribute = value
  end
  def my_attribute
    @my_attribute
  end
end

单例方法 singleton method

  • 只对单个对象定义的方法，称为单例方法，该方法只对这个对象生效。
str = 'just a regular string'
def str.title?
  # self => 'just a regular string'
  self.upcase == self
end 

str.title? => false
str.methods.grep(/title?/) => [:title?]
str.singleton_methods => [:title?]

单例类 singleton class

  • 单例类定义被用于定义对象的专属实例方法。
  • 在类中定义类方法， class << 类名 ~ end这种写法的类定义称为单例类定义，单例类定义中定义的方法称为单例方法 singleton method
# 3种定义类方法的方式
class C
  def C.hello
    "hello #{self}"
  end
end

class C
 def self.hello
   "hello #{self}"
 end
end

class C
  class << self   # class << C 一样, 表名单例类才是类方法真正所在之处
    def hello
       "hello #{self}"
     end
   end
end
p C.hello # =>  "hello C" 单例类方法
p C.singleton_class #=> #<Class:C>
p C.singleton_methods #=> [:hello]

# 接上面代码 
a = C.new
class << a #单例类
  def hello 
    self
  end
end

b = class << a
  self
end
p a.hello #=> #<C:0x00007fd3aa171760> C的实例
p a.singleton_class #=> #<Class:#<C:0x00007ffe10933b48>> 对单例类的引用方法一
p b #=> #<Class:#<C:0x00007fa6b6897bc8>> 对单例类的引用方法二
  • 不能用未定义的常量，或者变量去定义单例类
class << Hi  # class << hi
  def hello
     "hello #{self}"
  end
end
NameError (uninitialized constant Hi)  # NameError (undefined local variable or method `hi' for main:Object)
  • 单例类，单例方法，单例类方法，实例方法，单例类的超类，超类的单例类
class C
  class << self
    def a_class_method
      'C.a_class_method'
    end
  end
end

class D < C
  def a_method
    'D#a_instance_method'
  end
end
obj = D.new
obj1 = D.new

class << obj #单例类
  def a_method
    'obj#a_singleton_method'
  end
end

p obj.a_method #=> "obj#a_singleton_method"  说明实例找方法时候会先找单例类方法
p obj1.a_method #=> "D#a_instance_method"
p obj.class.superclass #=> C
p obj.singleton_class #=> #<Class:#<D:0x00007fcf51134390>>
p obj.singleton_class.superclass #=> D 也是obj的类 obj.class
p obj.singleton_methods #=> [:a_method]  单例方法
p D.singleton_class #=> #<Class:D> 
p D.super_class #=> C
p D.singleton_class.superclass #=> #<Class:C> D的单例类的超类是C的单例类
p D.superclass.singleton_class #=> #<Class:C> D的超类的单例类是C的单例类
p D.a_class_method #=> 'C.a_class_method' 调用D的单列方法，找到了继承的C的单例方法
  • ruby 对象模型七条规则
  1. 只有一种对象——要么是普通对象，要么是模块。
  2. 只有一种模块——可以是一个普通模块、一个类或者一个单例类。
  3. 只有这一种方法，它存在于一个模块中——通常是在一个类中。
  4. 每个对象（包括类）都有自己的“真正的类”——要么是一个普通类，要么是一个单例类。
  5. 除了BasicObject类没有超类外，每个类有且只有一个祖先——要么是一个类，要么是一个模块。这意味着任何类只有一条向上的、直到BasicObject的祖先链。
  6. 一个对象的单例类的超类是这个对象的类。一个类的单例类的超类是这个类的超类的单例类。
  7. 调用一个方法时，Ruby先向右进入接收者真正的类，然后向上进入祖先链。这就是Ruby查找方法的方式。
# 初始化变量
str1 = 'Ruby'   # String的一个对象
str2 = 'Ruby'  # String的一个对象
str3 = 'ruby'  # String的一个对象
str4 = [1,2]  # Array的一个对象
str5 = {a:6}  # Hash的一个对象
str6 = 1  # Numeric的一个对象
str7 = Numeric.new
  • str1是String的一个实例对象，可以定义单例类
class << str1 #单例类
  def hello 
    "hello #{self}"
  end
end
p str1.hello # => "hello Ruby"
p str2.hello # => NoMethodError: undefined method `hello' for "Ruby":String
  • 需要把实例先赋值给一个变量，再定义单例类，否则无法调用
class << "Ruby" 
  def hello 
    "hello #{self}"
  end
end
无法调用
p "Ruby".hello # => NoMethodError (undefined method `hello' for "Ruby":String)
  • str3是String的一个实例对象，可以定义单例类
class << str3 #单例类
  def hello 
    "hello #{self}"
  end
end
p str3.hello # => "hello ruby"
  • str4是Array的一个实例对象，可以定义单例类
class << str4 #单例类
  def hello 
    "hello #{self}"
  end
end
p str4.hello # => "hello [1, 2]"
  • str5是Hash的一个实例对象，可以定义单例类
class << str5 #单例类
  def hello 
    "hello #{self}"
  end
end
p str6.hello # => "hello {:a=>6}"
  • str6是Integer的一个实例对象，不能 定义单例类
class << str6 
  def hello 
    "hello #{self}"
  end
end
TypeError (can't define singleton)
  • str7是Numeric.new的一个实例对象，不能 定义单例类
class << str7
  def hello 
    "hello #{self}"
  end
end
TypeError (can't define singleton method "hello" for Numeric)
微信-yangfansky
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Ruby 基础+进阶 第五天
weixin_43645545的博客
05-14 345
本次学习资料 通读《Ruby元编程》，记录下有趣的以及不明白的知识点 当前类 当前类和当前对象都是一直存在的，当前对象可以用self调用，但是没有方法能获取当前类。定义一个方法，那个方法将成为当前类的一个实例方法。 一般情况下，当前对象的类就是当前类。 比如，在程序的顶层，当前对象是main，main的类就是Object，也就是当前类。在一个方法中，当前类就是当前对象的类。 class_eval方法 会在一个已存在类的上下文中执行一个块。 class_eval方法会同时修改self和当前类。 def tes
Ruby设计模式透析之 —— 单例(Singleton)
runfeel
04-30 409
转载请注明出处：http://blog.csdn.net/sinyu890807/article/details/8868758 此为Java设计模式透析的拷贝版，专门为Ruby爱好者提供的，不熟悉Ruby语法的朋友请转阅 ： Java设计模式透析之 —— 单例(Singleton) 写软件的时候经常需要用到打印日志功能，可以帮助你调试和定位问题，项目上线后还可以帮助你分析数据，但是...
ruby的单例方法
系统运维
06-22 134
=begin 在Ruby里，可以给具体的实例对象添加实例方法，这个方法只属于这个实例 对象，我们把这样的方法称之为单例方法。 单例方法也叫作单件方法。定义单例方法，首先要生成一个实例对象，其次， 要在方法名前加上对象名和一个点号“.”。 在下面示例中，对象p1不可以laugh , laugh方法只属于p2对象。 实例方法，属于类的每个实例对象。单例方法只出现在单个实例对象中。用单 例...
ruby 中的单件方法和单件类
weixin_33878457的博客
06-11 192
singleton_class 和Singleton Method class 混入 module 时的相关思考 在Ruby里, 我们可以通过在 class 里混入 module 来达到一些用途,那么 module 里面的代码是怎么混入class 里,又是被放置在了什么地方呢? module MyModule def a_...
ruby单例方法 单例类_Ruby中的单例方法
cumtv80668的专栏
07-31 275
ruby单例方法 单例类 Ruby| 单例方法 (Ruby | Singleton Methods) In the last tutorial frozen objects, we have studied the way to freeze the objects in Ruby. We can't assign singleton methods to the objects which ar...
Singleton class
小宋的专栏
10-14 751
From the name we can see that a singleton class is a kind of class that only has one class object. Why we need to use this pattern? Sometimes we can use it instead of the global variables.  Here i
详解Ruby中的instance_eval方法及其与class_eval的对比
09-21
### Ruby中的instance_eval方法及其与class_eval的对比 #### 一、instance_eval方法详解 **instance_eval** 方法属于Ruby语言中的eval家族成员之一，它的主要功能是将一个代码块（通常是一个包含Ruby代码的字符串...
Ruby元编程技术详解（Ruby Metaprogramming techniques）
09-22
1. 单例类（Singleton Class）： 在Ruby中，每个对象都有一个与之关联的单例类，这个类只包含该对象的实例方法。通过`class ; self; end`可以访问到对象的单例类，这对于在运行时添加或修改对象的方法非常有用。`...
ruby设计模式的代码有好多
最新发布
09-18
例如，Ruby中的Singleton模块可以轻松实现单例类，确保在整个程序中只有一个实例存在。 结构型模式如适配器模式（Adapter）、装饰器模式（Decorator）和代理模式（Proxy）等，关注如何将不同组件组合在一起。Ruby的...
singleton class
Allen_白的专栏
08-25 675
public class Singleton   {       // Private static object can access only inside the Emp class.       private static Singleton instance;          // Private empty constructor to restrict end use
ruby Singleton Class和Singleton Method
eric的博客
07-11 1318
也许你经常听说singleton class，但是并没有搞清楚它到底是什么，为啥呢，就我查的，概念太绕。绕了半天也不知道咋回事，所以要总结下呢，咳咳。 首先我们要搞明白一个问题，管他是不是单例类，所以我们先搞明白一个类中的作用域，先举个例子吧： class A p self class self p self end def hello
java SingletonClass
robert198837的专栏
09-06 540
public class SingletonClass {         private static class SingletonClassInstance {      private static final SingletonClass instance = new SingletonClass();    }   public static SingletonClass
java创建单例类(Singleton Class)
机器学习算法与Python学习
12-21 2036
用容易理解的方式实现单例类的java编程
「Ruby」命名之争 ：singleton_class? meta_class? eigen_class?
weixin_33928467的博客
12-21 96
class &lt;&lt; self; self; end这段代码，每个Rubyist应该都很熟悉。但是这里面的self是什么？ singleton_class? meta_class? eigen_class?在早期，确切来说应该是Ruby1.9.2发布之前，Ruby社区关于以上这段代码的命名，有很大的争议，后来Ruby团队准备在1.9.2中增加一个方法，来消除这种命名的争议。 这个名字除...
C++完美实现Singleton模式
xu的blog
06-03 1474
Singleton模式是常用的设计模式之一，但是要实现一个真正实用的设计模式却也不是件容易的事情。 1. 标准的实现 class Singleton { public: static Singleton * Instance() { if( 0== _instance) { _instance = new Singleton; }
Ruby的Singleton method
JDoc
09-23 178
Ruby中，特定于某一对象的方法被称为Singleton method。   例如：   a = "string" def a.run puts "#{self} run" end str.run # =&gt;#string run     run方法是特定于a这个对象的，故run方法是a的Singleton方法。   实现上，当定义Singleton...
Ruby实现单例模式
teashown
06-27 939
单例模式是一种常用的设计模式，在ruby的标准库中有singleton模块，可以直接像下面这样使用： require 'Singleton' class Test include Singleton end a, b = Test.instance, Test.instance puts a==b #=>true 如果不使用标准库，该如何实现呢？在看完《ruby元编程》第五章后
Ruby 的 Singleton 单例模块
Looking的博客
04-26 746
一般来说，对于某个类，我们可以创建无穷多个对象，且不会受到任何限制。但是，有时候，我们只需要类的一个实例来协调整个程序的操作，并不需要多个实例。对于这种场景，我们希望确保正在运行的程序只存在给定类的一个实例。也就是所谓的 单例模式。单例模式 是一种设计模式，它将给定类的实例化限制为一个对象。 常规模式 直接用例子来说更简单易懂一些。 class HelloWorld def instance_method puts "instance method" end end
Singleton* Singleton::s_Instance = nullptr;
02-15
这是一行 C++ 代码，它定义了一个静态的空指针变量 s_Instance。该变量是 Singleton 类的静态成员变量，并且初始值为 nullptr。这意味着这个变量在程序整个生命周期内仅有一个实例，并且在整个程序生命周期内，它只能通过 Singleton 类的静态方法来访问。 关于 Singleton，可以说它是一种设计模式，它确保了一个类仅有一个实例，并且提供一个全局访问点来访问该实例。这种设计模式经常用于创建全局单例对象，例如系统配置、数据库连接等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值