安卓脚本类型判断与Boolean对象综合示例 - B2B网络软件

/**
* 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) === '[object Object]') 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[i];
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 = [1, 2, 3]; // 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 ([1,2,3]): ' + 类型.判断类型(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[i];
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[i];
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 = [1, 2, null, 4, undefined, 6, "text", true, false, 0];
console.log('原始数组: [' + items.join(', ') + ']');
// 过滤出有效数字
var validNumbers = [];
for (var i = 0; i < items.length; i++) {
var item = items[i];
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[i];
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 = [1, 2, 3]; // 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 ([1,2,3]): ' + 类型.判断类型(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[j];
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[k];
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 = [1, 2, null, 4, undefined, 6, "text"];
console.log('原始数组: [' + items.join(', ') + ']');
var validNumbers = [];
for (var m = 0; m < items.length; m++) {
var item = items[m];
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();
}
}

复制代码