JS怎么判断变量是字符串

在日常 JavaScript 开发中，变量类型检查是最基础也是出现频率最高的操作之一。当我们需要验证用户输入、解析接口数据或为函数参数增加防御性校验时，准确判断一个未知变量是否为字符串至关重要。

看似简单的问题，在实际应用中却常常遇到陷阱：例如通过字面量声明的字符串与使用构造函数创建的字符串包装对象在某些操作符下的表现截然不同；跨 iframe 或不同全局执行上下文时原型链也会发生隔离。接下来，我们按具体场景逐一剖析常用的判断手段。

方法一：最常用的 typeof 运算符

对于绝大多数普通的 JavaScript 应用场景，通过 typeof 运算符进行判断是最直接、最快速的方式。

const str1 = "hello";
const str2 = `template string`;
const str3 = String(123); // 显式类型转换，返回原始字符串 "123"

console.log(typeof str1 === 'string'); // 输出: true
console.log(typeof str2 === 'string'); // 输出: true
console.log(typeof str3 === 'string'); // 输出: true

typeof 的优势

• 运算性能极高：typeof 属于语言级别的单目运算符，执行效率高于函数调用。
• 未声明变量安全：即使直接对一个未声明的变量执行 typeof undeclaredVar，也不会抛出 ReferenceError，而是安全返回 "undefined"。
• 语法简洁直观：无需引入辅助方法，团队协作时代码易读性好。

typeof 的局限性与盲区

typeof 仅适用于原始字符串（Primitive String）。如果变量是通过 new String(...) 实例化的包装对象，typeof 的返回值将是 "object" 而不是 "string"：

const strObj = new String("hello");

console.log(typeof strObj); // 输出: "object"
console.log(typeof strObj === 'string'); // 输出: false （判定遗漏！）

方法二：使用 instanceof String 辅助判断

既然 new String() 会生成一个以 String.prototype 为原型的对象，那么通过 instanceof String 就可以检测出这类包装对象：

const strObj = new String("test");
console.log(strObj instanceof String); // 输出: true

const primitiveStr = "test";
console.log(primitiveStr instanceof String); // 输出: false (注意：原始值不是对象，instanceof 返回 false)

因此，如果你希望同时兼容字面量与包装对象，可以将两者组合起来：

function isStringBasic(val) {
  return typeof val === 'string' || val instanceof String;
}

console.log(isStringBasic("abc"));            // true
console.log(isStringBasic(new String("abc"))); // true
console.log(isStringBasic(123));              // false
console.log(isStringBasic(null));             // false

方法三：终极稳健方案 —— Object.prototype.toString.call()

要构建一个能够在任何环境下（包括各类包装对象、跨全局上下文环境）都能保证 100% 准确的字符串判断逻辑，ECMAScript 规范定义的 Object.prototype.toString.call() 是最推荐的黄金标准。

function isString(val) {
  return Object.prototype.toString.call(val) === '[object String]';
}

console.log(isString("hello world"));           // true
console.log(isString(new String("hello")));     // true
console.log(isString(`template`));              // true
console.log(isString(null));                    // false
console.log(isString(undefined));               // false
console.log(isString({}));                      // false

为什么必须使用 Object.prototype.toString.call ？

为什么不能直接写 val.toString() 呢？主要原因有两点：

1. 如果 val 为 null 或 undefined，直接访问 val.toString() 会抛出 TypeError: Cannot read property 'toString' of null。
2. String.prototype、Array.prototype 等子类原型通常重写了默认的 toString() 方法，例如 "abc".toString() 返回的是字符串内容 "abc"，而不是包含类型标签的 "[object String]"。只有借用根对象原型上的 Object.prototype.toString，才能获取内部标签。

不推荐的误区与陷阱写法

在编写判断代码时，有一些常见做法看似可行，实则存在隐患：

1. 使用 val.constructor === String

// 极其危险！
function badIsString(val) {
  return val.constructor === String;
}

badIsString(null);      // 抛出 TypeError: Cannot read property 'constructor' of null
badIsString(undefined); // 抛出 TypeError: Cannot read property 'constructor' of undefined

另外，constructor 属性可以被人为随意篡改，并不可信：

const fake = { constructor: String };
console.log(badIsString(fake)); // 输出: true (严重误判)

2. 依赖字符串特有方法是否存在（鸭子类型检测）

function duckTypeString(val) {
  return val != null && typeof val.indexOf === 'function';
}

console.log(duckTypeString([1, 2, 3])); // 输出: true (因为数组也有 indexOf 方法，发生误判)

多种判断方案的综合对比

最佳工程实践：封装高健壮性工具函数

在工程项目中，我们可以封装一个既兼顾性能、又具备绝对安全性的工具函数（这也是很多知名实用工具库如 Lodash 内部所采用的实现思路）：

/**
 * 判断变量是否为字符串类型（支持原始字符串与包装对象）
 * @param {*} value - 待检测的变量
 * @returns {boolean} 如果是字符串则返回 true，否则返回 false
 */
function isString(value) {
  // 1. 如果是基本类型字符串，直接利用 typeof 快速命中并返回
  if (typeof value === 'string') {
    return true;
  }
  
  // 2. 如果不是对象或者是 null，则必然不是字符串包装对象
  if (typeof value !== 'object' || value === null) {
    return false;
  }
  
  // 3. 对于对象类型，借用 Object.prototype.toString 确认是否为 String 包装对象
  return Object.prototype.toString.call(value) === '[object String]';
}

// TypeScript 类型守卫版本示例：
// function isString(value: unknown): value is string {
//   return typeof value === 'string' || 
//     (typeof value === 'object' && value !== null && Object.prototype.toString.call(value) === '[object String]');
// }

这种阶梯式的判断方式首先通过 typeof value === 'string' 快速阻断并返回绝大多数常规情况，极大保留了运行时性能；仅在遇到对象形态的特殊输入时，才向下进入 Object.prototype.toString.call() 的深层校验，在性能与完备性之间取得了最佳平衡。