标签: iterator

我有一个非常大的文本文件(最多几百MB),我想用STL正则表达式处理.我正在寻找的匹配区域跨越几行,并在文件中至少发生几千次.

我可以为此目的使用流迭代器吗？我试过std :: istream_iterator,但没有运气.可以发布一个最小的工作示例吗？

请注意,我正在寻找仅涉及STL的解决方案.在完美的解决方案中,我想迭代所有比赛.

编辑

一旦我阅读了评论,我就明白这是不可能的.所以也许有另一种方法来迭代在大文本文件中找到的正则表达式匹配:

#include <regex>
#include <iostream>
#include <string>

const std::string s = R"(Quick brown fox
jumps over
several lines)"; // At least 200MB of multiline text here

int main(int argc,char* argv[]) {

    std::regex find_jumping_fox("(Quick(?:.|\\n)+?jump\\S*?)");
    auto it = std::sregex_iterator(s.begin(), s.end(),        find_jumping_fox);

    for (std::sregex_iterator i = it; i != std::sregex_iterator(); ++i) {
        std::smatch match = *i;                                                 
        std::string match_str = match.str(); 
        std::cout << match_str << '\n';
    }  
}

在 Rust 中，如何在for样式循环中执行可变大小的步骤？我可以使用此构造执行固定大小的步骤：

for i in (0..vals.len()).step_by(4)
{
    println!("{}: {}", i, vals[i]);
}

或者更合适的：

for (i,val) in vals.iter().enumerate().step_by(4)
{
    println!("{}: {}", i, val);
}

但我真正想做的是：

for i in 0..vals.len()
{
    println!("{}: {}", i, vals[i]);
    if      vals[i] == 1 { i += 2; }
    else if vals[i] == 2 { i += 4; }
}

但当然，修改i不会影响循环迭代器。

由于主要具有 C 语言背景，现代语言对迭代器的依赖常常让人感觉像是戴着手套进行编程。通常谷歌会来救援，但我还没有找到任何解决方案来解决这个看似相当简单的问题。

我想出的最好的是

let mut i:usize = 0;
while i < vals.len()
{
    println!("{}: {}", i, vals[i]);
    if      vals[i] == …

假设我有一个迭代器：

function* someIterator () {
    yield 1;
    yield 2;
    yield 3;
}

let iter = someIterator();

...我查看下一个要迭代的元素：

let next = iter.next(); // {value: 1, done: false}

...然后我在循环中使用迭代器：

for(let i of iterator)
    console.log(i); 
// 2
// 3

循环将不包括所查看的元素。我希望看到下一个元素，同时不将其从迭代系列中删除。

换句话说，我希望实现：

let next = peek(iter); // {value: 1, done: false}, or alternatively just 1

for(let i of iterator)
    console.log(i); 
// 1
// 2
// 3 

...而且我不想在不修改可迭代函数的代码的情况下做到这一点。

我的尝试就在我的回答中。它有效（这就是我将其作为答案的原因），但我担心它构建的对象比它必须的更复杂。我担心它不适用于“完成”对象与{ value = undefined, done = true }. 因此，非常欢迎任何改进的答案。

我有几个布尔矩阵，我想要一个结果矩阵来指示这些矩阵的该位置中的任何元素是否为真。Julia 语言中是否有一个函数可以让我对任意数量的矩阵进行元素或运算？

# My data\na = Bool[1 0; 1 1]\nb = Bool[0 0; 1 1]\nc = Bool[0 0; 0 0]\nd = Bool[0 0; 1 1]\n\n# Arrays of Bool Arrays\nz1 = [a]\nz2 = [a, b]\nz3 = [b, c, d]\nz4 = [a, b, c, d]\nz100 = [rand(Bool, 2, 2) for i in 1:100]\n\n# Expected\njulia> some_function(z1)\n2\xc3\x972 BitMatrix:\n 1  0\n 1  1\n\njulia> some_function(z2)\n2\xc3\x972 BitMatrix:\n 1  0\n 1  1\n\njulia> some_function(z3)\n2\xc3\x972 BitMatrix:\n 0  0\n 1  1\n\njulia> some_function(z4)\n2\xc3\x972 BitMatrix:\n 1  0\n 1  1\n\njulia> some_function(z100)\n2\xc3\x972 BitMatrix:\n 1 …

仔细看看代码

function* NinjaGenerator() {
  yield "yoshi";
  return "Hattori";
}
for (let ninja of NinjaGenerator()) {
  console.log(ninja);
}

// console log : yoshi

为什么“服部”没有登录？当我们使用 iterator.next() 迭代迭代器时，它会显示该值。

function* NinjaGenerator() {
  yield "yoshi";
  return "Hattori";
}

let ninjaIterator = NinjaGenerator();
let firstValue = ninjaIterator.next().value;
let secondValue = ninjaIterator.next().value;
console.log(firstValue, secondValue);

// console log: yoshi Hattori

有人请帮助我理解 for-of 循​​环在生成器创建的迭代器中如何工作？

Rust 的迭代有两个主要特征：Iterator可以按顺序遍历的标准，以及DoubleEndedIterator可以从后面额外迭代的标准。

这对我来说很有意义。许多有用的方法都定义在Iterator、map、filter等上。然后，从“后面”操作的东西，可以说，像rfind和 一样rfold被定义，DoubleEndedIterator因为这样的操作只在这样的迭代器上才有意义。

但我们有Iterator::rev

fn rev(self) -> Rev<Self>
where
    Self: Sized + DoubleEndedIterator,
{
    Rev::new(self)
}

Run Code Online (Sandbox Code Playgroud)

rev是一个定义的函数，但也有Iterator一个附加约束。SelfDoubleEndedIterator

定义此函数有什么实际好处Iterator？我们只能在DoubleEndedIterator实现者和DoubleEndedIterator扩展上调用它，Iterator因此我们永远不会遇到实现前者而不是后者的情况。那么为什么没有在like和arerev上定义呢？DoubleEndedIteratorrfindrfold

我正在尝试将请求（请参阅https://developer.mozilla.org/en-US/docs/Web/API/Request/headers）对象中的标头列表转换为普通的键/值对象。

// Create a Request object.
const req = new Request('https://example.com', {
    headers: {
        'X-Test-header': 'Test'
    }
});

遗憾的是，以下内容不起作用，因为该headers属性是iterator：

无法使用的结果：

const result1 = JSON.stringify(req.headers);
// result1 =  `{}`

可用的结果，但创建起来非常冗长：

const headers = {};
for(const [key, value] of req.headers.entries()) {
    headers[key] = value;
}
const result2 = JSON.stringify(headers)
// result2 = `{'X-Test-Header': 'Test'}`

我正在寻找某种单行（可能包括对象Array.from()上的一些其他方法，Request.headers例如.keys()/ .values()），以便我能够对结果进行字符串化。

随机访问迭代器的要求可在此处找到。在此页面上，您将看到对于任意两个RandIts,a和b,a<b和a-b都是合法的 c++。a-b返回一个difference_type.

在我的代码中，我想计算a<b，但不是比较a和b，而是比较a-first和b-first。这需要两件事：

1. difference_types 具有可比性。
2. (a-first < b-first) == (a < b)。

将 s的比较实现difference_type为满足 (2) 是很容易的，但我无法判断标准是否要求这样做。(1) 和 (2) 成立吗？

使用迭代器时如何避免smth.begin(), smth.end()一直编写？

例如，如果您必须使用std::reverse\xe2\x80\x93 ，它将如下所示：

std::reverse(mystr.begin(), mystr.end());\n

但我想我在某个地方看到人们在做同样的事情，如下所示：

std::<something>::reverse(mystr);\n

假设我们有以下嵌套循环：

MyClass myobject;

for (const std::array<int,16>& arr : myobject)
{
    for (int i : arr)  {  /* do something with i */  }
}

例如， whereMyClass可以迭代 16 个整数的数组。

现在，我想要一个循环来迭代所有数组的所有整数myobject：

for (int i : MagicClass(myobject))  {  /* do something with i */  }

MagicClass我想要设计的课程在哪里。我知道MagicClass应该实现begin/end返回特定迭代器的方法，即。就像是：

class MagicClass
{
public:
    MagicClass (MyClass obj) : obj_(obj) {}

    struct iterator 
    {
        // the hard part comes here...
    };

    iterator begin()  { return iterator (obj_.begin()); }
    iterator …