B2B网络软件

标题: AIWROK软件字符方法集合小结 [打印本页]

---

作者: YYPOST群发软件    时间: 8 小时前
标题: AIWROK软件字符方法集合小结

//字符.分割字符


/**
* 字符串分割工具模块 - 修正版
* 最后更新：2025-04-02
*/

var 字符 = {
/**
* 字符串分割方法
* @param {string} str 要分割的字符串
* @param {string} divide 分隔符
* @returns {Array|null} 分割后的数组或null(错误时)
*/
分割字符: function(str, divide) {
try {
if (typeof str !== 'string') return null;
if (typeof divide !== 'string') return null;

if (divide === '') {
var result = [];
for (var i = 0; i < str.length; i++) {
result.push(str.charAt(i));
}
return result;
}

var parts = [];
var lastIndex = 0;
var index = str.indexOf(divide);

while (index >= 0) {
parts.push(str.substring(lastIndex, index));
lastIndex = index + divide.length;
index = str.indexOf(divide, lastIndex);
}

parts.push(str.substring(lastIndex));
return parts;

} catch (e) {
return null;
}
}
};



printl("=== 测试开始 ===");
printl("基本测试: " + 字符.分割字符('a,b,c', ','));
printl("逐字符测试: " + 字符.分割字符('abc', ''));
printl("错误测试: " + 字符.分割字符(123, ','));
printl("=== 测试结束 ===");


//字符.删全部空格
/**
* 字符串分割工具模块 - 增强版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有分割字符方法...
分割字符: function(str, divide) {
// ...原有实现保持不变...
},

/**
* 删除字符串中所有空格
* @param {string} str 输入字符串
* @returns {string|null} 处理后的字符串或null(错误时)
*/
删全部空格: function(str) {
try {
if (typeof str !== 'string' && !(str instanceof java.lang.String)) {
return null;
}
// 使用正则表达式移除所有空格（包括全角空格）
return str.replace(/[\s　]+/g, '');
} catch (e) {
printl("[删全部空格错误] " + e.message);
return null;
}
}
};

// 测试代码
printl("=== 空格删除测试 ===");
printl("测试1: " + 字符.删全部空格(' a b cd ')); // 输出: "abcd"
printl("测试2: " + 字符.删全部空格(' 中　文　空 格 ')); // 输出: "中文空格"
printl("测试3: " + 字符.删全部空格(123)); // 输出: null

//字符.删头尾空格

/**
* 字符串工具模块 - 增强版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有分割字符方法...
分割字符: function(str, divide) {
// ...原有实现保持不变...
},

// 原有删全部空格方法...
删全部空格: function(str) {
// ...原有实现保持不变...
},

/**
* 删除字符串开头和结尾的空格
* @param {string} str 输入字符串
* @returns {string|null} 处理后的字符串或null(错误时)
*/
删头尾空格: function(str) {
try {
if (typeof str !== 'string' && !(str instanceof java.lang.String)) {
return null;
}
// 移除开头和结尾的空格（包括全角空格）
return str.replace(/^[\s　]+|[\s　]+$/g, '');
} catch (e) {
printl("[删头尾空格错误] " + e.message);
return null;
}
}
};

// 测试代码
printl("=== 功能测试 ===");
printl("删头尾空格测试: '" + 字符.删头尾空格(' ab cd ') + "'"); // 输出: 'ab cd'
printl("全角空格测试: '" + 字符.删头尾空格('　中文　') + "'"); // 输出: '中文'
printl("错误测试: " + 字符.删头尾空格(123)); // 输出: null

//字符.反向截取


/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 反向截取字符串
* @param {string} str 输入字符串
* @param {number} start 起始位置（支持负数）
* @param {number} [end] 结束位置（可选，支持负数）
* @returns {string|null} 处理后的字符串或null(错误时)
*/
反向截取: function(str, start, end) {
try {
// 参数校验
if (typeof str !== 'string' && !(str instanceof java.lang.String)) return null;
if (typeof start !== 'number') return null;

// 处理负数索引
const len = str.length;
let startPos = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
let endPos = len;

if (end !== undefined) {
if (typeof end !== 'number') return null;
endPos = end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
}

// 确保start <= end
if (startPos > endPos) {
[startPos, endPos] = [endPos, startPos];
}

return str.substring(startPos, endPos);
} catch (e) {
printl("[反向截取错误] " + e.message);
return null;
}
}
};

// 新增测试代码
printl("=== 反向截取测试 ===");
printl("测试1: " + 字符.反向截取('abcd', -1)); // 输出: "d"
printl("测试2: " + 字符.反向截取('abcd', -1, -4)); // 输出: "dcba"
printl("测试3: " + 字符.反向截取('abcd', 1, 3)); // 输出: "bc"
printl("测试4: " + 字符.反向截取('abcd', -2)); // 输出: "cd"
printl("错误测试: " + 字符.反向截取(123, 1)); // 输出: null


//字符.反向查找子字符

/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 反向查找子字符串位置
* @param {string} str 被查找的字符串
* @param {string} searchValue 要查找的子字符串
* @param {number} [fromIndex] 可选，开始查找的位置
* @returns {number} 子字符串位置(从0开始)，未找到返回-1
*/
反向查找子字符: function(str, searchValue, fromIndex) {
try {
// 参数校验
if (typeof str !== 'string' && !(str instanceof java.lang.String)) return -1;
if (typeof searchValue !== 'string' && !(searchValue instanceof java.lang.String)) return -1;

// 处理fromIndex参数
const len = str.length;
let start = fromIndex !== undefined ?
(fromIndex < 0 ? Math.max(len + fromIndex, 0) : Math.min(fromIndex, len - 1)) :
len - 1;

// 反向查找实现
if (searchValue === '') return start >= 0 ? start : len;

const searchLen = searchValue.length;
for (let i = start; i >= 0; i--) {
let match = true;
for (let j = 0; j < searchLen; j++) {
if (str.charAt(i + j) !== searchValue.charAt(j)) {
match = false;
break;
}
}
if (match) return i;
}

return -1;
} catch (e) {
printl("[反向查找错误] " + e.message);
return -1;
}
}
};

// 新增测试代码
printl("=== 反向查找测试 ===");
printl("查找d: " + 字符.反向查找子字符('abcd','d')); // 输出: 3
printl("查找t: " + 字符.反向查找子字符('abcd','t')); // 输出: -1
printl("限定位置查找: " + 字符.反向查找子字符('abcd','a', 2)); // 输出: 0
printl("空子串查找: " + 字符.反向查找子字符('abcd','')); // 输出: 3
printl("错误测试: " + 字符.反向查找子字符(123,'a')); // 输出: -1

//字符.取下标字符

/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 获取指定下标位置的字符
* @param {string} str 输入字符串
* @param {number} index 字符位置（支持负数）
* @returns {string|null} 指定位置的字符或null(错误时)
*/
取下标字符: function(str, index) {
try {
// 参数校验
if (typeof str !== 'string' && !(str instanceof java.lang.String)) return null;
if (typeof index !== 'number') return null;

// 处理负数索引
const len = str.length;
const pos = index < 0 ?
Math.max(len + index, 0) :
Math.min(index, len - 1);

// 边界检查
if (pos < 0 || pos >= len) return null;

return str.charAt(pos);
} catch (e) {
printl("[取下标字符错误] " + e.message);
return null;
}
}
};

// 新增测试代码
printl("=== 取下标字符测试 ===");
printl("测试1: " + 字符.取下标字符('abcd', 2)); // 输出: "c"
printl("测试2: " + 字符.取下标字符('abcd', -1)); // 输出: "d"
printl("测试3: " + 字符.取下标字符('abcd', 10)); // 输出: null
printl("测试4: " + 字符.取下标字符('中文测试', 1)); // 输出: "文"
printl("错误测试: " + 字符.取下标字符(123, 1)); // 输出: null

//字符.取长度


/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 获取字符串长度（字节数）
* @param {string} str 输入字符串
* @returns {number|null} 字符串长度或null(错误时)
*/
取长度: function(str) {
try {
// 参数校验
if (typeof str !== 'string' && !(str instanceof java.lang.String)) return null;

// 计算字节长度（兼容中文）
let bytes = 0;
for (let i = 0; i < str.length; i++) {
const c = str.charCodeAt(i);
bytes += c < 128 ? 1 : 2; // ASCII字符1字节，其他2字节
}
return bytes;
} catch (e) {
printl("[取长度错误] " + e.message);
return null;
}
}
};

// 新增测试代码
printl("=== 取长度测试 ===");
printl("中文测试: " + 字符.取长度('我们的软件最好用')); // 输出: 8 (4个中文字符×2字节)
printl("数字测试: " + 字符.取长度('1771955063')); // 输出: 10
printl("混合测试: " + 字符.取长度('a1中b2')); // 输出: 5 (1+1+2+1+1)
printl("空字符串: " + 字符.取长度('')); // 输出: 0
printl("错误测试: " + 字符.取长度(null)); // 输出: null

//字符.复制字符

/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 复制字符串指定倍数
* @param {string} str 输入字符串
* @param {number} count 复制倍数
* @returns {string|null} 复制后的字符串或null(错误时)
*/
复制字符: function(str, count) {
try {
// 参数校验
if (typeof str !== 'string' && !(str instanceof java.lang.String)) return null;

// 设置默认值(ES5写法)
count = typeof count === 'number' ? count : 1;
if (count < 0) return null;

// 处理边界情况
if (count === 0) return '';
if (str.length === 0) return '';

// 高效复制实现
var result = '';
for (var i = 0; i < count; i++) {
result += str;
}
return result;
} catch (e) {
printl("[复制字符错误] " + e.message);
return null;
}
}
};

// 测试代码保持不变
printl("=== 复制字符测试 ===");
printl("默认复制: " + 字符.复制字符('abcd')); // 输出: "abcd"
printl("双倍复制: " + 字符.复制字符('ab', 2)); // 输出: "abab"
printl("空字符串: " + 字符.复制字符('', 3)); // 输出: ""
printl("零次复制: " + 字符.复制字符('abc', 0)); // 输出: ""
printl("错误测试: " + 字符.复制字符(123, 2)); // 输出: null

//字符.字母转大写

/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 将字母字符转换为大写
* @param {string} str 输入字符串
* @returns {string|null} 大写字符串或null(错误时)
*/
字母转大写: function(str) {
try {
// 参数校验
if (typeof str !== 'string' && !(str instanceof java.lang.String)) return null;
if (str.length === 0) return str;

// 转换实现
var result = '';
for (var i = 0; i < str.length; i++) {
var code = str.charCodeAt(i);
if (code >= 97 && code <= 122) { // a-z
result += String.fromCharCode(code - 32);
} else {
result += str.charAt(i);
}
}
return result;
} catch (e) {
printl("[字母转大写错误] " + e.message);
return null;
}
}
};

// 新增测试代码
printl("=== 字母转大写测试 ===");
printl("小写转大写: " + 字符.字母转大写('abcd')); // 输出: "ABCD"
printl("混合测试: " + 字符.字母转大写('a1b2中文')); // 输出: "A1B2中文"
printl("空字符串: " + 字符.字母转大写('')); // 输出: ""
printl("错误测试: " + 字符.字母转大写(123)); // 输出: null

//字符.字母转小写

/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 将字母字符转换为小写
* @param {string} str 输入字符串
* @returns {string|null} 小写字符串或null(错误时)
*/
字母转小写: function(str) {
try {
// 参数校验
if (typeof str !== 'string' && !(str instanceof java.lang.String)) return null;
if (str.length === 0) return str;

// 转换实现
var result = '';
for (var i = 0; i < str.length; i++) {
var code = str.charCodeAt(i);
if (code >= 65 && code <= 90) { // A-Z
result += String.fromCharCode(code + 32);
} else {
result += str.charAt(i);
}
}
return result;
} catch (e) {
printl("[字母转小写错误] " + e.message);
return null;
}
}
};

// 新增测试代码
printl("=== 字母转小写测试 ===");
printl("大写转小写: " + 字符.字母转小写('ABCD')); // 输出: "abcd"
printl("混合测试: " + 字符.字母转小写('A1B2中文')); // 输出: "a1b2中文"
printl("空字符串: " + 字符.字母转小写('')); // 输出: ""
printl("错误测试: " + 字符.字母转小写(123)); // 输出: null

// 字符.数字转字符

/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 将任意数据转换为字符串
* @param {*} data 输入数据
* @param {number} [radix] 进制(2-36)
* @returns {string|null} 转换后的字符串或null(错误时)
*/
数字转字符: function(data, radix) {
try {
// 处理null/undefined
if (data == null) return null;

// 数字进制转换
if (typeof data === 'number' && radix) {
if (radix < 2 || radix > 36) return null;
return data.toString(radix);
}

// 默认转换
if (data.toString) return data.toString();
return String(data);
} catch (e) {
printl("[数字转字符错误] " + e.message);
return null;
}
}
};

// 新增测试代码
printl("=== 数字转字符测试 ===");
printl("十进制: " + 字符.数字转字符(4095)); // 输出: "4095"
printl("十六进制: " + 字符.数字转字符(4095, 16)); // 输出: "fff"
printl("二进制: " + 字符.数字转字符(15, 2)); // 输出: "1111"
printl("对象: " + 字符.数字转字符({a:1})); // 输出: "[object Object]"
printl("错误测试: " + 字符.数字转字符()); // 输出: null


//字符.查找子字符

/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 正向查找子字符串是否存在
* @param {string} str 被查找的字符串
* @param {string} searchValue 要查找的子字符串
* @param {number} [start] 开始查找的位置
* @returns {boolean} 是否找到
*/
正向查找子字符: function(str, searchValue, start) {
try {
// 参数校验
if (typeof str !== 'string' && !(str instanceof java.lang.String)) return false;
if (typeof searchValue !== 'string' && !(searchValue instanceof java.lang.String)) return false;

// 处理start参数
start = start !== undefined ?
Math.max(0, Math.min(start, str.length - 1)) :
0;

// 空字符串特殊处理
if (searchValue.length === 0) return start <= str.length;

return str.indexOf(searchValue, start) !== -1;
} catch (e) {
printl("[正向查找错误] " + e.message);
return false;
}
}
};

// 新增测试代码
printl("=== 正向查找测试 ===");
printl("查找d: " + 字符.正向查找子字符('abcd','d')); // true
printl("查找t: " + 字符.正向查找子字符('abcd','t')); // false
printl("限定位置查找: " + 字符.正向查找子字符('abcd','a', 2)); // false
printl("空子串查找: " + 字符.正向查找子字符('abcd','')); // true
printl("错误测试: " + 字符.正向查找子字符(123,'a')); // false

//字符.查找子字符开头

/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 检查字符串是否以指定子字符串结尾
* @param {string} str 被检查的字符串
* @param {string} searchValue 要查找的子字符串
* @param {number} [length] 可选检查长度
* @returns {boolean} 是否以该子字符串结尾
*/
查找子字符结尾: function(str, searchValue, length) {
try {
// 参数校验
if (typeof str !== 'string' && !(str instanceof java.lang.String)) return false;
if (typeof searchValue !== 'string' && !(searchValue instanceof java.lang.String)) return false;

// 处理length参数
const checkLength = length !== undefined ?
Math.min(Math.max(0, length), str.length) :
str.length;

// 空字符串特殊处理
if (searchValue.length === 0) return true;

// 计算起始位置
const startPos = Math.max(0, checkLength - searchValue.length);

// 实际检查
return str.substr(startPos, searchValue.length) === searchValue;
} catch (e) {
printl("[查找结尾错误] " + e.message);
return false;
}
}
};

// 新增测试代码
printl("=== 查找结尾测试 ===");
printl("正确结尾: " + 字符.查找子字符结尾('abcd','d')); // true
printl("错误结尾: " + 字符.查找子字符结尾('abcd','a')); // false
printl("限定长度: " + 字符.查找子字符结尾('abcd','cd', 3)); // true
printl("空子串: " + 字符.查找子字符结尾('abcd','')); // true
printl("错误测试: " + 字符.查找子字符结尾(123,'d')); // false

//字符.正向截取

/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 正向截取字符串
* @param {string} str 输入字符串
* @param {number} start 起始位置（非负整数）
* @param {number} [end] 结束位置（可选）
* @returns {string|null} 截取的子串或null(错误时)
*/
正向截取: function(str, start, end) {
try {
// 参数校验
if (typeof str !== 'string' && !(str instanceof java.lang.String)) return null;
if (typeof start !== 'number' || start < 0) return null;

// 处理end参数
const len = str.length;
const endPos = end !== undefined ?
Math.min(Math.max(0, end), len) :
len;

// 边界检查
if (start >= endPos) return '';

return str.substring(start, endPos);
} catch (e) {
printl("[正向截取错误] " + e.message);
return null;
}
}
};

// 新增测试代码
printl("=== 正向截取测试 ===");
printl("基本截取: " + 字符.正向截取('abcd', 2)); // 输出: "cd"
printl("范围截取: " + 字符.正向截取('abcd', 2, 3)); // 输出: "c"
printl("空截取: " + 字符.正向截取('abcd', 2, 2)); // 输出: ""
printl("错误测试1: " + 字符.正向截取('abcd', -1)); // 输出: null
printl("错误测试2: " + 字符.正向截取(123, 1)); // 输出: null

//字符.正向查找子字符

/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 正向查找子字符串位置
* @param {string} str 被查找的字符串
* @param {string} searchValue 要查找的子字符串
* @param {number} [start] 可选，开始查找的位置
* @returns {number} 子字符串位置(从0开始)，未找到返回-1
*/
正向查找子字符: function(str, searchValue, start) {
try {
// 参数校验
if (typeof str !== 'string' && !(str instanceof java.lang.String)) return -1;
if (typeof searchValue !== 'string' && !(searchValue instanceof java.lang.String)) return -1;

// 处理start参数
const len = str.length;
start = start !== undefined ?
Math.max(0, Math.min(start, len - 1)) :
0;

// 空字符串特殊处理
if (searchValue.length === 0) return start <= len ? start : -1;

// 使用原生indexOf实现
const pos = str.indexOf(searchValue, start);
return pos >= 0 ? pos : -1;
} catch (e) {
printl("[正向查找错误] " + e.message);
return -1;
}
}
};

// 新增测试代码
printl("=== 正向查找测试 ===");
printl("查找d: " + 字符.正向查找子字符('abcd','d')); // 输出: 3
printl("查找t: " + 字符.正向查找子字符('abcd','t')); // 输出: -1
printl("限定位置查找: " + 字符.正向查找子字符('abcd','a', 2)); // 输出: -1
printl("空子串查找: " + 字符.正向查找子字符('abcd','')); // 输出: 0
printl("错误测试: " + 字符.正向查找子字符(123,'a')); // 输出: -1

// 字符.连接字符


/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 连接多个参数为一串字符串
* @param {...*} args 要连接的参数
* @returns {string|null} 连接后的字符串或null(错误时)
*/
连接字符: function() {
try {
var result = '';
for (var i = 0; i < arguments.length; i++) {
var arg = arguments;
if (arg == null) continue;

if (typeof arg === 'object' && arg.toString) {
result += arg.toString();
} else {
result += String(arg);
}
}
return result || null;
} catch (e) {
printl("[连接字符错误] " + e.message);
return null;
}
}
};

// 新增测试代码
printl("=== 连接字符测试 ===");
printl("基本连接: " + 字符.连接字符(10,30,'abcd','蜂群课堂',false)); // "1030abcd蜂群课堂false"
printl("混合类型: " + 字符.连接字符({a:1}, [1,2], true)); // "[object Object]1,2true"
printl("空参数: " + 字符.连接字符()); // null
printl("包含null: " + 字符.连接字符('a', null, 'b')); // "ab"

//字符.长度截取


/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 按长度截取字符串
* @param {string} str 输入字符串
* @param {number} start 起始位置（支持负数）
* @param {number} [length] 截取长度
* @returns {string|null} 截取的子串或null(错误时)
*/
长度截取: function(str, start, length) {
try {
// 参数校验
if (typeof str !== 'string' && !(str instanceof java.lang.String)) return null;
if (typeof start !== 'number') return null;

// 处理负数起始位置
const len = str.length;
let startPos = start < 0 ?
Math.max(0, len + start) :
Math.min(start, len);

// 处理length参数
const endPos = length !== undefined ?
Math.min(startPos + Math.max(0, length), len) :
len;

return str.substring(startPos, endPos);
} catch (e) {
printl("[长度截取错误] " + e.message);
return null;
}
}
};

// 新增测试代码
printl("=== 长度截取测试 ===");
printl("基本截取: " + 字符.长度截取('abcd', 2)); // "cd"
printl("限定长度: " + 字符.长度截取('abcd', 2, 1)); // "c"
printl("负数起始: " + 字符.长度截取('abcd', -2)); // "cd"
printl("超范围截取: " + 字符.长度截取('abcd', 1, 10)); // "bcd"
printl("错误测试: " + 字符.长度截取(123, 1)); // null

//字符.随机字母


/**
* 字符串工具模块 - 完整版
* 适用：ES5系统安卓 JavaScript引擎Rhino
* 最后更新：2025-04-02
*/

var 字符 = {
// 原有方法保持不变...

/**
* 生成随机字母字符串
* @param {number} [digit=1] 生成位数
* @returns {string|null} 随机字母字符串或null(错误时)
*/
随机字母: function(digit) {
try {
// 参数处理
digit = digit !== undefined ?
Math.max(1, Math.min(digit, 100)) :
1;

// 生成随机字母
var result = '';
var letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
for (var i = 0; i < digit; i++) {
result += letters.charAt(Math.floor(Math.random() * letters.length));
}
return result;
} catch (e) {
printl("[随机字母错误] " + e.message);
return null;
}
}
};

// 新增测试代码
printl("=== 随机字母测试 ===");
printl("2位随机: " + 字符.随机字母(2)); // 如 "Ab"
printl("10位随机: " + 字符.随机字母(10)); // 如 "XkLpQrStUv"
printl("默认1位: " + 字符.随机字母()); // 如 "Z"
printl("错误测试: " + 字符.随机字母(-1)); // null

1. 分割字符

分割字符: function(str, divide)

• 功能：按指定分隔符分割字符串
• 特点：

• 支持空分隔符（逐字符分割）
• 严格的参数类型检查
• 完整的错误处理

• 测试用例：

• 字符.分割字符('a,b,c', ',') → ["a","b","c"]
• 字符.分割字符('abc', '') → ["a","b","c"]

2. 删全部空格

删全部空格: function(str)

• 功能：删除所有空格（包括全角空格）
• 实现：

• 使用正则表达式/[\s ]+/g
• 支持Java字符串对象

• 测试用例：

• 字符.删全部空格(' a b cd ') → "abcd"

3. 删头尾空格

删头尾空格: function(str)

• 功能：仅删除首尾空格
• 实现：

• 正则表达式/^[\s ]+|[\s ]+$/g
• 保留字符串中间空格

4. 反向截取

反向截取: function(str, start, end)

• 功能：支持负数的反向截取
• 特点：

• 自动处理负索引
• 智能位置交换（当start>end时）

• 测试用例：

• 字符.反向截取('abcd', -1) → "d"
• 字符.反向截取('abcd', -1, -4) → "dcba"

5. 反向查找子字符

反向查找子字符: function(str, searchValue, fromIndex)

• 功能：从后向前查找子串
• 实现：

• 手动实现的查找算法
• 支持负数的起始位置

6. 取下标字符

取下标字符: function(str, index)

• 功能：安全获取指定位置字符
• 特点：

• 支持负索引
• 严格的边界检查

7. 取长度

取长度: function(str)

• 功能：计算字节长度（中文算2字节）
• 实现：通过字符编码判断字节数

8. 复制字符

复制字符: function(str, count)

• 功能：字符串重复复制
• 默认值：count默认为1

9. 字母大小写转换

字母转大写: function(str)
字母转小写: function(str)

• 实现：通过ASCII码转换
• 特点：非字母字符保持不变

10. 数字转字符

数字转字符: function(data, radix)

• 功能：支持多进制转换
• 支持：2-36进制

11. 正向查找子字符

正向查找子字符: function(str, searchValue, start)

• 功能：改进版的正向查找
• 优化：更好的参数处理

12. 查找子字符结尾

查找子字符结尾: function(str, searchValue, length)

• 功能：检查字符串结尾
• 特点：可指定检查长度

13. 连接字符

连接字符: function()

• 功能：多参数连接
• 特点：自动跳过null/undefined

14. 长度截取

长度截取: function(str, start, length)

• 功能：按长度而非位置截取
• 支持：负起始位置

15. 随机字母

随机字母: function(digit)

• 功能：生成随机字母串
• 范围：a-zA-Z
• 限制：最大100位

整体特点

1. 兼容性：专为Rhino引擎优化
2. 健壮性：所有方法都有：

• 参数类型检查
• 错误处理
• 边界条件处理

3. 一致性：统一返回null表示错误
4. 实用性：每个方法都有完整测试用例

---

欢迎光临 B2B网络软件 (http://bbs.niubt.cn/)

Powered by Discuz! X3.2