Types d'expérience de lecture de base JavaScript, valeurs et variables

Le fonctionnement d'un programme informatique nécessite des valeurs de fonctionnement telles que le nombre 3.14 ou le texte "Hello World". Dans les langages de programmation, le type de valeur qui peut être représenté et opéré est appelé type de données. La caractéristique la plus élémentaire des langages de programmation consiste à héberger plusieurs types de données. Lorsque le programme doit conserver la valeur pour une utilisation future, il est affecté à (enregistrer "la valeur à) une variable. Une variable est un nom symbolique d'une valeur, et une référence à une valeur peut être obtenue par le nom. Le mécanisme de travail des variables est une caractéristique de base 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ée plus en profondeur plus tard.

Les données JavaScript sont divisées en deux catégories: type primitif et type d'objet

Les classes originales en JavaScript incluent les nombres, les chaînes et les valeurs booléennes. Ce chapitre aura un chapitre distinct discutant spécifiquement des nombres, des chaînes et des valeurs booléens de JavaScript. JavaScript a également deux valeurs brutes spéciales, null (vide) et non définies (non définies), ce ne sont pas des nombres, des chaînes ou des valeurs booléennes. Ils représentent les seuls membres de leurs types spéciaux respectifs.

JavaScript est un objet en plus des nombres, des chaînes, des valeurs booléennes, null et non définis. Un objet est une collection de propriétés. Chaque attribut se compose d'une "paire de nom / valeur" (la valeur peut être une valeur primitive, comme un nombre, une chaîne ou un objet). L'un des objets les plus spéciaux (l'objet global sera introduit dans Miss Fifth, et la sixième section sera décrite plus en détail)

Les objets JavaScript normaux sont des collections non nécessaires de "valeurs nommées". JavaScript définit également un objet spécial - un tableau, représentant un ensemble ordonné de valeurs numérotées. JavaScript définit une syntaxe dédiée pour les tableaux. Faites des tableaux qui ont des propriétés de comportement uniques différentes des objets ordinaires.

JavaScript définit également une fonction d'objet spéciale. Une fonction est un objet avec le code exécutable avec lequel il souhaite associer. Il exécute le code en appelant la fonction et renvoie le résultat de l'opération. Comme les tableaux, les caractéristiques du comportement de fonction sont différentes des autres objets. JavaScript définit une syntaxe spéciale pour l'utilisation de fonctions. Pour les fonctions JavaScript. Plus important encore, ce sont toutes de vraies valeurs, et JavaScript peut être utilisé pour les traiter comme des objets ordinaires.

Si une fonction initialise (en utilisant le nouvel opérateur) un nouvel objet, nous l'appelons un constructeur. Chaque constructeur définit une collection d'objets de classe-A composée d'objets d'initialisation du constructeur. Les classes peuvent être considérées comme des sous-types de types d'objets. En plus des classes de table et des classes de fonctions, JavaScript définit également trois autres classes utilisées. Une date définit un objet représentant une date. Regexp définit l'objet d'expressions régulières. La classe d'erreur définit la ligne qui représente l'erreur d'exécution et l'objet d'erreur de syntaxe dans un programme JavaScript. Vous pouvez définir la classe requise en définissant votre propre constructeur.

L'interprète JavaScript a son propre mécanisme de gestion de la mémoire, qui peut attribuer automatiquement la collecte de mémoire. Cela signifie que le programme peut créer des objets à la demande et que les programmeurs n'ont pas à se soucier de la destruction de ces objets et du recyclage de la mémoire. Lorsqu'aucune référence ne pointe vers un objet, l'interprète sait que l'objet est inutile et recyclera automatiquement les ressources de mémoire qu'il occupe.

JavaScript est une langue orientée objet. Pas à proprement parler, cela signifie que nous n'utilisons pas de fonctions de définition globale pour utiliser différents types de valeurs. Le type de données lui-même peut définir des méthodes pour utiliser les valeurs. Par exemple, pour trier les éléments dans le tableau A, il n'est pas nécessaire de passer une fonction Sort (), mais pour transférer une méthode Sort ()

a.sort (); // Trier (a) version orientée objet

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, seuls nuls et non définis sont des valeurs qui ne peuvent pas avoir de méthodes.

Les types de JavaScript peuvent être divisés en types primitifs et types d'objets, et peuvent être divisés en types qui peuvent avoir des méthodes et des types qui ne peuvent pas avoir de méthodes. Il peut également être divisé en types mutables et immuables. Les valeurs des types mutables peuvent être modifiées et les objets et les tableaux appartiennent à des types mutables: les programmes JavaScript peuvent modifier la valeur de la valeur d'attribut d'un objet et la valeur des éléments du tableau.

Les nombres, les booléens, les nuls et les non définis sont des types immuables. Par exemple, modifier le contenu d'un tableau lui-même n'a pas de sens. Une chaîne peut être considérée comme un tableau de caractères, et vous pouvez penser qu'elle peut être modifiée. Cependant, en JavaScript, les chaînes sont immuables. Vous pouvez accéder au texte à n'importe quelle position d'une chaîne, mais JavaScript ne fournit pas de moyen de modifier le contenu texte de la chaîne tout le temps.

JavaScript peut effectuer librement la conversion du type de données. Par exemple, si un nombre est utilisé lorsque le programme prévoit d'utiliser une chaîne, JavaScript convertira automatiquement le numéro en une chaîne. Si vous vous attendez à utiliser une valeur non boolienne où la valeur booléenne est utilisée, JavaScript se convertira également en conséquence. En JavaScript, les règles de "l'égalité du jugement" sont utilisées pour "l'égalité du jugement" (égalité)

Les variables JavaScript ne sont pas typées. Les variables peuvent être affectées aux personnes et aux types. Les variables peuvent être déclarées en utilisant le mot-clé VAR. JavaScript adopte la portée de la syntaxe. Les variables non déclarées dans aucune fonction sont appelées variables globales. Ils sont visibles n'importe où dans le programme de JavaScript.

1. Nombres

Contrairement à d'autres langages de programmation, JavaScript ne fait pas de distinction entre les valeurs entières et les valeurs des points flottants. Toutes les valeurs de JavaScript sont exprimées par des valeurs de points flottants. Lorsqu'un nombre apparaît directement dans un programme JavaScript, nous sommes un littéral numérique et JavaScript prend en charge les quantités directes numériques en plusieurs formats. (Remarque: l'ajout d'un signe négatif (-) directement avant que n'importe quel nombre puisse obtenir leurs valeurs négatives) mais le signe négatif est un opérateur inverse unidirectionnel. , pas une composante de la grammaire des quantités numériques directes. )

Je type entier de type direct

Un entier décimal est représenté par une séquence de tableau en javascript

En plus de la quantité directe entière décimale, JavaScript reconnaît également les valeurs du mécanisme seize (16) comme cardinalité. Le soi-disant système hexadécimal est une quantité directe préfixée avec "0x" ou "0x" suivi d'une chaîne de nombres hexadécimaux. La valeur hexadécimale est composée de lettres entre 0 et 9 et a (a) -f (f). Les lettres de l'AF sont exprimées dans les numéros 10-15 ci-dessous. Voici des exemples de quantités directes d'entiers hexadécimaux

La copie de code est la suivante:

0xff // 15 * 16 + 15 = 255

0xcafe911

Bien que ECMascript ne prenne pas en charge les quantités directes octales, certaines implémentations de JavaScript peuvent permettre la représentation des entiers en octal (base 8). La quantité directe octale commence par le nombre 0, suivie d'une séquence de nombres entre 0 et 7.

La copie de code est la suivante:

0377 // 3 * 64 + 7 * 8 +7 = 255 (décimal)

Étant donné que certaines implémentations JavaScript prennent en charge l'octobre octal, alors que certains ne le font pas, il est préférable de ne pas utiliser le nombre inter-nombre entier préfixé avec 0. Après tout, nous ne pouvons pas savoir si l'implémentation JavaScript actuelle prend en charge l'analyse octale. Dans le mode strict d'Ecmascript6, la quantité octale directe est explicitement interdite.

ii Quantité directe du point flottante

Les quantités directes des points flottants peuvent contenir des points décimaux et utilisent la méthode d'écriture du nombre réel traditionnel. Un nombre réel se compose d'une partie entière, d'un point décimal et d'une partie décimale.

De plus, la méthode de comptage exponentielle peut également être utilisée pour représenter des quantités directes à points flottants. Autrement dit, le nombre réel est suivi de la lettre E ou E, suivi du signe positif et négatif, puis un exposant entier est ajouté. La valeur numérique représentée par cette méthode de comptage est une puissance exponentielle du numéro réel précédent multiplié par 10.

Peut être exprimé dans une syntaxe plus concise

La copie de code est la suivante:

[chiffres] [. chiffres] [(e | e) [(+ | -)] chiffres]

3.14

2345.455

.33333333333333333333333333333333

6.02e23 //6.02*10 à la 23e puissance

1.255454E-23 //1.255454*10 à la 23e puissance

Opération arithmétique dans iii.javascript

Les programmes JavaScript utilisent des opérateurs arithmétiques fournis par la province linguistique pour effectuer des opérations numériques. Ces opérateurs contiennent + - * / et l'opérateur restant (reste divisé)%

En plus des opérateurs de base, JavaScript prend également en charge les opérations arithmétiques plus complexes. Cette opération compliquée en ligne est implémentée par des fonctions et des constantes définies comme des propriétés des objets mathématiques.

La copie de code est la suivante:

Math.Pow (2, 53) // => 9007199254740992 Document.Write (Math.Pow (2,53)))

Math.round (.6) //=>1.0 Round

Math.Ceil (.6) //=>1.0 Recherche ascendante

Math.floor (.6) //=>0.0 Downward

Math.abs (-5) // => 5 Trouvez la valeur absolue

Math.max (x, y, z) // renvoie la valeur maximale

Math.min (x, y, z) // renvoie la valeur minimale

Math.random () // générer un nombre pseudo-aléatoire supérieur à 0 et inférieur à 1

Math.pi // pi

Math.e // e: la base du logarithme naturel

Math.sqrt (3) // Root carré 3

Math.Pow (3, 1/3) // Root de cube de 3

Math.Sin (0) // Fonctions trigonométriques, ainsi que math.cos, math.atan, etc.

Math.log (10) //=>2.302585092994046 Logarithme naturel avec base 10

Math.log (512) / math.ln2 // log de 512 avec la base 2

Math.log (100) / math.ln10 // log de 100 avec la base 10

Math.exp (3) // E's Power of Three

Les opérations arithmétiques en JavaScript ne signaleront pas les erreurs lorsque le débordement, le sous-flux ou divisible par zéro. Cependant, le résultat de l'opération numérique dépasse le nombre qui peut être représenté dans JavaScript (Overflow), et le résultat est une valeur infinie spéciale (infusation), qui est exprimée en infortation en JavaScript. De même, lorsque la valeur du nombre négatif dépasse la plage de nombres négatifs que JavaScript peut exprimer, le résultat est l'infini négatif, qui est exprimé en influence en JavaScript. Les propriétés comportementales des valeurs de l'infini sont cohérentes avec ce que nous attendons: le résultat de l'addition, de la soustraction, de la multiplication et de la division basés sur eux est l'infini (préserver les signes)

Le sous-flux est une situation qui se produit lorsque le résultat de calcul est proche de zéro et est plus petit que la valeur minimale que JavaScript peut représenter. Lorsqu'un nombre négatif sous-écoute, JavaScript renvoie une valeur spéciale, "zéro négatif", qui (négatif zéro) est presque exactement le même que le zéro normal. Les programmeurs JavaScript utilisent rarement des zéros négatifs.

JavaScript a prédéfini les variables globales infinaty et nan pour exprimer des valeurs non nucères. Dans ECMASCIPT3, ces deux valeurs peuvent être lues et écrites. ECMAScript5 a résolu ce problème en les définissant en lecture seule. La valeur d'attribut définie par l'objet numérique dans ECMASCIPT3 est également en lecture seule, voici quelques exemples:

La copie de code est la suivante:

Infinity // Initialisez une variable lisible / écrite à Infinity

Numéro.Positive_infinity // même valeur, lire uniquement

1/0 // c'est la même valeur

Numéro.max_value + 1 // Le résultat du calcul est toujours à l'infini

Number.negative_infinity // désigne l'infini négatif

-Infini

-1/0

-Number.max_value -1

Nan // initialise une variable lisible / écrite à nan

Numéro.nan // même valeur, mais lisez uniquement

0/0 // Le résultat du calcul est toujours nan

Numéro.min_value / 2 // Underflow s'est produit. Le résultat calculé est 0

-Number.min_value / 2 // négatif zéro

-1 / infinité // zéro négatif

-0 // zéro négatif

Il y a un peu spécial sur les valeurs non nucères en JavaScript, qui ne sont pas égales aux humains et aux valeurs, y compris eux-mêmes. En d'autres termes, il est impossible de juger si X est nan par x == nan. Au lieu de cela, X devrait être utilisé! = x Pour juger que si et seulement lorsque x est nan, le résultat de l'expression est vrai. La fonction ISNAN () est similaire à celle-ci. Si le paramètre est nan ou une valeur non nucère (comme une chaîne et un objet), il renvoie true. Il existe une fonction similaire dans JavaScript qui Isfinite (), qui renvoie true lorsque les paramètres ne sont pas NAN, infsisty ou -infinity.

La valeur zéro négative est également un peu spéciale. Il est égal à un zéro positif et négatif (même jugé en utilisant le test d'égalité strict de JavaScript), ce qui signifie que ces deux valeurs sont presque exactement les mêmes sauf à l'exclusion:

La copie de code est la suivante:

var zéro = 0;

var negz = -0;

zéro === négz // => Les valeurs zéro positives et négatives sont égales

1 / zéro === 1 / négz // l'infini faux positif et l'infini négatif sont différents

IIII.Binary Floating Point Number and Arronding Error

Il y a d'innombrables nombres réels, mais JavaScript ne peut représenter que des nombres finis que par la forme de nombres de points flottants (pour être précis, il y a 18 437 736 874 454 810 627), c'est-à-dire que lorsque des nombres réels sont utilisés en JavaScript, il s'agit souvent d'une représentation approximative de la valeur réelle.

JavaScript adopte la notation du nombre de points flottants IEEE-754 (utilisé par presque tous les langages de programmation modernes). Il s'agit d'une représentation binaire qui peut représenter avec précision les fractions, telles que 1/2 1/8 et 1/1024. Malheureusement, les fractions que nous utilisons souvent, en particulier dans les calculs financiers, sont toutes basées sur les fractions décimales 1/10, 1/100, etc. La notation binaire ne peut pas représenter un nombre simple comme 0,1.

Les nombres en JavaScript ont une précision suffisante. Et peut être proche de 0,1. Mais en fait, l'incapacité d'exprimer avec précision les nombres entraîne quelques problèmes.

La copie de code est la suivante:

var x = .3 - .2;

var y = .2 - .1;

alerte (x == y) // => false les deux valeurs ne sont pas égales

x == .1 // => false .3-.2 ne correspond pas .1

y == .1 // => true .2- .1 est égal à 1

En raison de l'erreur d'arrondissement, la différence approximative entre 0,3 et 0,2 ne correspond pas réellement à la différence approximative entre 0,2 et 0,1 (dans des environnements de simulation réels, 0,3-0,2 = 0,099 999 999 999 999 999 999 98). Ce problème n'est pas seulement présent dans JavaScript, il est très important de comprendre ceci: ce problème se produira dans tout langage de programmation qui utilise des numéros de points flottants binaires. Il est également important de noter que les valeurs de x et y dans le code ci-dessus sont très proches les unes des autres et les valeurs correctes finales. Ce résultat de calcul peut être compétent pour la plupart des tâches de calcul. Ce problème ne se produit que lorsque vous comparez si les deux valeurs sont égales.

Les versions futures de JavaScript peuvent prendre en charge les types numériques décimaux pour éviter ce problème, avant que vous préférez utiliser de grands entiers pour des calculs financiers importants. Par exemple, utilisez des "segments" entiers au lieu d'éléments décimaux pour les unités monétaires.

iiiii.date et temps

Le noyau du langage JavaScript comprend le constructeur date (), qui a initialement créé des objets de date et d'heure. Les méthodes de ces objets de date fournissent une API simple pour le calcul de la date. Les objets de date ne peuvent pas être un type de données de base comme les nombres.

La copie de code est la suivante:

var zhen = nouvelle date (2011, 0, 1); // 1er janvier 2011

var ultérieurement = nouvelle date (2011, 0, 1, 17, 10, 30); // le même jour

var now = new Date (); // la date et l'heure actuelles

var elapsed = maintenant - zhen; // Date de soustraction. Calculez le nombre de millisecondes de l'intervalle de temps

ultérieurement.egultlyear (); // => 2011

plus tard.getMonth (); // => 0 mois compté à partir de 0

plus tard.getDate (); // => 1 le nombre de jours comptés à partir de 1

plus tard.getDay (); // => 5 Obtenez le jour de la semaine. 0 représente le dimanche, 5 représente le dimanche

plus tard.Gethours () // => heure locale

plus tard.getutchours () // Utilisez UTC pour représenter l'heure de l'heure, en fonction du fuseau horaire.

2. Texte

Une chaîne est une séquence immuable et ordonnée de valeurs 16 bits, chaque caractère provient généralement d'un jeu de caractères Unicode. JavaScript représente le texte via des types de chaînes. La longueur d'une chaîne est le nombre de valeurs 16 bits qu'il contient. L'index d'une chaîne JavaScript (et de son tableau) commence à 0. La longueur de la chaîne vide est 0, et il n'y a pas de "type de caractères" représentant un seul caractère en javascript. Pour représenter une valeur 16 bits, affectez-le simplement à une variable de chaîne. La longueur de cette chaîne est 1.

Jeu de caractères, code intérieur et chaîne javascript

JavaScript utilise un jeu de caractères Unicode codé UTF-16, et une chaîne JavaScript est une séquence composée d'un ensemble de valeurs 16 bits non ordonnées. Les caractères Unicode les plus couramment utilisés sont représentés par des codes intérieurs 16 bits et représentent un seul caractère dans la chaîne. Les caractères Unicode qui ne peuvent pas être représentés comme 16 bits sont suivis par les règles de codage UTF-16 - en utilisant deux valeurs 16 bits pour former une séquence (également appelée "paires de proxy"). Cela signifie qu'une chaîne JavaScript de longueur 2 (deux valeurs 16 bits) peut représenter un caractère Unicode.

La copie de code est la suivante:

var p = "π"; // π est représenté par le code intérieur 16 bits 0x03C0

var e = "e"; // E est représenté par le code intérieur de 17 bits 0x1d452

P.Length // => 1 P contient une valeur 16 bits

E.Length // => 2 E codé par UTF-16 contient deux valeurs: "/ ud835 / udc52"

Toutes les méthodes de fonctionnement des chaînes définies par JavaScript agissent sur des valeurs 16 bits, pas des caractères, et ne traitent pas l'élément proxy séparément. De même, JavaScript ne standardisera pas le traitement des chaînes. Il n'y a aucune garantie que les chaînes sont un format UTF-16 légal

Je corrige la quantité directe

Une quantité directe de chaînes dans un programme JavaScript est une séquence de caractères entourés de citations simples ou de citations doubles. Une chaîne délimitée par des citations simples peut contenir des citations doubles, et une chaîne délimitée par des citations doubles peut également contenir des citations simples. Voici quelques exemples de quantification directe des chaînes.

La copie de code est la suivante:

"" // chaîne vide, 0 caractères

'essai'

"3.14"

'name = "myform"'

"Ne préférerais-tu pas le livre d'O'Reily?"

Dans ECMascript3, la quantité directe de la chaîne doit être écrite en une seule ligne, tandis que dans ECMAScript5, la quantité directe de la chaîne peut être divisée en plusieurs lignes, et chaque ligne doit se terminer avec une barre oblique inverse (/). Ni la barre arrière ni le caractère de fin de ligne ne sont le contenu de la quantité directe de la chaîne. Si vous voulez être ensemble, vous pouvez utiliser / n pour échapper aux caractères.

Il convient de noter que lorsque vous utilisez des citations uniques pour délimiter les chaînes, vous devez faire très attention aux abréviations et à tous les formats en anglais. Les apostrophes anglaises et les citations simples sont le même caractère, donc les barres objets de barres (/) doivent être utilisées pour s'échapper.

II Échappez les caractères

Dans les chaînes JavaScript, les barres oblidviennes (/) ont un objectif spécial. L'ajout d'un personnage aux barreaux révolutionnaires ne représentera plus leur signification littérale. Par exemple, / n est un caractère d'évasion, qui représente une nouvelle ligne.

La copie de code est la suivante:

/ o // nul caractères

/ B // Caractère de retour arrière

/ T // Caractère d'onglet horizontal

/ N // Ligne Newline Caractère

/ V // Caractère de l'onglet vertical

/ F // Renouvellement de la page

/ r // Caractère de retour chariot

/ "// Double Citations

// bombardement

/ xxx Caractère latin-1 spécifié par HexaDecimal à deux bits

/ xxxxxx Unicode Caractère spécifié par HexaDecimal à quatre bits xxxxx

Utilisation de la chaîne III

L'une des fonctionnalités intégrées de JavaScript est la concaténation des cordes. Utilisez l'opérateur + pour les chaînes pour représenter la concaténation des chaînes. Par exemple

La copie de code est la suivante:

var msg = "hello" + "monde"; // Générer le monde de la chaîne Hello

Pour déterminer la longueur d'une chaîne - le nombre de valeurs 16 bits qu'il contient, vous pouvez utiliser l'attribut de longueur, comme la longueur de la chaîne s.

la longueur

En plus de l'attribut de longueur, les chaînes fournissent également de nombreuses méthodes qui peuvent être appelées.

La copie de code est la suivante:

var s = "Hello, world";

S.Carat (0); // premier personnage "H"

S.Charat (S.Length - 1) // "D" Dernière caractère

S.Substring (1, 4) // "Ell" 2-4 caractères

S.slice (1, 4) // ell Idem que ci-dessus

S.slice (-3) // Les 3 derniers caractères apparaissent

S.Indexof (l ") // 2 caractères l la première position d'occurrence

S.LastIndexof ("L") // 10 La dernière fois que le caractère l apparaît

S.Indexof ("L", 3) // Après la position 3, la première position où le caractère L apparaît

S.Split (",") // => ["Hello", "World"] est séparé en sous-chaînes

S.replace ("H", "H") // => "Hllo, World" Remplacement de caractère en texte intégral

S.ToupperCase () // => "Bonjour, monde"

En JavaScript, les chaînes sont fixes et inchangées. Des méthodes comme Remplace () et ToupperCase () renvoient de nouvelles chaînes, et les personnages originaux eux-mêmes n'ont pas changé.

Dans ECMAScript, les caractères peuvent être traités comme des tableaux en lecture seule. En plus d'utiliser la méthode Charat (), les crochets peuvent également être utilisés pour accéder aux caractères individuels dans une chaîne. (Valeur 16 bits)

La copie de code est la suivante:

S = "Bonjour, monde"

s [0] // => "h"

S [S.Length-1] // => "D"

Foxfire a pris en charge l'indexation des cordes pour cette méthode il y a longtemps, et la plupart des navigateurs modernes (sauf IE) ont suivi les traces de Mozaulla et terminé cette fonction avant la formation d'ECMAScript.

IIII Match Matching

JavaScript définit le constructeur regexp (), qui est utilisé pour créer des objets qui représentent la correspondance du modèle de texte. Ces modèles sont appelés "expressions régulières", syntaxe d'expression régulière dans JavaScript Perl. Les objets String et Regexp définissent les fonctions qui utilisent des expressions régulières pour correspondre aux modèles, à trouver et à remplacer.

L'objet regexp n'est pas un type de données de base dans la langue. Comme la date, c'est juste un objet spécial avec une API pratique. Les expressions régulières ont une syntaxe complexe et des API riches. Il sera introduit en détail dans le chapitre 10. Regexp est un outil de traitement de texte puissant et couramment utilisé, et voici juste un aperçu.

Bien que RegExP ne soit pas un type de données de base dans la langue, ils ont toujours des quantités directes et peuvent être utilisés directement dans JavaScript. Le texte entre deux barres obliques forme une quantité directe d'expression régulière. La deuxième barre oblique peut également suivre une ou plusieurs lettres. Utilisé pour modifier la signification du modèle d'appariement. Par exemple:

La copie de code est la suivante:

/ ^ Html / // correspond aux chaînes à commencer par html

/ [1-9] [0-9] * / // correspondent à un numéro non nul, suivi de n'importe quel numéro

// bjavascript / b / i / // correspond au mot javascrip

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:

La copie de code est la suivante:

var text = "test: 1,2,3"; // Exemple de texte

Var Pattern = // d + / g // correspond à toutes les instances contenant un ou plusieurs nombres

Pattern.test (texte) // => true: le match réussit

text.search (modèle) // => 9: la position où le premier match a réussi

text.match (motif) // => ["1", "2", "3"] Toutes les correspondances forment un tableau

text.repeat (modèle, "#"); // => "Test: #, #, #"

text.split (// d + /); // => ["", "1", "2", "3"]: utilisez des caractères non numériques pour intercepter les chaînes

3. Valeur booléenne

Les valeurs booléennes se réfèrent à vrai ou false, sur ou hors ou off. Ce type n'a que deux valeurs, et le mot true ou false est réservé.

Les résultats des instructions de comparaison en JavaScript sont généralement des valeurs booléennes. Par exemple

a == 4

Ce code est utilisé pour détecter si la valeur de A de la variable est égale à 4. S'il est égal, la valeur est vraie, si la valeur n'est pas égale, faux

Les valeurs booléennes sont généralement utilisées dans les instructions de contrôle JavaScript, telles que les instructions IF / ELLE dans JavaScript. Si la valeur booléenne est vraie, exécutez le premier morceau de logique, et si un autre morceau de code est faux, par ex.

La copie de code est la suivante:

si (a == 4)

b = b + 1;

autre

a = a + 1;

Toute valeur JavaScript peut être convertie en valeurs booléennes, et les valeurs suivantes sont converties en faux

La copie de code est la suivante:

indéfini

nul

0

-0

Nan

"" // chaîne vide

Toutes les autres valeurs, y compris tous les objets (tableaux), seront converties en vraie, fausse, et les 6 valeurs ci-dessus qui peuvent être converties en false sont parfois appelées "fausses valeurs". JavaScript s'attend à ce que lorsque vous utilisez une valeur booléenne, la fausse valeur sera traitée comme fausse et la vraie valeur sera traitée comme vraie.

Jetons un coup d'œil à un exemple. L'ajout de la variable O est un objet ou nul, vous pouvez utiliser une instruction IF pour détecter si O est une valeur non nulle.

if (o! == null) ...

L'opérateur inégal "! ==" Compare O et NULL et donne le résultat 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 ne sera exécuté que lorsque O n'est pas nul, et les limites du deuxième cas ne sont pas si strictes. Ceci est exécuté uniquement si O n'est pas faux ou une fausse valeur (comme null ou non lié).

Booléen contient la méthode toString (), vous pouvez donc utiliser cette méthode pour convertir une chaîne en "vraie" ou "false", mais elle ne contient pas d'autres méthodes utiles, et en plus de cette API sans importance, il existe trois opérateurs booléens importants.

&& opérateur, || Opérateur et opérateur unaire "!" effectuer une opération booléenne non (pas). Si la vraie valeur retourne fausse, la fausse valeur renvoie vrai, par exemple

La copie de code est la suivante:

if ((x == 0 && y == 0) ||! (z == 0)) {

// x et y sont tous les deux zéro ou z ne sont pas nuls

}

4. nul et indéfini

Null est un mot-clé dans la langue javascript. Il représente une valeur spéciale "valeur nul". Pour NULL, il effectue l'opération TypeOf () et renvoie l'objet. C'est-à-dire que 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 que les nombres, les chaînes et les objets sont "sans valeur". La plupart des langages de programmation contiennent null comme JavaScript, et vous pouvez être familier avec 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'a pas été initialisée. Si vous souhaitez interroger la valeur d'un attribut d'objet ou d'un élément de tableau, il renvoie non défini, cela signifie que l'attribut 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 n'est pas définie. Si vous utilisez le typeof pour tester le type non défini, "Undefined" est renvoyé, indiquant que la valeur est le seul membre du type.

Bien que nul et indéfinis soient différents, ils représentent tous les deux des "vacances de valeurs" et les deux sont souvent interchangeables. L'opérateur qui juge l'égalité "==" pense que les deux sont égaux (utilisez l'opérateur d'égalité strict "===" pour les distinguer). Lorsque la valeur devrait être de type booléen, leurs valeurs sont toutes fausses. Similaire à false. NULL et UNDEFINED ne contiennent aucune propriété et méthodes. En fait, en utilisant "." et "[]" pour accéder aux membres ou aux méthodes de ces deux valeurs produira une erreur de type.

Vous pourriez penser que les indéfinis représentent le niveau du système, vivant inattendu des postes vacants de mauvaises valeurs, tandis que NULL représente les postes vacants au niveau du programme, normaux ou attendus. Si vous souhaitez les copier sur des variables ou des propriétés, ou les transmettre sous forme de paramètres dans une fonction, Null est le meilleur choix.

5. Objets globaux

Les sections précédentes discutent des types d'éléments et des valeurs d'origine de JavaScript. Types d'objets - objets, tableaux et fonctions / mais il existe une classe d'objets très importante qui ne doit pas être claire maintenant: objets globaux

L'objet global a des utilisations importantes dans JavaScript. Les propriétés d'un objet global sont des symboles définis à l'échelle mondiale. Les programmes JavaScript peuvent être utilisés directement. Lorsque l'interprète JavaScript démarre, il crée un nouvel objet global et lui donne un ensemble de propriétés initiales définies.

Propriétés mondiales telles que l'infini non défini et NAN

Fonctions globales telles que Isnan (), ParseInt () et EVAL ()

Des constructeurs tels que date (), regexp (), string (), object () et array ()

Objets mondiaux, tels que les mathématiques et JSON

L'attribut initial d'un objet global n'est pas un mot réservé, mais ils doivent être traités comme un mot réservé.

Au niveau supérieur du code - code JavaScript pas dans aucune fonction, vous pouvez vous référer à l'objet global via le mot-clé JavaScript.

var global = this; // Définir une variable globale qui fait référence à un objet global.

Dans Client JavaScript, l'objet Window agit comme un objet global. Cet objet de fenêtre global a une référence de fenêtre familière elle-même. Il peut le remplacer pour se référer à l'objet global. Windows définit les attributs de base globaux. Cependant, certains autres attributs globaux sont définis pour les navigateurs Web et le JavaScript interactif.

Lorsqu'il est créé pour la première fois, l'objet global définit toutes les valeurs globales prédéfinies en JavaScript, et 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 un attribut de l'objet global.

6. Objet d'emballage

Un objet JavaScript est une valeur composée: il s'agit d'une collection d'attributs ou de valeurs nommées. La valeur d'attribut est référencée via "." Lorsque la valeur d'attribut est une fonction, il s'agit d'une méthode et utilise om () pour transférer les méthodes dans l'objet o.

Nous voyons que les chaînes ont également des propriétés et des méthodes.

La copie de code est la suivante:

var s = "Hello World";

var word = s.substring (s.indexof ("") + 1, s.length); // Utilisez les attributs de la chaîne.

Document.Write (Word) // "Ello World"

Puisqu'une chaîne n'est pas un objet, pourquoi a-t-il des propriétés? Tant que l'attribut de String S est référencé, JavaScript convertira la valeur de la chaîne en un objet en appelant de nouvelles chaînes, ce qui hérite de la méthode de chaîne. et est utilisé pour traiter les références d'attribut. 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 ne crée pas ou ne détruit pas nécessairement, mais ce 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 numéro () et boolean (). Toutes ces méthodes sont appelées à partir de cet objet temporaire. (Null et Undefined n'ont pas été enveloppés d'objets, l'accès à leurs propriétés aura une erreur de type)

Regardez le code suivant et réfléchissez à leur processus d'exécution

La copie de code est la suivante:

var s = "test";

S.Len = 4; // définit une propriété pour cela

var t = s.len // trouver cette propriété

Lors de l'exécution de ce code, la valeur de T n'est pas définie. La deuxième ligne de code crée un objet de chaîne temporaire et donne à Len une valeur de 4. L'objet est ensuite détruit. La troisième ligne utilise la chaîne originale (non modifiée) pour créer un nouvel objet de chaîne et essaie de lire les attributs de Len.

Cette propriété n'existe pas naturellement, indiquant que le résultat n'est pas défini. Ce code montre que lors de la lecture des valeurs de propriété (ou des méthodes) des chaînes, des tableaux et des valeurs booléennes, elle se comporte comme un objet, mais si vous essayez d'attribuer une valeur à sa propriété. Cette opération sera ignorée; La modification n'arrive qu'aux objets temporaires. Cet objet temporaire n'a pas été conservé.

Il convient de noter que la création d'objets wrapper peut être affichée via les constructeurs String (), Number () et Boolean ():

La copie de code est la suivante:

var s = "test",

n = 1,

b = true;

var s = nouvelle chaîne (s);

var n = nouveau nombre (n);

var b = nouveau booléen (b);

JavaScript convertit l'emballage en valeur d'origine lorsque cela est nécessaire, donc l'objet SNB dans le code précédent souvent - mais pas toujours - représente la même valeur que SNB, "==" égal à l'opérateur traite la valeur d'origine et son objet de wrapper comme égal.

Mais l'opérateur complet "===" les traite comme des inégalités, et la différence entre la valeur d'origine et l'objet qu'il enroule peut être observée via l'opérateur de type.

7. Valeurs d'origine immuables et références d'objets mutables.

La valeur d'origine de JavaScript (nombres et chaînes booléens null non définis) est fondamentalement différent des objets (y compris des tableaux et des fonctions). La valeur d'origine est immuable; Aucune méthode ne peut (ou muter) une valeur primitive. C'est évidemment vrai pour les nombres et les booléens - changer la valeur d'un nombre n'a pas de sens en soi, mais ce n'est pas si évident pour les cordes, car les cordes semblent être un éventail de personnages. Nous nous attendons à ce que les caractères de la chaîne puissent être modifiés par l'index spécifié. En fait, JavaScript interdit de faire cela. Toutes les méthodes de la chaîne semblent renvoyer une chaîne modifiée, qui est en fait une nouvelle chaîne.

La copie de code est la suivante:

var s = "Hello World";

S.ToupperCase (); // Renvoie "Hello World" et ne change pas la valeur de S

S // => "Hello World" La chaîne originale n'a pas changé

原始值的比较是值的比较，只有在他们的值相当时它们在才相等。这对数字、布尔值、null和undefined来说听起来有点难，并没有其他办法来比较他们。同样，对于字符串来说则不那么明显；如果比较两个单独的字符串，当且仅当他们的长度相等且每个索引的字符都相等时，javascript的才认为相等。

La copie de code est la suivante:

var o = {x:1} //定义一个对象

ox = 2 //通过修改对象的属性来改变对象

oy = 3 //再次更改这个对象，给它增加一个新属性

var a =[1,2,3] //数组也是可以修改的

a[0]=0; //更改数组中的一个元素

a[3]=4; 给数组增加一个新元素

对象的比较并非值的比较：即使两个对象包含同样的属性及相同的值，他们也是不相等的，各个索引元素完全相等的两个数组也不相等

La copie de code est la suivante:

var o ={x:1}, p={x:1}//两个具有相同属性的两个对象

o === p ;//=>false 两个单独的对象永不相等( o == p ; =>false)

var a =[],b=[]; //两个单独的空数组

a === b ; //=>false两个单独的数组永不相等

我们通常将对象称为引用类型(reference type),以此来和javascript的基本类型区分开来。依照术语的叫法，对象都是引用(reference),对象的比较均是引用的比较；当且当它们应用同一个基对象时，它们才相等。

La copie de code est la suivante:

var a = []; //定义一个引用空数组的变量a

var b = a; //变量b引用同一个数组

b[0] = 1;

a[0] //=>1 变量a也会修改

a === b //=>true a和b引用同一个数组，因此他们相等。

就像你刚才看到的如上代码，将对象（或数组）赋值给一个变量，仅仅是赋值的引用值：对象本身并没有复制一次。

如果你想得到一个对象或数组的副本，则必须显式复制对象的每个属性或数组的每个元素。下面的这个例子则是通过循环来完成对数组的复制。

La copie de code est la suivante:

var a = ['a', 'b', 'c']; //待复制的数组

var b = []; //复制到目标的空数组

for (var i = 0; i < a.length; i++) { //遍历a[]中的每个元素

b[i] = a[i]; //将元素复制到b中。

}

同样的，如果我们想比较两个单独或者数组，则必须比较他们的属性或元素。下面这段代码定义了一个比较练个数组的函数。

La copie de code est la suivante:

function equalArrays(a, b) {

if (a.length != b.length) return false; //两个长度不相同的数组不相等

for (var i = 0; i < a.length; i++) //循环遍历所有元素

if (a[i] !== b[i]) return false; //如果有任意元素不等，则数组不相等

Retour Vrai; // Otherwise they are equal

}

8.类型转化

javascript中的取值型非常灵活，我们已经从布尔值看到了这一点：当javascript期望使用一个布尔值时候，你可以提供任意类型值。javascript将根据需要自行转换类型。一些值（真值）为true，其它值（假值）转化为false.这在其它类型中同样适用。如果javascript期望使用一个字符串，它把给定的值转换为字符串。如果javascript期望使用一个数组，它把给定的值转换为数字（如果转化结果无意义的话将返回NaN）,一些例子如下：

La copie de code est la suivante:

10 + "object" //=> "10object";

"7" * "4" // =>28 两个字符串均转化为数字

var n = 1 - "x" // =>NaN字符串x无法转换为数字

n + " objects" // =>"NaN objects":NaN转换为字符串"NaN"

下表说明了在javascript中如何进行类型转化。粗体突出了那些让你倍感意外的类型转化。空单元格表示不必要也没有执行的转换。

上表提到的原始值到原始值的转换行对简单，我们已经在第本文第三小节讨论过转换为布尔值的情况了。所有原始值转换为字符串的情形也已经明确定义。转换为数字的情形比较微妙。那些以数字表示的字符串可以直接转化为数字，也允许在开始和结尾处带有空格。但在开始和结尾处的任意非空字符都不会被当成数字量的一部分，进而造成字符串为数字的结果为NaN。有一些数字转换看起来让人奇怪：true转换为1，false、空字符串""转换为0.

原始值到对象的转换也非常简单，原始值通过调用String()，Number()或Boolean()构造函数，转化为它们各自的包装对象。见本文第6节。

null和undefined属于例外，当将它们用在期望是一个对象的地方都会造成一个类型错误(TypeError)异常。而不会执行正常的转换。

对象到原始值的转换多少有些复杂，本小节第三小节有专门描述。

je. Conversion and Equality

由于javascript可以做灵活的类型转换，因此其“==”相等运算符也随相等的含义灵活多变。例如：如下这些比较结果均是true；

null == undefined //这两值被认为相等

"0" == 0 //在比较之前，字符串转换成数字。

0 = false //在这之前布尔值转换成数字。

"0" ==false //在比较之前字符串和布尔值都转换成数字

在第四章9节第一小节相信讲解了“==”等于运算符在判断两个值是否相等时做了那些类型转换，并同样介绍了“===”恒等运算符在判断相等时并未做任何的类型转换。

需要特别注意的是：一个值转换为另一个值并不意味着两个值相等。比如在期望使用布尔值的地方使用了undefined，将会转换为false，但这不表明undefined==false。javascript运算符和语句期望使用多样化的数据类型，并可以互相转换。if语句将undefined转化为false,但“==”运算符从不试图将其转化为布尔值。

ii Explicit type conversion

尽管javascript可以做做很多类型转换，但有时仍需要做显式转换，或者为了使代码变得清晰易读而做显式转换。

做显式转换最重简单的方法就是使用Boolean()、Number()、String()或Object函数。我们在本文第6节已经介绍过了. 当不通过new运算符调运这些函数时，他们会作为类型转换函数并按照上边表格所描述的规则做类型转换。

La copie de code est la suivante:

Number("3") //=>3

String(false) //=>"false"或使用false.toString()

Boolean([]) //=>true

Object(3) // =>new Number(3)

需要注意的是，除了null或undefined之外的任何值都具有toString()方法，在这个方法的执行结果通常和String()方法返回的结果一致。同样需要注意的话，如果试图把null或undefined转化为对象。则会抛出一个类型错误typeerro。Object()函数在这种情况下不会抛出异常：它仅简单返回一个新创建的空对象。

javascript中的某些运算符会做隐式的类型转换，有时用于类型转换。如果“+”运算符的一个操作数是字符串，它将会把令一个操作数转换为字符串。一元“+”运算符将其操作数转换为数字。同样，一元“！”运算符将其操作数转换为布尔值取反，在代码中常会看到这种类型转换的惯用法。

La copie de code est la suivante:

x + "" // 等于字符串String(x)

+x //等价于Number(x),也可以写成x-0

!!x //等价于Boolean(x)

在计算机中数字的解析和格式化代码是非常普通的工作。javascript中提供了专门的函数和方法用来更加精确的数字到字符串（number-to-string）和字符串到数字(string-to-number)的抓换。

Nmuber类定义的toString()方法可以接收表示基数（二进制，八进制，十六进制等）的可选参数，如果不指定该参数，转化规则将是十进制。同样也可以将数字转换为其它进制数。（范围在2-36之间）

La copie de code est la suivante:

var n = 17;

b_string = n.toString(2); //转化为10001

o_string = "0" + n.toString(8); //转化为八进制021

hex_string = "0x" + n.toString(16); //转化为16进制0x11

javascript为控制输出中小数点位置和有效数字位数，或者决定是否需要指定指数计数法。Number类为这种数字到字符串定义了三个方法。

toFixed()根据小数点后指定位数，将数字转换为字符串，它从不使用指数计数法。toExponential()使用指数计数法，将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位置则由参数指定（也就是说有效数字位数要比指定的位数多一位）。toPrecision()根据指定的有效数字位数，将数字转换为字符串。如果有效数字的位数小于数字整数部分的位数，则转换成指数形式。我们注意到，三个方法都会适当的进行四舍五入或填充0,

La copie de code est la suivante:

var n = 123456.789;

n.toFixed(0); //"123457"

n.toFixed(2); //"123456.79"

n.toFixed(5); //"123456.78900"

n.toExponential(1); //"1.2e+5"

n.toExponential(3); //"1.235e+5"

n.toPrecision(4); // "1.235e+5"

n.toPrecision(7); //"123456.8"

n.toPrecision(10); //"123456.7890"

如果通过Number()转换函数传入一个字符串，它会试图将其转化为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且不能出现非法的尾随字符。parseInt()和parseFloat()函数（它们是全局函数，不属于人和类的方法），更加灵活。parseInt()只解析整数。而parseFloat()则可以解析整数和浮点数。如果字符串前边是0x或0X,parseInt()将其解析为16进制数。两个方法都会跳过任意量的前导空格，尽可能解析更多数值字符。并忽略后边的内容。如果第一个是非法的数字直接量，则返回NaN

La copie de code est la suivante:

parseInt("3many nice") //=>3;

parseFloat("3.14meters") //=>3.14

parseInt("-12.34") //=>-12

parseInt("0xff") //=>255

parseInt("-0XFF") //=>-255

parseFloat(".1") // =>0.1

parseInt("0.1") //=> 0

parseInt(".1") //=>NaN 不能以.开始

parseInt("$112") //=>NaN 不能以$开头

parseInt()可以接收第二个可选参数。这个参数指定数字转换的基数。合法的取值范围是2-36

La copie de code est la suivante:

parseInt("11", 2) //=>3(1*2+1)

parseInt("ff", 16) //=> 255(15*16 +15)

parseInt("zz", 36) //=>1295(35*36+35)

parseInt("077", 8) // 63(7*8 +7)

parseInt("077", 10) //77(7*10+7)

iii.对象转化为原始值。

对象到布尔值的转换非常简单：所有的对象（包括数组和函数）都转换为true。对于包装对象亦是如此，new Boolean(false)是一个对象而不是原始值，它将转换为true。 对象到字符串（object-to-String）和对象到数字(object-to-number)的转换是通过调用带转换对象的一个方法来完成的。一个麻烦的事实是，javascript对象有两个不同的方法来执行转换，并且接下来要讨论并且接下来要讨论的场景更加复杂。值得注意的是，这里提到的字符串和数字的转换规则只适用于本地对象（native fangf object）.宿主对象(例如：由web浏览器定义的对象)，根据各自的算法可以转换成字符串和数字。

所有的对象继承了两个转换方法。第一个是toString(), 它的作用是返回一个反映这个对象的字符串。默认的toString()方法并不会返回一个有趣的值。

({x:1,y:2}).toString() //=>"[object object]"

很多类定义了更多特定版本的toString()方法.

例如：数组类(Array class)的toString()方法将每个数组元素转换为一个字符串，并在元素之间添加逗号后并合成结果字符串。

函数类(Function class)的toString()方法返回这个函数的实现定义的表示方式。实际上，这里的实现方式是通常是将用户定义函数转换为javascript源代码字符串。

日期类(Date class)定义toString()方法返回一个可读的（可被javascript-parsable解析的）日期和事件字符串

RegExp class定义的toString()方法将RegExp对象转换为正则表达式直接量字符串。

La copie de code est la suivante:

[1, 2, 3].toString(); //=> "1,2,3"

(function(x) {f(x);}).toString(); // =>"function(x){/nf(x); /n}"

//d+/g.toString(); //=> ///d+/g

new Date(2015, 0, 1).toString() //=>Thu Jan 01 2015 00:00:00 GMT+0800 (中国标准时间)

另外一个函数是valueOf(),这个方法的任务并未详细定义：如果存在任意原始值，它就默认将对象转换为表示它的原始值。对象是复合值，而且大多数对象无法真正表示一个原始值，数组、函数和正则表达式简单地继承了这个默认方法，调用这些类型的实例的的valueOf()方法简单地返回对象本身。日期类定义的valueOf()方法返回它的一个内部表示：1970年1月1日以来的毫秒数。

La copie de code est la suivante:

var d = new Date(2015, 0, 1); //=>Thu Jan 01 2015 00:00:00 GMT+0800 (中国标准时间)

d.valueOf() //=>1420041600000

通过是用我们刚才讲解过的toString()和valueOf()方法，就可以做到对象到字符串和对象到数字的转换了。但在某些场景中，javascript执行了完全不同的对象到原始值的转换。这些特殊的场景在本节的最后会讲到。

javascript对象到字符串的转换经过了如下这些步奏

如果对象具有toString()方法，则调用这个方法。如果它返回一个原始值，javascript将这个值转换为字符串（如果本身不是字符串的话），并返回这个字符串结果。

如果对象没toString()方法，或者这个方法并不返回一个原始值，那么javascript会调用valueOf()方法。如果存在这个方法，则javascript调用它。如果返回值是原始值，javascript将责怪值转换为字符串。

9.变量声明。

在javascript程序中，使用一个变量之前应该先声明，变量是通过var来声明的，如下所示：

var i;

var sum;

也可以通过一个var关键字声明多个变量

var i,sun;

而且还可以将变量的初始值和变量声明和写在一起；

var message = "hello";

var i=0 ,j=0,k=0;

If the variable is specified in the var declaration statement, even though the variable is declared, its initial value is undefined before storing it a value. We noticed that the var statement can also be used in the for and fo/in loops, which can more concisely declare the loop variables used in the loop body syntax. Par exemple:

La copie de code est la suivante:

for (var i = 0; i < 10; i++) log(i);

for (var i = 0, j = 10; i < 10, j = 100; i++, j--) console.log(i * j)

for (var p in o) console.log(p);

If the variable is specified in the var declaration statement, even though the variable is declared, its initial value is undefined before storing it a value. We noticed that the var statement can also be used in the for and fo/in loops, which can more concisely declare the loop variables used in the loop body syntax. Par exemple:

La copie de code est la suivante:

var i=10;

i="ten";

10.变量作用域

一个变量的左右域（scope）是程序源代码中定义这个变量的区域，全局变量拥有全局作用域，在javascript代码中的任何地方都是定义。然而在函数内部声明变量只在函数体内有定义。他们是局部变量，作用是局部性的。函数参数也是局部变量，它们只在函数体内有定义。

在函数体内，局部变量的优先级高于同名的全局变量。如果在函数内声明一个局部变量或者函数参数中带有的变量和全局变量重名，那么全局变量就被局部变量所遮盖。

La copie de code est la suivante:

var scope = "global"; //声明一个全局变量

function checkscope() {

var scope = "local"; //声明一个同名的局部变量

return scope;

}

checkscope(); //=>"local"

尽管在全局作用域编写代码时可以不写var语句，但声明局部变量时则必须使用var语句。

La copie de code est la suivante:

scope = "global"; //声明一个全局变量,甚至不使用var来声明

function checkscope2() {

scope = "local"; //修改了全局变量

myscope = "local"; //这里显示式得声明了一个新的全局变量

return [scope, myscope]; //

}

checkscope2(); //=> ["local","local"]:产生了副作用

scope // =>"local"全局变量修改了

myscope //=> "local"全局命名空间搞乱了。

函数定义是可以嵌套的。由于每个函数都有它直接的作用域，因此会出现几个局部作用域嵌套的情况。

La copie de code est la suivante:

var scope = "global scope"; //全局变量

function checkscope() {

var scope = "local scope"; //局部变量

function nested() {

var scope = "sested scope"; //嵌套作用域内的局部变量

return scope;

}

return nested();

}

checkscope() //=>"嵌套作用域" sested scope

je. Function scope and declaration in advance

在一些类似c语言的编程语言中，花括号内的每一段代码都具有各自的左右域，而且变量在声明他们的代码之外是不可见的我们称之为块级作用域(block scope),而javascript中没有块级作用域，javascript取而代之的使用了函数作用域(function scope);变量在声明它们的函数体以及这个函数体嵌套的任意函数体内都是有意义的。

如下代码，在不同的位置定义了ijk，他们都在同一个作用域内，这三个变量在函数体内均有定义的。

La copie de code est la suivante:

function test(o) {

var i = 0; //i在整个函数体内均是定义的

if (typeif o == "object") {

var j = 0; //j在函数体内是有定义的，不仅仅是在这个代码段内

for (var k = 0; k < 10; k++) { //k在函数体内是有定义的，不仅仅是在循环内

console.log(k); //输出数字0-9

}

console.log(k); //k已经定义，输出10

}

console.log(j); //j已经定义了，但可能没有初始化。

}

javascript的函数作用域是指在函数内声明的所有变量在函数体内始终是可见的。有意思的是，这意味这变量在声明之前甚至已经可用。javascript的这个特性被非正式的称为声明提前（hoisting），即javascript函数里声明的所有变量(但不涉及赋值)都被提前至函数整体的顶部。如下代码：

La copie de code est la suivante:

var scope = "global";

function f() {

console.log (portée); //Output "undefined", not "global"

var scope = "local"; //变量在这里赋初始值，但变量本身在函数体内任何地方都是有定义的

console.log (portée); //Output "local"

你可能误以为函数的第一行会输出"global",因为代码还没有执行到var语句声明局部变量的地方。其实不然，由于函数作用域的特性模具部变量在整个函数体内始终有定义的，也就是说，在函数体内局部变量覆盖了同名全局变量。尽管如此，只有在程序执行到var语句的时候，局部变量才能正真的被赋值。

因此，上述的过程等价于：将函数内的变量声明"提前"至函数顶部，同时变量初始化留在原来的位置：

La copie de code est la suivante:

function f() {

var scope; //在函数的顶部声明了局部变量

console.log (portée); //The variable exists, but its value is "undefined"

scope = "local"; //在这里将其初始化，并赋值

console.log (portée); //Here it has the value we expect

}

在具有块级作用域的编程语言中，在狭小的作用域里让变量声明和使用变量的代码尽可能靠近彼此，通常来说，这是一个非常不错的编程习惯。由于在javascript中没有块级作用域，因此一些程序员特意将变量声明放在函数体顶部，而不是将声明放在靠近使用变量之处。这种做法使得他们的源代码非常清晰地反映了真实的变量作用域。

ii作为属性的变量

当声明一个javascript全局变量时面试及上是定义了全局对象的一个属性。见本文第三节。

当使用var声明一个变量时，创建的这个属性是不可配置的。见第六章第7节。也就是说这个变量无法通过delete运算符删除。可能你已经注意到了，如果你没有使用严格模式并给一个未声明的变量赋值的话。javascript会自动创建一个全局变量。以这种方式创建变量是全局对象正常的可配置属性。可以删除它们。

La copie de code est la suivante:

var truevar = 1; //声明一耳光不可删除的全局变量

fakevar = 2; //创建全局对象的一个可删除的属性

this.fakevar2 = 3; //同上

delete truevar // =>false 变量并没有删除

delete fakevar //=>true 变量被删除

delete this.fakevar2 //=>true 变量被删除

javascript全局变量是全局对象的属性，这是在ECMAScript规范中强制规定的。对于局部变量则没有此规定，但我们可以想象得到，局部变量当做跟函数调用相关的某个对象的属性。ECMAScript3规范称对象为“调用对象”（call object）,ECMAScript5规定范称为“声明上下文对象”（declarative environment record）。javascript可以允许使用this关键字引用全局对象，却没有方法可以引用局部变量中存放的对象。这种存放局部变量的对象的特有性质，是一种对我们不可见的内部实现。然而，这些局部变量对象存在的观念是非常重要的。

iii作用域链

javascript是基于词法作用域的语言：通过阅读包含变量定义在内的舒航源码就能知道变量的作用域。

全局变量在程序中始终是都是有定义的。局部变量在声明它的函数体内以及其所嵌套的函数内始终是有定义的。