Cinq types de données de base dans les compétences javascript_javascript

[0] 5 types de données :

[0.1]Types de données de base : non défini, nul, booléen, nombre, chaîne

           [0.1.1] Les valeurs de type de base font référence à des segments de données simples, les 5 types de base sont accessibles par valeur, car la valeur réelle stockée dans la variable peut être manipulée

                                                                        [0.1.2] Les valeurs de type de base occupent une taille fixe d'espace dans la mémoire et sont stockées dans la mémoire de la pile. Copier une valeur d'un type primitif d'une variable à une autre crée une copie de la valeur.

                                                                                 [0.1.3] Impossible d'ajouter des attributs aux valeurs de type de base

[0.2] Type de données de référence : Objet

[0.2.1] Les valeurs de type référence font référence à des objets qui peuvent être composés de plusieurs valeurs. js ne permet pas d'accéder directement à l'emplacement dans la mémoire, c'est-à-dire que l'espace mémoire de l'objet opération n'est pas directement accessible. Lorsque vous manipulez un objet, vous manipulez en réalité une référence à l'objet plutôt qu'à l'objet lui-même.

                                                                                                                                                                                       La valeur du type de référence peut être un objet, qui peut être stocké dans la mémoire tas. La variable contenant la valeur du type de référence ne contient en réalité pas l'objet lui-même, mais un pointeur vers l'objet. Copier une valeur de type référence d'une variable à une autre copie en fait un pointeur, de sorte que les deux variables pointent finalement vers le même objet.

                                                      [0.2.3] Pour les valeurs de type référence, vous pouvez leur ajouter des attributs et des méthodes, et vous pouvez également modifier et supprimer leurs attributs et méthodes

[1]Non défini

[1.1] Le type Indéfini n'a qu'une seule valeur, qui est indéfinie

[1.2]var a 96b4fef55684b9312718d5de63fb7121 var a = indéfini;

[1.3] Pour les variables qui n'ont pas été déclarées, vous ne pouvez effectuer qu'une seule opération, qui consiste à utiliser l'opérateur typeof pour détecter son type de données [mais cela provoquera une erreur en mode strict]

[1.4] Scène d'apparition :

                                                                                     [1.4. 1] Variable non attribuée déclarée

                                                                                                                                 Récupérer les attributs inexistants de l'objet

         [1.4.3] Résultats d'exécution de fonctions sans valeurs de retour

         [1.4.4] Les paramètres de la fonction ne sont pas passés dans

[1.4.5]vide(expression)

[1.5]Conversion de types

Booléen(indéfini)：faux

Nombre (non défini) : NaN

Chaîne (non définie) : 'non définie'

[2]Nul

[2.1] Le type Null n'a qu'une seule valeur, qui est nulle D'un point de vue logique, la valeur nulle représente un pointeur d'objet nul

.

[2.2] Si la variable définie sera utilisée pour enregistrer l'objet, il est préférable d'initialiser la variable à null

[2.3] En fait, la valeur non définie est dérivée de la valeur nulle, donc undéfini == null

[2.4] Scénario d'occurrence : lorsque l'objet n'existe pas

[2.5]Conversion de types

Booléen(null)：faux

Nombre (nul):0

Chaîne(null):'null'

[Note 1] null est un pointeur d'objet nul, [] est un tableau vide, {} est un objet vide, les trois sont différents

[Note 2]null ne peut pas ajouter d'attributs personnalisés

[3]Booléen

[3.1] Le type booléen n'a que deux valeurs : vrai et faux

[3.2] Scène d'apparition :

                                                                    [3.2.1] Les instructions conditionnelles entraînent la conversion du type d'ermite par le système

[3.2.2]Définition littérale ou variable

[3.3]Conversion de types

Nombre (vrai) : 1 || Nombre (faux) : 0

Chaîne(vrai):'vrai' || Chaîne(faux):'faux'

[3.4]Booléen()

Booléen (non défini): faux

Booléen(null):false

Booléen (les objets non vides incluent les tableaux vides [] et les objets vides {}) : vrai

Booléen(non-0) : vrai || Booléen(0 et NaN) :faux

Boolean (chaîne non vide incluant les espaces):true || Boolean(''):false

[Note] vrai n'est pas nécessairement égal à 1, et faux n'est pas nécessairement égal à 0

[4]Numéro

[4.1] Le type Number utilise le format IEEE754 pour représenter les entiers et les valeurs à virgule flottante

[Note] Vous pouvez utiliser une valeur de -0 pour la convertir en nombre

[4.2] Les trois formats littéraux sont décimal, octal et hexadécimal

                                                                                                                                         Le premier chiffre doit être 0, suivi de la séquence de chiffres octaux (0-7). Si la valeur littérale dépasse la plage, le 0 initial sera ignoré et les valeurs suivantes seront analysées comme un nombre décimal.

[4.2.2] Les littéraux octaux ne sont pas valides en mode strict et entraîneront une erreur de js

[4.2.3] Les deux premiers chiffres de la valeur littérale hexadécimale doivent être 0x, suivis d'une séquence de chiffres hexadécimaux, et les lettres peuvent être majuscules ou minuscules

                                                                                                                                                                                                               La valeur littérale dans le système hexadécimal est hors plage. Si g, h, etc. apparaissent, une erreur sera signalée

         [4.2.5] Lors de l'exécution de calculs arithmétiques, toutes les valeurs exprimées en octal et hexadécimal seront éventuellement converties en valeurs décimales

[4.3] Représentation numérique :

[4.3.1] Le 0 positif et le 0 négatif peuvent être stockés dans js et sont considérés comme égaux

[4.3.2] Valeur à virgule flottante : La valeur doit contenir un point décimal, et il doit y avoir au moins un chiffre après le point décimal.

                 [4.3.2.1] Étant donné que les valeurs à virgule flottante nécessitent deux fois plus d'espace mémoire pour stocker des valeurs entières, js convertira les valeurs à virgule flottante en valeurs entières sans perdre aucune opportunité s'il n'y a pas de nombre. ou valeur à virgule flottante après la virgule décimale, elle représente un entier et cette valeur sera enregistrée sous forme de valeur entière.

                                                         [4.3.2.2] La plus haute précision des valeurs à virgule flottante est de 17 décimales

                                     [4.3.2.3] Pour les nombres très grands ou très petits, ils peuvent être représentés par des valeurs à virgule flottante représentées par la notation scientifique e

              [4.3.2.4] Par défaut, js convertira les valeurs à virgule flottante avec plus de 6 zéros après la virgule décimale en valeurs exprimées en notation e

                                                                                 [4.3.2.5] Un problème courant avec les calculs à virgule flottante basés sur les valeurs numériques IEEE754 est le problème de l'arrondi erreurs de saisie. Tel que : 0,1 0,2 === 0,3(15 0)4

[4.3.3] La plage numérique en js est Number.MIN_VALUE(5e-324) —— Number.MAX_VALUE(1.7976931348623157e 308)

                                                                    [4.3.3.1] S'il dépasse la plage des nombres positifs, l'infini (infini positif) est émis, et s'il dépasse la plage des nombres négatifs, -Infini (négatif en finitude) est sorti

                                 [4.3.3.2] -Infinity ne peut pas participer aux calculs numériques

[4.3.3.3] number.max_value 1 ! = Infini, car l'ordinateur est stocké au maximum sur 52 bits de chiffres numériques, il ne peut pas en stocker plus de 1 000 et la précision a été perdue depuis longtemps, c'est-à-dire la décimale la position est entièrement 0, donc l'addition est inchangée >.

            [4.3.3.4]Number.MIN_VALUE - 1 != -Infini, la même raison, donc le résultat est -1

           [4.3.3.5] Vous pouvez utiliser isFinite() pour déterminer si une valeur est finie, y compris la conversion de type implicite Number()

[4.3.3.6]isFinite(NaN) //false

[4.3.4]NaN

             [4.3.4.1]NaN n'est égal à aucune valeur, y compris NaN lui-même

              [4.3.4.2] Toute opération impliquant NaN renverra NaN

            [4.3.4.3] isNaN() pour déterminer si le nombre est NaN, y compris la conversion de type implicite Number()

[4.4] Conversion numérique : Number() peut être utilisé pour n'importe quel type, parseInt() et parseFloat sont spécifiquement utilisés pour convertir des chaînes en nombres

[Note 1]Number(), parseInt() et parseFloat() peuvent accepter des nombres dans différentes bases, mais ils ne s'appliquent pas aux chaînes contenant des nombres

[Note 2] Si le nombre dans Number(), parseInt(), parseFloat() est 1,2, une erreur sera signalée, mais si la chaîne est '1.2.', aucune erreur ne sera signalée

[4.4.1]Nombre()

Nombre (vrai):1 || Nombre (faux):0

Nombre (nombres dans différentes bases) : le nombre décimal après opération, tel que 1,0 ou 1. ou 01 sera affiché sous la forme 1

Nombre (non défini) : NaN

Nombre (nul):0

Numéro (chaîne) :

Nombre (une chaîne contenant uniquement des nombres décimaux et hexadécimaux) : nombre décimal après opération

[Remarque] La preuve huit n'est pas reconnue dans la chaîne, et le traitement des nombres décimaux

Numéro('' et ' '):0

Nombre (chaîne dans les autres cas) : NaN

Numéro (objet) :

Nombre([] et [0] et [-0]):0

Numéro([numéro]) : Numéro après opération

Nombre([1,2] et {} et autres objets) :NaN

[4.4.2] parseInt() : Lors de la conversion d'une chaîne, les espaces devant la chaîne sont ignorés jusqu'à ce que le premier caractère non-espace soit trouvé. Si le premier caractère n'est pas un caractère numérique ou un signe négatif, parseInt() renvoie NaN. Si tel est le cas, l'analyse continue jusqu'à ce qu'elle soit terminée ou qu'un caractère non numérique soit rencontré.

              [4.4.2.1] parseInt() peut identifier des entiers de différentes bases, mais lors de l'analyse de chaînes littérales octales, ECMAScript3 analysera l'octal, mais ECMAScript5 n'a pas la capacité d'analyser l'octal

                      [4.4.2.2] La fonction parseInt() fournit un deuxième paramètre, indiquant le numéro de base, tel que : parseInt('123', 16 ou 10 ou 2)

                                       [4.4.2.3] parseInt (nombres dans diverses bases) : nombres décimaux après l'opération, tels que 1,0 ou 1. ou 01 sera affiché sous la forme 1

                                                                                                                                                                                Parce que parseInt() est spécialement utilisé pour traiter les nombres de conversion de chaînes, donc parseInt (les autres types incluent '')//NaN

          [4.4.3] parseFloat() : similaire à parseInt(), il ignorera les espaces devant la chaîne jusqu'à ce que le premier caractère non-espace

soit trouvé

                    [4.4.3.1] parseFloat() ne peut analyser que des chaînes décimales

                     [4.4.3.2] parseFloat (nombres dans différentes bases) : les nombres décimaux après l'opération, tels que 1,0 ou 1. ou 01 seront affichés sous la forme 1

[5]Chaîne : une séquence de caractères entourée de guillemets simples ou doubles. La longueur de n'importe quelle chaîne peut être obtenue en accédant à l'attribut length

.

[5.1] Littéral de caractère, également appelé séquence d'échappement

n Saut de ligne

t Tabulation

espace b

r Entrer

f Alimenter le papier

\ barre oblique

        ' Guillemet simple

« Guillemets doubles

xnn représente un caractère en hexadécimal nn (n est 0-f), tel que x41 représente 'A'

unnnn représente un caractère Unicode en hexadécimal nnnn (n est 0-f), tel que u03a3 représente le caractère grec ε

[5.2] Les chaînes dans ECMAScript sont immuables

[5.3] La concaténation de chaînes nécessite d'abord de créer une nouvelle chaîne, puis de remplir la nouvelle chaîne avec deux chaînes qui doivent être épissées, et enfin de détruire la chaîne d'origine. Ce processus se produit en arrière-plan et est également la raison pour laquelle l'épissage des chaînes est lent dans certains navigateurs plus anciens (IE6), mais ce problème d'inefficacité a depuis été résolu

[5.4] Conversion de chaîne

[5.4.1]toString()

Null et Undefined n'ont pas cette méthode

Boolean, Object et String ont cette méthode

Nombre Utilisez cette méthode pour transmettre les nombres de base 2, 8, 10, 16, tels que var num = 10;num.toString(2);//1010

Mais 10.toString(2) signalera une erreur car le numéro ne peut pas être suivi de l'identifiant

[5.4.2]Chaîne()

Il existe la méthode toString(), utilisez la méthode toString()

String(null);//'null'

Chaîne (non définie);//'non définie'

           [5.4.3] Pour convertir une valeur en chaîne, vous pouvez utiliser l'opérateur plus pour l'ajouter à une chaîne vide ''

　 [5.4.4] Si la valeur d'un élément dans le tableau est nulle ou indéfinie, alors la valeur sera une chaîne vide dans les résultats renvoyés par join(), toLocaleString(), toString() et valueOf( ) méthodes.

Enfin, je vais vous donner un exemple simple pour illustrer les différences entre ces cinq types de base

var testString = "Hello"; 
var testBoobean = true; 
var testUndefined = undefined; 
var testUndefined1; 
var testNull = null; 
var testObject = {a:1}; 
var testFunction = function(){return;}; 
 
alert(testString);//"string" 
alert(testBoobean);//"boolean" 
alert(testUndefined);//"undefined" 
alert(testUndefined1);//"undefined" 
alert(testUndefined2);//"undefined" 
alert(testNull);//"object" 
alert(testObject);//"object" 
alert(testFunction);//"function"