41

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

它的全部意义是什么？

4

9 回答 9

61

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"

于 2011-04-21T23:05:02.150 回答
23

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

var j = new String("x");
j === "x" //假
j == "x" //真
于 2011-04-21T23:05:34.147 回答
8

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
于 2016-08-24T01:22:35.763 回答
3

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

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

instanceof运算符也将正确处理 String 的子类：

obj instanceof ConstructorFunction通过检查是否ConstructorFunction.prototype在obj.

我认为我实际上从未在 JavaScript 中使用过 String 类，但偏执并以正确为目标并没有错。

于 2011-04-21T23:20:22.080 回答
1

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

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（这确实是完全模糊的）的人的影响，即使它不是字符串......

于 2011-04-21T23:04:49.290 回答
0 
Object.prototype.toString.call(aVariable) == '[object String]'
于 2011-04-22T04:24:44.603 回答
0

您还可以使用以下方法将 String 对象（以及其他任何东西）转换为 String 原语toString： var str = new String("foo"); typeof str; // object typeof str.toString(); // string

于 2015-02-07T22:03:10.000 回答
0

谢谢大家，即使经过这么多年，这个问题也没有确切的答案。

JavaScript 有两种类型的数据，

  1. 原语：- 字符串（让 a = 'testStr'）、数字、布尔值、空值、未定义、符号和大整数。
  2. 对象：- 其他一切（函数、数组、JS 对象……）

它是 JS 为提高效率而设计的方式（您知道 V8 上的 JS 就像火箭一样）所有原语都是不可变的（更改 num 的 str 会在场景后面创建一个新变量）并且对象是可变的。

为了支持使用类似对象的原语，JS 具有 AutoBoxing 的此功能。因此，当我们使用任何带有原语的方法（比如数字的 toString()）时，JS 会自动将其转换为相应的 Object，然后执行该方法并将其转换回原语。通常我们永远不应该使用构造函数（with new）并且只像原始类型一样使用它（let str = 'testStr'）。使用构造函数对象而不是原始对象可能会导致执行缓慢和复杂化。

于 2019-12-18T12:23:57.607 回答
-1

为什么需要检查它是否是字符串？

只需检查它是否已定义或为 null，否则会防御性地将其转换为您想要的任何类型，无论是var bar = new String(foo);还是var bar = "" + foo;.

于 2012-01-26T13:48:53.937 回答