Le fonctionnement d'un programme informatique nécessite l'opération de valeurs telles que le nombre 3.14 ou le texte "hello world". Dans les langages de programmation, le type de valeurs qui peuvent être représentées et manipulées est appelé type de données ( type). Le plus basique des langages de programmation. La fonctionnalité consiste à héberger plusieurs types de données. Lorsqu'un programme a besoin de sauvegarder une valeur pour une utilisation future, il lui attribue ("enregistre" la valeur dans) une variable. Une variable est un nom symbolique pour une valeur, et une référence à la valeur peut être obtenue par son nom. Le fonctionnement des variables est une caractéristique fondamentale des langages de programmation. Ce chapitre fera référence à la section précédente pour aider à comprendre le contenu de ce chapitre, et sera expliqué plus en profondeur ultérieurement.
Les données Javascript sont divisées en deux catégories : le type primitif et le type d'objet
Les classes originales en JavaScript incluent des nombres, des chaînes et des valeurs booléennes. Ce chapitre comportera un chapitre distinct dédié aux nombres, aux chaînes et aux valeurs booléennes en JavaScript. JavaScript a également deux valeurs primitives spéciales, null (vide) et Undefined (non défini). Ce ne sont pas des nombres, des chaînes ou des valeurs booléennes. Ils représentent chacun un membre unique de leur propre type spécial.
Javascript est un objet en plus des nombres, des chaînes, des valeurs booléennes, nulles et non définies. Un objet est une collection de propriétés. Chaque attribut est composé d'une « paire nom/valeur » (la valeur peut être une valeur primitive, telle qu'un nombre, une chaîne ou un objet). L'un des objets les plus spéciaux (l'objet global sera introduit dans Miss 5, et sera décrit plus en détail dans la section 6)
Les objets JavaScript ordinaires sont des collections inutiles de « valeurs nommées ». JavaScript définit également un objet spécial : un tableau, qui représente une collection ordonnée de valeurs numérotées. JavaScript définit une syntaxe spéciale pour les tableaux. Faire en sorte que les tableaux aient des propriétés comportementales uniques qui diffèrent des objets ordinaires.
Javascript définit également une fonction objet spéciale. Une fonction est un objet auquel est associé un code exécutable. La fonction est appelée pour exécuter le code exécutable et renvoyer le résultat de l'opération. Comme les tableaux, les fonctions se comportent différemment des autres objets. JavaScript définit une syntaxe spéciale pour l'utilisation des fonctions. Pour les fonctions javascript. Plus important encore, ce sont toutes de vraies valeurs et JavaScript peut les traiter comme des objets ordinaires.
Si une fonction initialise (à l'aide de l'opérateur new) un nouvel objet, nous l'appelons un constructeur. Chaque constructeur définit une classe d'objets, une collection d'objets que le constructeur initialise. Les classes peuvent être considérées comme des sous-types de types d’objets. En plus de la classe tableau et de la classe fonction, JavaScript définit également trois autres classes utiles. Date définit un objet qui représente une date. L'objet Regular (regExp) définit une expression régulière. La classe d'erreur définit des objets qui représentent les erreurs d'exécution et les erreurs de syntaxe dans les programmes JavaScript. Vous pouvez définir les classes requises en définissant votre propre constructeur.
L'interpréteur JavaScript possède son propre mécanisme de gestion de la mémoire qui peut effectuer automatiquement un garbage collection sur la mémoire. Cela signifie que le programme peut créer des objets à la demande et que le programmeur n'a pas à se soucier de la destruction de ces objets ni du recyclage de la mémoire. Lorsqu'il n'y a plus de référence à un objet, l'interpréteur sait que l'objet n'est plus utile, et récupérera automatiquement les ressources mémoire qu'il occupe.
JavaScript est un langage orienté objet. En gros, cela signifie que nous n'avons pas besoin de définir globalement des fonctions pour utiliser différents types de valeurs. Le type de données lui-même peut définir des méthodes pour utiliser des valeurs. Par exemple, pour trier les éléments d'un tableau a, il n'est pas nécessaire de passer. a Entrez la fonction sort(), mais appelez une méthode sort()
a.sort(); //Version orientée objet de sort(a)
Techniquement, seuls les objets JavaScript peuvent avoir des méthodes. Cependant, les nombres, les chaînes et les valeurs booléennes ont également leurs propres méthodes. En JavaScript, seules les valeurs null et indéfinies sont des valeurs qui ne peuvent pas avoir de méthodes.
Les types Javascript peuvent être divisés en types primitifs et types d'objets, et peuvent être divisés en types pouvant avoir des méthodes et en types ne pouvant pas avoir de méthodes. Il peut également être divisé en types mutables et immuables. La valeur d'un type de variable peut être modifiée. Les objets et les tableaux sont des types de variables : les programmes JavaScript peuvent modifier les valeurs d'attribut des objets et les valeurs des éléments du tableau.
Les nombres, les valeurs booléennes, nulles et indéfinies sont des types immuables. Par exemple, modifier le contenu d’un tableau n’a pas de sens en soi. Une chaîne peut être considérée comme un tableau de caractères et vous pouvez la considérer comme modifiable. Cependant, en JavaScript, les chaînes sont immuables. Vous pouvez accéder au texte à n'importe quelle position de la chaîne, mais JavaScript ne fournit pas de méthode pour modifier le contenu textuel de la chaîne.
Javascript peut effectuer librement une conversion de type de données. Par exemple, si un nombre est utilisé là où le programme attend une chaîne, JavaScript convertira automatiquement le nombre en chaîne. Si une valeur non booléenne est utilisée alors qu'une valeur booléenne est attendue, JavaScript sera converti en conséquence. Règles flexibles de saisie et d'échange de types en JavaScript pour "l'égalité"
Les variables Javascript ne sont pas typées. Les variables peuvent se voir attribuer des valeurs humaines et de type. Utilisez le mot-clé var pour déclarer les variables. JavaScript utilise une portée syntaxique. Les variables qui ne sont déclarées dans aucune fonction sont appelées variables globales, visibles n'importe où dans le programme JavaScript.
1. Les chiffres
Contrairement à d'autres langages de programmation, JavaScript ne fait pas de distinction entre les valeurs entières et les valeurs à virgule flottante. Les valeurs numériques en JavaScript sont représentées par des valeurs à virgule flottante. Lorsqu'un nombre apparaît directement dans un programme JavaScript, nous l'appelons un littéral numérique. JavaScript prend en charge les littéraux numériques dans plusieurs formats. (Remarque : l'ajout d'un signe moins (-) directement avant un nombre vous donne sa valeur négative.) Mais le signe moins est l'opérateur de négation unaire. , ne fait pas partie de la grammaire littérale numérique. )
i quantité directe entière
Utilisez une séquence de tableau pour représenter un entier décimal en JavaScript
En plus des littéraux entiers décimaux, JavaScript reconnaît également les valeurs basées sur le mécanisme hexadécimal (16) comme base. Le nombre dit hexadécimal est préfixé par « 0X » ou « 0x », suivi de la quantité directe de la chaîne de nombres hexadécimaux. Les valeurs hexadécimales sont composées de chiffres de 0 à 9 et de lettres comprises entre a(A) et f(F). Les lettres a-f représentent les nombres 10-15. Voici un exemple de littéral entier hexadécimal
.Bien qu'ECMAScript ne prenne pas en charge les littéraux octaux, certaines implémentations de JavaScript peuvent permettre aux entiers d'être représentés sous forme octale (base 8). Les littéraux octaux commencent par le chiffre 0, suivi d'une séquence de chiffres entre 0 et 7.
Étant donné que certaines implémentations javascript prennent en charge les scalaires octaux et d'autres non, il est préférable de ne pas utiliser de scalaires entiers préfixés par 0. Après tout, nous n'avons aucun moyen de savoir si l'implémentation javascript actuelle prend en charge l'analyse octale. Dans le mode strict d'ECMAScript 6, les littéraux octaux sont explicitement interdits.
ii. Littéral à virgule flottante
Les littéraux à virgule flottante peuvent contenir des points décimaux et utilisent la méthode d'écriture traditionnelle des nombres réels. Un nombre réel se compose d’une partie entière, d’un point décimal et d’une partie décimale.
De plus, vous pouvez également utiliser la notation exponentielle pour représenter des littéraux à virgule flottante. Autrement dit, le nombre réel est suivi de la lettre E ou e, suivie d'un signe positif ou négatif, puis d'un exposant entier. La valeur représentée par cette méthode de comptage est la puissance exponentielle du nombre réel précédent multipliée par 10.
Une syntaxe plus concise peut être utilisée pour représenter
Opérations arithmétiques dans iii.javascript
Les programmes Javascript utilisent des opérateurs arithmétiques fournis par le langage pour effectuer des opérations numériques. Ces opérateurs incluent - * / et l'opérateur reste (reste après division) %
En plus des opérateurs de base, JavaScript prend également en charge des opérations arithmétiques plus complexes. Cette opération complexe est implémentée via des fonctions et des constantes définies comme propriétés de l'objet Math.
Les opérations arithmétiques en JavaScript ne signaleront pas les erreurs en cas de débordement, de sous-débordement ou de division par zéro. Cependant, le résultat de l'opération numérique dépasse la limite supérieure du nombre pouvant être exprimé en JavaScript (débordement), et le résultat est une valeur infinie spéciale (infini), qui est représentée par l'infini en JavaScript. De même, lorsque la valeur d'un nombre négatif dépasse la plage de nombres négatifs que JavaScript peut exprimer, le résultat est l'infini négatif, représenté par -Infinty en JavaScript. Les valeurs infinies se comportent comme on pourrait s'y attendre : l'addition, la soustraction, la multiplication et la division basées sur elles aboutissent à l'infini (signes conservés)
Underflow est une situation qui se produit lorsque le résultat d'une opération est infiniment proche de zéro et inférieur à la valeur minimale que JavaScript peut représenter. Lorsqu'un nombre négatif dépasse le plafond, JavaScript renvoie une valeur spéciale, "zéro négatif", qui est presque exactement la même que le zéro normal. Les programmeurs JavaScript utilisent rarement le zéro négatif.
Javascript prédéfinit les variables globales Infinaty et NaN, qui sont utilisées pour exprimer l'infini positif et les valeurs non numériques dans ECMAScipt3, ces deux valeurspeuvent être lues et écrites. ECMAScript5 résout ce problème en les définissant en lecture seule. Les valeurs de propriété définies par l'objet Number dans ECMAScipt3 sont également en lecture seule. Voici quelques exemples :
.La valeur du zéro négatif est également quelque peu spéciale. Elle est égale au zéro positif et négatif (même jugé à l'aide du test d'égalité stricte de JavaScript), ce qui signifie que les deux valeurssont presque identiques, sauf en tant que diviseur :
Il existe d'innombrables nombres réels, mais JavaScript ne peut représenter qu'un nombre limité sous forme de nombres à virgule flottante (18 437 736 874 454 810 627 pour être exact). En d'autres termes, lorsque des nombres réels sont utilisés en JavaScript, ils sont utilisés. souvent, ce n'est qu'une représentation approximative de la vraie valeur.
Javascript utilise la représentation des nombres à virgule flottante IEEE-754 (utilisée par presque tous les langages de programmation modernes). Il s'agit d'une représentation binaire qui peut représenter avec précision des fractions, telles que 1/2 1/8 et 1/1024. Malheureusement, les fractions que nous utilisons souvent, notamment dans les calculs financiers, sont toutes des fractions décimales 1/10, 1/100, etc. La représentation binaire ne peut pas représenter des nombres simples comme 0,1.
Les nombres en javascript ont une précision suffisante. Et peut être proche de 0,1. Mais le fait que ce nombre ne puisse pas être exprimé avec précision pose certains problèmes.
En raison d'une erreur d'arrondi, la différence approximative entre 0,3 et 0,2 n'est pas réellement égale à la différence approximative entre 0,2 et 0,1 (dans un environnement de simulation réel, 0,3-0,2 = 0,099 999 999 999 999 98). Ce problème n'existe pas. unique à JavaScript, mais il est important de comprendre que cela se produit dans tout langage de programmation utilisant des nombres binaires à virgule flottante. Notez également que les valeurs de x et y dans le code ci-dessus sont très proches les unes des autres et les valeurs finales correctes. Ce résultat de calcul peut être utilisé pour la plupart des tâches informatiques. Ce problème ne se produit que lors de la comparaison de deux valeurs d'égalité.
Les futures versions de JavaScript pourront prendre en charge les types de nombres décimaux pour éviter ce problème, mais d'ici là, vous préférerez peut-être utiliser de grands entiers pour les calculs financiers importants. Par exemple, utilisez des « cents » entiers au lieu de « dollars » décimaux pour les opérations basées sur les unités monétaires.
iiii.Date et heure
Le cœur du langage JavaScript contient le constructeur Date(), qui crée à l'origine des objets date et heure. Les méthodes de ces objets date fournissent une API simple pour les calculs de date. Les objets date ne peuvent pas être des types de données de base comme les nombres.
2. Texte
Une chaîne est une séquence ordonnée immuable de valeurs de 16 bits. Chaque caractère provient généralement du jeu de caractères Unicode. JavaScript représente le texte via le type chaîne. La longueur d'une chaîne est le nombre de valeurs de 16 bits qu'elle contient. Les chaînes Javascript (et leurs tableaux) sont indexées à partir de 0. La longueur d'une chaîne vide est 0 et il n'existe pas de « type de caractère » qui représente un seul caractère en JavaScript. Pour représenter une valeur de 16 bits, affectez-la simplement à une variable chaîne. La longueur de cette chaîne est 1.
Jeu de caractères, code interne et chaîne javascript
JavaScript utilise le jeu de caractères Unicode codé en UTF-16. Une chaîne JavaScript est une séquence composée d'un ensemble de valeurs non sérialisées de 16 bits. Les caractères Unicode les plus couramment utilisés sont représentés par des codes internes de 16 bits et représentent un seul caractère dans une chaîne. Les caractères Unicode qui ne peuvent pas être représentés sous forme de caractères 16 bits suivent les règles de codage UTF-16 : utilisez deux caractères de 16 bits. sont représentés sous forme de séquence (également appelée « paire de substitution »). Cela signifie qu'une chaîne JavaScript de longueur 2 (deux valeurs de 16 bits) peut représenter un caractère Unicode.
Les différentes méthodes d'opération sur chaîne définies par JavaScript fonctionnent toutes sur des valeurs 16 bits, et non sur des caractères, et les paires de substitution ne seront pas traitées séparément. De même, JavaScript n'effectue pas de traitement standardisé sur les chaînes. Il n'y a aucune garantie que la chaîne soit même au format légal UTF-16
je chaîne littéral
Une chaîne littérale dans un programme JavaScript est une séquence de caractères entourée de guillemets simples ou doubles. Une chaîne délimitée par des guillemets simples peut contenir des guillemets doubles, et une chaîne délimitée par des guillemets doubles peut également contenir des guillemets simples. Voici quelques exemples de chaînes littérales.
Dans ECMAScript3, les littéraux de chaîne doivent être écrits sur une seule ligne, mais dans ECMAScript5, les littéraux de chaîne peuvent être divisés en plusieurs lignes, et chaque ligne doit se terminer par une barre oblique inverse (), une barre oblique inverse et un terminateur de ligne. Aucun d'entre eux n'est le contenu des chaînes littérales. Si vous les voulez ensemble, vous pouvez utiliser Personnages d'évasion.
Il convient de noter que lorsque vous utilisez des guillemets simples pour délimiter des chaînes, vous devez faire très attention aux abréviations et à tout le formatage en anglais. L'apostrophe anglaise et le guillemet simple sont le même caractère, vous devez donc utiliser une barre oblique inverse () pour l'échappement.
ii caractère d'échappement
Dans les chaînes JavaScript, la barre oblique inverse () a un objectif particulier. L'ajout d'un caractère après la barre oblique inverse ne représente plus leur signification littérale. Par exemple, n est un caractère d'échappement, qui représente un caractère de nouvelle ligne.
L'une des fonctions intégrées de JavaScript est la concaténation de chaînes. Utiliser l'opérateur avec des chaînes signifie une concaténation de chaînes. Par exemple
s.longueur
En plus de l'attribut length, les chaînes fournissent également de nombreuses méthodes pouvant être appelées.
En JavaScript, les chaînes sont fixes. Des méthodes comme replace() et toUpperCase() renvoient de nouvelles chaînes et les caractères d'origine eux-mêmes ne changent pas.
Dans ECMAScript, les caractères peuvent être traités comme des tableaux en lecture seule. En plus d'utiliser la méthode charAt(), vous pouvez également utiliser des crochets pour accéder aux caractères individuels d'une chaîne. (valeur 16 bits)
Foxfire prend en charge l'indexation de chaînes de cette manière depuis longtemps, et la plupart des navigateurs modernes (sauf IE) ont suivi les traces de Mozailla et ont complété cette fonctionnalité avant qu'ECMAScript ne prenne forme
iiii correspondance de motifs
Javascript définit le constructeur RegExp(), qui est utilisé pour créer des objets qui représentent la correspondance de modèles de texte. Ces modèles sont appelés « expressions régulières » (expressions régulières), la syntaxe des expressions régulières en JavaScript Caiyang Perl. Les objets String et RegExp définissent des fonctions de correspondance de modèles, de recherche et de remplacement à l'aide d'expressions régulières.
L'objet RegExp n'est pas un type de données de base dans le langage comme Date, c'est juste un objet spécial avec une API pratique. La syntaxe des expressions régulières est complexe et l'API est riche. Il sera présenté en détail au chapitre 10. RegExp est un outil de traitement de texte puissant et couramment utilisé, ce n'est qu'un aperçu.
Bien que RegExp ne soit pas un type de données de base dans le langage, ils ont toujours un mode d'écriture direct et peuvent être utilisés directement en JavaScript. Le texte entre deux barres obliques forme le littéral d'une expression régulière. La deuxième barre oblique peut également être suivie d'une ou plusieurs lettres. Utilisé pour modifier la signification des modèles correspondants. Par exemple :
L'objet RegExp définit de nombreuses méthodes utiles, et les chaînes ont également des méthodes qui peuvent accepter les paramètres RegExp. Par exemple :
3.Valeur booléenne
La valeur booléenne fait référence à vrai ou faux, activé ou désactivé. Ce type n'a que deux valeurs, les mots réservés vrai ou faux
Les résultats des instructions de comparaison en JavaScript sont généralement des valeurs booléennes. Par exemple
a==4
Ce code permet de détecter si la valeur de la variable a est égale à 4. Si égale, la valeur est vraie, sinon, la valeur est fausse
Les valeurs booléennes sont généralement utilisées dans les instructions de contrôle JavaScript, telles que les instructions if/else en JavaScript. Si la valeur booléenne est vraie, exécutez le premier élément de logique, et si elle est fausse, exécutez un autre élément de code. comme
Toute valeur JavaScript peut être convertie en valeur booléenne. Les valeurs suivantes sont converties en faux
.Toutes les autres valeurs, y compris tous les objets (tableaux) seront converties en vrai, faux et les 6 valeurs ci-dessus qui peuvent être converties en faux sont parfois appelées « fausses valeurs ». Lorsque JavaScript s'attend à utiliser une valeur booléenne, la fausse valeur sera traitée comme fausse, la vraie valeur sera traitée comme vraie
Regardons un exemple. En ajoutant que la variable o est un objet ou nulle, vous pouvez utiliser une instruction if pour détecter si o est une valeur non nulle.
si(o!==null)...
L'opérateur d'inégalité "!==" compare o et null et le résultat est vrai ou faux. Vous pouvez d'abord ignorer l'instruction de comparaison ici, null est une fausse valeur et l'objet est une vraie valeur.
si(o)...
Pour le premier cas, le code après if sera exécuté tant que o n'est pas nul. Les restrictions dans le second cas ne sont pas si strictes. Ceci if est exécuté uniquement si o n'est pas faux ou une valeur fausse (telle que nulle ou non).
Boolean contient la méthode toString(), vous pouvez donc utiliser cette méthode pour convertir une chaîne en "true" ou "false", mais elle ne contient pas d'autres méthodes utiles. En plus de cette API sans importance, il existe trois méthodes importantes. l'opérateur booléen.
L'opérateur&&, l'opérateur || et l'opérateur unaire "!" effectuent l'opération booléenne NOT (NOT). Si la valeur vraie renvoie faux, la valeur fausse renvoie vrai, par exemple
.4.null et non défini
Null est un mot-clé dans le langage JavaScript. Il représente une valeur spéciale "valeur nulle". Pour null, l'opération typeof() est effectuée et l'objet est renvoyé, en d'autres termes, null peut être considéré comme une valeur d'objet spéciale, ce qui signifie « non-objet ». Mais en fait, null est généralement considéré comme le seul membre de son type libre. Il peut représenter des nombres, des chaînes et des objets « sans valeur ». La plupart des langages de programmation contiennent des valeurs nulles comme JavaScript, et vous connaissez peut-être null ou nil.
Javascript a également une deuxième valeur indiquant la vacance de la valeur. Utilisé pour représenter des « valeurs nulles » plus profondes. C'est une valeur d'une variable. Indique que la variable n'est pas initialisée. Si vous souhaitez interroger la valeur d'une propriété d'objet ou d'un élément de tableau et renvoyer undéfini, cela signifie que la propriété ou l'élément n'existe pas. undefined est une variable globale prédéfinie (elle est différente de null, ce n'est pas un mot-clé) et sa valeur est indéfinie. Si typeof est utilisé pour tester un type non défini, « undéfini » est renvoyé, indiquant que cette valeur est le seul membre de ce type.
Bien que null et indéfini soient différents, ils représentent tous deux « une vacance de valeur » et les deux sont souvent interchangeables. L'opérateur d'égalité "==" considère les deux comme égaux (l'opérateur d'égalité stricte "===" doit être utilisé pour les distinguer). Lorsqu'une valeur est censée être de type booléen, sa valeur est fausse. Semblable à faux. Null et undefined ne contiennent aucune propriété ou méthode. En fait, utiliser "." et "[]" pour accéder aux membres ou méthodes de ces deux valeurs générera une erreur de type.
Vous pensez peut-être que undéfini représente des valeurs vacantes au niveau du système, inattendues ou semblables à une erreur, et que null représente des valeurs vacantes au niveau du programme, normales ou attendues si vous souhaitez les copier. Variables ou propriétés, ou les transmettre dans des fonctions en tant que. paramètres, null est le meilleur choix.
5. Objet global
Les sections précédentes traitaient des types d'éléments JavaScript et des valeurs primitives. Types d'objets - objets, tableaux et fonctions/Mais il existe une classe d'objets très importante qui doit être précisée maintenant : les objets globaux
Les objets globaux jouent un rôle important en JavaScript. Les propriétés des objets globaux sont des symboles définis globalement. Les programmes JavaScript peuvent être utilisés directement. Lorsque l'interpréteur JavaScript démarre, il crée un nouvel objet global et lui attribue un ensemble défini de propriétés initiales.
Propriétés globales telles que Infinty et NaN non définies
Fonctions globales telles que isNaN(), parseInt() et eval()
Constructeurs tels que Date(), RegExp(), String(), Object() et Array()
Objets globaux, tels que Math et JSON
Les propriétés initiales des objets globaux ne sont pas des mots réservés, mais elles doivent être traitées comme telles.
Au niveau supérieur du code - code javascript qui ne fait partie d'aucune fonction, l'objet global peut être référencé via le mot-clé javascript.
var global = this; //Définit une variable globale qui fait référence à l'objet global.
Dans JavaScript côté client, l'objet window agit comme un objet global. Cet objet window global a une référence window familière à lui-même. Il peut la remplacer pour faire référence à l'objet global Window qui définit les propriétés de base globales. Mais il définit également d'autres propriétés globales pour les navigateurs Web et le JavaScript interactif.
Lors de sa première création, l'objet global définit toutes les valeurs globales prédéfinies en JavaScript. Cet objet spécial contient également les valeurs globales définies pour le programme. Si le code déclare une variable globale. Cette variable globale est une propriété de l'objet global.
6. Objet d'emballage
Un objet JavaScript est une valeur composite : c'est une collection de propriétés ou de valeurs nommées. La valeur de l'attribut est référencée via ".". Lorsque la valeur de l'attribut est une fonction, il s'agit d'une méthode et la méthode dans l'objet o est distribuée via o.m().
On voit que les chaînes ont aussi des propriétés et des méthodes.
Puisqu'une chaîne n'est pas un objet, pourquoi a-t-elle des attributs ? Tant que les propriétés de string s sont référencées, JavaScript convertira la valeur de la chaîne en objet en appelant de nouvelles String. Cet objet hérite des méthodes de string. et est utilisé pour gérer les références de propriétés. Une fois le nouvel attribut référencé. Une fois la référence terminée, l'objet nouvellement créé sera détruit. (Cet objet temporaire n'est pas réellement créé ou détruit, mais le processus ressemble à ceci.)
Comme les chaînes, les nombres et les valeurs booléennes ont également leurs propres méthodes, créant un objet temporaire via les constructeurs Number() et Boolean(). Les appels à ces méthodes proviennent tous de cet objet temporaire. (null et undefined ne sont pas des objets encapsulés, et accéder à leurs propriétés entraînera une erreur de type)
Regardez les codes suivants et réfléchissez à leur processus d'exécution
Lorsque ce code est exécuté, la valeur de t n'est pas définie. La deuxième ligne de code crée un objet chaîne temporaire et donne la valeur de len à 4, puis détruit l'objet. La troisième ligne de code utilise l'original (non modifié). ) ) crée un nouvel objet chaîne et essaie de lire la propriété len.
Cet attribut n'existe naturellement pas, indiquant que le résultat n'est pas défini. Ce code illustre que lors de la lecture des valeurs d'attribut (ou méthodes) des chaînes, des tableaux et des valeurs booléennes, il se comporte comme un objet, mais si vous essayez d'attribuer une valeur à son attribut. Cette opération est ignorée ; la modification n'intervient que sur l'objet temporaire. Cet objet temporaire n'est pas conservé.
Il convient de noter que vous pouvez créer des objets wrapper explicitement via les constructeurs String(), Number() et Boolean() :
Javascript convertira le wrapper en une valeur primitive si nécessaire, de sorte que l'objet S N B dans le code ci-dessus se comporte souvent - mais pas toujours - de la même manière que s n b. L'opérateur "==" égal convertit la valeur d'origine et leur encapsulation. les objets sont traités sur un pied d’égalité.
Mais l'opérateur "===" les traite comme inégaux, et l'opérateur typeof peut voir la différence entre la valeur d'origine et l'objet qu'il enveloppe.
7. Valeurs primitives immuables et références d'objets mutables.
Les valeurs primitives de Javascript (valeurs booléennes nulles non définies, nombres et chaînes) sont fondamentalement différentes des objets (y compris les tableaux et les fonctions). La valeur primitive ne peut pas être modifiée ; aucune méthode ne peut (ou muter) une valeur primitive. Cela est évidemment vrai pour les nombres et les valeurs booléennes – changer la valeur d'un nombre en soi n'a pas de sens, mais c'est moins évident pour les chaînes, qui ressemblent à des tableaux de caractères. Nous nous attendons à ce que les caractères de la chaîne puissent être modifiés par l'index spécifié. En fait, JavaScript l'interdit. Toutes les méthodes de chaîne semblent renvoyer une chaîne modifiée, mais renvoient en réalité une nouvelle chaîne.
La comparaison des valeurs originales est une comparaison de valeurs Elles ne sont égales que lorsque leurs valeurs sont égales. Cela semble un peu difficile pour les nombres, booléens, nuls et indéfinis, et il n'y a pas d'autre moyen de les comparer. Encore une fois, c'est moins évident pour les chaînes ; si vous comparez deux chaînes distinctes, JavaScript les considère égales si et seulement si leurs longueurs et leurs caractères à chaque index sont égaux.
Une comparaison d'objets n'est pas une comparaison de valeurs : même si deux objets contiennent les mêmes attributs et les mêmes valeurs, ils ne sont pas égaux, et deux tableaux avec des éléments d'index exactement égaux ne sont pas égaux
Nous appelons généralement les types de référence d'objets pour les distinguer des types de base de JavaScript. Selon la terminologie, les objets sont des références, et les comparaisons d'objets sont des comparaisons de références ; ils ne sont égaux que lorsqu'ils utilisent le même objet de base ;
Tout comme le code que vous venez de voir ci-dessus, l'attribution d'un objet (ou d'un tableau) à une variable n'est qu'une valeur de référence attribuée : l'objet lui-même n'est pas copié une seule fois.
Si vous souhaitez obtenir une copie d'un objet ou d'un tableau, vous devez explicitement copier chaque propriété de l'objet ou chaque élément du tableau. L'exemple suivant termine la copie du tableau via une boucle.
De même, si l'on veut comparer deux individus ou tableaux, ils doivent comparer leurs attributs ou éléments. Le code suivant définit une fonction qui compare un tableau.
8. Conversion de types
Les types de valeur en JavaScript sont très flexibles. Nous l'avons déjà vu avec les valeurs booléennes : lorsque JavaScript attend une valeur booléenne, vous pouvez fournir n'importe quel type de valeur. JavaScript convertira le type lui-même selon les besoins. Certaines valeurs (valeurs vraies) sont vraies et d'autres valeurs (fausses valeurs) sont converties en faux. La même chose s'applique aux autres types. Si JavaScript attend une chaîne, il convertit la valeur donnée en chaîne. Si JavaScript attend un tableau, il convertit la valeur donnée en nombre (renvoyant NaN si le résultat de la conversion n'a pas de sens), quelques exemples sont les suivants :
Le tableau suivant explique comment effectuer une conversion de type en JavaScript. Des types de faits saillants en gras qui pourraient vous surprendre. Les cellules vides représentent les conversions inutiles et non effectuées.
| Valeur | Convertir en chaîne | Numéro | Valeur booléenne | Objet |
| indéfini nul |
"non défini" "nul" |
NaN 0 |
faux faux |
lance TypeError lance TypeError |
| true false |
"ture" "false" |
1 0 |
new Boolean(true) new Boolean(false) |
|
| ""（空字符串） "1.2"(非空，数字) "one"(非空，非数字) |
0 1.2 NaN |
false vrai vrai |
nouvelle chaîne("") nouvelle chaîne("1.2") new String("un") |
|
| 0 -0 NaN Infini -Infini 1(infini, non nul) |
"0" "0" "NaN" "Infini" "-Infini" "1" |
faux faux faux vrai vrai vrai |
nouveau numéro(0); nouveau numéro (-0); nouveau numéro (NaN) nouveau numéro (infini) nouveau numéro (-Infinty) nouveau numéro (1) |
|
| {}(n'importe quel objet) [](tableau arbitraire) [9](1 élément numérique) ['a'](autre tableau) fonction(){}(任意函數) |
參考本小節第三節內容 "" "9" 使用join()方法 參考本小節第三節內容 |
參考本小節第三節內容 0 9 NaN NaN |
true true true true true |
上表提到的原始值到原始值的轉換行對簡單，我們已經在第本文第三小節討論過轉換為布林值的情況了。所有原始值轉換為字串的情形也已經明確定義。轉換為數字的情形比較微妙。那些以數字表示的字串可以直接轉換為數字，也允許在開始和結尾處帶有空格。但在開始和結尾處的任意非空字元都不會被當成數字量的一部分，進而造成字串為數字的結果為NaN。有一些數字轉換看起來很奇怪：true轉換為1，false、空字串""轉換為0.
原始值到物件的轉換也非常簡單，原始值
requête multi-tables mysql
Que faire s'il n'y a pas de curseur lorsque vous cliquez sur la zone de saisie
Quels sont les modèles de conception utilisés par Laravel ?
Qu'est-ce que le trading de devises numériques
Solution d'erreur 0x80070057
que signifie pm
expression lambda
Comment exécuter du code HTML dans vscode
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
