什么'；JavaScript中新字符串（“x”）的意义是什么？

执行

新字符串（“已经是字符串”）

的用例是什么

---

它的全部意义是什么？

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

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

（这确实是非常模糊的），即使它不是字符串…

由

新字符串（“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;

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

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

不用担心字符串对象，只需使用typeof。这将是我的建议

typeof str==“string”

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

typeof str==“string”| | str instanceof string

使用。检查是否存在一个或多个特定于字符串的方法，例如substring（）或toLowerCase（）。这显然是不精确的，因为它将为一个对象返回一个假阳性，而该对象恰好有一个与您正在检查的名称相同的方法，但在大多数情况下，它已经足够好了

typeof str==“string”| typeof str.substring==“function”

---

Javascript创建者为string或int等基本类型创建包装器，只是为了使其类似于java。不幸的是，如果someome生成新字符串（“x”），元素的类型将是“object”，而不是“String”

var j=新字符串（“x”）； j==“x”//false j==“x”//true

---

如果你真的想成为偏执狂，你可以使用

instanceof

：

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

也将正确处理字符串的子类：

obj instanceof ConstructorFunction

通过检查

ConstructorFunction.prototype

是否在

obj

的原型链中工作

---

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

为什么需要检查它是否是String

Object.prototype.toString.call(aVariable) == '[object String]'

---

只需检查它是否已定义或为null，否则将它转换为您想要的任何类型，

var bar=newstring（foo）或
var bar=”“+foo
您还可以使用
toString
将字符串对象（以及任何其他对象）转换为字符串原语：

var str=新字符串（“foo”）；
str的类型；//对象
str.toString（）的类型；//一串
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

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

和
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

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 aStringObject=new String("I'm a String object");
console.log(typeof aStringObject); //--> object
aStringObject=aStringObject.toUpperCase();
console.log(typeof aStringObject); //--> string

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

JavaScript有两种类型的数据

原语：-字符串（设a='testStr'）、数字、布尔值、null、未定义、符号和bigint
对象：-其他一切（函数、数组、JS对象等）
JS的设计就是为了提高效率（你知道V8上的JS就像火箭一样），所有的原语都是不可变的（更改num的str会在场景后面创建一个新的变量），对象是可变的

为了支持原语像对象一样使用，JS具有自动装箱的特性。因此，当我们对原语使用任何方法（比如说toString（）表示number）时，JS会自动将其转换为相应的对象，然后执行该方法并将其转换回原语。
通常情况下，我们不应该使用构造函数（new），而应该像使用原语一样使用它（让str='testStr'）。使用构造函数对象而不是原语可能会导致执行缓慢和复杂性。
那么，检查变量是否为字符串的最佳方法是什么呢？仅检查
构造函数
属性是不够的。JavaScript中的子类字符串可能会有一些奇怪的人。@mu太短了，是的，你说得有道理，尽管我考虑了
instanceof
，但OP似乎只是试图区分对象、字符串文本和
新字符串（'blah'）
。不管怎样，我们可以整天挑剔。我只是觉得你应该对学究半途而废，如果你想学究，那么就一直这么做：）我正在创建一个类，它的构造函数中包含一个参数。但此参数由用户提供。如果参数是s，构造函数将执行某些操作