1. 项目概述：为什么我们需要关注接口的前后置处理？

如果你用过Postman，大概率已经熟悉了发送请求、查看响应的基本操作。但当你开始面对复杂的业务场景，比如需要动态生成一个登录Token、从上一个接口的响应里提取数据塞给下一个接口、或者批量测试前需要先清理测试数据时，光会点“Send”按钮就显得捉襟见肘了。这时候，Postman的“前置脚本”和“测试脚本”功能，就成了区分普通用户和效率玩家的分水岭。

简单来说，前置脚本就是在请求发送之前自动执行的一段JavaScript代码，而后置处理（通常指“Tests”标签页里的脚本）则是在收到响应之后执行。它们就像给接口测试装上了“自动驾驶”和“智能分析”系统。前置脚本能帮你准备请求数据、设置环境变量、甚至进行复杂的加密签名；后置脚本则能验证响应结果、提取关键数据、并驱动后续的测试流程。

我见过不少团队，接口测试还停留在手动复制粘贴Token、肉眼比对JSON数据的阶段，不仅效率低下，还容易出错。掌握前后置处理，意味着你能将一系列重复、繁琐的操作自动化，构建出真正可靠、可复用的接口测试流程或自动化测试集。无论是单接口的深度测试，还是多接口串联的业务场景模拟，这套组合拳都能让你游刃有余。

2. 核心能力拆解：前置与后置脚本究竟能做什么？

2.1 前置脚本的核心应用场景

前置脚本的执行时机非常关键——在请求被发送到服务器之前。这意味着你可以动态地修改即将发出的请求。以下是几个最典型的应用场景：

动态参数构造：这是最常用的功能。比如，你的接口要求一个按特定规则生成的时间戳，或者一个对请求体进行MD5加密后的签名。你不可能每次手动计算。在前置脚本里，你可以用pm.request.url.addQueryParam()动态添加查询参数，或者用pm.request.body.raw修改请求体内容。

// 示例：为请求添加一个动态时间戳和签名 const moment = require('moment'); const CryptoJS = require('crypto-js'); // 生成当前时间戳 const timestamp = moment().valueOf(); // 假设签名规则是：对 `timestamp+secret` 的字符串进行MD5 const secret = pm.environment.get('api_secret'); const sign = CryptoJS.MD5(timestamp + secret).toString(); // 将时间戳和签名添加到URL查询参数中 pm.request.url.addQueryParams([ { key: 'timestamp', value: timestamp.toString() }, { key: 'sign', value: sign } ]);

环境与变量管理：你可以从环境变量、全局变量或集合变量中读取值，并赋值给请求的Header、Body或URL。更强大的是，你可以根据条件逻辑选择不同的环境配置。

// 根据环境变量决定请求的Host const env = pm.environment.get('env'); let baseUrl; if (env === 'production') { baseUrl = 'https://api.prod.com'; } else { baseUrl = 'https://api.test.com'; } // 替换请求URL中的变量 const originalUrl = pm.request.url.toString(); pm.request.url = originalUrl.replace('{{base_url}}', baseUrl);

流程控制与逻辑判断：前置脚本可以包含if/else、for循环等逻辑。例如，你可以判断如果某个环境变量不存在，则自动跳过该请求，或者根据前一个请求的结果（存储在变量中）来决定本次请求的参数。

注意：前置脚本中无法直接获取其他请求的响应（因为还没发生），但可以通过读取之前请求存储在变量中的结果来间接实现流程控制。

2.2 后置脚本的核心应用场景

后置脚本在收到响应后执行，其能力核心围绕“验证”和“提取”。

自动化断言（测试验证）：这是Postman测试的灵魂。你可以用类似pm.test()和pm.expect()的语法，对响应状态码、响应头、响应体甚至响应时间进行全方位的验证。这远比肉眼比对要精确和高效。

// 验证状态码为200 pm.test('Status code is 200', function () { pm.response.to.have.status(200); }); // 验证JSON响应体中包含特定字段和值 pm.test('Response has user id and name', function () { const jsonData = pm.response.json(); pm.expect(jsonData).to.have.property('userId'); pm.expect(jsonData.userId).to.be.a('number'); pm.expect(jsonData).to.have.property('username'); pm.expect(jsonData.username).to.include('test'); }); // 验证响应时间在合理范围内 pm.test('Response time is less than 500ms', function () { pm.expect(pm.response.responseTime).to.be.below(500); });

数据提取与持久化：这是实现接口串联的关键。你可以从复杂的JSON或XML响应中，精准地提取出需要的值（如token、订单ID、用户信息），并保存到Postman的变量系统中，供后续请求使用。

// 从JSON响应中提取access_token并设置为环境变量 const jsonData = pm.response.json(); if (jsonData && jsonData.data && jsonData.data.access_token) { // 将提取到的token设置为环境变量，作用域为当前环境 pm.environment.set('access_token', jsonData.data.access_token); console.log('Access token has been set: ', pm.environment.get('access_token')); } // 从Header中提取数据 const contentType = pm.response.headers.get('Content-Type'); pm.environment.set('last_content_type', contentType);

复杂业务逻辑校验：除了简单的字段存在性检查，你还可以编写逻辑更复杂的校验。例如，检查一个订单列表返回的数据是否按创建时间倒序排列，或者计算响应数组中某项数据的总和是否符合预期。

// 校验返回的数组是否按id升序排列 pm.test('Items are sorted by ID ascending', function () { const items = pm.response.json().data.items; for (let i = 1; i < items.length; i++) { pm.expect(items[i].id).to.be.greaterThan(items[i-1].id); } });

2.3 前后置脚本的联动：构建自动化工作流

单独使用前置或后置脚本已经很强大了，但它们的真正威力在于联动。一个经典的“登录-查询-登出”业务流程可以这样自动化：

1. 登录请求：
   • 前置脚本：可能不需要特殊处理。
   • 后置脚本：提取响应中的session_id或token，保存为环境变量auth_token。
2. 查询用户信息请求：
   • 前置脚本：读取环境变量auth_token，将其添加到请求的Authorization头中。
   • 后置脚本：验证返回的用户信息是否正确，并可能提取用户ID保存为变量。
3. 登出请求：
   • 前置脚本：同样读取auth_token添加到请求头。
   • 后置脚本：验证登出成功，并可选地清除环境变量auth_token。

这个流程可以在Postman的“Collection Runner”或通过Newman命令行工具一键完整运行，无需任何人工干预。

3. 深度实操：从基础到高级的脚本编写指南

3.1 脚本编写环境与基础语法

Postman的脚本基于Node.js的JavaScript运行时，并内置了许多强大的库和pmAPI对象。你不需要搭建任何外部环境，直接在“Pre-request Script”或“Tests”标签页里写就行。

pm对象详解：这是与Postman交互的核心对象。

• pm.environment/pm.globals/pm.collectionVariables: 分别用于管理环境、全局和集合级别的变量。常用方法有get()、set()、unset()。
• pm.request: 在前置脚本中，用于获取和修改即将发送的请求对象。你可以修改其URL、头信息、请求体。

  // 修改请求头 pm.request.headers.add({ key: 'X-Custom-Header', value: 'MyValue' }); // 修改请求体（假设是JSON） const reqBody = JSON.parse(pm.request.body.raw); reqBody.newField = 'dynamic'; pm.request.body.raw = JSON.stringify(reqBody);

• pm.response: 在后置脚本中，用于访问服务器返回的响应对象。包含状态码、头信息、响应体、响应时间等。
• pm.test()/pm.expect(): Postman内置的BDD风格断言库，语法直观，用于编写测试用例。
• pm.sendRequest(): 一个非常强大的方法，允许你在脚本中异步发送新的请求。这可以用来在测试一个主接口前，先调用一个准备接口（如获取Token）。

内置库：Postman预置了lodash、cheerio（用于解析HTML）、CryptoJS（用于加密）、moment（用于日期处理）、tv4（用于JSON Schema验证）等常用库，无需require即可直接使用（部分老版本可能需要）。

// 使用CryptoJS进行HMAC-SHA256签名 const CryptoJS = require('crypto-js'); const message = pm.request.body.raw + pm.environment.get('secret_key'); const signature = CryptoJS.HmacSHA256(message, pm.environment.get('secret_key')).toString(CryptoJS.enc.Hex); pm.request.headers.add({ key: 'X-Signature', value: signature });

3.2 动态变量与数据驱动测试

Postman支持在请求的URL、Header、Body中使用双花括号{{variable_name}}来引用变量。脚本可以和这个特性完美结合。

在脚本中设置变量：

// 设置一个随机数作为订单号 const randomOrderId = 'ORD' + Math.floor(Math.random() * 1000000); pm.environment.set('dynamic_order_id', randomOrderId);

然后在请求体中可以这样引用：{ “orderId”: “{{dynamic_order_id}}” }。当请求发送时，Postman会自动替换。

数据驱动测试：这是高级用法。你可以准备一个JSON或CSV文件，里面包含多组测试数据（如不同的用户名/密码）。在运行集合时，通过Collection Runner导入这个数据文件。在脚本中，你可以通过pm.iterationData来获取当前迭代的数据。

1. 准备数据文件test_data.json:

   [ {“username”: “user1”, “password”: “pass1”, “expected_status”: 200}, {“username”: “user2”, “password”: “”, “expected_status”: 400} ]

2. 在请求的Body中引用变量：{ “username”: “{{username}}”, “password”: “{{password}}” }
3. 在后置脚本中断言：

   const expectedStatus = pm.iterationData.get('expected_status'); pm.test(`Status should be ${expectedStatus}`, () => { pm.response.to.have.status(expectedStatus); });

4. 在Collection Runner中选择该数据文件并运行，Postman会自动用每一行数据运行一次请求，并执行相应的断言。

3.3 使用pm.sendRequest实现链式调用

这是实现复杂前置准备的关键。比如，你的主接口需要OAuth 2.0的Client Credentials Token，你可以先在前置脚本中自动获取它。

// 在主请求的Pre-request Script中 const getTokenRequest = { url: pm.environment.get('auth_url'), method: 'POST', header: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: { mode: 'urlencoded', urlencoded: [ {key: 'grant_type', value: 'client_credentials'}, {key: 'client_id', value: pm.environment.get('client_id')}, {key: 'client_secret', value: pm.environment.get('client_secret')} ] } }; // 发送获取token的请求，这是一个异步操作 pm.sendRequest(getTokenRequest, function (err, response) { if (err) { console.error('Failed to get token:', err); // 可以选择让主请求失败 // throw new Error('Token acquisition failed'); } else { const token = response.json().access_token; // 将获取到的token设置到环境变量，并添加到主请求的Header中 pm.environment.set('access_token', token); pm.request.headers.add({ key: 'Authorization', value: `Bearer ${token}` }); console.log('Token set successfully.'); } });

重要提示：pm.sendRequest是异步的。Postman会等待这个回调函数执行完毕（即token被设置并添加到header）后，才发送主请求。这保证了依赖关系的正确性。

4. 实战案例：构建一个完整的API测试流程

让我们模拟一个电商场景：用户登录 -> 浏览商品 -> 加入购物车 -> 创建订单。我们将为一个包含这4个请求的集合编写前后置脚本。

4.1 案例设计与变量规划

首先，我们需要规划在整个流程中需要传递哪些数据：

1. auth_token: 用户登录后获得的认证令牌，后续所有请求都需要。
2. user_id: 用户ID，可能在创建订单时用到。
3. product_id: 浏览商品后选定的商品ID。
4. cart_id: 加入购物车后返回的购物车标识。
5. order_id: 最终创建的订单号，可用于后续查询。

我们将这些变量大部分存储在环境变量中，因为环境可以切换（测试/生产），且作用域合适。

4.2 分步脚本实现

请求1：用户登录 (POST /api/login)

• 前置脚本：无特殊需求。
• 后置脚本：

  // 1. 基础断言 pm.test('Login successful', function () { pm.response.to.have.status(200); pm.expect(pm.response.json()).to.have.property('success', true); }); // 2. 提取关键数据 const responseJson = pm.response.json(); const token = responseJson.data.token; const userId = responseJson.data.user.id; // 3. 存储到环境变量 pm.environment.set('auth_token', token); pm.environment.set('current_user_id', userId); console.log('Token and User ID saved for session.');

请求2：浏览商品 (GET /api/products?category=electronics)

• 前置脚本：添加认证头。

  // 从环境变量获取token并添加到请求头 const token = pm.environment.get('auth_token'); if (token) { pm.request.headers.add({ key: 'Authorization', value: `Bearer ${token}` }); } else { console.warn('No auth token found. Request may fail.'); }

• 后置脚本：

  pm.test('Product list retrieved', function () { pm.response.to.have.status(200); pm.expect(pm.response.json().data).to.be.an('array').that.is.not.empty; }); // 假设我们选取列表中的第一个商品 const firstProduct = pm.response.json().data[0]; if (firstProduct && firstProduct.id) { pm.environment.set('selected_product_id', firstProduct.id); pm.environment.set('selected_product_price', firstProduct.price); console.log(`Selected product: ${firstProduct.name} (ID: ${firstProduct.id})`); }

请求3：加入购物车 (POST /api/cart/items)

• 前置脚本：

  // 1. 添加认证头 const token = pm.environment.get('auth_token'); pm.request.headers.add({ key: 'Authorization', value: `Bearer ${token}` }); // 2. 动态构建请求体，使用之前保存的商品ID和价格 const productId = pm.environment.get('selected_product_id'); const price = pm.environment.get('selected_product_price'); const requestBody = { productId: productId, quantity: 1, unitPrice: price }; // 注意：需要将请求体模式设置为raw，并选择JSON格式。这里脚本修改的是原始字符串。 pm.request.body.raw = JSON.stringify(requestBody);

• 后置脚本：

  pm.test('Item added to cart', function () { pm.response.to.have.status(201); // 通常创建成功返回201 }); const cartInfo = pm.response.json().data; pm.environment.set('cart_id', cartInfo.cartId); pm.environment.set('cart_total', cartInfo.totalAmount); console.log(`Added to cart. Cart ID: ${cartInfo.cartId}`);

请求4：创建订单 (POST /api/orders)

• 前置脚本：

  // 添加认证头 const token = pm.environment.get('auth_token'); pm.request.headers.add({ key: 'Authorization', value: `Bearer ${token}` }); // 构建订单请求体，引用购物车和用户信息 const orderBody = { cartId: pm.environment.get('cart_id'), userId: pm.environment.get('current_user_id'), shippingAddress: '123 Test Street', // 可以从变量或固定值获取 paymentMethod: 'credit_card' }; pm.request.body.raw = JSON.stringify(orderBody);

• 后置脚本：

  pm.test('Order created successfully', function () { pm.response.to.have.status(201); const jsonData = pm.response.json(); pm.expect(jsonData.data).to.have.property('orderId'); pm.expect(jsonData.data.status).to.eql('pending_payment'); }); // 提取订单号，这是整个流程的重要产出 const orderId = pm.response.json().data.orderId; pm.environment.set('created_order_id', orderId); console.log(`✅ Order created! Order ID: ${orderId}`); // 可选：清理本次流程产生的临时环境变量，避免影响下次测试 // pm.environment.unset('selected_product_id'); // pm.environment.unset('cart_id');

4.3 流程执行与验证

将这四个请求按顺序放入一个Postman集合中。你可以：

1. 在Postman界面手动顺序运行：依次点击发送，观察控制台输出和环境变量的变化。
2. 使用Collection Runner：这是更标准的做法。打开Collection Runner，选择该集合，点击“Run”。Postman会严格按照顺序执行所有请求，并自动运行每个请求的前后置脚本。你可以在运行结果中看到所有测试的通过/失败状态。
3. 导出为Newman命令行运行：这对于集成到CI/CD流水线中至关重要。在Runner中点击“Export”即可获得一个JSON文件，通过Newman命令newman run your_collection.json -e your_environment.json即可运行。

通过这个案例，你可以看到前后置脚本如何将独立的接口粘合成一个完整的、自动化的业务流测试。每个请求都依赖于前一个请求的“产出”，整个过程无需人工介入任何数据传递。

5. 高级技巧与避坑指南

5.1 脚本调试与日志输出

编写复杂脚本时，调试是必不可少的。Postman提供了多种方式：

• console.log(): 这是最常用的。输出信息会显示在Postman的“Console”（视图 -> 显示Postman控制台，或Ctrl+Alt+C）。你可以打印变量值、对象、函数执行到哪一步。
• console.error()/console.warn(): 用于输出错误和警告信息，在控制台中会以不同颜色高亮显示。
• 使用“Send”按钮旁的“Preview”：在编写请求体时，如果使用了变量{{var}}，点击“Preview”可以查看变量被替换后的实际请求内容，这对于调试前置脚本修改请求的结果非常有用。
• 设置断点？Postman脚本不支持传统断点调试。通常的调试方法是：多写console.log语句，将复杂逻辑分步打印出来；或者将大段脚本拆分成小函数，分别测试。

5.2 常见问题与解决方案

问题1：脚本中设置的变量，在下一个请求中获取不到？

• 检查变量作用域：pm.environment.set()设置的是环境变量，确保你当前激活的环境是正确的。pm.globals.set()设置的是全局变量。在请求中引用时，要使用对应的{{}}语法。
• 检查执行顺序：确保设置变量的脚本（通常是后置脚本）在引用它的请求之前执行。在集合运行器中，请求是按顺序执行的。
• 异步问题：如果在pm.sendRequest的回调函数中设置变量，要确保主请求确实等待了这个回调完成。Postman会自动处理这种异步，但如果你在同一个前置脚本里有其他不依赖回调的代码，它们可能先执行。

问题2：pm.response.json()解析出错，提示“Unexpected token...”

• 原因：响应体可能不是有效的JSON格式（可能是HTML错误页面、纯文本或空的）。
• 解决：在解析前先检查状态码和内容类型。

  pm.test('Response is valid JSON', function () { pm.response.to.have.status(200); pm.response.to.have.header('Content-Type', 'application/json'); }); // 或者用try-catch包裹 try { const jsonData = pm.response.json(); // 处理jsonData } catch (e) { console.error('Failed to parse response as JSON:', pm.response.text()); }

问题3：使用pm.sendRequest时，主请求似乎没有等到回调完成就发送了？

• 现象：主请求的Header里没有包含在回调中设置的Token。
• 原理与解决：实际上，Postman的脚本执行环境会等待pm.sendRequest的回调函数执行完毕，才发送主请求。这个问题更多是由于脚本逻辑错误造成的。例如，你在回调函数外部又写了一行代码去读取auth_token变量并添加到Header，这时回调可能还没执行，变量是空的。正确的做法是所有依赖于异步结果的逻辑，都必须写在回调函数内部（如上面pm.sendRequest的示例所示）。

问题4：如何共享通用的脚本函数？

• 场景：多个请求都需要用到同一个复杂的签名算法函数。
• 解决：
  1. 集合级别的脚本：在集合的“Pre-request Scripts”和“Tests”标签页中编写的脚本，会对集合下的所有请求生效。这是放置通用函数（如generateSignature()）的最佳位置。集合脚本会先于单个请求的脚本执行。
  2. 全局/环境变量存储函数字符串：虽然不优雅，但可以将函数定义以字符串形式存在变量中，然后在请求脚本中用eval()执行（需谨慎）。
  3. 使用外部JS文件（通过Newman）：在本地编写一个JavaScript模块，通过Newman运行集合时，使用--require参数引入该模块，然后在脚本中通过require()调用。这是在CI/CD中管理复杂脚本的推荐方式。

5.3 性能与最佳实践

• 避免无限循环和繁重计算：脚本在发送请求前/后执行，复杂的计算会延迟请求的发送和测试结果的返回。对于加密等操作，确保其效率。
• 及时清理变量：对于一个独立的测试流程，在流程结束时（如最后一个请求的后置脚本中），可以考虑清理掉那些为本次流程创建的临时环境变量（使用pm.environment.unset('var_name')），避免它们残留并影响下一次不相关的测试。
• 编写健壮的断言：断言不要过于脆弱。例如，不要断言一个动态生成的ID完全等于某个固定值，而是断言它存在并且符合某种格式（如字符串、数字）。使用.a('type')、.that.match(/pattern/)等更灵活的匹配器。
• 充分利用预请求脚本进行健壮性检查：在前置脚本中，可以检查必要的变量是否存在，如果不存在则主动抛出错误，让测试快速失败，而不是发送一个注定失败的请求。

  // 前置脚本中检查必要变量 const requiredToken = pm.environment.get('auth_token'); if (!requiredToken) { throw new Error('Authentication token is missing. Please run the login request first.'); }

掌握Postman的前后置处理，本质上是在掌握一种将手动、离散的接口测试活动，转化为自动化、智能化工作流的能力。它让测试从“验证接口是否通”的初级阶段，迈入了“验证业务逻辑是否正确”、“保障系统交互质量”的深水区。花时间学习和实践这些技巧，对于提升后端开发、测试工程师甚至前端开发者的工作效率和交付质量，都有着极高的投资回报率。