万能营销软件脚本 › »AIWORK源码分享 › 安卓脚本类型判断与Boolean对象综合示例

YYPOST群发软件 发表于 2026-4-16 09:32:35

安卓脚本类型判断与Boolean对象综合示例

安卓脚本类型判断与Boolean对象综合示例








/**
* JavaScript类型判断与Boolean对象综合示例 - H5日志显示版
* 演示如何在H5界面中实时显示JavaScript类型判断的运行过程
*/

// ==========================================
// 第一部分：定义类型判断工具
// ==========================================

var 类型 = {};

/**
* 判断变量数据是什么类型
* @param {任意} use
* @returns {字符串|null} 成功:返回对应类型单词,失败:null
*/
类型.判断类型 = function (use) {
    switch (typeof (use)) {
      case 'undefined':
            return 'undefined';
      case 'number':
            return 'number';
      case 'string':
            return 'string';
      case 'boolean':
            return 'boolean';
      default:
            if (Array.isArray(use)) return 'Array';
            if (Object.prototype.toString.call(use) === '') return 'Object';
    }
};

// ==========================================
// 第二部分：H5日志输出函数
// ==========================================



// ==========================================
// 第三部分：Boolean方法综合示例
// ==========================================

/**
* Boolean构造函数引用示例
*/
function booleanConstructor示例() {
    console.log('=== Boolean构造函数引用示例 ===');
   
    var myBool = new Boolean(true);
    console.log('创建布尔对象: new Boolean(true)');
    console.log('构造函数引用: ' + myBool.constructor);
    console.log('构造函数检查: ' + (myBool.constructor === Boolean));
    console.log('');
}

/**
* Boolean转字符串示例
*/
function booleanToString示例() {
    console.log('=== Boolean转字符串示例 ===');
   
    var boolTrue = new Boolean(true);
    var boolFalse = new Boolean(false);
   
    var strTrue = boolTrue.toString();
    var strFalse = boolFalse.toString();
   
    console.log('true 转换为字符串: "' + strTrue + '"');
    console.log('false 转换为字符串: "' + strFalse + '"');
   
    var boolNum = new Boolean(1);
    var boolStr = new Boolean("");
   
    console.log('Boolean(1) 转换为字符串: "' + boolNum.toString() + '"');
    console.log('Boolean("") 转换为字符串: "' + boolStr.toString() + '"');
    console.log('');
}

/**
* Boolean.valueOf获取原始值示例
*/
function booleanValueOf示例() {
    console.log('=== Boolean.valueOf获取原始值示例 ===');
   
    var testCases = [
      { value: 1, desc: '数字1' },
      { value: 0, desc: '数字0' },
      { value: null, desc: 'null' },
      { value: undefined, desc: 'undefined' },
      { value: "hello", desc: '非空字符串"hello"' },
      { value: "", desc: '空字符串""' }
    ];
   
    for (var i = 0; i < testCases.length; i++) {
      var testCase = testCases;
      var boolObj = new Boolean(testCase.value);
      var primitiveValue = boolObj.valueOf();
      
      console.log(testCase.desc + ' -> ' + primitiveValue);
    }
    console.log('');
}

/**
* Boolean原型扩展示例
*/
function booleanPrototype扩展示例() {
    console.log('=== Boolean原型扩展示例 ===');
   
    // 扩展 Boolean 的原型，添加一个名为 myColor 的方法
    Boolean.prototype.myColor = function () {
      if (this.valueOf() === true) {
            this.color = "green"; // 如果布尔值为 true，设置颜色为绿色
      } else {
            this.color = "red"; // 如果布尔值为 false，设置颜色为红色
      }
    };
   
    var a = new Boolean(1); // 创建时传入 1，相当于 true
    a.myColor(); // 调用 myColor 方法
    var b = a.color; // 结果为 "green"
    console.log('Boolean(1).myColor() -> 颜色: ' + b);
   
    var c = new Boolean(0); // 创建时传入 0，相当于 false
    c.myColor(); // 调用 myColor 方法
    var d = c.color; // 结果为 "red"
    console.log('Boolean(0).myColor() -> 颜色: ' + d);
    console.log('');
}

// ==========================================
// 第四部分：类型判断综合示例
// ==========================================

/**
* 类型判断基础示例
*/
function 类型判断基础示例() {
    console.log('=== 类型判断基础示例 ===');
   
    var a; // undefined
    var b = 1223; // number
    var c = 'abcd'; // string
    var d = true; // boolean
    var e = ; // Array
    var f = {a: 10, b: 20}; // Object
   
    console.log('变量 a (未定义): ' + 类型.判断类型(a));
    console.log('变量 b (1223): ' + 类型.判断类型(b));
    console.log('变量 c ("abcd"): ' + 类型.判断类型(c));
    console.log('变量 d (true): ' + 类型.判断类型(d));
    console.log('变量 e (): ' + 类型.判断类型(e));
    console.log('变量 f ({a:10,b:20}): ' + 类型.判断类型(f));
    console.log('');
}

/**
* 复杂数据类型判断示例
*/
function 复杂类型判断示例() {
    console.log('=== 复杂数据类型判断示例 ===');
   
    var testCases = [
      { value: null, desc: 'null' },
      { value: NaN, desc: 'NaN' },
      { value: Infinity, desc: 'Infinity' },
      { value: [], desc: '空数组[]' },
      { value: {}, desc: '空对象{}' },
      { value: function(){}, desc: '函数' },
      { value: new Date(), desc: 'Date对象' },
      { value: /regex/, desc: '正则表达式' }
    ];
   
    for (var i = 0; i < testCases.length; i++) {
      var testCase = testCases;
      var typeResult = 类型.判断类型(testCase.value);
      console.log(testCase.desc + ' -> ' + (typeResult || '未知类型'));
    }
    console.log('');
}

// ==========================================
// 第五部分：综合应用场景
// ==========================================

/**
* 数据验证场景
*/
function 数据验证场景() {
    console.log('=== 数据验证场景 ===');
   
    function validateInput(value) {
      var isValid = new Boolean(typeof value === "boolean" && (value === true || value === false));
      
      if (isValid.valueOf()) {
            return "✓ 输入是有效的布尔值";
      } else {
            return "✗ 输入无效，必须是布尔值 (当前类型: " + 类型.判断类型(value) + ")";
      }
    }
   
    console.log(validateInput(true));
    console.log(validateInput(false));
    console.log(validateInput("test"));
    console.log(validateInput(123));
    console.log(validateInput(null));
    console.log('');
}

/**
* 任务管理系统示例
*/
function 任务管理系统示例() {
    console.log('=== 任务管理系统示例 ===');
   
    var tasks = [
      { name: '任务1: 学习JavaScript', completed: false },
      { name: '任务2: 理解Boolean对象', completed: true },
      { name: '任务3: 掌握类型判断', completed: true },
      { name: '任务4: H5交互开发', completed: false },
    ];
   
    var completedCount = 0;
    var totalCount = tasks.length;
   
    for (var i = 0; i < tasks.length; i++) {
      var task = tasks;
      if (task.completed) {
            console.log('✓ ' + task.name + ' - 已完成');
            completedCount++;
      } else {
            console.log('○ ' + task.name + ' - 尚未完成');
      }
    }
   
    console.log('');
    console.log('进度: ' + completedCount + '/' + totalCount + ' 任务完成');
    console.log('完成率: ' + ((completedCount / totalCount) * 100).toFixed(1) + '%');
    console.log('');
}

/**
* 数组过滤示例
*/
function 数组过滤示例() {
    console.log('=== 数组过滤示例 ===');
   
    var items = ;
   
    console.log('原始数组: [' + items.join(', ') + ']');
   
    // 过滤出有效数字
    var validNumbers = [];
    for (var i = 0; i < items.length; i++) {
      var item = items;
      var isValidNumber = new Boolean(item !== null && item !== undefined && typeof item === 'number').valueOf();
      if (isValidNumber) {
            validNumbers.push(item);
      }
    }
   
    console.log('有效数字: [' + validNumbers.join(', ') + ']');
    console.log('数量: ' + validNumbers.length + ' 个');
    console.log('');
}

/**
* 条件判断逻辑示例
*/
function 条件判断逻辑示例() {
    console.log('=== 条件判断逻辑示例 ===');
   
    var isLoggedIn = new Boolean(false);
    var hasPermission = true;
    var isAdmin = false;
   
    console.log('登录状态: ' + isLoggedIn.valueOf());
    console.log('权限状态: ' + hasPermission);
    console.log('管理员: ' + isAdmin);
   
    if (isLoggedIn.valueOf() && (hasPermission || isAdmin)) {
      console.log('✓ 用户具有访问权限');
    } else {
      console.log('✗ 用户没有访问权限（未登录）');
    }
   
    // 模拟登录
    isLoggedIn = new Boolean(true);
    console.log('\n--- 模拟登录后 ---');
    console.log('登录状态: ' + isLoggedIn.valueOf());
   
    if (isLoggedIn.valueOf() && (hasPermission || isAdmin)) {
      console.log('✓ 用户具有访问权限');
    } else {
      console.log('✗ 用户没有访问权限');
    }
    console.log('');
}

// ==========================================
// 第六部分：主执行函数
// ==========================================

/**
* 延迟执行函数 - 带倒计时显示
* @param {number} seconds - 延迟秒数
*/
function 延迟执行(seconds) {
    var remaining = seconds;
    while (remaining > 0) {
      console.log('⏱ 等待 ' + remaining + ' 秒...');
      sleep.millisecond(1000);
      remaining--;
    }
}

/**
* 运行所有示例
*/
function 运行所有示例() {
    console.log('╔══════════════════════════════════════╗');
    console.log('   JavaScript类型判断综合示例系统');
    console.log('   开始时间: ' + new Date().toLocaleTimeString());
    console.log('╚══════════════════════════════════════╝');
    console.log('');
   
    // Boolean相关示例
    booleanConstructor示例();
    延迟执行(2);
   
    booleanToString示例();
    延迟执行(2);
   
    booleanValueOf示例();
    延迟执行(2);
   
    booleanPrototype扩展示例();
    延迟执行(2);
   
    // 类型判断示例
    类型判断基础示例();
    延迟执行(2);
   
    复杂类型判断示例();
    延迟执行(2);
   
    // 综合应用场景
    数据验证场景();
    延迟执行(2);
   
    任务管理系统示例();
    延迟执行(2);
   
    数组过滤示例();
    延迟执行(2);
   
    条件判断逻辑示例();
   
    console.log('╔══════════════════════════════════════╗');
    console.log('   所有示例执行完毕');
    console.log('   结束时间: ' + new Date().toLocaleTimeString());
    console.log('╚══════════════════════════════════════╝');
}

// ==========================================
// 主函数入口 - 供start.js调用
// ==========================================

/**
* 主函数入口
*/
function main() {
    // 使用try-catch确保错误不会阻塞
    try {
      console.log('╔══════════════════════════════════════╗');
      console.log('   JavaScript类型判断综合示例系统');
      console.log('   开始时间: ' + new Date().toLocaleTimeString());
      console.log('╚══════════════════════════════════════╝');
      console.log('');
      
      // Boolean相关示例
      console.log('=== Boolean构造函数引用示例 ===');
      var myBool = new Boolean(true);
      console.log('创建布尔对象: new Boolean(true)');
      console.log('构造函数检查: ' + (myBool.constructor === Boolean));
      console.log('');
      
      console.log('⏱ 等待 2 秒...');
      sleep.millisecond(2000);
      
      console.log('=== Boolean转字符串示例 ===');
      var boolTrue = new Boolean(true);
      var boolFalse = new Boolean(false);
      console.log('true 转换为字符串: "' + boolTrue.toString() + '"');
      console.log('false 转换为字符串: "' + boolFalse.toString() + '"');
      console.log('');
      
      console.log('⏱ 等待 2 秒...');
      sleep.millisecond(2000);
      
      console.log('=== Boolean.valueOf示例 ===');
      var testCases = [
            { value: 1, desc: '数字1' },
            { value: 0, desc: '数字0' },
            { value: null, desc: 'null' },
            { value: undefined, desc: 'undefined' }
      ];
      for (var i = 0; i < testCases.length; i++) {
            var testCase = testCases;
            var boolObj = new Boolean(testCase.value);
            console.log(testCase.desc + ' -> ' + boolObj.valueOf());
      }
      console.log('');
      
      console.log('⏱ 等待 2 秒...');
      sleep.millisecond(2000);
      
      console.log('=== Boolean原型扩展示例 ===');
      Boolean.prototype.myColor = function () {
            return this.valueOf() === true ? "green" : "red";
      };
      var a = new Boolean(1);
      console.log('Boolean(1).myColor() -> ' + a.myColor());
      var c = new Boolean(0);
      console.log('Boolean(0).myColor() -> ' + c.myColor());
      console.log('');
      
      console.log('⏱ 等待 2 秒...');
      sleep.millisecond(2000);
      
      // 类型判断示例
      console.log('=== 类型判断基础示例 ===');
      var testA; // undefined
      var testB = 1223; // number
      var testC = 'abcd'; // string
      var testD = true; // boolean
      var testE = ; // Array
      var testF = {a: 10, b: 20}; // Object
      
      console.log('变量 a (未定义): ' + 类型.判断类型(testA));
      console.log('变量 b (1223): ' + 类型.判断类型(testB));
      console.log('变量 c ("abcd"): ' + 类型.判断类型(testC));
      console.log('变量 d (true): ' + 类型.判断类型(testD));
      console.log('变量 e (): ' + 类型.判断类型(testE));
      console.log('变量 f ({a:10,b:20}): ' + 类型.判断类型(testF));
      console.log('');
      
      console.log('⏱ 等待 2 秒...');
      sleep.millisecond(2000);
      
      console.log('=== 复杂类型判断示例 ===');
      var complexCases = [
            { value: null, desc: 'null' },
            { value: NaN, desc: 'NaN' },
            { value: Infinity, desc: 'Infinity' },
            { value: [], desc: '空数组[]' },
            { value: {}, desc: '空对象{}' }
      ];
      for (var j = 0; j < complexCases.length; j++) {
            var complexCase = complexCases;
            var typeResult = 类型.判断类型(complexCase.value);
            console.log(complexCase.desc + ' -> ' + (typeResult || '未知类型'));
      }
      console.log('');
      
      console.log('⏱ 等待 2 秒...');
      sleep.millisecond(2000);
      
      // 综合应用场景
      console.log('=== 数据验证场景 ===');
      function validateInput(value) {
            var isValid = typeof value === "boolean";
            return isValid ? "✓ 有效的布尔值" : "✗ 无效 (当前类型: " + 类型.判断类型(value) + ")";
      }
      console.log(validateInput(true));
      console.log(validateInput(false));
      console.log(validateInput("test"));
      console.log(validateInput(123));
      console.log('');
      
      console.log('⏱ 等待 2 秒...');
      sleep.millisecond(2000);
      
      console.log('=== 任务管理系统示例 ===');
      var tasks = [
            { name: '任务1: 学习JavaScript', completed: false },
            { name: '任务2: 理解Boolean对象', completed: true },
            { name: '任务3: 掌握类型判断', completed: true }
      ];
      var completedCount = 0;
      for (var k = 0; k < tasks.length; k++) {
            var task = tasks;
            if (task.completed) {
                console.log('✓ ' + task.name + ' - 已完成');
                completedCount++;
            } else {
                console.log('○ ' + task.name + ' - 尚未完成');
            }
      }
      console.log('进度: ' + completedCount + '/' + tasks.length + ' 任务完成');
      console.log('');
      
      console.log('⏱ 等待 2 秒...');
      sleep.millisecond(2000);
      
      console.log('=== 数组过滤示例 ===');
      var items = ;
      console.log('原始数组: [' + items.join(', ') + ']');
      var validNumbers = [];
      for (var m = 0; m < items.length; m++) {
            var item = items;
            if (item !== null && item !== undefined && typeof item === 'number') {
                validNumbers.push(item);
            }
      }
      console.log('有效数字: [' + validNumbers.join(', ') + ']');
      console.log('');
      
      console.log('⏱ 等待 2 秒...');
      sleep.millisecond(2000);
      
      console.log('=== 条件判断逻辑示例 ===');
      var isLoggedIn = false;
      var hasPermission = true;
      console.log('登录状态: ' + isLoggedIn);
      console.log('权限状态: ' + hasPermission);
      if (isLoggedIn && hasPermission) {
            console.log('✓ 用户具有访问权限');
      } else {
            console.log('✗ 用户没有访问权限（未登录）');
      }
      console.log('');
      
      console.log('╔══════════════════════════════════════╗');
      console.log('   所有示例执行完毕');
      console.log('   结束时间: ' + new Date().toLocaleTimeString());
      console.log('╚══════════════════════════════════════╝');
    } catch(e) {
      // 错误处理 - 优先使用ERR
      if (typeof LogManagerH5 !== 'undefined' && typeof LogManagerH5.ERR === 'function') {
            LogManagerH5.ERR('执行出错: ' + e.message);
      } else if (typeof LogManagerH5 !== 'undefined' && typeof LogManagerH5.error === 'function') {
            LogManagerH5.error('执行出错: ' + e.message);
      }
      if (typeof printl !== 'undefined') {
            printl('错误: ' + e.message);
      }
    }
}

// 只在直接运行时执行，Import时不执行
// 通过检查 global.web1 判断是否通过start.js导入
if (typeof global !== 'undefined' && global.web1) {
    // 通过start.js导入，不自动执行
    console.log('主脚本已加载，等待start.js调用...');
} else {
    // 直接运行此脚本
    if (typeof main === 'function') {
      main();
    }
}

查看完整版本: 安卓脚本类型判断与Boolean对象综合示例