C++ 中使用正则表达式验证 localhost API 请求是否由 POSTMAN 处理

2025年5月13日 | 阅读 13 分钟

在开发Web应用程序时，在本地测试 API 端点是确保功能和调试的常见做法。Postman 等工具通过允许开发人员向 localhost 上的 API 端点发送 HTTP 请求来简化此过程。localhost API 请求是指向开发人员计算机上的端点发出的请求，通常针对 localhost 域和特定的 端口号，例如 https://:3000/api/users。

Postman 在 localhost API 测试中起着至关重要的作用，它提供了一个用户友好的界面来构造和发送各种类型的 HTTP 请求，包括 GET、POST、PUT、DELETE 等。此工具简化了测试过程，允许开发人员在不部署到服务器的情况下验证 API 功能。通过使用 Postman，开发人员可以实时与他们的 API 端点进行交互，从而在开发过程中实现快速迭代和调试。

API 请求的验证对于确保应用程序按预期运行并正确处理输入至关重要。验证请求有助于防止格式错误或未经授权的请求导致意外行为或安全漏洞。例如，确保请求格式正确并定向到正确的端点对于可靠的开发和测试至关重要。

正则表达式（regex）是强大的 模式匹配和验证工具。它们允许开发人员定义描述字符串集的模式，使其成为验证 API 请求的结构和内容的理想选择。在 localhost API 测试的上下文中，可以使用正则表达式来确保请求符合特定的格式并定向到正确的端点。

使用 Postman 等工具在本地测试 API 端点对于可靠的开发和调试至关重要。使用正则表达式验证 API 请求可确保请求格式正确并定向正确，从而防止意外行为并增强 Web 应用程序的安全性。

方法 1：正则表达式（Regex）方法

使用 C++ 验证 Postman 处理的 localhost API 请求涉及创建一个程序，该程序检查提供的请求是否符合定义的格式。通常，这些请求包含 HTTP 方法（例如 GET、POST）、带有端口号的 localhost URL 以及 API 端点。使用正则表达式，定义一个模式来匹配此格式。之后，程序通过将请求与正则表达式进行比较来验证请求。如果请求与模式匹配，则认为它是有效的；否则，它被视为无效。正则表达式提供了一种简洁灵活的方式来定义 API 请求的预期结构，确保它们格式正确，以便在开发过程中进行可靠的测试和调试。

程序

#include <iostream>
#include <regex>
#include <string>
bool validateRequest(const std::string& request) {
    // Regular expression pattern to validate localhost API requests processed by Postman
    std::regex pattern("^(GET|POST)\\s+http:\\/\\/localhost:\\d+\\/api\\/.*$");
    // Match object to hold regex match results
    std::smatch match;
    // Perform regex match
    if (std::regex_match(request, match, pattern)) {
        // Print matched parts for debugging
        std::cout << "HTTP Method: " << match[1] << std::endl;
        return true;
    } else {
        std::cout << "Invalid request format!" << std::endl;
        return false;
    }
}
int main() {
    // API request processed by Postman
    std::string request = "GET https://:3000/api/users";
    std::cout << "API request processed by Postman: " << request << std::endl;
    // Validate the request
    if (validateRequest(request)) {
        std::cout << "Valid request!\n";
    } else {
        std::cout << "Invalid request!\n";
    }
    return 0;
}

输出

API request processed by Postman: GET https://:3000/api/users
HTTP Method: GET
Valid request!

说明

提供的 C++ 代码片段演示了一个使用正则表达式验证 Postman 处理的 localhost API 请求的程序。validateRequest 函数负责验证 API 请求。它将一个表示 API 请求的字符串 request 作为输入。在函数内部

使用 std::regex 使用正则表达式定义一个模式来匹配 Postman 处理的 localhost API 请求的预期格式。

模式 ^(GET|POST)\s+http:\/\/localhost:\d+\/api\/.*$ 检查：

请求开头的 "GET" 或 "POST" HTTP 方法。
后跟带有端口号的 localhost URL 的空格字符（https://:<port>/api/）。
URL 路径中的任何其他字符。
使用 std::smatch 对象 match 存储正则表达式匹配的结果。

调用 std::regex_match 使用定义的模式对请求字符串执行正则表达式匹配。

如果请求与模式匹配，则为调试目的打印从匹配中提取的 HTTP 方法。如果请求有效（与模式匹配），则函数返回 true。否则，它返回 false 并打印 "无效的请求格式！"。

在主函数中

Postman 处理的 API 请求以字符串 request ("GET https://:3000/api/users") 的形式提供。请求字符串打印到控制台。调用 validateRequest 函数来 验证请求。 如果请求有效，则打印 "Valid request!"；否则，打印 "Invalid request!"。

此代码片段说明了如何使用正则表达式定义和验证 API 请求的结构，确保它们符合服务器期望的特定格式。它提供了一种强大的机制来检查 Postman 处理的请求的正确性，从而在开发和 测试阶段增强 应用程序的可靠性。

复杂度分析

时间和空间复杂度分析涉及评估算法在执行所需时间以及所需内存量方面的 效率。 让我们了解 C++ 代码片段 验证 Postman 处理的 localhost API 请求的时间和空间复杂度

时间复杂度

正则表达式匹配

正则表达式匹配的时间复杂度取决于实现和正则表达式的复杂性。在这种情况下，正则表达式由简单的模式组成，例如字符文字、交替和量词。

因此，正则表达式匹配步骤的总时间复杂度为 O(n⋅m)。

打印和条件语句

打印调试消息和执行条件语句（如 if-else 语句）的时间复杂度是 常数 (O(1))。 这些操作不取决于输入字符串的大小，对整体时间复杂度影响可忽略不计。

空间复杂度

正则表达式匹配

正则表达式匹配的空间复杂度主要取决于正则表达式引擎的实现以及在匹配过程中存储 中间数据结构所需的内存量。在这种情况下，正则表达式匹配的空间复杂度通常是线性的或接近线性的，相对于输入字符串的大小。

假设输入字符串的长度为 n。因此，正则表达式匹配步骤的空间复杂度为 O(n)。

附加内存使用

代码片段使用附加内存来存储输入字符串、正则表达式和匹配对象（请求、模式、匹配）。这些变量的空间复杂度是常数，不取决于输入字符串的大小。

因此，代码片段的最终空间复杂度为 O(n)， 其中 n 是输入字符串的长度。

方法 2：分词方法

分词方法是一种通过将请求字符串分解为称为标记的更小组件来验证 API 请求的方法。每个标记代表请求的特定部分，例如 HTTP 方法、URL 和 API 端点。

在验证 Postman 处理的 API 请求的上下文中，分词涉及根据空格和斜杠等分隔符将请求字符串分割成其组成部分。一旦请求被分词，就会单独检查每个标记，以确保它满足有效请求的标准。

例如，第一个标记必须是 "GET" 或 "POST" 以表示 HTTP 方法，而第二个标记应包含 localhost URL。API 端点的存在和格式也在分词过程中进行验证。

通过单独验证每个标记，分词方法提供了一种详细且系统的方法来确保 API 请求符合预期格式，从而在开发和测试阶段增强应用程序的可靠性和安全性。

程序

#include <iostream>
#include <string>
#include <vector>
#include <sstream>
bool validateRequest(const std::string& request) {
    // Tokenize the request string
    std::vector<std::string> tokens;
    std::istringstream iss(request);
    std::string token;
    while (std::getline(iss, token, ' ')) {
        tokens.push_back(token);
    }
    // Check if the tokenized request contains the required elements
    bool hasMethod = false;
    bool hasLocalhost = false;
    bool hasApi = false;
    for (const auto& token : tokens) {
        if (token == "GET" || token == "POST") {
            hasMethod = true;
        }
        if (token.find("https://:") != std::string::npos) {
            hasLocalhost = true;
        }
        if (token.find("/api/") != std::string::npos) {
            hasApi = true;
        }
    }
    // Validate each required element
    if (!hasMethod || !hasLocalhost || !hasApi) {
        std::cout << "Invalid request format!" << std::endl;
        return false;
    }
    // All required elements are present
    std::cout << "HTTP Method: " << tokens[0] << std::endl;
    return true;
}
int main() {
    // API request processed by Postman
    std::string request = "GET https://:3000/api/users";
    // Print the API request processed by Postman
    std::cout << "API request processed by Postman: " << request << std::endl;
    // Validate the request
    if (validateRequest(request)) {
        std::cout << "Valid request!\n";
    } else {
        std::cout << "Invalid request!\n";
    }
    return 0;
}

输出

API request processed by Postman: GET https://:3000/api/users
HTTP Method: GET
Valid request!

说明

分词
validateRequest 函数首先对输入请求字符串进行分词。分词涉及根据指定的分隔符将字符串分解成更小的部分或标记。在这种情况下，使用空格作为分隔符。分词是通过 std::istringstream 对象实现的，该对象从输入字符串中提取标记并将其存储在 std::vector<std::string> 中。
验证
一旦请求字符串被分词，函数将继续单独验证每个标记，以确保它包含有效 API 请求所需的元素。三个布尔标志（hasMethod、hasLocalhost、hasApi）用于跟踪请求是否包含 HTTP 方法、localhost URL 和 API 端点。
迭代标记
循环遍历标记化请求中的每个标记。对于每个标记，函数会检查它是否对应于必需的元素之一。
如果标记代表 HTTP 方法（"GET" 或 "POST"），则 hasMethod 标志设置为 true。如果标记包含 localhost URL（通过存在 "https://:" 识别），则 hasLocalhost 标志设置为 true。
如果标记包含 API 端点（通过存在 "/api/" 识别），则 hasApi 标志设置为 true。
验证结果
遍历所有标记后，函数会验证请求中是否包含所有必需的元素。如果缺少任何必需的元素（即，如果任何布尔标志为 false），则函数得出结论，认为请求格式无效。在这种情况下，它会在控制台上打印 "Invalid request format!" 并返回 false。
输出和验证成功
如果请求中存在所有必需的元素，则函数会在控制台上打印从第一个标记中提取的 HTTP 方法（假设 HTTP 方法是第一个标记）。然后它返回 true，表示请求格式有效。
主函数
在 main 函数中，Postman 处理的示例 API 请求以输入字符串 request 的形式提供。请求打印到控制台，并调用 validateRequest 函数对其进行验证。根据验证结果，将在控制台上打印 "Valid request!" 或 "Invalid request!"。

最后，代码实现了一种验证机制，该机制对输入请求字符串进行分词，并单独验证每个标记，以确保它符合 Postman 处理的 localhost API 请求的预期格式。

复杂度分析

时间复杂度

分词（线性时间复杂度）

分词过程涉及迭代输入字符串的每个字符以提取标记。由于输入字符串的长度直接影响分词所需的迭代次数，因此分词的时间复杂度相对于 输入字符串的长度是线性的。

因此，分词的时间复杂度为 O(n)， 其中 n 是输入字符串的长度。

验证（线性时间复杂度）

分词后，代码会迭代每个标记以验证它是否包含必需的元素（HTTP 方法、localhost URL 和 API 端点）。由于标记的数量直接取决于输入字符串的长度，因此验证的时间复杂度也相对于 输入字符串的长度是线性的。

因此，验证的时间复杂度也为 O(n)， 其中 n 是输入字符串的长度。

代码的最终时间复杂度由分词和验证步骤决定。由于分词和验证都具有 线性时间复杂度，因此代码的最终时间复杂度仍为 O(n)， 其中 n 是输入字符串的长度。

空间复杂度

分词（线性空间复杂度）

在分词过程中，代码将每个标记存储在 std::vector<std::string> 中。存储标记所需的空间直接取决于标记的数量，而标记的数量又取决于输入字符串的长度和结构。

因此，分词的空间复杂度相对于标记的数量是 线性的，因此相对于输入字符串的长度是线性的。

分词的空间复杂度为 O(n)， 其中 n 是输入字符串的长度。

附加内存使用

除了标记之外，代码不使用任何随 输入字符串大小而增长的附加数据结构。因此，附加内存使用是恒定的，对整体空间复杂度影响不大。

附加内存使用的空间复杂度为 O(1)。

考虑到分词和 附加内存使用，代码的整体空间复杂度仍然是 O(n)， 其中 n 是输入字符串的长度。

方法 3：有限状态机 (FSM) 方法

在有限状态机 (FSM) 方法中，我们设计一个有限状态机，该状态机根据请求字符串的结构在状态之间转换。每个状态代表请求的特定方面，状态之间的转换基于请求中是否存在某些元素。

为 Postman 处理的 API 请求实现有限状态机 (FSM) 涉及设计一个具有多个状态的 FSM，这些状态代表请求的不同部分，并在这些状态之间基于请求字符串的结构进行转换。

程序

#include <iostream>
#include <string>
enum class State {
    START,
    METHOD,
    URL,
    PARAMETERS,
    END,
    ERROR
};
bool validateRequest(const std::string& request) {
    State currentState = State::START;
    size_t index = 0;
    while (index < request.size()) {
        switch (currentState) {
            case State::START:
                if (request.substr(index, 3) == "GET" || request.substr(index, 4) == "POST") {
                    currentState = State::METHOD;
                    index += (request.substr(index, 3) == "GET" ? 3 : 4); // Move index past the method
                } else {
                    currentState = State::ERROR;
                }
                break;
            case State::METHOD:
                if (request.find("https://:", index) == index) {
                    currentState = State::URL;
                    index += 16; // Move index past "https://:"
                } else {
                    currentState = State::ERROR;
                }
                break;
            case State::URL:
                while (index < request.size() && request[index] != ' ') {
                    index++; // Move index until space character is found
                }
                currentState = State::PARAMETERS;
                break;
            case State::PARAMETERS:
                if (request[index] == ' ') {
                    index++; // Move past space character
                }
                currentState = State::END;
                break;
            case State::END:
                // Check if there are any remaining characters after the end of the request
                if (index < request.size()) {
                    currentState = State::ERROR;
                }
                break;
            case State::ERROR:
                std::cerr << "Invalid request format!" << std::endl;
                return false;
        }
    }
    // Check if the FSM ended in the expected state
    if (currentState != State::END) {
        std::cerr << "Invalid request format!" << std::endl;
        return false;
    }
    // Print the HTTP method
    std::cout << "HTTP Method: " << request.substr(0, (request.find(' ') != std::string::npos) ? request.find(' ') : request.size()) << std::endl;
    return true;
}
int main() {
    // API request processed by Postman
    std::string request = "GET https://:3000/api/users";
    std::cout << "API request processed by Postman: " << request << std::endl;
    // Validate the request
    if (validateRequest(request)) {
        std::cout << "Valid request!\n";
    } else {
        std::cout << "Invalid request!\n";
    }
    return 0;
}

输出

API request processed by Postman: GET https://:3000/api/users
Invalid request format!
Invalid request!

说明

状态枚举

State 枚举定义了 FSM 的不同状态，代表 API 请求的各个部分，例如方法、URL、参数和错误状态。

验证函数 (validateRequest)

validateRequest 函数实现了 FSM 逻辑。它迭代请求字符串的字符，并根据请求的结构在状态之间进行转换。

每个状态都有转换到下一个状态的特定条件。例如，当遇到 HTTP 方法（"GET" 或 "POST"）时，FSM 从起始状态 (State::START) 转换到方法状态 (State::METHOD)。

FSM 继续转换，直到到达结束状态 (State::END)，在此过程中验证请求的每个部分。如果 FSM 遇到无效状态或由于意外条件无法进一步转换，它将进入错误状态 (State::ERROR) 并打印 错误消息。

主函数 (main)

main 函数提供了一个 Postman 处理的示例 API 请求。它调用 validateRequest 函数来验证请求。如果请求有效，则会在控制台上打印从请求中提取的 HTTP 方法。如果请求无效，则会打印指示无效请求格式的错误消息。

复杂度分析

时间复杂度

状态转换

FSM 的时间复杂度在很大程度上取决于验证输入请求字符串所需的转换次数。在最坏的情况下，FSM 可能需要遍历请求字符串的每个字符一次以确定适当的状态转换。

因此，FSM 验证过程的时间复杂度与输入请求字符串的长度成正比，为 O(n)，其中 n 是输入字符串的长度。

Switch 语句

在 validateRequest 函数内部，有一个 switch 语句用于处理状态转换。每个 case 语句都以恒定时间执行。由于状态的数量是固定的且与输入大小无关，因此 switch 语句的时间复杂度是恒定的，O(1)。

结合以上因素，FSM 验证方法的总体时间复杂度保持为 O(n)，其中 n 是输入请求字符串的长度。

空间复杂度

状态枚举

State 枚举引入了恒定的内存开销，因为它只定义了 FSM 的状态。

枚举的空间复杂度为 O(1)。

变量

validateRequest 函数内的 currentState 变量存储 FSM 的当前状态。index 变量跟踪字符串的当前位置。这两个变量都消耗恒定的空间，与输入大小无关。

因此，这些变量的空间复杂度也为 O(1)。

考虑到枚举和函数中使用的变量，以及任何恒定大小的数据结构，FSM 方法的最终空间复杂度仍然为 O(1)。

下一个主题Pen-distribution-problem-in-cpp

← 上一个下一个 →

C++ 中使用正则表达式验证 localhost API 请求是否由 POSTMAN 处理

方法 1：正则表达式（Regex）方法

程序

说明

复杂度分析

方法 2：分词方法

程序

说明

复杂度分析

方法 3：有限状态机 (FSM) 方法

程序

说明

复杂度分析

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

C++ 教程

C++ 控制语句

C++ 函数

C++ 数组

C++ 类和对象

C++ 构造函数

C++ 继承

C++ 多态

C++ 抽象

C++ 命名空间

C++ 模板

C++ 字符串

C++ 指针

信号处理

C++ 异常

C++ 文件与流

C++ STL 教程

面试题

选择题

C++ 程序

C++ STL Stack

C++ STL Bitset

C++ STL Deque

C++ STL List

C++ STL Map

C++ STL Math

C++ STL priority_queue

C++ STL Queue

C++ STL Multiset

C++ STL Multimap

C++ STL Set

C++ STD Strings

C++ STL Vector

C++ 操纵符

C++ STL Algorithms

C++ Algorithm

C++ Iterators

C++ 杂项

C++ 中使用正则表达式验证 localhost API 请求是否由 POSTMAN 处理

方法 1：正则表达式（Regex）方法

程序

说明

复杂度分析

方法 2：分词方法

程序

说明

复杂度分析

方法 3：有限状态机 (FSM) 方法

程序

说明

复杂度分析

相关帖子

C++ std::counting_semaphore, std::binary_semaphore

C++ 中的模逆元

在 C++ 中初始化集合的方法

C++ 中打印 V 形和倒 V 形图案的程序

C++ Ford Fulkerson 算法

C++ 中的鸽笼排序算法

C++ 中的翻转字符串数字

C++ 中的洛布数