AIWROK软件对象工具函数库例子 - B2B网络软件

/**
* //🍎交流QQ群711841924群一，苹果内测群，528816639
* 通用对象操作工具函数库
* 适用本文档ES5系统安卓 JavaScript引擎Rhino
* 提供实用的对象操作方法，解决实际项目中的常见问题
*/
print.log("开始执行日志窗口操作");
print.log("1. 显示日志窗口");
printl( logWindow.show())
print.log("日志窗口显示完成");
print.log("2. 清空日志窗口");
printl(logWindow.clear())
print.log("日志窗口清空完成");
print.log("3. 设置日志窗口高度为2500");
printl(logWindow.setHeight(2500))
print.log("日志窗口高度设置完成");
print.log("4. 设置日志窗口宽度为1000");
printl(logWindow.setWidth(1000))
print.log("日志窗口宽度设置完成");
print.log("5. 设置日志窗口为不可点击模式");
printl(logWindow.setNoClickModel())
print.log("日志窗口不可点击模式设置完成");
print.log("所有日志窗口操作执行完毕");
// 合并对象 - 将多个对象合并为一个新对象
function mergeObjects() {
print.log("执行mergeObjects函数 - 合并多个对象");
var target = {};
var i, source;
for (i = 0; i < arguments.length; i++) {
source = arguments[i];
print.log(" - 合并第" + (i + 1) + "个对象: " + safeStringify(source));
if (source != null && typeof source === 'object') {
for (var key in source) {
if (source.hasOwnProperty(key)) {
target[key] = source[key];
}
}
}
}
print.log(" - 合并结果: " + safeStringify(target));
print.log(" - 结果: 拷贝成功，目标对象变为: " + safeStringify(target));
return target;
}
// 获取对象键值对 - 返回[[key1, value1], [key2, value2], ...]格式数组
function getObjectEntries(obj) {
print.log("执行getObjectEntries函数 - 获取对象键值对");
print.log(" - 对象: " + safeStringify(obj));
var entries = [];
var key;
if (obj != null && typeof obj === 'object') {
for (key in obj) {
if (obj.hasOwnProperty(key)) {
entries.push([key, obj[key]]);
}
}
}
print.log(" - 结果: " + safeStringify(entries));
return entries;
}
// 获取对象键数组
function getObjectKeys(obj) {
print.log("执行getObjectKeys函数 - 获取对象键数组");
print.log(" - 对象: " + safeStringify(obj));
var keys = [];
var key;
if (obj != null && typeof obj === 'object') {
for (key in obj) {
if (obj.hasOwnProperty(key)) {
keys.push(key);
}
}
}
print.log(" - 结果: " + safeStringify(keys));
return keys;
}
// 获取对象值数组
function getObjectValues(obj) {
print.log("执行getObjectValues函数 - 获取对象值数组");
print.log(" - 对象: " + safeStringify(obj));
var values = [];
var key;
if (obj != null && typeof obj === 'object') {
for (key in obj) {
if (obj.hasOwnProperty(key)) {
values.push(obj[key]);
}
}
}
print.log(" - 结果: " + safeStringify(values));
return values;
}
// 冻结对象 - 防止对象被修改
function freezeObject(obj) {
print.log("执行freezeObject函数 - 冻结对象");
print.log(" - 对象: " + safeStringify(obj));
if (obj != null && typeof obj === 'object') {
var frozen = Object.freeze(obj);
print.log(" - 结果: 对象已冻结");
return frozen;
}
print.log(" - 结果: 对象为null或非对象类型，直接返回");
print.log(" - 结果: " + safeStringify(obj));
return obj;
}
// 检查对象是否被冻结
function isObjectFrozen(obj) {
print.log("执行isObjectFrozen函数 - 检查对象是否被冻结");
print.log(" - 对象: " + safeStringify(obj));
var result;
if (obj != null && typeof obj === 'object') {
result = Object.isFrozen(obj);
} else {
result = false;
}
print.log(" - 结果: " + (result ? "对象已被冻结" : "对象未被冻结"));
print.log(" - 结果: " + safeStringify(result));
print.log(" - 结果: " + safeStringify(result));
print.log(" - 结果: 转换成功");
print.log(" - 结果: 扁平化成功，扁平对象: " + safeStringify(result));
return result;
}
// 深度克隆对象 - 支持嵌套对象和数组
function deepCloneObject(obj) {
print.log("执行deepCloneObject函数 - 深度克隆对象");
print.log(" - 对象: " + safeStringify(obj));
var clone;
var i, key;
if (obj == null || typeof obj !== 'object') {
print.log(" - 结果: 对象为null或非对象类型，直接返回");
return obj;
}
// 处理数组
if (obj instanceof Array) {
clone = [];
for (i = 0; i < obj.length; i++) {
clone[i] = deepCloneObject(obj[i]);
}
}
// 处理对象
else {
clone = {};
for (key in obj) {
if (obj.hasOwnProperty(key)) {
clone[key] = deepCloneObject(obj[key]);
}
}
}
print.log(" - 结果: 克隆成功");
return clone;
}
// 1. 对象属性安全获取 - 避免undefined错误
function getSafe(obj, path, defaultValue) {
print.log("执行getSafe函数 - 安全获取对象属性");
print.log(" - 对象: " + safeStringify(obj));
print.log(" - 路径: " + path);
if (obj == null) {
print.log(" - 结果: 对象为null，返回默认值: " + defaultValue);
return defaultValue;
}
var keys = path.split('.');
var current = obj;
for (var i = 0; i < keys.length; i++) {
if (current == null || !current.hasOwnProperty(keys[i])) {
print.log(" - 结果: 路径不存在，返回默认值: " + defaultValue);
return defaultValue;
}
current = current[keys[i]];
}
print.log(" - 结果: 获取成功，值为: " + safeStringify(current));
return current;
}
// 2. 对象比较 - 深度比较两个对象是否相等
function isEqual(obj1, obj2) {
print.log("执行isEqual函数 - 深度比较两个对象是否相等");
print.log(" - 对象1: " + safeStringify(obj1));
print.log(" - 对象2: " + safeStringify(obj2));
if (obj1 === obj2) {
print.log(" - 结果: 对象引用相同，直接返回true");
print.log(" - 结果: 对象深度比较，相等");
return true;
}
if (obj1 == null || obj2 == null) {
print.log(" - 结果: 其中一个对象为null，返回false");
return false;
}
if (typeof obj1 !== typeof obj2) {
print.log(" - 结果: 对象类型不同，返回false");
return false;
}
if (typeof obj1 !== 'object') {
var result = obj1 === obj2;
print.log(" - 结果: 基础类型比较，" + (result ? "相等" : "不相等"));
return result;
}
if (obj1 instanceof Array && obj2 instanceof Array) {
if (obj1.length !== obj2.length) return false;
for (var i = 0; i < obj1.length; i++) {
if (!isEqual(obj1[i], obj2[i])) return false;
}
return true;
}
if (obj1 instanceof Array || obj2 instanceof Array) return false;
var keys1 = getObjectKeys(obj1);
var keys2 = getObjectKeys(obj2);
if (keys1.length !== keys2.length) return false;
for (var j = 0; j < keys1.length; j++) {
var key = keys1[j];
if (!obj2.hasOwnProperty(key) || !isEqual(obj1[key], obj2[key])) {
return false;
}
}
return true;
}
// 3. 对象过滤 - 保留符合条件的属性
function filterObject(obj, predicate) {
print.log("执行filterObject函数 - 过滤对象属性");
print.log(" - 对象: " + safeStringify(obj));
print.log(" - 过滤条件: " + predicate.toString());
if (obj == null || typeof obj !== 'object' || typeof predicate !== 'function') {
print.log(" - 结果: 参数无效，返回空对象");
return {};
}
var result = {};
for (var key in obj) {
if (obj.hasOwnProperty(key) && predicate(obj[key], key, obj)) {
result[key] = obj[key];
}
}
return result;
}
// 4. 对象转换为Map - 适合需要键值对操作的场景
function objectToMap(obj) {
print.log("执行objectToMap函数 - 对象转换为Map");
print.log(" - 对象: " + safeStringify(obj));
if (obj == null || typeof obj !== 'object') {
print.log(" - 结果: 对象为null或非对象类型，返回空Map");
return new HashMap();
}
var map = new HashMap();
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
map.put(key, obj[key]);
}
}
print.log(" - 结果: 转换成功，Map大小: " + map.size());
return map;
}
// 5. Map转换为对象
function mapToObject(map) {
print.log("执行mapToObject函数 - Map转换为对象");
print.log(" - Map: " + map.toString());
if (map == null || typeof map !== 'object' || typeof map.entrySet !== 'function') {
print.log(" - 结果: Map无效，返回空对象");
return {};
}
var obj = {};
var entries = map.entrySet().toArray();
for (var i = 0; i < entries.length; i++) {
var entry = entries[i];
obj[entry.getKey()] = entry.getValue();
}
return obj;
}
// 6. 对象属性遍历 - 对每个属性执行回调函数
function forEachObject(obj, callback) {
print.log("执行forEachObject函数 - 遍历对象属性");
print.log(" - 对象: " + safeStringify(obj));
print.log(" - 回调函数: " + callback.toString());
if (obj == null || typeof obj !== 'object' || typeof callback !== 'function') {
print.log(" - 结果: 参数无效，直接返回");
return;
}
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
print.log(" - 处理属性: " + key + " = " + safeStringify(obj[key]));
callback(obj[key], key, obj);
}
}
print.log(" - 结果: 遍历完成");
}
// 7. 对象属性转换 - 转换对象的属性值
function transformObject(obj, transformer) {
print.log("执行transformObject函数 - 转换对象属性值");
print.log(" - 对象: " + safeStringify(obj));
print.log(" - 转换函数: " + transformer.toString());
if (obj == null || typeof obj !== 'object' || typeof transformer !== 'function') {
print.log(" - 结果: 参数无效，返回空对象");
return {};
}
var result = {};
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
result[key] = transformer(obj[key], key, obj);
}
}
return result;
}
// 8. 检查对象是否包含指定属性
function hasOwnProperty(obj, key) {
print.log("执行hasOwnProperty函数 - 检查对象属性是否存在");
print.log(" - 对象: " + safeStringify(obj));
print.log(" - 属性: " + key);
var result;
if (obj == null || typeof obj !== 'object') {
result = false;
} else {
result = obj.hasOwnProperty(key);
}
print.log(" - 结果: " + (result ? "存在" : "不存在"));
return result;
}
// 9. 获取对象大小（属性数量）
function getObjectSize(obj) {
print.log("执行getObjectSize函数 - 获取对象属性数量");
print.log(" - 对象: " + safeStringify(obj));
var count = 0;
if (obj == null || typeof obj !== 'object') {
count = 0;
} else {
for (var key in obj) {
if (obj.hasOwnProperty(key)) count++;
}
}
print.log(" - 结果: 属性数量为" + count);
return count;
}
// 10. 对象序列化增强 - 处理循环引用和特殊类型
function safeStringify(obj, space) {
print.log("执行safeStringify函数 - 对象序列化");
try {
var cache = [];
var result = JSON.stringify(obj, function(key, value) {
if (typeof value === 'object' && value !== null) {
if (cache.indexOf(value) !== -1) {
return '[Circular Reference]';
}
cache.push(value);
}
return value;
}, space);
cache = null; // 释放内存
return result;
} catch (e) {
print.log(" - 结果: 序列化失败，返回空对象字符串");
return '{}';
}
}
// 11. 对象属性更新 - 安全更新对象属性，支持嵌套路径
function updateObject(obj, path, value) {
print.log("执行updateObject函数 - 更新对象属性");
print.log(" - 对象: " + safeStringify(obj));
print.log(" - 路径: " + path);
print.log(" - 新值: " + safeStringify(value));
if (obj == null || typeof obj !== 'object') {
print.log(" - 结果: 对象为null或非对象类型，直接返回");
return obj;
}
var keys = path.split('.');
var current = obj;
for (var i = 0; i < keys.length - 1; i++) {
var key = keys[i];
if (!current[key] || typeof current[key] !== 'object') {
current[key] = {};
}
current = current[key];
}
current[keys[keys.length - 1]] = value;
print.log(" - 结果: 更新成功，对象变为: " + safeStringify(obj));
return obj;
}
// 12. 对象属性删除 - 安全删除对象属性，支持嵌套路径
function deleteProperty(obj, path) {
print.log("执行deleteProperty函数 - 删除对象属性");
print.log(" - 对象: " + safeStringify(obj));
print.log(" - 路径: " + path);
if (obj == null || typeof obj !== 'object') {
print.log(" - 结果: 对象为null或非对象类型，直接返回");
return obj;
}
var keys = path.split('.');
var current = obj;
for (var i = 0; i < keys.length - 1; i++) {
var key = keys[i];
if (!current[key] || typeof current[key] !== 'object') {
print.log(" - 结果: 路径不存在，直接返回原对象");
return obj;
}
current = current[key];
}
delete current[keys[keys.length - 1]];
print.log(" - 结果: 删除成功，对象变为: " + safeStringify(obj));
return obj;
}
// 13. 对象属性遍历并转换 - 深度转换对象的所有属性
function deepTransform(obj, transformer) {
print.log("执行deepTransform函数 - 深度转换对象属性");
print.log(" - 对象: " + safeStringify(obj));
print.log(" - 转换函数: " + transformer.toString());
if (obj == null || typeof obj !== 'object' || typeof transformer !== 'function') {
print.log(" - 结果: 参数无效，直接返回");
return obj;
}
if (obj instanceof Array) {
return obj.map(function(item) {
return deepTransform(item, transformer);
});
}
var result = {};
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
var value = obj[key];
if (typeof value === 'object' && value !== null) {
result[key] = deepTransform(value, transformer);
} else {
result[key] = transformer(value, key, obj);
}
}
}
return result;
}
// 14. 对象扁平化 - 将嵌套对象转换为扁平结构
function flattenObject(obj, prefix) {
print.log("执行flattenObject函数 - 扁平化嵌套对象");
print.log(" - 嵌套对象: " + safeStringify(obj));
if (obj == null || typeof obj !== 'object') {
print.log(" - 结果: 参数无效，直接返回");
return obj;
}
var result = {};
prefix = prefix || '';
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
var fullPath = prefix ? prefix + '.' + key : key;
var value = obj[key];
if (typeof value === 'object' && value !== null && !(value instanceof Array)) {
var flatChild = flattenObject(value, fullPath);
for (var childKey in flatChild) {
if (flatChild.hasOwnProperty(childKey)) {
result[childKey] = flatChild[childKey];
}
}
} else {
result[fullPath] = value;
}
}
}
return result;
}
// 15. 扁平对象还原 - 将扁平结构转换为嵌套对象
function unflattenObject(flatObj) {
print.log("执行unflattenObject函数 - 还原扁平对象");
print.log(" - 扁平对象: " + safeStringify(flatObj));
if (flatObj == null || typeof flatObj !== 'object') {
print.log(" - 结果: 参数无效，直接返回");
return flatObj;
}
var result = {};
for (var key in flatObj) {
if (flatObj.hasOwnProperty(key)) {
print.log(" - 还原属性: " + key + " = " + safeStringify(flatObj[key]));
updateObject(result, key, flatObj[key]);
}
}
print.log(" - 结果: 还原成功，嵌套对象: " + safeStringify(result));
return result;
}
// 16. 对象属性存在性检查 - 检查嵌套属性是否存在
function hasNestedProperty(obj, path) {
print.log("执行hasNestedProperty函数 - 检查嵌套属性是否存在");
print.log(" - 对象: " + safeStringify(obj));
print.log(" - 路径: " + path);
if (obj == null || typeof obj !== 'object') {
print.log(" - 结果: 对象为null或非对象类型，返回false");
return false;
}
var keys = path.split('.');
var current = obj;
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (!current.hasOwnProperty(key)) {
print.log(" - 结果: 路径" + keys.slice(0, i + 1).join('.') + "不存在，返回false");
return false;
}
current = current[key];
}
print.log(" - 结果: 路径存在");
return true;
}
// 17. 对象属性拷贝 - 从一个对象拷贝属性到另一个对象
function copyProperties(source, target, properties) {
print.log("执行copyProperties函数 - 拷贝对象属性");
print.log(" - 源对象: " + safeStringify(source));
print.log(" - 目标对象: " + safeStringify(target));
print.log(" - 指定属性: " + safeStringify(properties));
if (source == null || typeof source !== 'object' || target == null || typeof target !== 'object') {
print.log(" - 结果: 参数无效，返回目标对象");
return target;
}
if (!properties || !(properties instanceof Array)) {
// 拷贝所有属性
for (var key in source) {
if (source.hasOwnProperty(key)) {
target[key] = source[key];
}
}
} else {
// 只拷贝指定属性
for (var i = 0; i < properties.length; i++) {
var key = properties[i];
if (source.hasOwnProperty(key)) {
target[key] = source[key];
}
}
}
return target;
}
// 18. 对象属性重命名 - 重命名对象的属性
function renameProperties(obj, mapping) {
print.log("执行renameProperties函数 - 重命名对象属性");
print.log(" - 对象: " + safeStringify(obj));
print.log(" - 映射关系: " + safeStringify(mapping));
if (obj == null || typeof obj !== 'object' || mapping == null || typeof mapping !== 'object') {
print.log(" - 结果: 参数无效，直接返回");
return obj;
}
var result = {};
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
var newKey = mapping[key] || key;
print.log(" - 重命名: " + key + " -> " + newKey + " = " + safeStringify(obj[key]));
result[newKey] = obj[key];
}
}
print.log(" - 结果: 重命名成功，对象变为: " + safeStringify(result));
return result;
}
// 19. 对象类型转换 - 将对象属性转换为指定类型
function convertPropertyTypes(obj, typeMap) {
print.log("执行convertPropertyTypes函数 - 转换对象属性类型");
print.log(" - 对象: " + safeStringify(obj));
print.log(" - 类型映射: " + safeStringify(typeMap));
if (obj == null || typeof obj !== 'object' || typeMap == null || typeof typeMap !== 'object') {
print.log(" - 结果: 参数无效，直接返回");
return obj;
}
var result = {};
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
var value = obj[key];
var type = typeMap[key];
if (type && typeof type === 'function') {
print.log(" - 转换类型: " + key + " = " + safeStringify(value) + " -> " + safeStringify(type(value)));
result[key] = type(value);
} else {
result[key] = value;
}
}
}
print.log(" - 结果: 类型转换成功，对象变为: " + safeStringify(result));
return result;
}
// 20. 对象属性验证 - 验证对象属性是否符合条件
function validateObject(obj, validations) {
print.log("执行validateObject函数 - 验证对象属性");
print.log(" - 对象: " + safeStringify(obj));
print.log(" - 验证规则: " + safeStringify(validations));
if (obj == null || typeof obj !== 'object' || validations == null || typeof validations !== 'object') {
print.log(" - 结果: 参数无效，返回验证失败");
return {isValid: false, errors: []};
}
var errors = [];
for (var key in validations) {
if (validations.hasOwnProperty(key)) {
var validator = validations[key];
var value = obj[key];
if (typeof validator === 'function') {
if (!validator(value, key, obj)) {
errors.push({key: key, message: '属性验证失败', value: value});
}
} else if (validator.required && !obj.hasOwnProperty(key)) {
errors.push({key: key, message: '属性必填', value: value});
} else if (validator.type && typeof value !== validator.type) {
errors.push({key: key, message: '属性类型错误', value: value});
}
}
}
print.log(" - 结果: 验证" + (errors.length === 0 ? "通过" : "失败"));
if (errors.length > 0) {
print.log(" - 错误信息: " + safeStringify(errors));
}
return {isValid: errors.length === 0, errors: errors};
}
// 使用示例 - 展示实际项目中的应用场景
function objectUtilsExample() {
print.log("执行objectUtilsExample函数 - 对象工具函数示例");
printl("=== 对象工具函数使用示例 ===");
// 示例1: 安全获取嵌套属性 - 避免undefined错误
printl("\n1. 安全获取嵌套属性:");
var user = {
name: "张三",
contact: {
email: "zhangsan@example.com"
}
};
var phone = getSafe(user, "contact.phone", "未设置");
var email = getSafe(user, "contact.email", "未设置");
printl(" 用户电话: " + phone);
printl(" 用户邮箱: " + email);
// 示例2: 对象深度比较 - 验证数据一致性
printl("\n2. 对象深度比较:");
var serverData = {id: 1, name: "产品A", price: 100};
var localData = {id: 1, name: "产品A", price: 100};
var isSame = isEqual(serverData, localData);
printl(" 服务器数据: " + safeStringify(serverData));
printl(" 本地数据: " + safeStringify(localData));
printl(" 数据是否一致: " + (isSame ? "是" : "否"));
// 示例3: 对象过滤 - 获取有效数据
printl("\n3. 对象过滤:");
var products = {
"product1": {name: "手机", price: 2000, inStock: true},
"product2": {name: "电脑", price: 5000, inStock: false},
"product3": {name: "平板", price: 3000, inStock: true}
};
var availableProducts = filterObject(products, function(product) {
return product.inStock && product.price < 4000;
});
printl(" 库存充足且价格低于4000的产品: " + safeStringify(availableProducts));
// 示例4: 对象属性更新 - 动态更新配置
printl("\n4. 对象属性更新:");
var config = {
server: {
host: "localhost",
port: 8080
},
timeout: 3000
};
updateObject(config, "server.port", 9090);
updateObject(config, "server.ssl", true);
printl(" 更新后的配置: " + safeStringify(config));
// 示例5: 对象扁平化 - 便于存储和传输
printl("\n5. 对象扁平化:");
var nestedData = {
user: {
info: {
name: "李四",
age: 25
},
contact: {
email: "lisi@example.com",
phone: "13800138000"
}
}
};
var flatData = flattenObject(nestedData);
printl(" 扁平化数据: " + safeStringify(flatData));
// 示例6: 对象验证 - 确保数据完整性
printl("\n6. 对象验证:");
var formData = {
username: "testuser",
password: "123",
email: "invalid-email"
};
var validationRules = {
username: {required: true, type: "string"},
password: function(value) {
return value.length >= 6;
},
email: function(value) {
return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
}
};
var validationResult = validateObject(formData, validationRules);
printl(" 验证结果: " + (validationResult.isValid ? "通过" : "失败"));
if (!validationResult.isValid) {
printl(" 错误信息: " + safeStringify(validationResult.errors));
}
// 示例7: 对象类型转换 - 统一数据格式
printl("\n7. 对象类型转换:");
var apiData = {
id: "123",
price: "99.99",
quantity: "10",
isActive: "true"
};
var typeConversions = {
id: parseInt,
price: parseFloat,
quantity: parseInt,
isActive: function(value) { return value === "true"; }
};
var convertedData = convertPropertyTypes(apiData, typeConversions);
printl(" 转换前: " + safeStringify(apiData));
printl(" 转换后: " + safeStringify(convertedData));
printl(" 价格类型: " + (typeof convertedData.price));
printl(" 数量类型: " + (typeof convertedData.quantity));
printl(" 是否激活: " + convertedData.isActive);
}
// 可以通过调用这个函数来运行示例
print.log("准备执行示例函数");
objectUtilsExample();
print.log("示例函数执行完成");
// 实际项目应用示例 - 模拟AIWROK项目中的数据处理场景
function aiwrokProjectExample() {
print.log("执行aiwrokProjectExample函数 - AIWROK项目应用示例");
printl("\n=== AIWROK项目实际应用示例 ===");
// 模拟从服务器获取的数据
var serverResponse = {
"code": 200,
"message": "success",
"data": {
"userInfo": {
"userId": "user_123456",
"userName": "AIWROK用户",
"userType": "normal",
"createTime": "2023-12-25T10:30:00Z",
"preferences": {
"theme": "dark",
"language": "zh-CN",
"notifications": true
}
},
"deviceList": [
{
"deviceId": "device_789",
"deviceName": "测试设备",
"status": "online",
"battery": "85",
"temperature": "25.5"
}
]
}
};
// 1. 安全获取用户信息
var userInfo = getSafe(serverResponse, "data.userInfo", {});
var userName = getSafe(userInfo, "userName", "未知用户");
var userTheme = getSafe(userInfo, "preferences.theme", "light");
printl("1. 用户信息获取:");
printl(" 用户名: " + userName);
printl(" 主题设置: " + userTheme);
// 2. 处理设备数据
var deviceList = getSafe(serverResponse, "data.deviceList", []);
if (deviceList.length > 0) {
var firstDevice = deviceList[0];
// 转换设备属性类型
var deviceData = convertPropertyTypes(firstDevice, {
battery: parseInt,
temperature: parseFloat
});
printl("\n2. 设备数据处理:");
printl(" 设备名称: " + deviceData.deviceName);
printl(" 设备状态: " + deviceData.status);
printl(" 电池电量: " + deviceData.battery + "%");
printl(" 设备温度: " + deviceData.temperature + "°C");
// 检查设备状态
if (deviceData.battery < 20) {
printl(" 警告: 电池电量低，需要充电！");
}
if (deviceData.temperature > 30) {
printl(" 警告: 设备温度过高！");
}
}
// 3. 准备发送到服务器的请求数据
var requestData = {
userId: userInfo.userId,
action: "update_preferences",
timestamp: new Date().getTime(),
data: {
theme: "light",
notifications: false
}
};
// 验证请求数据
var requestValidation = validateObject(requestData, {
userId: {required: true, type: "string"},
action: {required: true, type: "string"},
timestamp: function(value) {
return typeof value === "number" && value > 0;
}
});
printl("\n3. 请求数据验证:");
printl(" 验证结果: " + (requestValidation.isValid ? "通过" : "失败"));
if (requestValidation.isValid) {
printl(" 请求数据: " + safeStringify(requestData));
// 在实际项目中，这里会调用okHttp等网络库发送请求
// printl(" 正在发送请求...");
}
}
// 运行AIWROK项目应用示例
aiwrokProjectExample();

复制代码