c++11 regex 模块详解

于 2023-11-12 11:12:03 发布
阅读量600 收藏 1
点赞数
分类专栏： C/C++ Effectivve Modern Cpp 文章标签： c++ mysql 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rubikchen/article/details/134358494
版权

正则表达式库

说明: 如果以前懂正则, 那么regex就只是了解语法, 和cpp的差异;

头文件

#include <regex>

参考链接

https://en.cppreference.com/w/cpp/regex

几大要素

  • 被匹配串: 字符串, 三种指定方式 – 迭代器, \0结尾的字符串, std::string;
  • 匹配正则: std::basic_regex类型, std::regex则是std::basic_regex<char>的别名;
  • 匹配结果: std::match_results;
  • 替换表达式: 字符串, 决定如何对匹配内容进行替换;

正则和结果

正则表达式类: std::basic_regex

匹配结果类: std::match_results

匹配结果组: ()生成的组std::sub_match, 继承自std::pair, 存储一对迭代器, 而不是string; std::match_results::begin使用;

关联算法

regex_match: 正则匹配整个字符串;

regex_search: 正则匹配子串;

regex_replace: 将匹配内容按照指定规则进行替换;

迭代器

regex_iterator: 规则搜索所有匹配串;

regex_token_iterator: 迭代所有组;

异常

regex_error: 正则表达式非法

选项

syntax_option_type: 使用正则版本, 是否区分大小写之类;

match_flag_type: 匹配行为控制

正则表达式

类的声明

template<
    class CharT,
    class Traits = std::regex_traits<CharT>
> class basic_regex;
  • CharT数据类型;

typedef

std::regex	std::basic_regex<char>
std::wregex	std::basic_regex<wchar_t>

常用的regex就是别名;

构造

构造函数

// 默认构造
basic_regex(); // (1)	(since C++11)

// 使用 \0 结尾的字符串作为正则表达式, f 表示使用正则方案, egrep, extended, ecmascript 等
explicit basic_regex(const CharT *s,
                     flag_type f = std::regex_constants::ECMAScript); // (2)	(since C++11)

// 使用字符串 s 的前 n 个作为正则,   "(aa)bcd", 4 即 (aa) 作为正则
basic_regex(const CharT *s, std::size_t count,
            flag_type f = std::regex_constants::ECMAScript); // (3)	(since C++11)

// 拷贝其他正则;
basic_regex(const basic_regex &other);                       // (4)	(since C++11)

// 右值运算, 清空 other 正则;
basic_regex(basic_regex &&other) noexcept;                   // (5)	(since C++11)

// basic_string类型, 并萃取其基本类型; 常用 std::string 即 std::basic_string<char>
template <class ST, class SA>
explicit basic_regex(const std::basic_string<CharT, ST, SA> &str,
                     flag_type f = std::regex_constants::ECMAScript); // (6)	(since C++11)

// 使用迭代器进行初始化; 
template <class ForwardIt>
basic_regex(ForwardIt first, ForwardIt last,
            flag_type f = std::regex_constants::ECMAScript); // (7)	(since C++11)

// 使用列表进行初始化; {'a', 'b', 'c'}; 这种;
basic_regex(std::initializer_list<CharT> init,
            flag_type f = std::regex_constants::ECMAScript); //(8)	(since C++11)

异常: 构造函数可能抛出异常

1. 可能异常, 和实现有关
2. `std::regex_error` 如果正则非法就会抛出;
3. `std::regex_error` 如果正则非法就会抛出;
4. 可能异常, 和实现有关
5. 可能异常, 和实现有关
6. `std::regex_error` 如果正则非法就会抛出;
7. `std::regex_error` 如果正则非法就会抛出;
8. `std::regex_error` 如果正则非法就会抛出;

正则完全匹配

被匹配串是否完全匹配整个正则表达式

构造

函数原型: 返回值是否匹配, (链表 + 指针 + std::sring) * (返回结果 + 不返回结果) = 6 种, +1 delte 类型;

// BidirIt 双向链表; 
// [first, last) 指定搜索串;
// m 获取搜索结果
// e 正则表达式对象
// flags 匹配额外补充
template <class BidirIt,
          class Alloc, class CharT, class Traits>
bool regex_match(BidirIt first, BidirIt last,
                 std::match_results<BidirIt, Alloc> &m,
                 const std::basic_regex<CharT, Traits> &e,
                 std::regex_constants::match_flag_type flags =
                     std::regex_constants::match_default); //(1)	(since C++11)

// 和 (1) 类似, 但是不要结果
template <class BidirIt,
          class CharT, class Traits>
bool regex_match(BidirIt first, BidirIt last,
                 const std::basic_regex<CharT, Traits> &e,
                 std::regex_constants::match_flag_type flags =
                     std::regex_constants::match_default); //(2)	(since C++11)

// 字符串指定匹配串, 输出结果到 m
template <class CharT, class Alloc, class Traits>
bool regex_match(const CharT *str,
                 std::match_results<const CharT *, Alloc> &m,
                 const std::basic_regex<CharT, Traits> &e,
                 std::regex_constants::match_flag_type flags =
                     std::regex_constants::match_default); //(3)	(since C++11)

// std::string 类型, 输出结果到 m
template <class STraits, class SAlloc,
          class Alloc, class CharT, class Traits>
bool regex_match(const std::basic_string<CharT, STraits, SAlloc> &s,
                 std::match_results<
                     typename std::basic_string<CharT, STraits, SAlloc>::
                         const_iterator,
                     Alloc> &m,
                 const std::basic_regex<CharT, Traits> &e,
                 std::regex_constants::match_flag_type flags =
                     std::regex_constants::match_default); //(4)	(since C++11)

// 字符串指定匹配串, 不输出结果;
template <class CharT, class Traits>
bool regex_match(const CharT *str,
                 const std::basic_regex<CharT, Traits> &e,
                 std::regex_constants::match_flag_type flags =
                     std::regex_constants::match_default); // (5)	(since C++11)

// std::string 指定匹配串, 不输出结果;
template <class STraits, class SAlloc,
          class CharT, class Traits>
bool regex_match(const std::basic_string<CharT, STraits, SAlloc> &s,
                 const std::basic_regex<CharT, Traits> &e,
                 std::regex_constants::match_flag_type flags =
                     std::regex_constants::match_default); //(6)	(since C++11)

// 临时的 string 对象不支持; 即右值;
template <class STraits, class SAlloc,
          class Alloc, class CharT, class Traits>
bool regex_match(const std::basic_string<CharT, STraits, SAlloc> &&,
                 std::match_results<
                     typename std::basic_string<CharT, STraits, SAlloc>::
                         const_iterator,
                     Alloc> &,
                 const std::basic_regex<CharT, Traits> &,
                 std::regex_constants::match_flag_type flags =
                     std::regex_constants::match_default) = delete; //(7)	(since C++11)

返回值

函数返回值

true匹配, false不匹配

std::match_results: 执行后不管成功与否都会修改;

# If the match does not exist:
m.ready() == true
m.empty() == true
m.size() == 0
# If the match exists:
m.ready()	true
m.empty()	false
m.size()	number of marked subexpressions plus 1, that is, 1 + e.mark_count()

# 用迭代器表示匹配部分前的结果; 比字符串或std::string更灵活;
m.prefix().first	first
m.prefix().second	first
m.prefix().matched	false (the match prefix is empty)

# 匹配的后面字符串
m.suffix().first	last
m.suffix().second	last
m.suffix().matched	false (the match suffix is empty)

# 0 表示整个串
m[0].first	first
m[0].second	last
m[0].matched	true (the entire sequence is matched)

# n > 0 则表示第 n 个组;
m[n].first	the start of the sequence that matched marked sub-expression n, or last if the subexpression did not participate in the match
m[n].second	the end of the sequence that matched marked sub-expression n, or last if the subexpression did not participate in the match
m[n].matched	true if sub-expression n participated in the match, false otherwise

# 具体可了解 match_results 类, 重载了 operator<< , 可以直接输出;

正则搜索

声明

// BidirIt 双向链表
// 使用 frist, last 提供的字符串, e 的正则, m 输出结果 
template<class BidirIt,
        class Alloc, class CharT, class Traits> bool
regex_search(BidirIt first, BidirIt last,
             std::match_results<BidirIt, Alloc> &m,
             const std::basic_regex<CharT, Traits> &e,
             std::regex_constants::match_flag_type flags =
                 std::regex_constants::match_default); //(1)	(since C++11)

// 同一, 使用字符串指定;
template <class CharT, class Alloc, class Traits>
bool regex_search(const CharT *str,
                  std::match_results<const CharT *, Alloc> &m,
                  const std::basic_regex<CharT, Traits> &e,
                  std::regex_constants::match_flag_type flags =
                      std::regex_constants::match_default); //(2)	(since C++11)

// 同上使用 std::string 指定字符串
template <class STraits, class SAlloc,
          class Alloc, class CharT, class Traits>
bool regex_search(const std::basic_string<CharT, STraits, SAlloc> &s,
                  std::match_results<
                      typename std::basic_string<CharT, STraits, SAlloc>::const_iterator,
                      Alloc> &m,
                  const std::basic_regex<CharT, Traits> &e,
                  std::regex_constants::match_flag_type flags =
                      std::regex_constants::match_default); //(3)	(since C++11)

// 同一, 但不输出结果
template <class BidirIt,
          class CharT, class Traits>
bool regex_search(BidirIt first, BidirIt last,
                  const std::basic_regex<CharT, Traits> &e,
                  std::regex_constants::match_flag_type flags =
                      std::regex_constants::match_default); //(4)	(since C++11)

// 同二, 但不输出结果
template <class CharT, class Traits>
bool regex_search(const CharT *str,
                  const std::basic_regex<CharT, Traits> &e,
                  std::regex_constants::match_flag_type flags =
                      std::regex_constants::match_default); //(5)	(since C++11)
template <class STraits, class SAlloc,
          class CharT, class Traits>

// 同三, 但不输出结果
bool regex_search(const std::basic_string<CharT, STraits, SAlloc> &s,
                  const std::basic_regex<CharT, Traits> &e,
                  std::regex_constants::match_flag_type flags =
                      std::regex_constants::match_default); //(6)	(since C++11)

// 同三, 不支持右值;
template <class STraits, class SAlloc,
          class Alloc, class CharT, class Traits>
bool regex_search(const std::basic_string<CharT, STraits, SAlloc> &&,
                  std::match_results<
                      typename std::basic_string<CharT, STraits, SAlloc>::const_iterator,
                      Alloc> &,
                  const std::basic_regex<CharT, Traits> &,
                  std::regex_constants::match_flag_type flags =
                      std::regex_constants::match_default) = delete; //(7)	(since C++11)

返回结果: m

If the match does not exist:
m.ready() == true
m.empty() == true
m.size() == 0
If the match exists:
m.ready()	true
m.empty()	false
m.size()	number of marked subexpressions plus 1, that is, 1 + e.mark_count()
m.prefix().first	first
m.prefix().second	m[0].first
m.prefix().matched	m.prefix().first != m.prefix().second
m.suffix().first	m[0].second
m.suffix().second	last
m.suffix().matched	m.suffix().first != m.suffix().second
m[0].first	the start of the matching sequence
m[0].second	the end of the matching sequence
m[0].matched	true
m[n].first	the start of the sequence that matched marked sub-expression n, or last if the subexpression did not participate in the match
m[n].second	the end of the sequence that matched marked sub-expression n, or last if the subexpression did not participate in the match
m[n].matched	true if sub-expression n participated in the match, false otherwise

正则替换

声明

// OutputIt 输出迭代器, 并输出首地址;
// BidirIt 双向链表
// 使用 frist, last 提供的字符串, re 的正则
// fmt 使用 std::string 指定
template <class OutputIt, class BidirIt,
          class Traits, class CharT,
          class STraits, class SAlloc>
OutputIt regex_replace(OutputIt out, BidirIt first, BidirIt last,
                       const std::basic_regex<CharT, Traits> &re,
                       const std::basic_string<CharT, STraits, SAlloc> &fmt,
                       std::regex_constants::match_flag_type flags =
                           std::regex_constants::match_default); //(1)	(since C++11)

// 同上， fmt 用 字符串指定;
template <class OutputIt, class BidirIt,
          class Traits, class CharT>
OutputIt regex_replace(OutputIt out, BidirIt first, BidirIt last,
                       const std::basic_regex<CharT, Traits> &re,
                       const CharT *fmt,
                       std::regex_constants::match_flag_type flags =
                           std::regex_constants::match_default); //(2)	(since C++11)


// 同一: 输出结果为字符串而不是迭代器;
// fmt 用 std::string 指定;
template <class Traits, class CharT,
          class STraits, class SAlloc,
          class FTraits, class FAlloc>
std::basic_string<CharT, STraits, SAlloc>
regex_replace(const std::basic_string<CharT, STraits, SAlloc> &s,
              const std::basic_regex<CharT, Traits> &re,
              const std::basic_string<CharT, FTraits, FAlloc> &fmt,
              std::regex_constants::match_flag_type flags =
                  std::regex_constants::match_default); //(3)	(since C++11)

// 同上, fmt 用字符串指定;
template <class Traits, class CharT,
          class STraits, class SAlloc>
std::basic_string<CharT, STraits, SAlloc>
regex_replace(const std::basic_string<CharT, STraits, SAlloc> &s,
              const std::basic_regex<CharT, Traits> &re,
              const CharT *fmt,
              std::regex_constants::match_flag_type flags =
                  std::regex_constants::match_default); //(4)	(since C++11)

// s 用 字符串指定, 输出为 basic_string, fmt 为 std::basic_string
template <class Traits, class CharT,
          class STraits, class SAlloc>
std::basic_string<CharT>
regex_replace(const CharT *s,
              const std::basic_regex<CharT, Traits> &re,
              const std::basic_string<CharT, STraits, SAlloc> &fmt,
              std::regex_constants::match_flag_type flags =
                  std::regex_constants::match_default); //(5)	(since C++11)

// 同上, fmt用 字符串指定;
template <class Traits, class CharT>
std::basic_string<CharT>
regex_replace(const CharT *s,
              const std::basic_regex<CharT, Traits> &re,
              const CharT *fmt,
              std::regex_constants::match_flag_type flags =
                  std::regex_constants::match_default); //(6)	(since C++11)

差异点:

  1. 替换主串: 迭代器, std::basic_string, CharT 型;
  2. fmt格式: std::basic_string, CharT;

fmt

说明

  1. $& or $0 is used to insert the whole regex match.
#include <regex>
#include <iostream>

int main () {
    std::cout << std::regex_replace("hello, i'm xiaoli", std::regex(".+"), "$0!!") << std::endl;
}

$ g++ test.cpp && ./a.out
hello, i'm  xiaoli!!
  1. $1, $2, … up to $9 is used to insert the text matched by the first nine capturing groups.
#include <regex>
#include <iostream>

int main () {
    std::cout << std::regex_replace("hello, i'm xiaoli", std::regex("(hello, i'm )(\\w+)"), "$1 xiaowang") << std::endl;
}

$ g++ test.cpp && ./a.out
hello, i'm  xiaowang
  1. $` (back-tick) is used to insert the string that is left of the match.
#include <regex>
#include <iostream>

int main () {
    std::cout << std::regex_replace("hello, i'm xiaoli", std::regex("'"), "\n$`\n") << std::endl;
}

即正则表达式'匹配串(不包含匹配字符串本身)左边的内容;

$`  == hello, i

$ g++ test.cpp && ./a.out
hello, i
hello, i
m xiaoli
  1. $’ (quote) is used to insert the string that is right of the match.
#include <regex>
#include <iostream>

int main () {
    std::cout << std::regex_replace("hello, i'm xiaoli", std::regex("'"), "\n$'\n") << std::endl;
}

同样的道理, 是去除匹配串后的右边串;

$ g++ test.cpp && ./a.out
hello, i
m xiaoli
m xiaoli
  1. If number of capturing group is less than the requested, then that will be replaced by nothing.

参考链接

https://www.geeksforgeeks.org/regex_replace-in-cpp-replace-the-match-of-a-string-using-regex_replace/

regex_iterator

和regex_search一样; 只是match_results变为iter;

只输出匹配

案例

#include <iostream>
#include <iterator>
#include <regex>
#include <string>
 
int main()
{
    const std::string s = "Quick brown fox.";
 
    std::regex words_regex("[^\\s]+");
    auto words_begin = std::sregex_iterator(s.begin(), s.end(), words_regex);
    auto words_end = std::sregex_iterator();
 
    std::cout << "Found " << std::distance(words_begin, words_end) << " words:\n";
 
    for (std::sregex_iterator i = words_begin; i != words_end; ++i)
    {
        std::smatch match = *i;
        std::string match_str = match.str();
        std::cout << match_str << '\n';
    }
}

Found 3 words:
Quick
brown
fox.

regex_token_iterator

说明: 只获取组

案例

#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <regex>
 
int main()
{
    // Tokenization (non-matched fragments)
    // Note that regex is matched only two times; when the third value is obtained
    // the iterator is a suffix iterator.
    const std::string text = "Quick brown fox.";
    const std::regex ws_re("\\s+"); // whitespace
    std::copy(std::sregex_token_iterator(text.begin(), text.end(), ws_re, -1),
              std::sregex_token_iterator(),
              std::ostream_iterator<std::string>(std::cout, "\n"));
 
    std::cout << '\n';
 
    // Iterating the first submatches
    const std::string html = R"(<p><a href="http://google.com">google</a> )"
                             R"(< a HREF ="http://cppreference.com">cppreference</a>\n</p>)";
    const std::regex url_re(R"!!(<\s*A\s+[^>]*href\s*=\s*"([^"]*)")!!", std::regex::icase);
    std::copy(std::sregex_token_iterator(html.begin(), html.end(), url_re, 1),
              std::sregex_token_iterator(),
              std::ostream_iterator<std::string>(std::cout, "\n"));
}

Quick
brown
fox.
 
http://google.com
http://cppreference.com
502203305
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++Regex正则表达式
01-30
C++Regex正则表达式
c++11中regex正则表达式示例简述
08-25
主要给大家介绍了关于c++11中regex正则表达式的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用c++11具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
C++正则表达式regex库使用方法总结
热门推荐
Asia-Lee
12-07 3万+
目录 一、regex库中常用组件介绍 二、regex库中常用组件使用 1、regex库组件使用准备 2、regex_match使用 3、regex_search使用 4、regex_replace使用 5、sregex_iterator使用 三、基于regex库组件构建自己的正则接口类 1、C++正则表达式接口类设计 2、C++正则表达式接口类使用 四、部分语法规则介绍 正...
C++正则表达式（regex_match、regex_search与regex_replace）
qq_35886593的博客
04-17 5411
前言 1 转义字符 2 regex_match 2.1 基本概念 2.2 匹配结果 2.3 实例 3 regex_search 3.1 基本概念 3.2 实例 4 regex_replace 4.1 基本概念 4.2 扩展 5 匹配忽略大小写 6 帮助网站 1 转义字符 cout << regex_match("123", regex(...
C++11之正则表达式（regex_match、regex_search、regex_replace）
林夕07
06-27 1万+
详细讲解C++中的正则匹配如何使用，对regex_match、regex_search、regex_replace函数进行介绍。
C++ 正则表达式教程：C++ 中的正则表达式与示例
weixin_43229348的博客
05-10 1万+
C++ 正则表达式教程解释了 C++ 中正则表达式的工作，包括正则表达式匹配、搜索、替换、输入验证和标记化的功能。 几乎所有的编程语言都支持正则表达式。 C++ 从 C++11 开始直接支持正则表达式。除了编程语言之外，大多数文本处理程序（如词法分析器、高级文本编辑器等）都使用正则表达式。 在本教程中，我们将探讨正则表达式的一般细节以及 C++ 编程方面的细节。 正则匹配中的基础符号 ^开头 ()组 []或, {}几次 $结尾 1. C++ 中的正则表达式 (Regex) 正则表达式是包含一系列字符的表达
正则表达式 C++
生活需要深度
03-01 2606
若要判断一个输入的QQ号是否有效，你会如何处呢？ 首先你得分析一下其对应规则，依次列出： 长度大于5，小于等于11； 首位不能为0； 是否为纯数字？ 规则既列，接着就该尝试实现了，那么用什么来表示字符串呢？在C++中，最容易想到的就是string了，其中提供了许多成员函数可以处理字符串，所以有了如下实现： std::string qq; std::cin >> qq; // 1. 判断位数是否合法 if (qq.length() >= 5 && qq.leng
正则表达式
漆灿
07-10 1829
目录 1. 正则表达式的语法 2. 正则表达式的三个常用函数或功能 1). regex_match（全文匹配） 2). regex_search （搜索） 3). regex_replace（替换） 3. python中的正则使用 4. linux下正则的使用 5. 帮助网站 6. 参考 1. 正则表达式的语法 参考：https://www.runoob.com/reg...
C/C++ 正则表达式 regex库介绍（详细版）
余识-
05-28 1万+
详尽介绍C++标准正则表达式库regex的使用
C++ 正则表达式(匹配、搜索、替换)
qq_38409301的博客
09-03 4636
首先C++的正则表达式的速度比boost的正则表达式的数据要慢很多。链接：简单正则表达式的使用：一：匹配 regex_matchregex_match 要求的是内容完全匹配正则表达式，一个错误都不行。二：搜索匹配 regex_searchregex_search 要求的是只要内容中存在正则表达式的要求就是正确的。三：匹配替代 regex_replaceregex_replace 要求的是只要内容中存在正则表达式的要求就替换成新的文字正则表达式特殊字符的处理。
c++ 正则表达式-基础操作
cxu123321的博客
05-04 880
c++ 正则表达式-基础操作 philpanic9 2019-03-04 21:50:43 13462 收藏 30 展开 正则表达式是一个非常强大的工具，主要用于字符串匹配。如何在c++中使用正则表达式？下面就简要介绍一下c++中正则表达式相关函数的用法。 本篇博客中所涉及到的函数及其功能如下表所示： 函数 功能 regex_match(s,re) 目标字符...
易语言模块RegEx.rar
03-29
易语言模块RegEx.rar 易语言模块RegEx.rar 易语言模块RegEx.rar 易语言模块RegEx.rar 易语言模块RegEx.rar 易语言模块RegEx.rar
易语言模块RegEx1.rar
03-29
易语言模块RegEx1.rar 易语言模块RegEx1.rar 易语言模块RegEx1.rar 易语言模块RegEx1.rar 易语言模块RegEx1.rar 易语言模块RegEx1.rar
android backtrace实现
rubikchen的博客
09-15 1054
backtrace 简介 有的系统没有实现backtrace这个函数. 常见的就有linux还有一些docker的库. 判断是否支持backtrace #include<stdio.h> #include<dlfcn.h> int main() { void * bt = dlsym(NULL,"backtrace"); if(NULL != bt) { printf("support\n"); } else ..
获取线程在CPU的执行时间
rubikchen的博客
01-05 908
总览 说明 通过linux下的接口实现. 参考 man7 案例 代码 #include<pthread.h> #include<stdio.h> #include<time.h> #include<unistd.h> int main() { clockid_t st; struct timespec ts,te; if(pthread_getcpuclockid(pth..
valgrind massif 详解（内存分配释放分析）
最新发布
rubikchen的博客
09-16 814
内存分配释放分析
asan 输出案例解析
rubikchen的博客
05-29 730
【代码】asan 输出案例解析。
asan 关闭部分功能，禁止错误中止机制
rubikchen的博客
07-13 452
支持环境变量配置。
c++11 regex库
08-08
C语言中的regex库是一个用于处理正则表达式的库。正则表达式是一种强大的文本模式匹配工具，可以用于在字符串中搜索、查找和替换特定的模式。 regex库提供了一组函数，使得在C程序中可以使用正则表达式的功能。通过使用这些函数，我们可以从一个字符串中提取出符合特定模式的子字符串，也可以检查一个字符串是否与某个特定的模式匹配。 regex库中最常用的函数是regcomp和regexec。regcomp函数用于编译正则表达式，将其转换为一个可执行的模式。regexec函数用于在字符串中进行匹配，返回找到匹配的结果。 除了基本的匹配功能，regex库还提供了一些其他的函数，如regerror函数用于显示错误信息、regfree函数用于释放正则表达式对象等。 使用regex库需要导入<regex.h>头文件，并链接对应的库文件。具体的使用方法可以查阅C语言的相关文档和教程，也可以参考regex库的官方文档。 总之，C语言的regex库为我们提供了一个方便和强大的工具，使得可以在程序中处理和操作复杂的文本模式。无论是字符串的搜索、匹配还是替换，regex库都可以提供便捷的解决方案。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值