Une brève discussion sur les raisons pour lesquelles les chaînes en JavaScript ont des compétences méthodes_javascript

Présentation

Nous savons tous que les types de données JavaScript sont divisés en deux catégories, les types de base (ou types primitifs) et les types de référence.

Les valeurs de type de base sont de simples segments de données stockés dans la mémoire de la pile, et elles sont accessibles par valeur. Il existe cinq types de base dans JS : Indéfini, Null, Booléen, Nombre et Chaîne.

La valeur du type référence est un objet stocké dans la mémoire tas, et sa valeur est accessible par référence. Les types de référence incluent principalement Objet, Tableau, Fonction, RegExp et Date.

Les objets ont des propriétés et des méthodes, il n'est donc pas du tout surprenant que nous voyions le code suivant.

var favs=['鸡蛋','莲蓬'];
favs.push('秋葵');
console.log(favs);//["鸡蛋", "莲蓬", "秋葵"]
console.log(favs.length);//3

Array est un type de référence, il peut donc naturellement avoir des propriétés (longueur) et des méthodes (push). C'est aussi naturel que manger une glace en été. Cependant, regardez le code ci-dessous et réfléchissez-y attentivement, est-ce que ceci et cela sont légaux ?

var realMessage="Said I love you but I lied";
var myMessage=realMessage.substring(5,15);
console.log(myMessage); //"I love you"

Il y avait une fille au cœur brisé qui a volontairement exécuté la méthode "sous-chaîne" sur une chaîne utilisée pour se rompre, puis s'est endormie joyeusement en regardant la version éditée. Mais, mais, n'est-il pas dit que la chaîne est un type de base ? Pourquoi peut-elle avoir des méthodes ? ? Existe-t-il une méthode royale, Seigneur Qingtian ?

En fait, tout cela est dû à quelque chose appelé « Type d'emballage de base ». Ce type d'emballage de base est particulièrement droit, et est le véritable « faire et partir, cacher les mérites et la renommée » !

Types d'emballages de base

En plus des types de référence Object, Array et autres mentionnés au début, JavaScript nous fournit également trois types de référence spéciaux : String, Number et Boolean, ce qui nous facilite l'utilisation des types de base correspondants.

En continuant à regarder l'exemple ci-dessus de découpage d'une chaîne, avez-vous remarqué que malgré l'utilisation de la méthode substring, la valeur de realMessage elle-même ne changera pas. L'appel de cette méthode renvoie simplement une nouvelle chaîne.

C'est ce que fait le type d'emballage de base. A l'origine, vous n'avez pas de méthode, mais lorsque vous souhaitez utiliser une méthode, ajustez-la simplement. Le type d'emballage de base correspondant a cette méthode. Par exemple, la méthode de sous-chaîne ci-dessus est impossible pour le type de base string d'avoir cette méthode, mais le type d'empaquetage String l'a, et il exécutera la méthode et renverra le résultat. Lors de l'exécution vers :

realMessage.substring(5,15)

Il se passe beaucoup de choses avec cette ligne de code.

Tout d’abord, il lit la valeur de realMessage dans la mémoire. Dans ce mode de lecture, l'arrière-plan commence à fonctionner. L'élévation JS décrit ces actions effectuées en arrière-plan comme ceci :

1. Créez une instance de type String
2. Appelez la méthode spécifiée sur l'instance
3. Détruisez cette instance

L'exemple ci-dessus peut être illustré avec un code comme celui-ci :

var _realMessage=new String("Said I love you but I lied");
var myMessage=_realMessage.substring(5,15);
_realMessgae=null; //方法调用后即销毁

Donc, nous comprenons que ce n'est pas la chaîne de type de base qui exécute sa propre méthode, mais que l'arrière-plan crée une chaîne de type d'emballage de base correspondante, qui instancie une instance basée sur la valeur du type de base, de sorte que This L'instance appelle la méthode spécifiée et finit par se détruire, ce qui est incroyable.

Faites attention à la fonctionnalité « destructible » du type d'emballage de base dans la dernière étape, qui détermine que nous ne pouvons pas ajouter de propriétés et de méthodes personnalisées aux valeurs du type de base.

var me="sunjing";
me.age=18;
console.log(me.age);//undefined

J'ai ajouté l'attribut age à la chaîne "me" et défini la valeur sur un merveilleux 18 ans. Cependant, lorsque je l'ai visité à nouveau, il n'y avait aucune trace de cet attribut. C'est parce que :

Lorsque l'attribution d'attribut dans la deuxième ligne de code est exécutée, une instance du type d'emballage de base est créée en arrière-plan. L'attribut age est bien attaché à l'instance, mais celle-ci est ensuite détruite. Lorsque la troisième ligne d'exécution est exécutée, une nouvelle instance du type d'emballage de base est recréée, qui n'a naturellement aucun attribut age.

Afficher en utilisant le type d'emballage de base

En plus lorsque la chaîne est en mode lecture, l'arrière-plan nous aidera à créer des instances de type packaging de base, et nous pouvons également les créer explicitement nous-mêmes.

var str=new String("hello");
var str2=str.toUpperCase();
console.log(str2);//"HELLO:

Ceci est différent de ce qui est enregistré dans la variable lorsque l'arrière-plan nous aide à la créer.

var str1=new String("hello");
var str2="hello";
typeof str1 //"object"
typeof str2 //"string"

Résumé

Grâce aux types d'emballage de base, il est plus pratique pour nous d'utiliser les trois types de base de chaîne, booléen et numérique. Chaque fois que ces trois types de valeurs de base sont lus, l'instance de type d'empaquetage correspondante sera créée en arrière-plan. Cette instance appellera la méthode spécifiée et sera détruite après l'appel. Ce cycle de vie court détermine que nous ne pouvons pas ajouter de propriétés et de méthodes personnalisées aux types de base.

Jetons un coup d'œil à la méthode subString() et à la méthode slice() de la classe String en JavaScript

Récemment, je lisais le livre "Programmation avancée avec Javascript" et j'ai découvert des compétences pratiques et des points de connaissances que je n'avais jamais rencontrés auparavant. Je voulais les enregistrer sur mon blog pour approfondir ma mémoire.

Dans la section 2.8.4 du livre, nous avons parlé des méthodes subString() et slice() dans la classe String. Leur utilisation et leurs résultats de retour sont fondamentalement les mêmes, comme le montre l'exemple suivant :

var strObj = new String("hello world");
alert(strObj.slice(3));    　　// 输出结果："ol world"
alert(strObj.subString(3));  　　// 输出结果："ol world"
alert(strObj.slice(3, 7));    // 输出结果："lo w"
alert(strObj.subString(3,7));   // 输出结果："lo w"

由以上代码的输出结果可已看出，slice()方法和subString()方调用方法法和输出结果完全一样，这两种方法返回的都是要处理的字符串的子串，都接受一个或两个参数，第一个参数是要获取的子串的起始位置，第二个参数是要获取子串的终止位置，如果第二个参数省略终止位置就默认为字符串的长度，且两个方法都不改变String对象自身的值。

为什么有两个功能完全相同的方法呢？事实上，这两个方法并不完全相同，不过只在参数为负值时，他们处理参数的方式稍有不同。

对于负数参数，slice()方法会用字符串的长度加上参数，subString()方法将其作为0处理，例如：

var strObj = new String("hello world");
alert(strObj.slice(-3));　　　　　　// 输出结果："rld"
alert(strObj.subString(-3));　　　 // 输出结果："hello world"
alert(strObj.slice(3,-4));　　　　 // 输出结果："lo w"
alert(strObj.subString(3,-4))　　 // 输出结果："hel"

这样既可看到slice()和subString()方法的主要不同。当只有参数-3时，slice()返回"rld"，subString()则返回"hello world"。这是因为对于字符串"hello world"，slice(-3)将被转换成slice(8)，而subString(-3)则转化成subString(0)。同样，使用3和-4差别也是很明显。slice()方法将被转换成slice(3,7)，与前面的例子相同，返回"lo w"。而subString()方法则将这个两个参数解释为subString(0,3)，实际上是：subString(0,3)，因为subString()总是把较小的参数作为起始位，较大的数字最为终止位。