JavaScript字符串、数组和数字的健壮判空方法

一、隐式类型转换的致命陷阱与判空误区

在 ECMAScript 规范中，当一个表达式处于条件求值上下文（例如 if 语句或逻辑非运算符 !）时，JavaScript 引擎会在内部调用抽象操作 ToBoolean(argument)。根据规范定义，只有以下八个值为假值（Falsy）：false、0、-0、0n、""（空字符串）、null、undefined 和 NaN。除此以外的所有值均为真值（Truthy）。

这种隐式转换规则在日常判空场景中会引发两类致命错误：

• 误杀合法数据：数字 0 在统计、金额、折扣、分页索引（page=0）等场景中是合法的有效数值。使用 if (!count) 会将 0 误判为“未输入”或“空值”，导致系统使用默认值覆盖用户输入。
• 漏判空数据结构：在 JavaScript 中，任何对象（Object）在布尔转换时都为真值。空数组 [] 作为 Array 实例，其 Boolean([]) === true，因此 if (!arr) 根本无法拦截空数组；同理，未做修剪的空格字符串 " " 也会被视作真值。

二、字符串（String）的健壮判空

在前端表单采集、URL 参数解析及后端接口校验中，业务对“空字符串”的定义通常包含两个层次：一是物理空值（null 或 undefined），二是视觉上的空文本（空字符串 "" 以及全由空格、制表符组成的字符序列 " "）。

1. 常见的错误实现与运行时崩溃

初学者常写出 str === "" 或直接调用 str.trim() === ""。如果传入参数由于接口缺失或异常变为了 null、undefined 或数字类型，直接调用 .trim() 将立刻抛出未捕获的运行时异常：TypeError: str.trim is not a function，导致整个页面或调用链崩溃。

2. 规范的字符串判空实现

健壮的字符串判空必须遵循“先确权类型，再调用方法”的原则。先通过 typeof 运算符确认变量为字符串原生类型，再执行空白符裁剪并校验字符长度：

/**
 * 校验目标是否为空字符串
 * @param {unknown} val 待检测值
 * @param {boolean} trimWhitespace 是否剔除首尾空白字符，默认为 true
 * @returns {boolean} true 表示为空；false 表示包含有效字符串内容
 */
function isEmptyString(val, trimWhitespace = true) {
  // 1. 排除 null 和 undefined
  if (val === null || val === undefined) {
    return true;
  }
  // 2. 类型守卫：非字符串类型直接视为空或非法
  if (typeof val !== 'string') {
    return true;
  }
  // 3. 按业务需求进行 trim 后检验长度
  const target = trimWhitespace ? val.trim() : val;
  return target.length === 0;
}

/**
 * 校验目标是否为非空有效字符串（类型守卫辅助函数）
 */
function isNonEmptyString(val, trimWhitespace = true) {
  return typeof val === 'string' && (trimWhitespace ? val.trim().length > 0 : val.length > 0);
}

三、数组（Array）的健壮判空

数组判空的关键在于解决两层逻辑：首先必须确认为合法的数组实例，其次确认数组内部含有元素。

1. 为什么 typeof arr === 'object' 不够安全？

在 JavaScript 中，typeof null 和 typeof [] 都会返回 "object"。若采用 typeof arr === 'object' && arr.length === 0，当 arr 为 null 时依然会抛出读取属性的异常，并且像 DOM NodeList、函数的 arguments 对象或普通自定义对象 { length: 0 } 也会产生混淆。

2. 使用 Array.isArray 进行类型收窄

ECMAScript 5.1 引入的 Array.isArray() 是跨 iframe / 跨执行上下文最安全、最标准的数组检测机制。结合 length 属性即可构成两级防御：

/**
 * 校验目标是否为空数组
 * @param {unknown} val 待检测值
 * @param {boolean} deepCheck 是否进行全项空值深度检测，默认为 false
 * @returns {boolean} true 为空数组或非数组；false 为非空数组
 */
function isEmptyArray(val, deepCheck = false) {
  // 1. 类型确认
  if (!Array.isArray(val)) {
    return true;
  }
  // 2. 浅层长度校验
  if (val.length === 0) {
    return true;
  }
  // 3. 可选：深度全项空值排查（例如 [null, undefined, ""] 业务视为空）
  if (deepCheck) {
    return val.every(item => {
      if (item === null || item === undefined) return true;
      if (typeof item === 'string') return item.trim().length === 0;
      if (Array.isArray(item)) return isEmptyArray(item, true);
      return false;
    });
  }
  return false;
}

/**
 * 校验是否为非空数组（包含至少一个有效元素）
 */
function isNonEmptyArray(val) {
  return Array.isArray(val) && val.length > 0;
}

四、数字（Number）的“判空”与有效性校验

在严格的计算机语言类型理论中，基本数字类型只有数值大小，并不存在物理意义上的“空”。然而在日常业务开发（尤其是表单数据校验、财务计算、参数传递）中，所谓的“数字判空”通常是指：判断该变量是否未提供，或者是否处于非法的异常数值状态。

1. 严禁使用 if (!num) 校验数字

当业务字段为商品库存、折扣率、比赛得分或坐标偏移时，0 是十分核心的有效数据。执行 if (!num) 会将 0 归为假值，引发严重缺陷：

// 错误示例：将折扣 0 判定为“未打折/无折扣”
function applyDiscount(price, discountRate) {
  if (!discountRate) {
    discountRate = 1.0; // 严重 Bug：当用户传入 0（免单）时，被重置为 1.0（全价）
  }
  return price * discountRate;
}

2. 使用 Number.isFinite() 排除 NaN 与无穷大

对于数字变量，判定其是否为“有效非空数字”应包含以下几项：

• 不能为 null 或 undefined；
• 类型必须为 number；
• 不能为 NaN（算术运算失败标记）；
• 不能为正负无穷大（Infinity / -Infinity，除零或溢出产生）。

使用原生内置的 Number.isFinite() 方法（注意不要使用全局的 isFinite()，全局版本会对参数进行隐式类型转换，而 Number.isFinite() 不会进行转换，只有参数确实为有限数字类型时才返回 true）：

/**
 * 校验变量是否为有效的非空数字
 * @param {unknown} val 待检测值
 * @returns {boolean} 只有有限有效数字（包含 0、负数）才返回 true
 */
function isValidNumber(val) {
  return typeof val === 'number' && Number.isFinite(val);
}

/**
 * 校验表单/字符串输入中解析出的数字是否有效
 * 规避 Number("") === 0 的隐式转换缺陷
 */
function isValidNumericInput(val) {
  if (val === null || val === undefined) return false;
  if (typeof val === 'number') return Number.isFinite(val);
  if (typeof val === 'string') {
    const cleanStr = val.trim();
    if (cleanStr === '') return false; // 必须先行拦截空串！
    const parsed = Number(cleanStr);
    return Number.isFinite(parsed);
  }
  return false;
}

五、工程化实践：通用安全判空函数的封装

在大型业务系统或公用工具库中，除了单独调用各自类型的判空函数外，通常还需要一个集中处理各类型的通用入口。该函数应支持类型自动分流，并允许通过配置参数指定判定策略。

/**
 * 通用健壮判空工具函数
 * @param {unknown} val 待判断的目标值
 * @param {Object} options 判空规则配置项
 * @param {boolean} [options.trim=true] 针对字符串，是否过滤纯空格
 * @param {boolean} [options.deepArray=false] 针对数组，是否递归检查全项空值
 * @param {boolean} [options.zeroAsEmpty=false] 针对数字，是否将 0 视为空（极少情况）
 * @returns {boolean} true 表示空值；false 表示有效非空值
 */
function isEmpty(val, options = {}) {
  const { trim = true, deepArray = false, zeroAsEmpty = false } = options;

  // 1. 严格空指针排查
  if (val === null || val === undefined) {
    return true;
  }

  // 2. 字符串分支
  if (typeof val === 'string') {
    return (trim ? val.trim() : val).length === 0;
  }

  // 3. 数组分支
  if (Array.isArray(val)) {
    if (val.length === 0) return true;
    if (deepArray) {
      return val.every(item => isEmpty(item, options));
    }
    return false;
  }

  // 4. 数字分支
  if (typeof val === 'number') {
    if (!Number.isFinite(val)) return true; // NaN 与 Infinity 视为空/非法
    if (zeroAsEmpty && val === 0) return true;
    return false; // 0、正数、负数均属非空
  }

  // 5. 布尔值分支（布尔本身为有效状态，通常不视为空）
  if (typeof val === 'boolean') {
    return false;
  }

  // 6. 普通纯对象（Object）分支
  if (typeof val === 'object') {
    return Object.keys(val).length === 0;
  }

  return false;
}

测试用例验证与断言表现

通过标准的边界值测试，验证上述通用函数在各类常见边界下的判空准确性：

// 字符串测试
console.assert(isEmpty("") === true, '空串应为空');
console.assert(isEmpty("   ") === true, '纯空格串应为空');
console.assert(isEmpty("  abc  ") === false, '包含文本非空');

// 数组测试
console.assert(isEmpty([]) === true, '空数组应为空');
console.assert(isEmpty([1]) === false, '含元素数组非空');
console.assert(isEmpty([null, "  "], { deepArray: true }) === true, '深度模式下全空项数组为空');

// 数字测试（核心要点）
console.assert(isEmpty(0) === false, '0 绝不能被误判为空');
console.assert(isEmpty(-10) === false, '负数非空');
console.assert(isEmpty(NaN) === true, 'NaN 应视为空/非法数值');
console.assert(isEmpty(Infinity) === true, 'Infinity 应视为空/非法数值');

六、日常开发防坑清单

为了保证团队代码风格统一并杜绝线上低级隐患，请在日常代码审查与实现中遵循以下四条核心准则：

1. 先类型收窄，后调用属性： 永远不要对未知类型的变量直接执行 .length 或 .trim()。始终通过 typeof 或 Array.isArray() 确立类型边界后再执行相应操作。
2. 数字保零准则： 涉及计数、价格、百分比、下标等数值变量时，坚决弃用 if (!value)。采用 typeof val === 'number' && Number.isFinite(val) 才是守护数值合法性的唯一可靠途径。
3. 警惕隐式类型转换的双向坑： 牢记 Boolean([]) === true 以及 Number("") === 0。对于输入参数，空数组不会自动转化为假，未填写的空字符串也不会自动成为 undefined。
4. 明确空格过滤边界： 在表单提交和文本入库阶段，始终调用 .trim() 消除首尾空白；若业务允许且需要纯空格（如代码编辑器或特定格式符），应在判空参数中显式关闭自动修剪。