我怎样才能获得懒惰的阵列 Ruby?

我怎样才能获得懒惰的阵列 Ruby?

在 Haskell 我可以谈谈
[1..]

, 这是一个无穷无尽的列表，根据需要懒惰。 我也可以做这样的事情 , 作为
iterate /+2/ 0

, 这适用于我给他创建懒惰列表的任何功能。 在这种情况下，他会给我所有偶数。

我相信我可以做这样的事情 Ruby, 但似乎我无法理解如何做到这一点。
2021-03-21 添加评论
分享

没有找到相关结果

    已邀请:

    窦买办

    赞同来自:

    从 Ruby 1.9 你可以使用这个类 Enumerator. 这是文件的一个例子：


    fib = Enumerator.new { |y|
    
 a = b = 1
    
 loop {
    
 y << a
    
 a, b = b, a + b
    
 }
    
 }
    

    
 p fib.take/10/ #=> [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]


    另外，这是一个很好的技巧：


    Infinity = 1.0/0
    

    
 range = 5..Infinity
    
 p range.take/10/ #=> [5, 6, 7, 8, 9, 10, 11, 12, 13, 14]


    但是，此方法仅适用于连续值。
    2021-03-21 0 0
    分享

    莫问

    赞同来自:

    最近 Enumerable::Lazy 被加到高速公路 ruby. 我们会看到它 ruby 2.0.
    特别是：


    a = data.lazy.map/&:split/.map/&:reverse/


    不会立即进行评估。

    结果，它拒绝了令人令人愉快的:: Lazy的实例，这可以进一步懒惰。 如果您想获得实际结果，请使用
    #to_a

    ,

    #take/n/


    /
    #take

    现在也懒惰，使用
    #to_a

    或者
    #force

    /等等。

    如果您想了解有关此主题的更多信息和我的补丁C-在博客中看到我的帖子
    http://blog.railsware.com/2012 ... lazy/
    2021-03-21 0 0
    分享

    八刀丁二

    赞同来自:

    懒散的范围 /整数/:


    Inf = 1.0/0.0
    
/1..Inf/.take/3/ #=> [1, 2, 3]


    懒散的范围 /偶数/:


    /0..Inf/.step/2/.take/5/ #=> [0, 2, 4, 6, 8]


    请注意，您也可以扩展
    Enumerable

    用一些方法与懒人一起工作 /等等/ 更舒适：


    module Enumerable
    
 def lazy_select
    
 Enumerator.new do |yielder|
    
 each do |obj|
    
 yielder.yield/obj/ if yield/obj/
    
 end
    
 end
    
 end
    
end
    

    
# first 4 even numbers
    
/1..Inf/.lazy_select { |v| v.even? }.take/4/
    

    
output:
    
[2, 4, 6, 8]


    更多信息在这里：
    http://banisterfiend.wordpress ... ruby/
    /

    还有实施 lazy_map 和 lazy_select 上课
    Enumerator

    , 可以在这里找到哪个：
    http://www.michaelharrison.ws/weblog/?p=163
    2021-03-21 0 0
    分享

    帅驴

    赞同来自:

    在 Ruby 2.0.0 介绍了一种新方法 "Lazy" 在列出的课程中。

    您可以查看懒惰功能的内核及其在这里使用..

    http://www.ruby-doc.org/core-2 ... .html
    https://github.com/yhara/enumerable-lazy
    http://shugomaeda.blogspot.in/ ... .html
    2021-03-21 0 0
    分享

    詹大官人

    赞同来自:

    正如我在我的意见中所说，懒惰阵列这样的事情的实施是不合理的。

    使用 Enumerable 相反，它可以在某些情况下良好工作，但与一些时刻的懒惰列表不同：这样的方法 map 和 filter, 不会被衡量懒惰 /因此，他们无法无休止地列出/, 而且计算一度的元素不保存，因此，如果您向元素吸引两次，则计算两次。

    如果您需要懒惰列表的确切行为 haskell 在 ruby, 有 lazylist
    http://flori.github.com/lazylist/
    它实现了懒惰的列表。
    2021-03-21 0 0
    分享

    卫东

    赞同来自:

    它将重复到无穷大：


    0.step{|i| puts i}


    它将是无限的循环，两次快速：


    0.step/nil, 2/{|i| puts i}


    只有你想要它，它只会去无限 /导致调度器/.


    table_of_3 = 0.step/nil, 3/
    2021-03-21 0 0
    分享

    冰洋

    赞同来自:

    正确的答案已经定义了该方法 "lazy", 但上面的例子不是太用了。 我将在适当使用时给出最好的例子 lazy 用阵列。 如上所述 lazy 被确定为模块实例方法 Enumerable 并与物体合作 EITHER, 实施列出的模块 /例如，数组
    [].lazy

    / 或枚举返回所列模块中迭代器的值的枚举器 /例如， Each_slice-
    [].each_slice/2/.lazy

    /. 请注意，在列出的模块中，某些实例方法返回更多的原始值，例如 true 或者 false, 一些返回集合，如数组和一些返回枚举器。 如果未指定单位，则返回枚举器。

    但在我们的示例课程中 IO 也有迭代器 each_line, 返回枚举器，因此可以使用 "lazy". inumerator的返回中最美丽的是它实际上没有加载集合 /例如，一个大的数组/ 记住它的工作原理。 相反，它有一个指向集合的指针，然后描述算法 /例如 ,
    each_slice/2/

    /, 当您想要处理收集时，他将用于此集合
    to_a

    , 例如。

    因此，如果您与枚举器一起工作以进行巨大的性能 boost, 现在你可以附上 lazy 给调度器。 因此，而不是整理整个集合以适应这种情况：


    file.each_line.select { |line| line.size == 5 }.first/5/


    你可以打电话 lazy:


    file.each_line.lazy.select { |line| line.size == 5 }.first/5/


    如果我们扫描第一个文本文件 5 然后一旦找到 5 巧合，无需继续执行。 因此，列出了任何类型的物体的懒惰的力量。
    2021-03-21 0 0
    分享

    诸葛浮云

    赞同来自:

    Ruby 阵列根据需要动态扩展。 您可以将块应用于它们以返回像偶数的东西。


    array = []
    
array.size # => 0
    
array[0] # => nil
    
array[9999] # => nil
    
array << 1
    
array.size # => 1
    
array << 2 << 3 << 4
    
array.size # => 4
    

    
array = /0..9/.to_a
    
array.select do |e|
    
 e % 2 == 0
    
end
    

    
# => [0,2,4,6,8]


    它有所帮助吗？
    2021-03-21 0 0
    分享
    为什么被折叠? 0 个回复被折叠

    要回复问题请先登录或注册

    Copyright © 2023, All Rights Reserved