web-dev-qa-db-fra.com

Quel est le point de nouvelle chaîne ("x") en JavaScript?

Quels sont les cas d'utilisation pour faire new String("already a string")?

Quel est le point entier?

javascriptstringtypesinstanceoftypeof
36
Pacerier

Les créateurs JavaScript ont créé des emballages pour des types de base tels que String ou INT pour le rendre similaire à Java. Malheureusement, si quelqu'un crée une nouvelle chaîne ("x"), le type de l'élément sera "objet" et non "String".

 var j = nouvelle chaîne ("x"); 
 j === "x" //false
j == "x" //true[.____]
18
Lucia

String Les objets peuvent avoir des propriétés, tandis que les primitives de chaîne ne peuvent pas:

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

Et String Les objets peuvent être hérités, tandis que les primitives de chaîne ne peuvent pas:

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

String Les objets sont ne peuvent être égaux qu'à eux-mêmes, pas d'autres String Objets de la même valeur, tandis que les primitives avec la même valeur sont considérées comme égales:

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

Vous pouvez mettre en œuvre la surcharge -comme Comportement:

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

Ou spécifier l'argument but:

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];
    }
}

Ou des objets de piste:

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;
}

L'existence de String Objets et primitives de chaîne vous donne efficacement deux "types" de chaîne dans JavaScript avec des comportements différents et, par conséquent, des utilisations. Cela va pour Boolean et Number objets et leurs primitives respectives également.

Méfiez-vous, cependant, de transmettre des primitives de chaîne (ou autre) comme valeur de this lors de l'utilisation des méthodes de fonction bind(), call() et apply(), comme le La valeur sera convertie en un objet String objet (ou a Boolean ou un objet Number, en fonction de la primitive) avant d'être utilisé comme 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;

Et des types de retour inattendus/contre-intuitif:

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

Dans la plupart des cas, vous travaillez seuls et peut vous contrôler, ou sur une équipe et il y a une ligne directrice d'équipe, ou peut voir le code que vous travaillez avec cela, de sorte que cela ne devrait pas être un problème. Mais vous pouvez toujours être très sûr:

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

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

Mise à jour

Je ne sais pas beaucoup sur les implications de cela, bien qu'il semble fonctionner:

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

Bien sûr, vous devriez vérifier si l'objet a un constructeur (c'est-à-dire s'il s'agit d'un objet).

Donc, vous pourriez avoir:

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

Bien que je suggère que vous n'utilisez que typeof et "String", un utilisateur doit savoir passer par un littéral à chaîne normal.

Je dois noter que cette méthode est probablement susceptible de créer un objet et de définir son constructeur pour être String (qui serait en effet complètement obscur), même si ce n'est pas une chaîne ...

1
davin

Vous pouvez également convertir un objet de chaîne (avec quoi que ce soit d'autre) à une primitive à chaîne avec toString: var str = new String("foo"); typeof str; // object typeof str.toString(); // string _

0
jazmit

Pourquoi avez-vous besoin de vérifier si c'est une chaîne?

Vérifiez simplement s'il est défini ou null, puis le convertissez de manière défensive en tout type que vous souhaitez, soit la fonction var bar = new String(foo); ou var bar = "" + foo;.

0
bartosz.r

Merci tout, même après tant d'années, cette question n'a pas de réponse précise.

JavaScript a deux types de données,

  1. Primitives: - String (laissez A = 'testtr'), nombre, booléen, null, indéfini, symbole et bigint.
  2. Objets: - Tout le reste (fonctions, tableaux, objets JS, ....)

C'est la voie à laquelle JS est conçu pour l'efficacité (vous savez que JS ON V8 est comme une fusée) que toutes les primitives sont immuables (la modification d'un STR de num crée une nouvelle variable derrière la scène) et les objets sont mutables.

Pour soutenir les primitives à utiliser comme des objets JS a cette fonctionnalité d'autoboxage. Ainsi, lorsque nous utilisons n'importe quelle méthode (par exemple Tostring () pour Numéro) avec Primitives, JS le convertit automatiquement à l'objet correspondant, puis exécute la méthode et la convertit à la primitive. Normalement, nous ne devrions jamais utiliser le constructeur (avec nouveau) et l'utiliser comme une primitive uniquement (laissez Str = 'testtr'). L'utilisation d'un objet constructeur au lieu de primitive peut entraîner une exécution et des complications lentes.

0
Sumer