云压测常用函数

本文档介绍在云压测脚本模式中常用的 JavaScript 原生函数和 PTS 扩展库函数的使用方法。这些函数可用于数据处理、时间计算、随机数生成、字符串匹配等场景，帮助您构建更强大的压测脚本。
JS 公共库
云压测脚本模式支持 JavaScript 原生语法，详情请参见 JavaScript 标准内置对象。以下为常用函数的说明和示例。
Date 对象
函数说明
Date 对象用于处理日期和时间，在压测脚本中常用于：
生成时间戳用于请求参数。
计算请求耗时。
格式化时间字符串用于日志记录。
实现时间相关的业务逻辑。
前提条件
所有代码需放在 export default function() 函数中执行
日期字符串格式需符合 ISO 8601 标准或 JavaScript 支持的格式
函数签名
new Date(value?: string | number): Date
常用方法
Date.now()：返回当前时间戳（毫秒数）。
getTime()：返回时间戳（毫秒数）。
toISOString()：返回 ISO 8601 格式的字符串。
getFullYear()、getMonth()、getDate() 等：获取日期各部分。
使用限制
时区默认为 UTC+8（中国标准时间）。
日期字符串解析可能因格式不同而产生差异。
示例1：创建日期对象并格式化
本示例演示如何创建日期对象并获取不同格式的时间信息，适用于需要在请求中使用时间参数的场景。
import http from 'pts/http';
﻿
export default function () {
    // 创建日期对象
    const date1 = new Date('1995-12-17T03:24:00');
    console.log(date1); // Sun Dec 17 1995 11:24:00 GMT+0800 (CST)
    
    // 获取当前时间
    const now = new Date();
    console.log(now.toISOString()); // 2024-01-01T12:00:00.000Z
    
    // 获取时间戳（毫秒）
    const timestamp = Date.now();
    console.log(timestamp); // 1704096000000
    
    // 在 HTTP 请求中使用时间戳作为参数
    const resp = http.get('http://example.com/api', {
        query: {
            'timestamp': timestamp.toString()
        }
    });
}
示例2：计算请求耗时
本示例演示如何使用 Date 对象计算请求耗时，用于性能监控和调试。
import http from 'pts/http';
﻿
export default function () {
    // 记录开始时间
    const startTime = Date.now();
    
    // 发起请求
    const resp = http.get('http://example.com/api');
    
    // 计算耗时
    const endTime = Date.now();
    const duration = endTime - startTime;
    
    console.log(`请求耗时: ${duration} 毫秒`);
    
    // 检查响应状态
    if (resp.statusCode === 200) {
        console.log('请求成功');
    }
}
JSON 对象
函数说明
JSON 对象提供 parse() 和 stringify() 方法，在压测脚本中用于：
解析 HTTP 响应体中的 JSON 数据。
将 JavaScript 对象序列化为 JSON 字符串用于请求体。
处理嵌套的 JSON 数据结构。
数据格式转换。
前提条件
JSON.parse() 要求输入字符串必须是有效的 JSON 格式，否则会抛出异常。
JSON.stringify() 可以处理对象、数组、字符串、数字、布尔值、null 等类型。
函数、undefined、Symbol 等类型在序列化时会被忽略或转换为 null。
函数签名
JSON.parse(text: string, reviver?: function): any
JSON.stringify(value: any, replacer?: function | array, space?: number | string): string
参数说明
JSON.parse()
text (string，必填)：要解析的 JSON 字符串。
reviver (function，可选)：转换函数，用于在返回之前转换解析结果。
JSON.stringify()
value (any，必填)：要序列化的值。
replacer (function | array，可选)：用于控制序列化过程的函数或数组。
space (number | string，可选)：用于缩进的空格数或字符串。
返回值说明
JSON.parse()：返回解析后的 JavaScript 对象或值。
JSON.stringify()：返回 JSON 字符串。
使用限制
JSON.parse() 遇到无效 JSON 会抛出 SyntaxError 异常，建议使用 try-catch 处理。
循环引用的对象无法使用 JSON.stringify() 序列化。
undefined、函数、Symbol 等类型在序列化时会被忽略。
示例1：解析响应 JSON 数据
本示例演示如何解析 HTTP 响应中的 JSON 数据并提取字段，适用于处理 API 响应的场景。
import http from 'pts/http';
import { check } from 'pts';
﻿
export default function () {
    // 发起请求获取 JSON 响应
    const resp = http.get('http://example.com/api/user');
    
    // 解析 JSON 响应体
    const jsonData = JSON.parse(resp.body);
    console.log(jsonData.name); // 输出用户名称
    
    // 检查响应数据
    check('用户 ID 存在', () => jsonData.id !== undefined);
    check('用户名称不为空', () => jsonData.name && jsonData.name.length > 0);
}
示例2：构建 JSON 请求体
本示例演示如何将 JavaScript 对象序列化为 JSON 字符串用于 POST 请求，适用于需要发送复杂数据结构的场景。
import http from 'pts/http';
﻿
export default function () {
    // 构建请求数据对象
    const requestData = {
        name: "pts",
        language: "javascript",
        version: "1.0",
        features: ["http", "websocket", "grpc"]
    };
    
    // 序列化为 JSON 字符串
    const jsonStr = JSON.stringify(requestData);
    console.log(jsonStr); // {"name":"pts","language":"javascript","version":"1.0","features":["http","websocket","grpc"]}
    
    // 发送 POST 请求
    const resp = http.post('http://example.com/api/data', {
        headers: {
            'Content-Type': 'application/json'
        },
        body: jsonStr
    });
    
    console.log(resp.statusCode);
}
示例3：处理嵌套 JSON 和错误处理
本示例演示如何处理嵌套的 JSON 结构，并使用 try-catch 处理解析错误。
import http from 'pts/http';
﻿
export default function () {
    const resp = http.get('http://example.com/api/complex');
    
    try {
        // 解析可能包含嵌套结构的 JSON
        const data = JSON.parse(resp.body);
        
        // 访问嵌套字段
        if (data.user && data.user.profile) {
            console.log(data.user.profile.email);
        }
        
        // 处理数组
        if (Array.isArray(data.items)) {
            data.items.forEach(item => {
                console.log(item.name);
            });
        }
    } catch (error) {
        console.error('JSON 解析失败:', error.message);
        console.log('原始响应:', resp.body);
    }
}
Math 对象
函数说明
Math 对象提供数学运算方法，在压测脚本中常用于：
生成随机数用于参数化测试。
数值计算和转换。
实现随机延迟、随机选择等逻辑。
数学运算和比较。
前提条件
所有方法都是静态方法，通过 Math.方法名() 调用。
随机数生成基于伪随机算法。
常用方法
Math.random()：返回 0 到 1 之间的随机浮点数。
Math.floor(x)：向下取整。
Math.ceil(x)：向上取整。
Math.round(x)：四舍五入。
Math.pow(x, y)：返回 x 的 y 次幂。
Math.max(...values)：返回最大值。
Math.min(...values)：返回最小值。
返回值说明
Math.random()：返回 [0, 1) 区间的浮点数。
其他方法根据具体功能返回相应的数值。
使用限制
Math.random() 生成的是伪随机数，不适合用于加密场景。
数值运算需注意精度问题，浮点数运算可能存在精度误差。
示例1：生成随机数用于参数化
本示例演示如何生成随机整数和浮点数，用于参数化测试场景，如随机用户 ID、随机金额等。
import http from 'pts/http';
﻿
export default function () {
    // 生成 0 到 9 之间的随机整数
    const randomInt = Math.floor(Math.random() * 10);
    console.log(randomInt);
    
    // 生成指定范围内的随机整数（如 100 到 999）
    const min = 100;
    const max = 999;
    const randomInRange = Math.floor(Math.random() * (max - min + 1)) + min;
    console.log(randomInRange);
    
    // 在请求中使用随机参数
    const resp = http.get('http://example.com/api/user', {
        query: {
            'userId': randomInRange.toString()
        }
    });
}
示例2：数学运算和幂运算
本示例演示如何使用 Math 对象进行数学运算，适用于需要数值计算的场景。
export default function () {
    // 计算幂
    const result = Math.pow(2, 10);
    console.log(result); // 1024
    
    // 取最大值和最小值
    const numbers = [10, 20, 5, 30, 15];
    const max = Math.max(...numbers);
    const min = Math.min(...numbers);
    console.log(`最大值: ${max}, 最小值: ${min}`);
    
    // 四舍五入
    const rounded = Math.round(3.7);
    console.log(rounded); // 4
}
示例3：实现随机延迟和随机选择
本示例演示如何使用随机数实现随机延迟和随机选择逻辑，用于模拟真实用户行为。
import { sleep } from 'pts';
import http from 'pts/http';
﻿
export default function () {
    // 生成 1 到 5 秒之间的随机延迟
    const randomDelay = Math.floor(Math.random() * 4000) + 1000;
    sleep(randomDelay / 1000); // sleep 使用秒为单位
    
    // 随机选择操作
    const operations = ['read', 'write', 'delete'];
    const randomOperation = operations[Math.floor(Math.random() * operations.length)];
    console.log(`执行操作: ${randomOperation}`);
    
    // 根据随机选择执行不同请求
    if (randomOperation === 'read') {
        http.get('http://example.com/api/read');
    } else if (randomOperation === 'write') {
        http.post('http://example.com/api/write', {
            body: JSON.stringify({ data: 'test' })
        });
    }
}
RegExp 对象
函数说明
RegExp 对象用于正则表达式匹配，在压测脚本中常用于：
从响应中提取特定数据。
验证数据格式。
字符串替换和转换。
模式匹配和验证。
前提条件
正则表达式语法需符合 JavaScript 标准。
可以使用字面量形式 /pattern/ 或构造函数 new RegExp()。
函数签名
/pattern/flags
new RegExp(pattern: string, flags?: string): RegExp
常用方法
test(str)：测试字符串是否匹配，返回布尔值。
exec(str)：执行匹配，返回匹配结果数组或 null。
match(regexp)：字符串方法，返回匹配结果。
replace(regexp, replacement)：字符串方法，替换匹配内容。
search(regexp)：字符串方法，返回匹配位置索引。
返回值说明
test()：返回 true 或 false。
exec()：返回匹配结果数组（包含匹配内容和捕获组）或 null。
match()：返回匹配结果数组或 null。
replace()：返回替换后的新字符串。
search()：返回匹配位置的索引或 -1。
使用限制
复杂正则表达式可能影响性能，建议优化表达式。
全局标志 g 会影响 exec() 和 test() 的行为。
需注意特殊字符的转义。
示例1：从响应中提取数据
本示例演示如何使用正则表达式从 HTTP 响应中提取特定数据，如提取 token、ID 等。
import http from 'pts/http';
﻿
export default function () {
    const resp = http.get('http://example.com/api/data');
    
    // 使用正则表达式提取邮箱地址
    const emailRegex = /\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b/g;
    const emails = resp.body.match(emailRegex);
    
    if (emails) {
        console.log('找到邮箱:', emails);
    }
    
    // 提取数字 ID
    const idRegex = /"id":\\s*(\\d+)/;
    const match = resp.body.match(idRegex);
    if (match) {
        const id = match[1];
        console.log('提取的 ID:', id);
    }
}
示例2：字符串替换和格式化
本示例演示如何使用正则表达式进行字符串替换，适用于数据格式转换场景。
export default function () {
    // 替换姓名格式：从 "John Smith" 转换为 "Smith, John"
    let re = /(\\w+)\\s(\\w+)/;
    let str = "John Smith";
    let newStr = str.replace(re, "$2, $1");
    console.log(newStr); // Smith, John
    
    // 移除字符串中的空格
    const text = "Hello World Test";
    const noSpaces = text.replace(/\\s/g, "");
    console.log(noSpaces); // HelloWorldTest
    
    // 格式化电话号码
    const phone = "13812345678";
    const formatted = phone.replace(/(\\d{3})(\\d{4})(\\d{4})/, "$1-$2-$3");
    console.log(formatted); // 138-1234-5678
}
示例3：数据验证和检查
本示例演示如何使用正则表达式验证数据格式，适用于参数校验场景。
import http from 'pts/http';
import { check } from 'pts';
﻿
export default function () {
    // 验证邮箱格式
    const emailRegex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;
    const email = "user@example.com";
    const isValidEmail = emailRegex.test(email);
    check('邮箱格式正确', () => isValidEmail);
    
    // 验证手机号格式（11位数字）
    const phoneRegex = /^1[3-9]\\d{9}$/;
    const phone = "13812345678";
    const isValidPhone = phoneRegex.test(phone);
    check('手机号格式正确', () => isValidPhone);
    
    // 在请求中使用验证后的数据
    if (isValidEmail && isValidPhone) {
        const resp = http.post('http://example.com/api/register', {
            body: JSON.stringify({
                email: email,
                phone: phone
            })
        });
    }
}
PTS 扩展库
PTS 扩展库提供了额外的工具函数，用于增强脚本功能。使用前需通过 import util from 'pts/util' 导入模块。
Base64编码解码
函数说明
util.base64Encoding() 和 util.base64Decoding() 用于 Base64 编码和解码，在压测脚本中常用于：
对请求参数进行 Base64 编码。
解码响应中的 Base64 数据。
处理二进制数据的文本传输。
实现认证和加密相关功能。
前提条件
需先导入 pts/util 模块：import util from 'pts/util'。
所有代码需放在 export default function() 函数中执行。
编码输入可以是字符串或 ArrayBuffer。
解码输出可以是字符串或 ArrayBuffer（通过 mode 参数控制）。
函数签名
base64Encoding(input: string | ArrayBuffer, encoding?: "std" | "rawstd" | "url" | "rawurl"): string
base64Decoding(input: string, encoding?: "std" | "rawstd" | "url" | "rawurl", mode?: "b"): string | ArrayBuffer
参数说明
util.base64Encoding()
input (string | ArrayBuffer，必填)：要编码的字符串或字节数组。
encoding (string，可选)：编码方式，可选值：
"std"：标准 Base64编码（默认），符合 RFC 4648标准。
"rawstd"：标准原始编码，无填充字符。
"url"：URL 安全编码，适用于 URL 和文件名。
"rawurl"：URL 安全原始编码，无填充字符。
util.base64Decoding()
input (string，必填)：要解码的 Base64 字符串。
encoding (string，可选)：编码方式，需与编码时使用的编码方式一致，默认为 "std"。
mode (string，可选)：返回类型控制，不设置返回 string，设置为 "b" 返回 ArrayBuffer。
返回值说明
base64Encoding()：返回 Base64 编码后的字符串。
base64Decoding()：根据 mode 参数返回字符串或 ArrayBuffer。
使用限制
编码和解码需使用相同的 encoding 参数，否则可能无法正确解码。
URL 编码方式适用于需要在 URL 中使用的场景。
ArrayBuffer 模式适用于处理二进制数据。
示例1：基本编码解码
本示例演示基本的 Base64编码和解码操作，适用于简单的数据转换场景。
import util from 'pts/util';
﻿
export default function () {
    // Base64 编码
    const base64Encoded = util.base64Encoding("Hello, world");
    console.log(base64Encoded); // SGVsbG8sIHdvcmxk
﻿
    // Base64 解码
    const base64Decoded = util.base64Decoding(base64Encoded);
    console.log(base64Decoded); // Hello, world
}
示例2：在 HTTP 请求中使用 Base64编码
本示例演示如何在 HTTP 请求中使用 Base64编码，适用于需要传递编码参数的场景，如 Basic 认证、API 签名等。
import http from 'pts/http';
import util from 'pts/util';
﻿
export default function () {
    // 对用户名和密码进行 Base64 编码用于 Basic 认证
    const credentials = "username:password";
    const encodedCredentials = util.base64Encoding(credentials);
    
    // 在请求头中使用
    const resp = http.get('http://example.com/api/protected', {
        headers: {
            'Authorization': `Basic ${encodedCredentials}`
        }
    });
    
    console.log(resp.statusCode);
}
示例3：使用不同的编码方式
本示例演示如何使用不同的 Base64编码方式，适用于不同场景的需求。
import util from 'pts/util';
﻿
export default function () {
    const text = "http://www.example.com";
    
    // 标准编码（默认）
    const stdEncoded = util.base64Encoding(text);
    console.log('标准编码:', stdEncoded);
    
    // URL 安全编码（适用于 URL）
    const urlEncoded = util.base64Encoding(text, 'url');
    console.log('URL 编码:', urlEncoded);
    
    // 解码时需使用相同的编码方式
    const urlDecoded = util.base64Decoding(urlEncoded, 'url');
    console.log('URL 解码:', urlDecoded); // http://www.example.com
}
示例 4：处理 ArrayBuffer 数据
本示例演示如何使用 ArrayBuffer 模式处理二进制数据。
import util from 'pts/util';
﻿
export default function () {
    // 编码字符串
    const encoded = util.base64Encoding("Hello, world");
    
    // 解码为 ArrayBuffer
    const arrayBuffer = util.base64Decoding(encoded, 'std', 'b');
    console.log('ArrayBuffer 类型:', arrayBuffer);
    
    // 如果需要，可以将 ArrayBuffer 转换回字符串
    // 注意：实际使用时需根据具体需求处理 ArrayBuffer
}
UUID 生成
函数说明
util.uuid() 用于生成 UUID（通用唯一标识符），在压测脚本中常用于：
生成唯一的请求 ID。
创建唯一的用户标识。
生成唯一的订单号、会话 ID 等。
实现去重和追踪功能。
前提条件
需先导入 pts/util 模块：import util from 'pts/util'。
所有代码需放在 export default function() 函数中执行。
生成的 UUID 符合 UUID v4 标准（随机 UUID）。
函数签名
uuid(): string
参数说明
无需参数。
返回值说明
返回 UUID v4 格式的字符串，格式为：xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx，其中：
x 为十六进制数字。
y 为 8、9、a 或 b 之一。
示例：5fbf1e59-cabf-469b-9d9f-6622e97de1ec。
使用限制
每次调用都会生成新的 UUID，不会重复。
UUID 是随机生成的，不保证顺序性。
适用于需要唯一标识的场景，不适合用于加密。
示例1：生成唯一请求 ID
本示例演示如何生成 UUID 作为请求的唯一标识，适用于需要追踪和日志记录的场景。
import http from 'pts/http';
import util from 'pts/util';
﻿
export default function () {
    // 生成唯一请求 ID
    const requestId = util.uuid();
    console.log('请求 ID:', requestId); // 5fbf1e59-cabf-469b-9d9f-6622e97de1ec
    
    // 在请求头中传递请求 ID
    const resp = http.get('http://example.com/api/data', {
        headers: {
            'X-Request-ID': requestId
        }
    });
    
    console.log('响应状态:', resp.statusCode);
}
示例2：创建唯一用户标识
本示例演示如何使用 UUID 创建唯一的用户标识，适用于模拟多用户压测场景。
import http from 'pts/http';
import util from 'pts/util';
﻿
export default function () {
    // 为每个虚拟用户生成唯一 ID
    const userId = util.uuid();
    console.log('用户 ID:', userId);
    
    // 使用唯一用户 ID 进行注册
    const registerResp = http.post('http://example.com/api/register', {
        body: JSON.stringify({
            userId: userId,
            username: `user_${userId.substring(0, 8)}`,
            email: `user_${userId.substring(0, 8)}@example.com`
        })
    });
    
    // 使用该用户 ID 进行后续操作
    if (registerResp.statusCode === 200) {
        const loginResp = http.post('http://example.com/api/login', {
            body: JSON.stringify({
                userId: userId
            })
        });
    }
}
示例3：生成唯一订单号和会话 ID
本示例演示如何使用 UUID 生成订单号、会话 ID 等业务唯一标识，适用于电商、支付等场景的压测。
import http from 'pts/http';
import util from 'pts/util';
﻿
export default function () {
    // 生成会话 ID
    const sessionId = util.uuid();
    console.log('会话 ID:', sessionId);
    
    // 创建购物车会话
    const cartResp = http.post('http://example.com/api/cart', {
        headers: {
            'X-Session-ID': sessionId
        },
        body: JSON.stringify({
            sessionId: sessionId,
            items: []
        })
    });
    
    // 生成订单号
    const orderId = util.uuid();
    console.log('订单号:', orderId);
    
    // 提交订单
    const orderResp = http.post('http://example.com/api/order', {
        body: JSON.stringify({
            orderId: orderId,
            sessionId: sessionId,
            amount: 100.00
        })
    });
    
    console.log('订单状态:', orderResp.statusCode);
}
﻿
常用函数

本页目录：

JS 公共库

Date 对象

函数说明

前提条件

函数签名

常用方法

使用限制

示例1：创建日期对象并格式化

示例2：计算请求耗时

JSON 对象

函数说明

前提条件

函数签名

参数说明

返回值说明

使用限制

示例1：解析响应 JSON 数据

示例2：构建 JSON 请求体

示例3：处理嵌套 JSON 和错误处理

Math 对象

函数说明

前提条件

常用方法

返回值说明

使用限制

示例1：生成随机数用于参数化

示例2：数学运算和幂运算

示例3：实现随机延迟和随机选择

RegExp 对象

函数说明

前提条件

函数签名

常用方法

返回值说明

使用限制

示例1：从响应中提取数据

示例2：字符串替换和格式化

示例3：数据验证和检查

PTS 扩展库

Base64编码解码

函数说明

前提条件

函数签名

参数说明

返回值说明

使用限制

示例1：基本编码解码

示例2：在 HTTP 请求中使用 Base64编码

示例3：使用不同的编码方式

示例 4：处理 ArrayBuffer 数据

UUID 生成

函数说明

前提条件

函数签名

参数说明

返回值说明

使用限制

示例1：生成唯一请求 ID

示例2：创建唯一用户标识

示例3：生成唯一订单号和会话 ID
