class YAML::DBM

YAML + DBM = YDBM

YAML::DBM 提供了与 ::DBM 相同的接口。

然而，尽管 DBM 只允许字符串作为键和值，但这个库允许使用大多数 Ruby 对象作为值，方法是先将它们转换为 YAML。键必须是字符串。

与 YAML 的相互转换会自动执行。

有关更多信息，请参阅 ::DBM 和 ::YAML 的文档。

公共实例方法

ydbm[key] → value 点击切换源代码

从数据库返回与 key 关联的值。

如果不存在这样的 key，则返回 nil。

有关更多信息，请参阅 fetch。

# File yaml/dbm.rb, line 32
def []( key )
    fetch( key )
end

ydbm[key] = value 点击切换源代码

在数据库中将 key 设置为 value。

value 在存储之前将被转换为 YAML。

有关更多信息，请参阅 store。

# File yaml/dbm.rb, line 44
def []=( key, val )
    store( key, val )
end

delete(key) 点击切换源代码

从数据库中删除与 key 关联的值。

返回 value 或 nil。

调用超类方法

# File yaml/dbm.rb, line 111
def delete( key )
    v = super( key )
    if String === v
        if YAML.respond_to?(:safe_load)
            v = YAML.safe_load( v )
        else
            v = YAML.load( v )
        end
    end
    v
end

delete_if { |key, value| ... } 点击切换源代码

对数据库中的每个 key、value 对调用一次给定的代码块。删除代码块返回 true 的所有条目。

返回 self。

# File yaml/dbm.rb, line 130
def delete_if # :yields: [key, value]
    del_keys = keys.dup
    del_keys.delete_if { |k| yield( k, fetch( k ) ) == false }
    del_keys.each { |k| delete( k ) }
    self
end

each()

别名为：each_pair

each_pair { |key, value| } { |key, value| ... } 点击切换源代码

对数据库中的每个 key、value 对调用一次给定的代码块。

返回 self。

# File yaml/dbm.rb, line 153
def each_pair # :yields: [key, value]
    keys.each { |k| yield k, fetch( k ) }
    self
end

也别名为：each

each_value { |value| ... } 点击切换源代码

对数据库中的每个值调用给定的代码块。

返回 self。

调用超类方法

# File yaml/dbm.rb, line 164
def each_value # :yields: value
    super { |v| yield YAML.respond_to?(:safe_load) ? YAML.safe_load( v ) : YAML.load( v ) }
    self
end

fetch( key, ifnone = nil ) 点击切换源代码

fetch( key ) { |key| ... }

返回与 key 关联的值。

如果 key 没有值并且没有给出代码块，则返回 ifnone。

否则，调用代码块并传入给定的 key。

有关更多信息，请参阅 ::DBM#fetch。

调用超类方法

# File yaml/dbm.rb, line 59
def fetch( keystr, ifnone = nil )
    begin
        val = super( keystr )
        if String === val
            if YAML.respond_to?(:safe_load)
                return YAML.safe_load( val )
            else
                return YAML.load( val )
            end
        end
    rescue IndexError
    end
    if block_given?
        yield keystr
    else
        ifnone
    end
end

has_value?(value) 点击切换源代码

如果在数据库中找到指定的 value，则返回 true。

# File yaml/dbm.rb, line 181
def has_value?( val )
    each_value { |v| return true if v == val }
    return false
end

index( keystr ) 点击切换源代码

已弃用，请改用 YAML::DBM#key。

注意：YAML::DBM#index 会发出来自 ::DBM#index 内部的警告。它说 'DBM#index is deprecated; use DBM#key'，但是 DBM#key 的行为与 DBM#index 不同。

调用超类方法

# File yaml/dbm.rb, line 85
def index( keystr )
    super( keystr.to_yaml )
end

invert → hash 点击切换源代码

返回一个 Hash（不是 DBM 数据库），通过使用数据库中的每个值作为键，并将相应的键作为其值来创建。

请注意，哈希中的所有值都将是字符串，但键将是实际的对象。

# File yaml/dbm.rb, line 194
def invert
    h = {}
    keys.each { |k| h[ self.fetch( k ) ] = k }
    h
end

key(value) → string 点击切换源代码

返回指定值的键。

# File yaml/dbm.rb, line 93
def key( keystr )
    invert[keystr]
end

reject { |key, value| ... } 点击切换源代码

将数据库的内容转换为内存中的 Hash，然后使用指定的代码块调用 Hash#reject，返回一个新的 Hash。

# File yaml/dbm.rb, line 142
def reject
    hsh = self.to_hash
    hsh.reject { |k,v| yield k, v }
end

replace(hash) → ydbm 点击切换源代码

使用指定对象的内容替换数据库的内容。接受任何实现 each_pair 方法的对象，包括 Hash 和 DBM 对象。

# File yaml/dbm.rb, line 206
def replace( hsh )
    clear
    update( hsh )
end

select { |key, value| ... } 点击切换源代码

select(*keys)

如果提供了代码块，则返回一个新的数组，其中包含代码块返回 true 的 [key, value] 对。

否则，与 values_at 相同

# File yaml/dbm.rb, line 234
def select( *keys )
    if block_given?
        self.keys.collect { |k| v = self[k]; [k, v] if yield k, v }.compact
    else
        values_at( *keys )
    end
end

shift → [key, value] 点击切换源代码

从数据库中删除一个 [key, value] 对，并返回它。如果数据库为空，则返回 nil。

删除/返回值的顺序不能保证。

调用超类方法

# File yaml/dbm.rb, line 218
def shift
    a = super
    if a
      a[1] = YAML.respond_to?(:safe_load) ? YAML.safe_load( a[1] ) : YAML.load( a[1] )
    end
    a
end

store(key, value) → value 点击切换源代码

使用 key 作为索引将 value 存储在数据库中。value 在存储之前被转换为 YAML。

返回 value

调用超类方法

# File yaml/dbm.rb, line 249
def store( key, val )
    super( key, val.to_yaml )
    val
end

to_a → array 点击切换源代码

将数据库的内容转换为 [key, value] 数组的数组，并返回它。

# File yaml/dbm.rb, line 274
def to_a
    a = []
    keys.each { |k| a.push [ k, self.fetch( k ) ] }
    a
end

to_hash → hash 点击切换源代码

将数据库的内容转换为内存中的 Hash 对象，并返回它。

# File yaml/dbm.rb, line 286
def to_hash
    h = {}
    keys.each { |k| h[ k ] = self.fetch( k ) }
    h
end

update(hash) → ydbm 点击切换源代码

使用指定对象的多个值更新数据库。接受任何实现 each_pair 方法的对象，包括 Hash 和 DBM 对象。

返回 self。

# File yaml/dbm.rb, line 262
def update( hsh )
    hsh.each_pair do |k,v|
        self.store( k, v )
    end
    self
end

values 点击切换源代码

返回数据库中值的数组。

调用超类方法

# File yaml/dbm.rb, line 173
def values
    super.collect { |v| YAML.respond_to?(:safe_load) ? YAML.safe_load( v ) : YAML.load( v ) }
end

values_at(*keys) 点击切换源代码

返回包含与给定键关联的值的数组。

# File yaml/dbm.rb, line 101
def values_at( *keys )
    keys.collect { |k| fetch( k ) }
end