安卓脚本多变的function用法 - B2B网络软件

//🍎交流QQ群711841924群一，苹果内测群，528816639
/**
* =============================================================================
* AIWROK 高级函数封装库 - 实用案例集
* =============================================================================
* 本文件展示更复杂、多变的 function 用法，包括：
* 1. 闭包与私有变量
* 2. 高阶函数与函数组合
* 3. 递归与记忆化
* 4. 工厂模式与构造函数
* 5. 异步处理与回调
* 6. 装饰器模式
* 7. 观察者模式
* 8. 链式调用
*/
// =============================================================================
// 1. 闭包与私有变量 - 创建安全的计数器
// =============================================================================
/**
* 创建安全计数器（使用闭包保护内部状态）
* @returns {Object} 计数器对象
*/
function createSecureCounter() {
var count = 0; // 私有变量
return {
increment: function() {
count++;
console.log('计数器增加: ' + count);
return count;
},
decrement: function() {
if (count > 0) {
count--;
console.log('计数器减少: ' + count);
} else {
console.log('计数器已为最小值');
}
return count;
},
getCount: function() {
return count;
},
reset: function() {
count = 0;
console.log('计数器重置');
return count;
}
};
}
// =============================================================================
// 2. 高阶函数 - 函数作为参数和返回值
// =============================================================================
/**
* 通用重试机制（高阶函数）
* @param {Function} fn - 要执行的函数
* @param {number} maxRetries - 最大重试次数
* @param {number} delay - 重试间隔(毫秒)
* @returns {*} 函数执行结果
*/
function withRetry(fn, maxRetries, delay) {
var attempts = 0;
function execute() {
attempts++;
try {
console.log('尝试执行第 ' + attempts + ' 次...');
var result = fn();
console.log('执行成功！');
return result;
} catch (e) {
console.log('执行失败: ' + e.message);
if (attempts < maxRetries) {
console.log(delay + 'ms 后重试...');
Sleeper.millisecond(delay);
return execute();
} else {
throw new Error('达到最大重试次数: ' + maxRetries);
}
}
}
return execute();
}
/**
* 函数组合器（类似数学中的 f(g(x))）
* @param {...Function} functions - 要组合的函数列表
* @returns {Function} 组合后的函数
*/
function compose() {
var funcs = Array.prototype.slice.call(arguments);
return function(value) {
var result = value;
for (var i = funcs.length - 1; i >= 0; i--) {
result = funcs[i](result);
}
return result;
};
}
/**
* 管道函数（从左到右执行）
* @param {...Function} functions - 要管道的函数列表
* @returns {Function} 管道后的函数
*/
function pipe() {
var funcs = Array.prototype.slice.call(arguments);
return function(value) {
var result = value;
for (var i = 0; i < funcs.length; i++) {
result = funcs[i](result);
}
return result;
};
}
// =============================================================================
// 3. 递归与记忆化 - 优化重复计算
// =============================================================================
/**
* 带记忆化的斐波那契数列计算
* @param {number} n - 第n个斐波那契数
* @returns {number} 斐波那契数值
*/
function fibonacciMemoized() {
var cache = {}; // 缓存对象
function fib(n) {
if (n in cache) {
return cache[n];
}
if (n <= 1) {
return n;
}
cache[n] = fib(n - 1) + fib(n - 2);
return cache[n];
}
return fib;
}
/**
* 递归目录遍历（模拟）
* @param {string} path - 路径
* @param {number} depth - 当前深度
* @param {number} maxDepth - 最大深度
*/
function traverseDirectory(path, depth, maxDepth) {
if (depth > maxDepth) {
return;
}
console.log(' '.repeat(depth) + '├── ' + path);
// 模拟子目录
var subDirs = ['docs', 'src', 'config'];
for (var i = 0; i < subDirs.length; i++) {
traverseDirectory(path + '/' + subDirs[i], depth + 1, maxDepth);
}
}
// =============================================================================
// 4. 工厂模式 - 动态创建对象
// =============================================================================
/**
* UI组件工厂
* @returns {Object} 组件工厂对象
*/
function createUIFactory() {
var components = {};
return {
/**
* 注册组件模板
* @param {string} name - 组件名称
* @param {Function} template - 组件模板函数
*/
register: function(name, template) {
components[name] = template;
console.log('组件 [' + name + '] 已注册');
},
/**
* 创建组件实例
* @param {string} name - 组件名称
* @param {Object} options - 配置选项
* @returns {Object} 组件实例
*/
create: function(name, options) {
if (!components[name]) {
throw new Error('未找到组件: ' + name);
}
console.log('创建组件 [' + name + ']');
return components[name](options);
},
/**
* 获取所有已注册组件
* @returns {Array} 组件名称列表
*/
getRegisteredComponents: function() {
return Object.keys(components);
}
};
}
/**
* 按钮组件模板
* @param {Object} options - 配置选项
* @returns {Object} 按钮对象
*/
function buttonTemplate(options) {
return {
type: 'button',
text: options.text || '按钮',
onClick: options.onClick || function() {},
render: function() {
console.log('[按钮] ' + this.text);
}
};
}
/**
* 输入框组件模板
* @param {Object} options - 配置选项
* @returns {Object} 输入框对象
*/
function inputTemplate(options) {
return {
type: 'input',
placeholder: options.placeholder || '请输入...',
value: '',
onChange: options.onChange || function() {},
render: function() {
console.log('[输入框] 占位符: ' + this.placeholder);
}
};
}
// =============================================================================
// 5. 异步处理 - 模拟异步操作
// =============================================================================
/**
* 异步任务管理器
* @returns {Object} 任务管理器
*/
function createAsyncManager() {
var tasks = [];
var isRunning = false;
return {
/**
* 添加任务
* @param {Function} task - 任务函数
* @param {string} name - 任务名称
*/
addTask: function(task, name) {
tasks.push({
func: task,
name: name || ('Task_' + tasks.length),
status: 'pending'
});
console.log('任务 [' + name + '] 已添加');
},
/**
* 顺序执行所有任务
*/
runSequentially: function() {
if (isRunning) {
console.log('任务正在运行中...');
return;
}
isRunning = true;
console.log('========== 开始顺序执行任务 ==========');
for (var i = 0; i < tasks.length; i++) {
var task = tasks[i];
console.log('执行任务 [' + task.name + '] (' + (i + 1) + '/' + tasks.length + ')');
try {
task.func();
task.status = 'completed';
console.log('✓ 任务 [' + task.name + '] 完成');
} catch (e) {
task.status = 'failed';
console.log('✗ 任务 [' + task.name + '] 失败: ' + e.message);
}
Sleeper.millisecond(500); // 模拟延迟
}
isRunning = false;
console.log('========== 所有任务执行完毕 ==========');
},
/**
* 获取任务状态
* @returns {Array} 任务状态列表
*/
getStatus: function() {
return tasks.map(function(task) {
return {
name: task.name,
status: task.status
};
});
}
};
}
// =============================================================================
// 6. 装饰器模式 - 增强函数功能
// =============================================================================
/**
* 日志装饰器
* @param {Function} fn - 原函数
* @param {string} name - 函数名称
* @returns {Function} 装饰后的函数
*/
function withLogging(fn, name) {
return function() {
console.log('>>> 调用函数: ' + name);
console.log(' 参数: ' + JSON.stringify(Array.prototype.slice.call(arguments)));
var start = new Date().getTime();
var result = fn.apply(this, arguments);
var duration = new Date().getTime() - start;
console.log('<<< 函数 ' + name + ' 执行完成，耗时: ' + duration + 'ms');
console.log(' 返回值: ' + JSON.stringify(result));
return result;
};
}
/**
* 缓存装饰器
* @param {Function} fn - 原函数
* @returns {Function} 带缓存的函数
*/
function withCaching(fn) {
var cache = {};
return function() {
var key = JSON.stringify(Array.prototype.slice.call(arguments));
if (key in cache) {
console.log('命中缓存: ' + key);
return cache[key];
}
console.log('计算并缓存: ' + key);
var result = fn.apply(this, arguments);
cache[key] = result;
return result;
};
}
/**
* 节流装饰器
* @param {Function} fn - 原函数
* @param {number} delay - 延迟时间(毫秒)
* @returns {Function} 节流后的函数
*/
function throttle(fn, delay) {
var lastCall = 0;
return function() {
var now = new Date().getTime();
if (now - lastCall >= delay) {
lastCall = now;
return fn.apply(this, arguments);
} else {
console.log('节流: 忽略调用');
}
};
}
// =============================================================================
// 7. 观察者模式 - 事件系统
// =============================================================================
/**
* 创建事件总线
* @returns {Object} 事件总线对象
*/
function createEventBus() {
var listeners = {};
return {
/**
* 订阅事件
* @param {string} event - 事件名称
* @param {Function} callback - 回调函数
*/
on: function(event, callback) {
if (!listeners[event]) {
listeners[event] = [];
}
listeners[event].push(callback);
console.log('订阅事件: ' + event);
},
/**
* 取消订阅
* @param {string} event - 事件名称
* @param {Function} callback - 回调函数
*/
off: function(event, callback) {
if (!listeners[event]) return;
var index = listeners[event].indexOf(callback);
if (index > -1) {
listeners[event].splice(index, 1);
console.log('取消订阅事件: ' + event);
}
},
/**
* 发布事件
* @param {string} event - 事件名称
* @param {*} data - 事件数据
*/
emit: function(event, data) {
if (!listeners[event]) {
console.log('无监听者: ' + event);
return;
}
console.log('发布事件: ' + event);
listeners[event].forEach(function(callback) {
try {
callback(data);
} catch (e) {
console.log('事件回调错误: ' + e.message);
}
});
},
/**
* 一次性订阅
* @param {string} event - 事件名称
* @param {Function} callback - 回调函数
*/
once: function(event, callback) {
var self = this;
var wrapper = function(data) {
callback(data);
self.off(event, wrapper);
};
this.on(event, wrapper);
}
};
}
// =============================================================================
// 8. 链式调用 - 流畅API
// =============================================================================
/**
* 创建字符串处理器（支持链式调用）
* @param {string} str - 初始字符串
* @returns {Object} 处理器对象
*/
function createStringProcessor(str) {
var value = str || '';
return {
/**
* 转大写
* @returns {Object} 自身（支持链式调用）
*/
toUpperCase: function() {
value = value.toUpperCase();
return this;
},
/**
* 转小写
* @returns {Object} 自身
*/
toLowerCase: function() {
value = value.toLowerCase();
return this;
},
/**
* 去除空格
* @returns {Object} 自身
*/
trim: function() {
value = value.trim();
return this;
},
/**
* 替换文本
* @param {string} search - 搜索文本
* @param {string} replace - 替换文本
* @returns {Object} 自身
*/
replace: function(search, replace) {
value = value.replace(new RegExp(search, 'g'), replace);
return this;
},
/**
* 追加文本
* @param {string} text - 追加文本
* @returns {Object} 自身
*/
append: function(text) {
value += text;
return this;
},
/**
* prepend 文本
* @param {string} text - 前置文本
* @returns {Object} 自身
*/
prepend: function(text) {
value = text + value;
return this;
},
/**
* 获取结果
* @returns {string} 处理后的字符串
*/
getResult: function() {
return value;
},
/**
* 打印结果
* @returns {Object} 自身
*/
log: function() {
console.log('当前值: "' + value + '"');
return this;
}
};
}
// =============================================================================
// 工具函数
// =============================================================================
/**
* 延迟工具函数
*/
var Sleeper = {
millisecond: function(ms) {
var start = new Date().getTime();
while (new Date().getTime() - start < ms) {
// 等待
}
},
second: function(seconds) {
this.millisecond(seconds * 1000);
}
};
/**
* 倒计时显示函数
* @param {number} seconds - 倒计时秒数
* @param {string} prefix - 前缀文本
*/
function countdown(seconds, prefix) {
prefix = prefix || '等待';
for (var i = seconds; i > 0; i--) {
console.log(prefix + '... ' + i + '秒');
Sleeper.second(1);
}
console.log(prefix + '... 开始！');
Sleeper.millisecond(500); // 短暂停顿
}
// =============================================================================
// 演示函数
// =============================================================================
/**
* 演示1: 闭包计数器
*/
function demoClosure() {
countdown(2, '【演示1】即将开始');
console.log('========== 演示1: 闭包计数器 ==========');
var counter = createSecureCounter();
counter.increment();
counter.increment();
counter.increment();
console.log('当前计数: ' + counter.getCount());
counter.decrement();
counter.reset();
console.log('');
}
/**
* 演示2: 高阶函数
*/
function demoHigherOrder() {
countdown(2, '【演示2】即将开始');
console.log('========== 演示2: 高阶函数 ==========');
// 重试机制
var successCount = 0;
var retryResult = withRetry(function() {
successCount++;
if (successCount < 3) {
throw new Error('模拟失败');
}
return '成功!';
}, 5, 100);
console.log('重试结果: ' + retryResult);
// 函数组合
var addOne = function(x) { return x + 1; };
var multiplyTwo = function(x) { return x * 2; };
var composed = compose(multiplyTwo, addOne);
console.log('组合函数结果 (先+1再*2): ' + composed(5)); // (5+1)*2 = 12
// 管道
var piped = pipe(addOne, multiplyTwo);
console.log('管道函数结果 (先+1再*2): ' + piped(5)); // (5+1)*2 = 12
console.log('');
}
/**
* 演示3: 递归与记忆化
*/
function demoRecursion() {
countdown(2, '【演示3】即将开始');
console.log('========== 演示3: 递归与记忆化 ==========');
var fib = fibonacciMemoized();
console.log('斐波那契数列前10项:');
for (var i = 0; i < 10; i++) {
console.log(' F(' + i + ') = ' + fib(i));
}
console.log('\n目录遍历示例:');
traverseDirectory('root', 0, 2);
console.log('');
}
/**
* 演示4: 工厂模式
*/
function demoFactory() {
countdown(2, '【演示4】即将开始');
console.log('========== 演示4: 工厂模式 ==========');
var factory = createUIFactory();
factory.register('button', buttonTemplate);
factory.register('input', inputTemplate);
var btn = factory.create('button', {
text: '提交',
onClick: function() { console.log('按钮被点击'); }
});
btn.render();
var inp = factory.create('input', {
placeholder: '请输入用户名'
});
inp.render();
console.log('已注册组件: ' + factory.getRegisteredComponents().join(', '));
console.log('');
}
/**
* 演示5: 异步任务管理
*/
function demoAsync() {
countdown(2, '【演示5】即将开始');
console.log('========== 演示5: 异步任务管理 ==========');
var manager = createAsyncManager();
manager.addTask(function() {
console.log(' 任务1: 初始化数据');
}, '初始化');
manager.addTask(function() {
console.log(' 任务2: 加载配置');
}, '加载配置');
manager.addTask(function() {
console.log(' 任务3: 连接服务器');
}, '连接服务器');
manager.runSequentially();
var status = manager.getStatus();
console.log('任务状态:');
status.forEach(function(s) {
console.log(' ' + s.name + ': ' + s.status);
});
console.log('');
}
/**
* 演示6: 装饰器模式
*/
function demoDecorator() {
countdown(2, '【演示6】即将开始');
console.log('========== 演示6: 装饰器模式 ==========');
// 日志装饰
var originalFunc = function(a, b) {
return a + b;
};
var loggedFunc = withLogging(originalFunc, '加法函数');
var result = loggedFunc(10, 20);
console.log('结果: ' + result);
// 缓存装饰
var expensiveCalc = function(n) {
Sleeper.millisecond(100); // 模拟耗时计算
return n * n;
};
var cachedCalc = withCaching(expensiveCalc);
console.log('第一次调用:');
cachedCalc(5);
console.log('第二次调用（应命中缓存）:');
cachedCalc(5);
console.log('');
}
/**
* 演示7: 观察者模式
*/
function demoObserver() {
countdown(2, '【演示7】即将开始');
console.log('========== 演示7: 观察者模式 ==========');
var bus = createEventBus();
// 订阅事件
bus.on('dataUpdate', function(data) {
console.log(' 监听者1收到数据: ' + JSON.stringify(data));
});
bus.on('dataUpdate', function(data) {
console.log(' 监听者2收到数据: ' + JSON.stringify(data));
});
// 一次性订阅
bus.once('onceEvent', function(data) {
console.log(' 一次性监听者收到: ' + data);
});
// 发布事件
bus.emit('dataUpdate', { value: 100, timestamp: new Date().getTime() });
bus.emit('onceEvent', '测试数据');
bus.emit('onceEvent', '再次触发（应该无响应）');
console.log('');
}
/**
* 演示8: 链式调用
*/
function demoChaining() {
countdown(2, '【演示8】即将开始');
console.log('========== 演示8: 链式调用 ==========');
var result = createStringProcessor(' hello world ')
.trim()
.toUpperCase()
.replace('WORLD', 'AIWROK')
.append(' - 欢迎使用')
.prepend('【')
.append('】')
.log()
.getResult();
console.log('最终结果: ' + result);
console.log('');
}
/**
* 主函数 - 运行所有演示
*/
function main() {
console.log('========================================');
console.log(' AIWROK 高级函数封装库 - 实用案例集');
console.log('========================================');
console.log('');
countdown(2, '程序启动');
demoClosure();
demoHigherOrder();
demoRecursion();
demoFactory();
demoAsync();
demoDecorator();
demoObserver();
demoChaining();
console.log('========================================');
console.log(' 所有演示已完成！');
console.log('========================================');
}
// 执行主函数
main();

复制代码