JavaScript中新String("x")的意义何在？

Question

做的用例是什么new String("already a string")？

它的重点是什么？

Answer 1

对于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对象返回false negative.

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

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

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

Answer 2

Javascript创建者为string或int等基本类型创建了包装器,使其与java类似.不幸的是,如果someome使用新的String("x"),则元素的类型将是"object"而不是"string".

var j = new String("x");
j === "x"  //false
j == "x" //true

Answer 3

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