String由new String("foo").创建的对象几乎没有实际用途。String对象相对于原始字符串值的唯一优势是，作为对象它可以存储属性：

var str = "foo";
str.prop = "bar";
alert(str.prop); // undefined

var str = new String("foo");
str.prop = "bar";
alert(str.prop); // "bar"

如果您不确定可以将哪些值传递给您的代码，那么我建议您在项目中遇到更大的问题。返回字符串的原生 JavaScript 对象、主要库或 DOM 方法都不会返回String对象而不是字符串值。但是，如果你想绝对确定你有一个字符串值而不是一个String对象，你可以按如下方式转换它：

var str = new String("foo");
str = "" + str;

如果您检查的值可以是任何对象，您的选项如下：

1. 不要担心 String 对象，只需使用 typeof。这将是我的建议。

   typeof str == "string".

2. 使用 instanceof 和 typeof。这通常有效，但缺点是会为在另一个窗口中创建的 String 对象返回假阴性。

   typeof str == "string" || str instanceof String

3. 使用鸭子打字。检查是否存在一个或多个特定于字符串的方法，例如 substring() 或 toLowerCase()。这显然是不精确的，因为对于碰巧具有您正在检查的名称的方法的对象，它会返回误报，但在大多数情况下它已经足够了。

   typeof str == "string" || typeof str.substring == "function"

Javascript 创建者为 string 或 int 等基本类型创建了包装器，只是为了使其类似于 java。不幸的是，如果有人创建 new String("x") 元素的类型将是“对象”而不是“字符串”。

var j = new String("x");
j === "x" //假
j == "x" //真

String 对象可以有属性，而字符串原语不能：

var aStringObject=new String("I'm a String object");
var aStringPrimitive="I'm a string primitive";

aStringObject.foo="bar";
console.log(aStringObject.foo); //--> bar

aStringPrimitive.foo="bar";
console.log(aStringPrimitive.foo); //--> undefined

和String对象可以被继承，而字符串元不能：

var foo=Object.create(aStringObject);
var bar=Object.create(aStringPrimitive); //--> throws a TypeError

String对象只能等于自己，不能等于其他String具有相同值的对象，而具有相同值的基元被认为是相等的：

var aStringObject=new String("I'm a String object");
var anotherStringObject=new String("I'm a String object");

console.log(aStringObject==anotherStringObject); //--> false

var aStringPrimitive="I'm a string primitive";
var anotherStringPrimitive="I'm a string primitive";

console.log(aStringPrimitive==anotherStringPrimitive); //--> true

您可以实现类似重载的行为：

function overloadedLikeFunction(anArgument){
    if(anArgument instanceof String){
        //do something with a String object
    }
    else if(typeof anArgument=="string"){
        //do something with a string primitive
    }
}

或指定参数目的：

function aConstructorWithOptionalArugments(){
    this.stringObjectProperty=new String("Default stringObjectProperty value");
    this.stringPrimitiveProperty="Default stringPrimitiveProperty value";
    for(var argument==0;argument<arguments.length;argument++){
        if(arguments[argument] instanceof String)
            this.stringObjectProperty=arguments[argument];
        if(typeof arguments[argument]=="string")
            this.stringPrimitiveProperty=arguments[argument];
    }
}

或跟踪对象：

var defaultStringValue=new String("default value");
var stringValue=defaultStringValue;

var input=document.getElementById("textinput") //assumes there is an text <input> element with id equal to "textinput"
input.value=defaultStringValue;
input.onkeypress=function(){
    stringValue=new String(this.value);
}

function hasInputValueChanged(){
    //Returns true even if the user has entered "default value" in the <input>
    return stringValue!=defaultStringValue;
}

String对象和字符串原语的存在有效地为您提供了 Javascript 中具有不同行为的两种字符串“类型”，因此，使用。这同样适用于Boolean和Number对象以及它们各自的元太。

当心，然而，传递字符串（或其他）基元作为对值的this使用功能的方法时bind()，call()和apply()，作为值将被转换为一个String对象（或一个Boolean或一个Number对象，这取决于原始）之前被用作this：

function logTypeofThis(){
    console.log(typeof this);
}

var aStringPrimitive="I'm a string primitive";
var alsoLogTypeofThis=logTypeofThis.bind(aStringPrimitive);

console.log(typeof aStringPrimitive); //--> string;
logTypeofThis.call(aStringPrimitive); //--> object;
logTypeofThis.apply(aStringPrimitive); //--> object;
alsoLogTypeofThis(); //--> object;

以及意外/违反直觉的返回类型：

var aStringObject=new String("I'm a String object");
console.log(typeof aStringObject); //--> object
aStringObject=aStringObject.toUpperCase();
console.log(typeof aStringObject); //--> string

instanceof如果你真的想变得偏执，你可以使用：

if(typeof x === "string" || x instanceof String)

该instanceof运营商将妥善处理字符串的子太：

obj instanceof ConstructorFunction通过检查是否ConstructorFunction.prototype在 的原型链中来工作obj。

我认为我从来没有真正在 JavaScript 中使用过 String 类，但是偏执和追求正确性并没有错。

在大多数情况下，您可以单独工作并且可以控制自己，或者在团队中工作并且有团队指南，或者可以看到您正在使用的代码，所以这应该不是问题。但你总是可以更加安全：

var obj = new String("something");
typeof obj; // "object"

obj = ""+obj;
typeof obj; // "string"

更新

虽然它似乎有效：

var obj = new String("something"), obj2 = "something else";
obj.constructor === String; // true
obj2.constructor === String; // true

当然，你应该检查对象是否有构造函数（即它是否是一个对象）。

所以你可以有：

isString(obj) {
   return typeof obj === "string" || typeof obj === "object" && obj.constructor === String;
}

虽然我建议你只使用 typeof 和“string”，但用户应该知道传递一个普通的字符串文字。

我应该注意到这个方法可能容易受到创建对象并将它的构造函数设置为String（这确实是完全模糊的）的人的影响，即使它不是一个字符串......