查找文件名中的数字并与其他数字交叉引用

Question

首先，我将快速描述我这样做的动机和实际问题：
我经常处理大量文件，更具体地说，我发现自己必须根据以下规则重命名它们：
它们可能都包含单词和数字，但只有一组数字在递增，而不是 'constant'。我需要提取那些并且只提取那些数字并相应地重命名文件。例如：

Foo_1_Bar_2015.jpg
Foo_2_Bar_2015.jpg
Foo_03_Bar_2015.jpg
Foo_4_Bar_2015.jpg

将更名：

1.jpg
2.jpg
3.jpg or 03.jpg (The leading zero can stay or go)
4.jpg

因此，我们从一个矢量开始，其中包含指定目录中所有文件名的 std::wstring 个对象。我敦促您停止阅读 3 分钟，并在我继续我的尝试和问题之前考虑如何解决这个问题。我不希望我的想法将您推向某个方向，而且我一直发现新鲜的想法是最好的。

现在，我能想到的有两种方法：

1) 旧式 C 字符串操作和比较：
在我看来，这需要解析每个文件名并记住每个数字序列的位置和长度。对于每个文件，这很容易存储在矢量或类似的东西中。这很好用（基本上使用增加偏移量的字符串搜索）：

while((offset = filename_.find_first_of(L"0123456789", offset)) != filename.npos)
{
    size = filename.find_first_not_of(L"0123456789", offset) - offset;
    digit_locations_vec.emplace_back(offset, size);
    offset += size;
}

这之后我得到的是文件名中所有数字的（位置，大小）对向量，是否为常量（通过使用动机中的定义）。
在此之后，混乱接踵而至，因为您需要交叉引用字符串并找出哪些数字是需要提取的数字。这将随着未提及的文件数量（往往很大）乘以每个字符串中的数字序列数量而呈指数增长。此外，可读性、可维护性或优雅性都不是很好。不行。

2) 正则表达式

如果说正则表达式曾经有用过，那就是这个。从第一个文件名创建一个正则表达式对象，并尝试将其与下一个匹配。成功？即时提取所需数量的能力。失败？将有问题的文件名添加为新的正则表达式对象，并尝试匹配两个现有的正则表达式。冲洗并重复。正则表达式看起来像这样：

Foo_(\d+)_Bar_(\d+).jpg

或者分别为每个数字序列创建一个正则表达式：

Foo_(\d+)_Bar_2015.jpg
Foo_1_Bar_(\d+).jpg

剩下的就是蛋糕了。继续匹配，在最好的情况下，它可能只需要一次通过！问题是...

我需要知道的：

1) 你能想到任何其他更好的方法来实现这一目标吗？这几天我一直在用头撞墙
2) 尽管在第一种方法中字符串操作和向量 constructing\destructing 的成本可能很高，但与正则表达式对象的成本相比，它可能相形见绌。第二种方法，最坏的情况：与文件一样多的正则表达式对象。这对可能有数千个文件来说会是灾难性的吗？
3) 第二种方法可以针对两种可能性之一进行调整：很少 std::regex 对象构造，很多 regex_match 调用或相反。哪个更昂贵，正则表达式对象的构造或尝试用它匹配字符串？

Answer 1

对我来说（gcc4.6.2 32 位优化 O3），手动字符串操作比正则表达式快大约 2 倍。不值得。

可运行的完整代码示例（link 与 boost_system 和 boost_regex，或者如果编译器中已经有正则表达式则更改包含）：

#include <ctime>
#include <cctype>
#include <algorithm>
#include <string>
#include <iostream>
#include <vector>
#include <sstream>
using namespace std;

#include <boost/regex.hpp>
using namespace boost;

/*
Foo_1_Bar_2015.jpg
Foo_1_Bar_2016.jpg
Foo_2_Bar_2016.jpg
Foo_2_Bar_2015.jpg
...
*/
vector<string> generateNames(int lenPerYear, int yearStart, int years);

/*
Foo_1_Bar_2015.jpg -> 1_2015.jpg
Foo_7_Bar_2016.jpg -> 7_2016.jpg
*/

void rename_method_string(const vector<string> & names, vector<string> & renamed);
void rename_method_regex(const vector<string> & names, vector<string> & renamed);

typedef void rename_method_t(const vector<string> & names, vector<string> & renamed);
void testMethod(const vector<string> & names, const string & description, rename_method_t method);

int main()
{
    vector<string> names = generateNames(10000, 2014, 100);
    cout << "names.size() = " << names.size() << '\n';
    cout << '\n';
    testMethod(names, "method 1 - string manipulation: ", rename_method_string);
    cout << '\n';
    testMethod(names, "method 2 - regular expressions: ", rename_method_regex);

    return 0;
}

void testMethod(const vector<string> & names, const string & description, rename_method_t method)
{
    vector<string> renamed(names.size());
    clock_t timeStart = clock();
    method(names, renamed);
    clock_t timeEnd = clock();
    cout << "renamed examples:\n";
    for (int i = 0; i < 10 && i < names.size(); ++i)
        cout << names[i] << " -> " << renamed[i] << '\n';
    cout << description << 1000 * (timeEnd - timeStart) / CLOCKS_PER_SEC << " ms\n";
}

vector<string> generateNames(int lenPerYear, int yearStart, int years)
{
    vector<string> result;
    for (int year = yearStart, yearEnd = yearStart + years; year < yearEnd; ++year)
    {
        for (int i = 0; i < lenPerYear; ++i)
        {
            ostringstream oss;
            oss << "Foo_" << i << "_Bar_" << year << ".jpg";
            result.push_back(oss.str());
        }
    }
    return result;
}

template<typename T>
bool equal_safe(T itShort, T itShortEnd, T itLong, T itLongEnd)
{
    if (itLongEnd - itLong < itShortEnd - itShort)
        return false;
    return equal(itShort, itShortEnd, itLong);
}

void rename_method_string(const vector<string> & names, vector<string> & renamed)
{
    //manually: "Foo_(\d+)_Bar_(\d+).jpg" -> _.jpg
    const string foo = "Foo_", bar = "_Bar_", jpg = ".jpg";

    for (int i = 0; i < names.size(); ++i)
    {
        const string & name = names[i];
        //starts with foo?
        if (!equal_safe(foo.begin(), foo.end(), name.begin(), name.end()))
        {
            renamed[i] = "ERROR no foo";
            continue;
        }
        //extract number
        auto it = name.begin() + foo.size();
        for (; it != name.end() && isdigit(*it); ++it) {}
        string str_num1(name.begin() + foo.size(), it);
        //continues with bar?
        if (!equal_safe(bar.begin(), bar.end(), it, name.end()))
        {
            renamed[i] = "ERROR no bar";
            continue;
        }
        //extract number
        it += bar.size();
        auto itStart = it;
        for (; it != name.end() && isdigit(*it); ++it) {}
        string str_num2(itStart, it);
        //check *.jpg
        if (!equal_safe(jpg.begin(), jpg.end(), it, name.end()))
        {
            renamed[i] = "ERROR no .jpg";
            continue;
        }
        renamed[i] = str_num1 + "_" + str_num2 + ".jpg";
    }
}

void rename_method_regex(const vector<string> & names, vector<string> & renamed)
{
    regex searching("Foo_(\d+)_Bar_(\d+).jpg");
    smatch found;
    for (int i = 0; i < names.size(); ++i)
    {
        if (regex_search(names[i], found, searching))
        {
            if (3 != found.size())
                renamed[i] = "ERROR weird match";
            else
                renamed[i] = found[1].str() + "_" + found[2].str() + ".jpg";
        }
        else renamed[i] = "ERROR no match";
    }
}

它为我生成输出：

names.size() = 1000000

renamed examples:
Foo_0_Bar_2014.jpg -> 0_2014.jpg
Foo_1_Bar_2014.jpg -> 1_2014.jpg
Foo_2_Bar_2014.jpg -> 2_2014.jpg
Foo_3_Bar_2014.jpg -> 3_2014.jpg
Foo_4_Bar_2014.jpg -> 4_2014.jpg
Foo_5_Bar_2014.jpg -> 5_2014.jpg
Foo_6_Bar_2014.jpg -> 6_2014.jpg
Foo_7_Bar_2014.jpg -> 7_2014.jpg
Foo_8_Bar_2014.jpg -> 8_2014.jpg
Foo_9_Bar_2014.jpg -> 9_2014.jpg
method 1 - string manipulation: 421 ms

renamed examples:
Foo_0_Bar_2014.jpg -> 0_2014.jpg
Foo_1_Bar_2014.jpg -> 1_2014.jpg
Foo_2_Bar_2014.jpg -> 2_2014.jpg
Foo_3_Bar_2014.jpg -> 3_2014.jpg
Foo_4_Bar_2014.jpg -> 4_2014.jpg
Foo_5_Bar_2014.jpg -> 5_2014.jpg
Foo_6_Bar_2014.jpg -> 6_2014.jpg
Foo_7_Bar_2014.jpg -> 7_2014.jpg
Foo_8_Bar_2014.jpg -> 8_2014.jpg
Foo_9_Bar_2014.jpg -> 9_2014.jpg
method 2 - regular expressions: 796 ms

此外，我认为这完全没有意义，因为在您的示例中，实际 I/O（获取文件名、重命名文件）将比任何 CPU 字符串操作慢得多。所以回答你的问题：

我看不出有什么优越的方法，I/O就是慢，别在乎优越感
根据我的经验，regex 对象并不昂贵，与手动方法相比，减速在 2 倍以内，与它节省的工作量相比，这是持续的减速并且可以忽略不计
多少 std::regex 个对象用于多少次 regex_match 调用？取决于 regex_match 调用的数量：匹配越多，创建特定 std::regex 对象的价值就越大。然而，这将非常依赖库。如果match calls很多，就单独创建，不确定就别打扰了。

Answer 2

为什么不使用 split 在字母和数字之间拆分字符串：

Regex.Split(fileName, "(?<=\D)(?=\d)|(?<=\d)(?=\D)");

然后获取数字所需的任何索引，也许使用 Where 子句，找到增加值的索引，而其他索引匹配，然后您可以使用 .Last() 来获取扩展名。

查找文件名中的数字并与其他数字交叉引用

Find digits in file names and cross reference them with others

c++

regex

string

filenames