老版本Postman请求脚本编写指南：从Async/Await到回调函数的完整迁移方案

推荐使用兼容版本的方案

前言

在使用Postman进行API测试时，我们经常需要在预请求脚本或测试脚本中发送HTTP请求。随着Postman版本的更新，其JavaScript API也发生了变化。许多用户在从新版本切换到老版本时，会遇到脚本不兼容的问题。本文将详细介绍如何将新版本Postman的脚本适配到老版本中。

问题背景

在新版本Postman（v7.x及以上）中，我们习惯使用async/await语法和pm.sendRequest()方法：

// 新版本Postman的写法
try {
    const response = await pm.sendRequest({
        url: "http://localhost:8088/auth",
        method: "POST",
        header: {"Content-Type": "application/json"},
        body: "{\"username\":\"admin\",\"password\":\"cOnhFnNTV434EhQPtzgOsg==\",\"verifyCode\":\"111\"}"
    });
    var respObj = response.json();
    pm.environment.set("token", respObj.token);
    console.log(response.json());
} catch (err) {
    console.error(err);
}

但在老版本Postman（v6.x及更早）中，上述代码可能会遇到以下问题：

1. 不支持async/await语法
2. pm.sendRequest()的API不同
3. 环境变量设置方式不同

解决方案

方案一：使用回调函数（推荐）

这是最兼容老版本的写法，适用于Postman v5.0及更高版本：

pm.sendRequest({
    url: "http://localhost:8088/auth",
    method: "POST",
    header: {
        "Content-Type": "application/json"
    },
    body: {
        mode: 'raw',
        raw: JSON.stringify({
            username: "admin",
            password: "cOnhFnNTV434EhQPtzgOsg==",
            verifyCode: "111"
        })
    }
}, function (err, response) {
    if (err) {
        console.error("请求失败:", err);
        return;
    }
    
    // 检查响应状态
    if (response.code === 200) {
        try {
            var respObj = response.json();
            
            // 保存到环境变量
            if (pm.environment && pm.environment.set) {
                pm.environment.set("token", respObj.token);
            } else if (postman && postman.setEnvironmentVariable) {
                // 更老版本的写法
                postman.setEnvironmentVariable("token", respObj.token);
            }
            
            console.log("Token获取成功:", respObj.token);
        } catch (parseError) {
            console.error("响应解析失败:", parseError);
            console.log("原始响应:", response.text());
        }
    } else {
        console.error("请求返回错误状态码:", response.code);
        console.error("错误信息:", response.text());
    }
});

方案二：同步请求方式

对于某些老版本，可以使用同步方式发送请求：

// 发送请求
var response = pm.sendRequest({
    url: "http://localhost:8088/auth",
    method: "POST",
    header: {"Content-Type": "application/json"},
    body: {
        mode: 'raw',
        raw: "{\"username\":\"admin\",\"password\":\"cOnhFnNTV434EhQPtzgOsg==\",\"verifyCode\":\"111\"}"
    }
});

// 处理响应
if (response && response.code === 200) {
    try {
        // 尝试解析JSON
        var respObj;
        if (typeof response.json === 'function') {
            respObj = response.json();
        } else {
            respObj = JSON.parse(response.body);
        }
        
        // 设置环境变量
        if (typeof pm !== 'undefined' && pm.environment && pm.environment.set) {
            pm.environment.set("token", respObj.token);
        } else if (typeof postman !== 'undefined' && postman.setEnvironmentVariable) {
            postman.setEnvironmentVariable("token", respObj.token);
        } else {
            console.error("无法设置环境变量：未找到合适的方法");
        }
        
        console.log("Token已保存");
    } catch (e) {
        console.error("JSON解析失败:", e);
        console.log("响应内容:", response.body);
    }
} else {
    console.error("请求失败，状态码:", response ? response.code : "未知");
}

方案三：通用兼容脚本

如果你不确定用户使用的Postman版本，可以使用以下通用兼容脚本：

(function() {
    // 配置请求参数
    var requestConfig = {
        url: "http://localhost:8088/auth",
        method: "POST",
        headers: {
            "Content-Type": "application/json"
        },
        body: {
            mode: 'raw',
            raw: JSON.stringify({
                username: "admin",
                password: "cOnhFnNTV434EhQPtzgOsg==",
                verifyCode: "111"
            })
        }
    };
    
    // 检测Postman版本并选择相应的方法
    var sendRequestFunction;
    if (typeof pm !== 'undefined' && pm.sendRequest) {
        // 新版本Postman
        if (pm.sendRequest.length === 1) {
            // 支持Promise的版本
            try {
                pm.sendRequest(requestConfig)
                    .then(function(response) {
                        handleResponse(response);
                    })
                    .catch(function(err) {
                        console.error("请求错误:", err);
                    });
                return;
            } catch (e) {
                // 如果不支持Promise，回退到回调函数
                sendRequestFunction = function(config, callback) {
                    pm.sendRequest(config, callback);
                };
            }
        } else {
            // 使用回调函数的版本
            sendRequestFunction = function(config, callback) {
                pm.sendRequest(config, callback);
            };
        }
    } else if (typeof postman !== 'undefined' && postman.sendRequest) {
        // 更老的Postman版本
        sendRequestFunction = postman.sendRequest;
    } else {
        console.error("当前环境不支持发送请求");
        return;
    }
    
    // 使用回调函数发送请求
    sendRequestFunction(requestConfig, function(err, response) {
        if (err) {
            console.error("请求失败:", err);
            return;
        }
        handleResponse(response);
    });
    
    // 处理响应的通用函数
    function handleResponse(response) {
        try {
            var respObj;
            if (typeof response.json === 'function') {
                respObj = response.json();
            } else {
                respObj = JSON.parse(response.body || response.text());
            }
            
            // 保存token到环境变量
            if (pm && pm.environment && pm.environment.set) {
                pm.environment.set("token", respObj.token);
            } else if (postman && postman.setEnvironmentVariable) {
                postman.setEnvironmentVariable("token", respObj.token);
            } else {
                // 如果都无法使用，尝试直接设置
                try {
                    pm.variables.set("token", respObj.token);
                } catch (e) {
                    console.error("无法设置环境变量，请手动处理token:", respObj.token);
                }
            }
            
            console.log("认证成功，token已保存");
        } catch (parseError) {
            console.error("处理响应时出错:", parseError);
            console.log("原始响应:", response.body || response.text());
        }
    }
})();

关键差异点总结

特性	新版本Postman (v7.x+)	老版本Postman (v6.x及更早)
异步处理	支持async/await	仅支持回调函数
sendRequest参数	接受配置对象，返回Promise	接受配置对象和回调函数
环境变量设置	pm.environment.set()	postman.setEnvironmentVariable()
请求体格式	可以直接传字符串	需要指定mode和raw格式
响应解析	response.json()直接可用	可能需要JSON.parse(response.body)

调试技巧

1. 查看Postman版本：

   console.log("Postman版本信息:", pm.info);

2. 检测可用API：

   console.log("pm.sendRequest类型:", typeof pm.sendRequest);
   console.log("pm.sendRequest参数个数:", pm.sendRequest.length);

3. 错误处理：

   try {
       // 你的代码
   } catch (e) {
       console.error("错误类型:", e.name);
       console.error("错误信息:", e.message);
       console.error("堆栈:", e.stack);
   }

最佳实践建议

1. 始终使用回调函数：为了保证最大的兼容性，建议在老版本Postman中始终使用回调函数模式。

2. 添加版本检测：在团队协作或共享脚本时，添加版本检测逻辑可以避免兼容性问题。

3. 完整的错误处理：老版本Postman的错误信息可能不够明确，添加详细的错误处理可以帮助快速定位问题。

4. 注释说明：对于需要兼容老版本的脚本，添加详细的注释说明兼容性要求。

5. 考虑升级：如果可能，建议升级到新版本Postman，以获得更好的开发体验和更多功能。

总结

Postman的版本差异确实会给开发者带来一些困扰，但通过理解不同版本间的API差异，我们可以编写出兼容性更好的脚本。希望本文能帮助你顺利解决在老版本Postman中编写请求脚本的问题。如果你遇到其他兼容性问题，欢迎在评论区交流讨论。