Oraciones de lectura de JavaScript Core

En JavaScript, las expresiones son frases, y las declaraciones son la oración o comando completo. Así como una declaración en inglés termina con un período, JavaScript termina con un punto y coma.

La expresión calcula un valor, pero la declaración hace que algo suceda.

Una forma de "hacer que algo suceda" es calcular las expresiones con efectos secundarios. Las expresiones con efectos secundarios como tareas y llamadas de función se pueden usar como declaraciones separadas. Este uso de expresiones como declaraciones también se llama declaraciones de expresión. Declaraciones similares incluyen declaraciones de declaración, que se utilizan para declarar nuevas variables o definir nuevas funciones.

Un programa JavaScript es una colección de una serie de declaraciones ejecutables. Por defecto, el intérprete JavaScript se ejecuta en secuencia en orden de escritura. Otra forma de "hacer que algo suceda" es cambiar la orden de ejecución predeterminada de la declaración:

1. Declaración condicional: el intérprete de JavaScript puede determinar si ejecutar o omitir estas declaraciones, como las declaraciones de si y conmutador.

2. Declaración de bucle: declaraciones que se pueden ejecutar repetidamente, como mientras y para declaraciones

3. Declaración de salto: puede dejar que el intérprete salte a otras partes del programa para continuar la ejecución, como declaraciones de descanso, devolución y lanzamiento

A continuación, este artículo presentará varias declaraciones y su sintaxis en JavaScript. Este capítulo resume estas oraciones al final. Un programa JavaScript no es más que una colección de declaraciones separadas por separación, por lo que una vez que domina las declaraciones de JavaScript, puede escribir un programa JavaScript.

1. Declaración de expresión

Las declaraciones de asignación son una declaración de expresión relativamente importante. Su función es cambiar el valor de una variable, al igual que ejecutar una declaración de asignación: por ejemplo

La copia del código es la siguiente:

salud = "hola" + nombre;

i *= 3;

El operador de incremento (++) y el operador decreciente (-) están relacionados con la declaración de asignación. Su función es cambiar el valor de una variable, al igual que ejecutar una declaración de asignación.

La copia del código es la siguiente:

contador ++;

La función importante del operador Eliminar es eliminar las propiedades de un objeto (o elementos de una matriz) y todo lo que generalmente se usa como declaraciones, no como parte de una expresión compleja.

La copia del código es la siguiente:

eliminar buey;

Las llamadas de la función son otra categoría importante de declaraciones de expresión, por ejemplo

La copia del código es la siguiente:

alerta (salud);

window.close ();

Aunque estas funciones del cliente son expresiones, tienen un cierto impacto en el navegador web. Por lo tanto, creemos que también es una declaración, y no tiene sentido llamar a una función sin efectos secundarios a menos que sea parte de una expresión compleja o una declaración de asignación, por ejemplo. Es imposible descartar un valor coseno al azar;

Math.cos (x);

En cambio, para obtener el valor coseno, debe asignarlo a una variable para que este valor pueda usarse en el futuro:

var cx = math.cos (x);

Nuevamente, cada línea de código termina con un punto y coma.

2. Declaraciones compuestas y declaraciones vacías

Varias expresiones pueden concatenarse junto con un operador de coma para formar una expresión. Del mismo modo, JavaScript también puede decirle que múltiples declaraciones están unidas para formar una declaración compuesta. Simplemente envuelva múltiples declaraciones en aparatos ortopédicos rizados. Por lo tanto, las siguientes líneas de código se pueden usar como una declaración separada en cualquier lugar de JavaScript, desea utilizar una declaración.

La copia del código es la siguiente:

{

x = math.pi;

cx = math.cos (x);

console.log ("cos (π) =" + cx);

}

Hay varios puntos a tener en cuenta sobre los bloqueos de la declaración: primero, los bloques de declaración no requieren semicolones. Las declaraciones de elementos en los bloques deben terminar con las semicolones, pero los bloques de declaración no.

En segundo lugar, las líneas en el bloque de declaración están sangradas, lo que no es necesario, pero la sangría ordenada puede hacer que el código sea más legible y más fácil de entender.

En tercer lugar, JavaScript no tiene un alcance de nivel de bloque, y las variables declaradas en el bloque de declaración no son propiedad privada del bloque de declaraciones. (Consulte la primera sección del Capítulo 3, 10)

La práctica de combinar muchas declaraciones en un bloque de declaración grande es muy común en la programación de JavaScript. Expresiones similares generalmente contienen subexpresiones, muchos JavaScripts contienen otras sustataciones. En términos de formulario, JavaScript generalmente permite que un bloque de instrucciones contenga una sustancia. Por ejemplo: el cuerpo de bucle While puede contener solo una declaración. Usando un bloque de instrucciones, puede poner cualquier cantidad de declaraciones en este bloque, y este bloque de instrucciones se puede usar como una declaración.

En JavaScript, cuando desea que se usen múltiples declaraciones como una declaración, use una declaración conforme. Una declaración vacía (declaración vacía) es exactamente lo contrario, permite contener 0 declaraciones. La declaración vacía se ve así:

;//punto y coma

El intérprete de JavaScript obviamente no realiza ninguna acción al ejecutar una declaración vacía, pero la práctica ha demostrado que las declaraciones vacías a veces son útiles al crear un bucle con un cuerpo de bucle vacío, como lo siguiente para bucle

La copia del código es la siguiente:

// Inicializar una matriz A

para (i = 0; i <a.length; a [i ++] = 0);

En este bucle, todas las operaciones se completan en la expresión a [i ++] = 0, y no se necesita ningún cuerpo de bucle aquí. Sin embargo, JavaScript requiere que el cuerpo del bucle contenga al menos una declaración, por lo que solo se usa un punto y coma separado aquí para representar una declaración vacía.

Tenga en cuenta que los semicolones en el lado derecho del bucle for, mientras que la declaración de bucle o if son discretos, lo que puede causar algunos insectos fatales, que son difíciles de localizar. Por ejemplo, es probable que el resultado de ejecución del siguiente código sea un efecto que el autor no desee:

La copia del código es la siguiente:

if ((a == 0) || (b == 0)); // Esta línea de código no hace nada ...

o = nulo; // Esta línea de código siempre se ejecutará

Si usa una declaración vacía para un propósito especial, es mejor agregar comentarios en el código, lo que puede indicar claramente que esta declaración vacía es útil.

La copia del código es la siguiente:

para (i = 0; i <a.length; a [i ++] = 0) /*vacía* /;

3. Declaración de declaración

VAR y función son declaraciones de declaración que declaran o definen variables o funciones. Estas declaraciones definen y asignan identificadores (nombres de variables y nombres de funciones), que se pueden usar en cualquier parte del programa. Las declaraciones de declaración no hacen nada por sí mismas, pero tiene un significado importante: al crear variables y funciones, la semántica del código puede organizarse mejor.

Las siguientes secciones hablarán sobre declaraciones de VAR y declaraciones de funciones, pero no contienen todo el contenido de variables y funciones.

i.var

La instrucción VAR se utiliza para declarar una o más variables. Su sintaxis es la siguiente:

var name_1 [= value_1] [, ..., name_n [= value_n]]

La palabra clave VAR es seguida por una lista de variables que se declararán. Cada variable en la lista puede tener una expresión de inicialización que puede usarse para especificar su valor inicial. Por ejemplo:

La copia del código es la siguiente:

var i; // Una variable simple

var j = 0; // Una variable con valor inicial

var p, q; // Dos variables

var greet = "hola" + nombre; // Expresión de inicialización más compleja

var x = 2.34, y = math.cos (0.75), r, theta; // muchas variables

var x = 2, y = x * x; // La segunda variable usa la primera variable

var x = 2,

f = function (x) {return x * x}, // Cada variable tiene una fila exclusiva

y = f (x)

Si la instrucción VAR aparece en el cuerpo de funciones, entonces define una variable local, y su alcance es esta función. Si usa una instrucción VAR en el código de nivel superior, entonces declara una variable global, que es visible en todo JavaScript. En el Capítulo 3, Sección 10, se menciona que las variables globales son propiedades de los objetos globales. Luego, a diferencia de otras propiedades del objeto global, las variables declaradas por VAR no se pueden eliminar a través de Delete.

Si la variable en la instrucción VAR no especifica una expresión de inicialización, el valor de esta variable está inicialmente indefinido. Por lo tanto, el valor de la variable antes de la declaración de declaración no está definido.

Cabe señalar que la instrucción VAR también se puede usar como un componente del bucle for o for/in. (Igual que las declaraciones variables declaradas antes de los bucles, las variables declaradas aquí también serán "avanzadas"), por ejemplo:

La copia del código es la siguiente:

para (var i = 0; i <10; i ++) console.log (i);

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

para (var i en o) console.log (i);

Tenga en cuenta que no importa si declara la misma variable varias veces.

II.Función

La función de palabras clave se usa para declarar funciones. Hemos aprendido expresiones de funciones (4.3). Las definiciones de funciones se pueden escribir en una forma de declaración. Por ejemplo: dos definiciones se escriben en el siguiente código de ejemplo:

La copia del código es la siguiente:

var f = función f (x) {return x + 1;} // Asigna la expresión a una variable

función f (x) {return x + 1;} // oración que contiene nombres de variables

La sintaxis de la declaración de función es la siguiente:

La copia del código es la siguiente:

función funcname ([arg1 [, arg2 [..., argn]]]) {

declaraciones

}

Funcname es el identificador de nombre de la función que se declarará. El nombre de la función es seguido por la lista de parámetros, separado por comas. Al llamar a una función, estos identificadores se refieren a los parámetros reales pasados ​​a la función.

El cuerpo de la función está compuesto por declaraciones de JavaScript, sin límite en el número de declaraciones y está encerrado en aparatos ortopédicos. Al definir una función, las declaraciones en el cuerpo de la función no se ejecutan, pero se asocian con el nuevo objeto de función que se ejecutará al llamar a la función. Tenga en cuenta que son necesarias las declaraciones de función en funciones en funciones, lo que es diferente de los bloques de instrucción utilizados por bucles y otros bloqueos de declaración. Incluso si el cuerpo de la función tiene solo una declaración, todavía se requieren aparatos ortopédicos para concluir.

La copia del código es la siguiente:

función hyteus (x, y) {

return math.sqrt (x * x + y * y);

}

Hyteus (1, 2) //=>2.23606797749979

función facial (n) {// una función recursiva

if (n <= 1) return 1;

regreso n * facial (n - 1);

}

Facial (11) // => 39916800

Las declaraciones de funciones generalmente aparecen en la parte superior del código JavaScript y también pueden anidarse dentro de otras funciones. Pero cuando se anidan, las declaraciones de función solo pueden aparecer en la parte superior de la función anidada. Es decir: la definición de función no puede aparecer en si, mientras u otras declaraciones.

Al igual que la declaración VAR, las variables creadas por las declaraciones de declaración de funciones no se pueden eliminar. Sin embargo, estas variables no son de solo lectura, y los valores variables pueden reescribirse.

4. Declaraciones condicionales

Una declaración condicional es ejecutar o omitir ciertas declaraciones determinando si se valora el valor de la expresión especificada. Estas declaraciones son "puntos de decisión" del código, a veces llamado "ramas". Si el intérprete JavaScript se ejecuta siguiendo la "ruta" del código. La declaración condicional es el punto de bifurcación en este camino. Cuando el programa llega a este punto, debe seleccionar una ruta para continuar la ejecución.

Declaración I.IF

Si la declaración es una declaración de control básica. Para ser precisos, permite que el programa se ejecute condicionalmente. Hay dos formas de esta declaración: la primera es

La copia del código es la siguiente:

if (expresión)

declaración

En esta forma, si el valor de la expresión es verdadero, ejecute la declaración de la declaración y si es falso, no ejecute la declaración. Por ejemplo,

La copia del código es la siguiente:

if (username == null) // Si el nombre de usuario es nulo o indefinido

UserName = "Jack Wong"; // Defina

Cabe señalar que es necesario encerrar los soportes del jardín de la expresión si la declaración.

La sintaxis de JavaScript estipula que si las palabras clave y las expresiones con soportes de jardín deben ser seguidos por una declaración. Sin embargo, múltiples declaraciones se pueden combinar en una usando bloques de declaración. Por lo tanto, la forma de la declaración IF se ve así:

La copia del código es la siguiente:

if (! dirección) {

dirección = "";

Mensaje = "Por favor Dirección postal"

}

La segunda forma de la instrucción IF introduce la cláusula Else y ejecuta la lógica más cuando el valor de la expresión es falso.

La copia del código es la siguiente:

if (expresión)

Declaración 1

demás

declaración 2

Por ejemplo, el siguiente código

La copia del código es la siguiente:

if (n == 1)

console.log ("1 nuevo mensaje");

demás

console.log ("tienes" + n + "nuevo mensaje");

Cuando se usa las declaraciones IF/Else en el uso anidado de las declaraciones IF, debe tener cuidado para asegurarse de que la declaración de lo contrario coincida con la declaración correcta IF. Considere el siguiente código:

La copia del código es la siguiente:

i = j = 1;

k = 2;

if (i == j)

if (j == k)

console.log ("I igual k");

demás

console.log ("i dosent igual j"); //¡Error! !

En este ejemplo, la declaración IF interna constituye las cláusulas requeridas por la declaración externa IF. Sin embargo, la relación correspondiente entre IF y Else no está clara (solo la sangría da un poco de pista) y en este ejemplo, la pista dada por la sangría es incorrecta, porque el intérprete de JavaScript lo entiende.

La copia del código es la siguiente:

if (i == j) {

if (j == k)

console.log ("I igual k");

demás

console.log ("i dosent igual j");

}

Como la mayoría de los lenguajes de programación, las reglas IF y Else Match en JavaScript son eso siempre coincide con la declaración IF cercana. Para hacer que el ejemplo sea legible, más fácil de entender y más conveniente para el mantenimiento y la depuración, se deben usar aparatos rizados.

La copia del código es la siguiente:

if (i == j) {

if (j == k) {

console.log ("I igual k");

} else {// los aparatos ortopédicos hacen que el resultado del código sea más claro

console.log ("i dosent igual j");

}

}

Muchos programadores tienen el hábito de encerrar el cuerpo de las declaraciones de IF y de lo contrario en aparatos ortopédicos (al igual que en una declaración coincidente como un bucle de tiempo). Incluso si solo hay una declaración por rama, hacerlo puede evitar el problema ambiguo del programa en este momento.

ii.else si

La instrucción if/else selecciona una de las dos ramas juzgando el resultado del cálculo de una expresión. ¿Qué debo hacer cuando hay muchas ramas en el código? Una solución es usar la declaración de lose if. De lo contrario, si no es una declaración real de JavaScript, es solo una forma de escribir múltiples declaraciones if/else juntas.

La copia del código es la siguiente:

if (n == 1) {

// ejecutar el bloque de código 1

} else if (n == 2) {

// ejecutar el bloque de código 2

} else if (n == 3) {

// ejecutar el bloque de código 3

} demás {

// Las condiciones anteriores son falsas, entonces el bloque de código 4 se ejecuta

}

No hay nada especial en este tipo de código. Consiste en múltiples declaraciones IF, y cada una cláusula de la declaración IF más contiene otra declaración IF. El código equivalente de sintaxis se puede completar utilizando la forma anidada de las declaraciones IF, pero en comparación con esto, es obvio que la escritura de lo contrario es más clara y preferible.

iii.

Durante la ejecución del programa, una instrucción IF crea una rama y puede usar lo otro si para manejar múltiples ramas. Luego, cuando todas las ramas dependen del valor de la misma expresión, de lo contrario, si no es la mejor solución. En este caso, es una práctica muy derrochadora calcular repetidamente las expresiones en múltiples declaraciones IF.

La instrucción Switch es adecuada para manejar esta situación. El interruptor de palabras clave es seguida por una expresión encerrada en los soportes de jardín. Luego están los bloques de código encerrados en aparatos ortopédicos.

La copia del código es la siguiente:

Switch (Expression) {

declaraciones

}

Sin embargo, la sintaxis completa de la instrucción Switch es más complicada que esta. El caso es seguido por una expresión y un colon. El caso es muy similar a un lenguaje de marcado, excepto que este lenguaje de marcado no tiene un nombre.

Solo se asocia con las expresiones que lo siguen. Al ejecutar esta instrucción Switch, primero calcula el valor de la expresión y luego encuentra si la expresión de la cláusula de caso es la misma que el valor de la expresión. (Lo mismo se compara con el operador "==="). Si el caso coincide, ejecutará el código correspondiente. Si no se puede encontrar un caso coincidente, ejecutará el bloque de código en la etiqueta "predeterminada:". Si no hay una etiqueta "predeterminada:", Switch omitirá todos los bloques de código.

La instrucción Switch es muy fácil de confundir, y la introducción con ejemplos será más clara. La siguiente instrucción Switch es equivalente a la instrucción if/else justo ahora.

La copia del código es la siguiente:

Switch (n) {

Caso 1: // Si n === 1 comienza desde aquí

// ejecutar el bloque de código 1

romper;

Caso 2:

// ejecutar el bloque de código 2

romper;

Caso 3:

// ejecutar el bloque de código 3

romper;

por defecto:

// ejecutar el bloque de código 4

romper;

}

Cabe señalar que la ruptura de palabras clave se usa al final de cada declaración de caso. Presentaremos la declaración de descanso más adelante. La instrucción Break puede hacer que el intérprete salte de la instrucción Switch o el bucle. En Switch, el caso solo indica el punto de partida del código que se ejecutará, pero no especifica el punto final. Si no hay una declaración de interrupción, la instrucción Switch comienza a ejecutar desde el código en la etiqueta de caso coincidente del valor de expresión, y ejecuta declaraciones posteriores a su vez hasta el final del bloque de código de conmutación completo. Por supuesto, si usa una instrucción Switch en una función, puede usar retorno para reemplazar el descanso. La devolución y el descanso se utilizan para finalizar la instrucción Switch, que también evitará que una declaración de caso continúe ejecutando el siguiente bloque de instrucciones de caso.

La siguiente declaración está cerca del combate real, y convierte el valor en una cadena de acuerdo con el tipo de valor.

La copia del código es la siguiente:

función convert (x) {

Switch (typeof x) {

Caso 'número': // Convertir números a hexadecimal

return x.ToString (16);

Caso 'cadena':

return '"' + x + '"'; // Devuelve dos cadenas con cotizaciones dobles.

predeterminado: // use métodos ordinarios para convertir otros tipos

cadena de retorno (x);

}

}

console.log (convert (100255114)) // => 5F9C58A

Tenga en cuenta que en los dos ejemplos anteriores, la palabra clave del caso es seguida por un número directo y una cadena, que es el uso más común de Switch en la práctica, pero el estándar de ECMAScript permite que cada palabra clave siga expresiones arbitrarias.

La instrucción de interruptor calcula primero la expresión después de la palabra clave del interruptor, y luego calcula la expresión después de cada caso en orden de arriba a abajo, sabiendo que el valor de la expresión ejecutado en el caso y el valor de la expresión del interruptor son iguales. Dado que la operación coincidente para cada caso es en realidad una comparación de operadores de identidad "===", no "==", la coincidencia de expresión y caso no realiza ninguna conversión de tipo.

Cada vez que se ejecuta una instrucción Switch, no todas las expresiones de casos se pueden ejecutar. Por lo tanto, se deben evitar las expresiones de casos con efectos secundarios, como las expresiones de llamadas de función y expresiones de asignación. La forma más segura es usar expresiones constantes en las expresiones de casos.

Como se mencionó anteriormente, si la expresión del conmutador no coincide con todas las expresiones de casos, se ejecutará el bloque de instrucción marcado "predeterminado:". Si no hay una etiqueta "predeterminada:", se omitirá toda la instrucción Switch. En el ejemplo anterior, la etiqueta "predeterminada:" aparece al final del conmutador y está detrás de todas las etiquetas de caso. Por supuesto, esta es la forma de escribir más razonable y más comúnmente utilizada. De hecho, la etiqueta "predeterminada:" se puede colocar en cualquier lugar dentro de la instrucción Switch.

5. Loop.

Para comprender las declaraciones condicionales, puede pensar en el código en JavaScript como rutas de ramas. Las declaraciones de bucle son declaraciones de bucle que permiten que algún código se ejecute repetidamente. Hay cuatro declaraciones de bucle en JavaScript: mientras, do/while, para y para/in. Las siguientes secciones las explicarán a la vez. El bucle más utilizado es el recorrido de los elementos de matriz. (7.6 discutirá este bucle y métodos especiales de bucle definidos por clases de matriz en detalle).

I.cuencia

Si la declaración es una declaración de control básica utilizada para seleccionar declaraciones de rama que ejecutan el programa. Como si la declaración While también es una declaración de bucle básico, y su sintaxis es la siguiente:

La copia del código es la siguiente:

Mientras (expresión)

declaración

Antes de ejecutar una declaración de tiempo, el intérprete de JavaScript calcula primero el valor de la expresión. Si su valor es un valor falso, el programa omitirá la declaración lógica en el cuerpo del bucle y ejecutará la siguiente declaración en el programa. Si su valor es verdadero, entonces se ejecuta la lógica en la instrucción del cuerpo del bucle, y luego se calcula el valor de la expresión de expresión. El bucle continuará hasta que el valor de la expresión sea falso. En otras palabras, cuando la expresión es verdadera, la declaración se ejecutará en un bucle. Tenga en cuenta que usar while (true) creará un bucle muerto.

En términos generales, no queremos que JavaScript realice la misma operación repetidamente. En casi todos los bucles, una o más variables cambiarán iterativamente con el bucle. Es precisamente porque estas variables se cambian que las operaciones de instrucción realizadas en cada bucle son diferentes. Además, si cambia la variable se usa en la expresión, el valor de la expresión de cada bucle también es diferente. Esto es muy importante. La expresión responsable del valor inicial del valor verdadero es siempre el valor verdadero, y el bucle no finalizará. El siguiente ejemplo muestra que mientras el bucle sale los valores 0-9.

La copia del código es la siguiente:

Var Count = 0;

while (Count <10) {

console.log (cuenta);

contar ++;

}

Se puede encontrar que en este ejemplo, el valor inicial del recuento de variables es 0, y durante el bucle, su valor se incrementa en 1 cada vez, cuando el bucle se ejecuta diez veces. El valor de la expresión se programa falso, y luego, mientras finalizará, y el intérprete JavaScript ejecutará la siguiente declaración del programa. La mayoría de los bucles tienen una variable contraria como el recuento. Aunque los contadores a menudo usan nombres de variables como IJK, si desea que el código sea más legible, debe usar nombres de sintaxis más específicos.

ii.do/ mientras

El bucle do/while es muy similar al bucle While, excepto que detecta la expresión de bucle en la cola del bucle en lugar de en la parte superior, lo que significa que el cuerpo del bucle se ejecuta al menos una vez. La sintaxis del bucle do/while es la siguiente:

La copia del código es la siguiente:

hacer

declaración

mientras (expresión);

Do/mientras que los bucles no se usan tan comúnmente como los bucles. Esto se debe a que no es común en la práctica querer ejecutar bucles al menos una vez. Aquí hay un ejemplo de un bucle do/while

La copia del código es la siguiente:

función printArray (a) {

var len = a.length,

i = 0;

if (len == 0)

console.log ("matriz vacía");

demás

hacer {

console.log (a [i]);

} while (++ i <len);

}

printArray ([1,5,2,6])

Hay dos diferencias de sintaxis entre do/mientras que los bucles y los bucles normales. Primero, el bucle DO requiere que la palabra clave DO se use para identificar el comienzo del bucle, use mientras sea variable para identificar el final del bucle e ingrese la condición del bucle para juzgar; En segundo lugar, a diferencia del bucle While, el bucle do usa un final de semicolon. Si el cuerpo de bucle mientras esté encerrado en aparatos ortopédicos rizados, el bucle While no termina con un punto y coma.

iii.

La instrucción For proporciona una estructura de control de la declaración de bucle más conveniente que mientras. La instrucción For simplifica el modo de bucle de uso común. La mayoría de los bucles tienen variables de contador específicas. Esta variable se inicializa antes de que se inicie el bucle, y luego verifique su valor antes de cada bucle. Finalmente, la variable de contador se autoincrementa, de lo contrario se modificará después de que termine el ciclo y antes del siguiente juicio. En este tipo de bucle, las tres operaciones clave del contador son la inicialización, la detección y la actualización. La declaración para declarar explícitamente estas tres operaciones como parte de la sintaxis del bucle, cada una usando una expresión para representarla. La sintaxis de la declaración for es la siguiente:

La copia del código es la siguiente:

para (inicializar; prueba; incremento)

declaración

Las tres expresiones de inicialización, prueba e incremento están separadas por semicolones. Son responsables de inicializar las operaciones, el juicio de la condición cíclica y la actualización de las variables de contador. Ponerlos en la primera línea del bucle hace que sea más fácil entender lo que está haciendo el bucle para, y también evita olvidar inicializar o incrementar la variable de contador.

La forma más fácil de explicar cómo funciona un bucle para enumerar un equivalente mientras bucle

La copia del código es la siguiente:

inicializar

while (test) {

declaración

incremento;

}

En otras palabras, la expresión de inicialización se ejecuta solo una vez antes de que comience el bucle. La expresión de inicialización debe tener efectos secundarios (generalmente una declaración de asignación). JavaScript también permite expresiones de inicialización con declaraciones de declaración de variable VAR, de modo que se pueda declarar e inicializar una variable. Antes de cada bucle, se ejecutará la expresión de prueba y se juzgará el resultado de la expresión para determinar si ejecutar el cuerpo del bucle. Antes de cada bucle, se ejecutará la expresión de prueba y el resultado se determinará si se ejecutará el cuerpo de bucle. Si el resultado de la prueba es el valor verdadero, se ejecutará la declaración en el cuerpo del bucle. Finalmente, ejecute la expresión de incremento. También en aras de la utilidad, la expresión de incremento aquí también debe tener efectos secundarios. En términos generales, es una expresión de asignación o una expresión compuesta de operadores "++" y "-".

El anterior while bucle se puede escribir usando un bucle para

La copia del código es la siguiente:

para (var count = 0; Count <10; Count ++)

console.log (recuento)

Por supuesto, algunos bucles son más complejos, y se iteran múltiples variables a la vez. En JavaScript, este caso debe usarse con un operador de coma, que combina la expresión de inicialización y la expresión de autoincremento en una expresión para usar en un bucle for.

La copia del código es la siguiente:

var i, j;

para (i = 0, j = 10; i <10; i ++, j--)

console.log (i * j);

Hasta ahora, las variables de bucle en el código de muestra son todos los números. Por supuesto, los números son los más utilizados, pero no necesarios. El siguiente código utiliza un bucle for para atravesar los resultados de los datos de la tabla y devolver el último objeto en la lista vinculada (es decir, el primer objeto que no contiene el siguiente atributo)

La copia del código es la siguiente:

cola de función (o) {// Devuelve el último objeto de nodo de la lista vinculada

para (; o.next; o = o.next) /*vacía* /// Ejecutar Traversal en función de si O.Next es el verdadero valor

regreso o;

}

Cabe señalar que este código no contiene expresiones inicializadas, y las personas y una de las tres expresiones en el bucle for se pueden ignorar, pero dos semicolones son indispensables. Si se omite la expresión de prueba, será un bucle muerto. También con el tipo de tiempo (ture), una forma de escribir un bucle muerto es para (;;).

iiii. para/en

La instrucción for/in utiliza la palabra clave for, pero es un tipo de bucle diferente al de bucle regular para bucle. La sintaxis del bucle for/in es la siguiente

La copia del código es la siguiente:

para (variable en el objeto)

declaración

Una variable suele ser un nombre variable o una expresión que puede producir Lvalues ​​o una variable declarada a través de una declaración VAR. De todos modos, es un valor que se aplica al lado izquierdo de la expresión de la asignación. El objeto es una expresión, y el resultado de esta expresión es un objeto. Del mismo modo, una declaración es una declaración o bloque de declaraciones que forman el cuerpo del bucle.

Usar un bucle para iterar a través de elementos de matriz es muy simple

La copia del código es la siguiente:

var a = [1, 3, 5, "44"];

para (var i = 0; i <a.length; i ++) // i representa el índice de elementos de matriz

console.log (a [i]) // elementos de salida de cada matriz

El bucle for/in se usa para atravesar las propiedades del miembro del objeto convenientemente

La copia del código es la siguiente:

para (var p p in o) // asigna el nombre del atributo a la variable p

console.log (o [p]); // emite el valor de cada atributo

En el proceso de ejecutar la declaración for/in, el intérprete JavaScript calcula primero la expresión del objeto. Si la expresión es nula o indefinida, el intérprete JavaScript se omitirá el bucle y ejecutará el código posterior. Si la expresión es igual a un valor primitivo, este valor primitivo se convertirá en el objeto Wrapper (Sección 3.6). De lo contrario, la expresión en sí ya es un objeto. JavaScript enumera las propiedades del objeto a su vez para ejecutar el bucle. Sin embargo, antes de cada bucle, JavaScript calcula el valor de la expresión variable y le asigna el nombre del atributo (una cadena).

Cabe señalar que mientras el bucle for/in, el valor de la varibala se puede considerar como el lvalue de la expresión de la asignación, y puede ser cualquier expresión. Esta expresión se calcula en cada bucle, lo que significa que el valor que calcula puede ser diferente cada vez que boques. Por ejemplo, puede usar el siguiente código para copiar todas las propiedades del objeto en una matriz:

La copia del código es la siguiente:

var o = {x: 1, y: 2, z: 3};

var a = [], i = 0;

para (a [i ++] en o) /*vacío* /;

document.write (a) // => x, y, z

Las matrices de JavaScript son solo un objeto especial, por lo que el bucle for/in puede enumerar los índices de datos como enumeraciones de propiedades del objeto. Por ejemplo, agregar este código después del código anterior puede enumerar el índice de datos 0, 1, 2:

La copia del código es la siguiente:

var o = {x: 1, y: 2, z: 3};

var a = [], i = 0;

para (a [i ++] en o) /*vacío* /;

document.write (a) // => x, y, z Copiar propiedades del objeto en una matriz

para (i en a)

document.write (i) // => Enum Data Index 0 1 2

De hecho, el bucle for/in no atraviesa todas las propiedades del objeto. Solo los atributos "enumerables" se atravesarán (ver 6.7). Dado que los métodos integrados definidos por el núcleo del lenguaje JavaScript no son "enumerables". Por ejemplo, todos los objetos tienen toString (), pero el bucle for/in no enumera la propiedad toString (). Además de los métodos incorporados, hay muchos objetos incorporados que no son enumerables. Todos los atributos y métodos definidos en el código son enumerables (se mencionará la sección 6.7, pero hay medios especiales en ECMAScript5 que pueden hacer que los atributos no sean enumerables).

Los objetos pueden heredar las propiedades de otros objetos, y la línea hereda las propiedades personalizadas (6.2.ii) también se puede enumerar utilizando para/in.

Si el cuerpo de bucle for/in elimina una propiedad no enumerada, entonces esta propiedad no se enumerará nuevamente. Si el cuerpo del bucle define nuevas propiedades del objeto, estas propiedades generalmente no se enumeran (pero algunas implementaciones de JavaScript pueden enumerar las propiedades agregadas en el cuerpo del bucle).

El orden de la enumeración de atributos

La especificación de ECMAScript no especifica en qué orden el bucle for/in enumera las propiedades del objeto. Pero, de hecho, la implementación del fabricante del navegador convencional JavaScript Enumera las propiedades de los objetos simples en el orden de las definiciones de atributos, y las propiedades definidas primero se enumeran primero. Si se crea un objeto en forma de cantidad directa, se enumerará en el orden en que aparecen las propiedades en la cantidad directa. (Algunas bibliotecas de redes y JavaScript dependen de esta orden de enumeración, mientras que los fabricantes de navegadores en su mayoría no modifican este orden). En los siguientes casos, la orden de enumeración depende de la implementación específica (no la interacción)

1. Los objetos heredan atributos enumerables

2. El objeto tiene propiedades del índice de matriz de enteros

3. Use Eliminar para eliminar las propiedades existentes del objeto

4. Use Object.DefineProperty () o métodos similares para cambiar las propiedades del objeto

6. Saltar

En JavaScript, un tipo de declaración es una declaración de salto. Desde un entendimiento de la declaración, puede hacer que la ejecución de JavaScript salte de una posición a una posición.

La declaración de descanso es saltar al final de un bucle u otra declaración. La declaración Continuar termina la ejecución de este bucle e inicia la ejecución del siguiente bucle. Las declaraciones en JavaScript se pueden nombrar o etiquetar, romper y continuar pueden identificar bucles de destino u otras etiquetas de declaración.

La declaración de retorno permite al intérprete saltar de la ejecución del cuerpo de la función. Y proporcionar el valor de retorno de esta llamada. La declaración de lanzamiento desencadena o lanza una excepción, que se usa con la instrucción Try/Catch/Finalmente, que especifica la lógica del código de manejo de excepciones. Esta es una declaración de salto compleja. Cuando se lanza una excepción, el programa saltará a la estrella de excepción cerrada más cercana. Este programa de excepción puede estar en la misma función o en la pila de llamadas en un nivel superior.

A continuación, describe cada declaración de salto

i. Instrucción de etiqueta

Se puede etiquetar una declaración, y la etiqueta está compuesta por el identificador y el colon antes de la declaración:

Identificador: declaración

Al definir una etiqueta para una declaración, puede consultar esta declaración por su nombre de etiqueta en cualquier lugar del programa. Puede definir etiquetas para múltiples declaraciones, aunque solo es más útil al definir etiquetas para bloques de declaración, como declaraciones de bucle o declaraciones de juicio condicional. Al definir un nombre de etiqueta para el bucle, puede usar Break y continuar dentro del cuerpo del bucle para salir del bucle o desafiar directamente al inicio del siguiente bucle. break and continue are the only statements in JavaScript that can use statement tags (this chapter will be discussed next). The following example, where the while loop defines a tag, and the continue statement uses this tag:

La copia del código es la siguiente:

mainloop: while (token != null) {

//忽略这里代码...

continue mainloop; //跳转到下一次循环

//忽略这里的代码...

}

这里做标签的indentifier必须是一个合法的javascript标识符，而不能是一个保留字。标签的命名空间和变量或函数的命名空间是不同的，因此可以使用同一个标识符作为语句标签和作为变量名或函数名。语句标签只在它所起作用的语句（当然可以在它的子句）内是有定义的。一个语句标签不能和它内部的语句标签重名，但在两个代码不相互嵌套的情况下是可以出现同名语句标签的。带有标签的语句还可以带有标签，也就是说，任何语句可以有很多个标签。

ii.break

单独使用break语句的作用是立即退出最内存的循环或switch语句。它的语法如下：

romper;

由于它能够使循环和switch语句退出，因此这种形式的break只能出现在这类语句中才是合法的。

我们在switch语句的例子中已经见到果break语句。在循环中，无论出于什么原因，只要不想继续执行整个循环，就可以用break提前退出。当循环终止条件非常复杂时，要函数体内使用break语句实现这样些条件判断的做法要比直接在循环表达式中写出这个复杂的终止条件做法简单的多。

下面的例子中循环遍历整个数组元素来查找某个特定的值，当整个数组遍历完成后正常退出循环，如果找到了需要查找的数组元素，则使用break语句退出循环：

La copia del código es la siguiente:

for (var i = 0; i < a.length; i++) {

if (a[i] == target) break;

}

javascript中同样允许break关键字后跟随一个语句标签，（只有标识符，没有冒号）

romper el nombre de la etiqueta;

当break和标签一块使用时，程序将跳转到这个标签所识别的语句块的结束，或者直接终止这个闭合语句块的执行。当没有任何闭合语句块指定break所用的标签，这时会产生一个语法错误。当使用这种形式的break语句时，带标签的语句不应该是循环或者switch语句，因为break语句可以“跳出”任何闭合的语句块。这里的语句可以是由花括号组起来的一组语句，使用同一个标签来识别一组语句。

break关键字和labelname之间不能换行。因为javascript可以给语句自动补全省略掉的分号，如果break关键字和标签之间有换行，javascript解释器会认为你在使用break不带标签的最简形式，因此会在break后补充分号.

当你希望通过break来跳出非就近的循环体或者switch语句时，就会用到带标签的break语句。下面是示例代码：

La copia del código es la siguiente:

var matrix = getData(); //从某处获得一个二维数组

//将矩阵中所有元素进行求和

var sum = 0,

success = false;

//从签名处开始，以便在报错时推出程序。

compure_sum: if (matrix) {

for (var x = 0; x < matrix.length; x++) {

var row = matrix[x];

if (!row) break compure_sum;

for (var y = 0; y < row.length; y++) {

var cell = row[y];

if (isNaN(cell)) break compure_sum;

sum += cell;

}

}

success = true;

}

//break语句跳转至此

//如果success =false条件到达这里，说明我们给出的矩阵中有错误

//否则对矩阵中所有的元素进行求和

最后，需要注意的是，不管break语句带不带标签，它的控制权都无法越过函数的边界。比如：对于一条带标签的函数定义语句来说，不能通过函数内部通过这个标签来跳转到函数外部.

iii.continue语句

continue语句和break语句非常类似，但它不退出循环，而是转而执行下一次循环。continue语句的语法和break的语句语法一样简单

continuar;

continue语句会也会带有标签

continue lebname;

不管continue语句带不带标签，它只能在循环体使用，在其它地方使用将会报语法错误。

当执行到continue语句的时候，当前的循环逻辑就终止了，随即执行下一次循环，在不同类型的循环中，continue的行为也有区别

1.在while循环中，在循环开始处指定expression会重复检测，如果检测结果为true，循环体会从头执行。

2.在do/while循环中，程序的执行至今跳转到循环的结尾处，这时会重新判断循环条件，之后才会继续下一次循环。

3.在for循环中，首先会计算自增表达式，然后再检测test表达式，用以判断是否执行循环体。

4.在for/in循环中，循环开始遍历下一个属性名，这个属性名赋给了指定的变量。

需要注意continue语句在while和for循环中的区别，while循环直接进入下一轮的循环条件判断，但for循环首先计算器increment表达式，然后判断循环条件。之前的章节讨论了和while循环“等价”的for循环行为。但由于continue在这两种循环中行为表现不同，因此使用while循环不可能完美的模拟等价的for循环。

下面这段代码展示了不带标签的continue语句，产生一个错误的时候跳过当前循环的后续逻辑

La copia del código es la siguiente:

for (i = 0; i < data.length; i++) {

if (!data[i]) continue; //不能处理undefined数据

total += data[i];

}

和break语句类似，带标签的continue语句可以用在嵌套的循环中，用以跳出层次嵌套的循环体逻辑。同样和break语句类似，在continue语句和labname之间不能有换行。

iiii.return

回想一下，函数调用的一种表达式，而且所有的表达式都有值。函数中的return语句即是指函数调用后的返回值。这里是return语句的语法：

return expression;

The return statement can only appear in the function body. If not, it will report a syntax error. When the return statement is executed, the function terminates the execution and returns the value of the expression to the calling program. Por ejemplo:

La copia del código es la siguiente:

function square(x) {return x * x} //一个包含return的语句函数

square(4) //执行为16

如果没有return语句，则函数调用仅依次执行函数体内的每一条语句直到函数结束，最后返回调用程序。这种情况下，调用表达式的结果是undefined。return语句经常作为函数内最后的一条语句出现，但并不是说一定一定要放在函数的最后，即使在执行return语句的时候还有很多代码没有执行到，这时候函数也还返回调用程序。

The return statement can be used alone without having expression, so the function will also want to call the program to return undefined. Por ejemplo:

La copia del código es la siguiente:

//如果参数是null或者undefined则立即返回

if (!o) return;

//其它逻辑

由于javascript可以自动插入分号，因此，return关键字和它后面的表达式之间不能有换行。

iiiii.throw语句

所谓异常（excepion）是当发生了某种异常情况或错误时产生的一个信号。抛出异常，就是用信号通知发生了错误或异常状况。捕获异常是指处理这个信号，抛出异常，就是用信号通知发生了错误或异常状况。捕获异常是指处理这个信号，即采取必要的手段从异常中汇丰。在javascript中，当产生运行时错误或者程序使用throw语句时就会显式的抛出异常。使用try/catch/finally语句可以捕获异常，下一节会对它作详细介绍。

throw语句的语法如下：

throw expression

expression的值可以是任意类型的。可以抛出一个代表错误码的数组，或者包含可错误消息的字符串。当javascript解释器抛出异常的时候，通常采用Eeeor类型或其子类型，当然也可以使用它们。一个error对象有一个那么熟悉表示错误类型，一个message属性用来传递构造函数的字符串（参照第三部分的Error类），在下面的例子中，当使用非法参数调用函数时就抛出一个Error对象：

La copia del código es la siguiente:

function fa(x) {

//如果输入的参数是非法的，则抛出一个异常

if (x < 0) throw new Error("x不能是负数。");

//否则计算出一个值，正常地返回它

for (var f = 1; x > 1; f *= x, x--) /*empty*/;

return f;

}

当抛出异常时，javascript解释器会立即停止当前正在执行的逻辑，并跳转至就近的异常处理程序。异常处理程序用try/catch/finally语句的catch从句编写的。如果抛出的异常没有一条关联catch从句，解释器会检测更高层的闭合代码块，看它是否关联相关的异常处理程序。以此类推，直到扎到一个异常处理的程序为止。

如果抛出的异常函数没有处理它的try/catch/finally语句，异常将向上传播到调用该函数的代码。这样的话，异常就会沿着javascript方法的词法结构和调用栈向上传播。如果没有找到任何异常处理的程序，javascript将吧异常当成程序错误来处理，并报告给用户。

iiiiii.try/catch/finally语句

try/catch/finally语句是javascript的异常处理机制。其中try从句定义了需要处理的异常所在代码块。catch语句跟随在try从句之后，当try块从某处发送了异常时，调用了catch内的代码逻辑。catch从句跟随finnlly块，后者防置了清理代码，不管try块中是否产生了异常，finnally块内的逻辑总会执行。尽管catch和finally都是可选的，但try从句只杀二者之一与组成完整的语句。try、catch和finally语句块都需要花括号括起来，这里的花括号是必须的。即使从句中只有一条语句也不能省略花括号。

下面的代码说明了try/catch/finlly的语法和使用目的：

La copia del código es la siguiente:

intentar{

//通常来讲，这里的代码会从头执行到尾而不会产生任何问题，

//但有时会抛出一个异常，要么是由throw语句直接抛出异常

//要么通过调用一个方法间接抛出异常

}

catch(e){

//当且仅当try抛出了异常，才会执行这里的代码

//这里可以通过局部变量e来获得对Error对象或者抛出的其它值的引用

//这里的代码可以基于某种原因处理这个异常，也可以忽略这个异常。

//还可以通过throw语句重新抛出异常

}

Finalmente{

//不管try语句块是否抛出看异常，这里的逻辑总会执行，终止try的语句块方式有：

//1）正常终止，执行完语句块的最后一条语句

//2）通过break，continue或return语句终止

//3）抛出一个异常，异常被catch从句捕获

//4）抛出一个异常，异常未被捕获，继续向上传播

}

我们注意到，关键字catch后跟随了一对圆括号，圆括号内是一个标识符。这个标识符和函数参很像。当捕获一个异常时，把这个异常相关的值（比如Error对象）赋值给这个参数。和普通的变量不同，这条catch子句中的标识符具有块级作用域，它只在catch语句块内有定义。

这里有一个关于try/catch语句更实际的例子，这里使用了前面章节中提到factorial()方法，并使用客户端javascript方法prompt()和alert()来输入和输出

La copia del código es la siguiente:

intentar {

//要求用户输入一个数字

var n = Number(prompt("请输入一个正整数", ""));

//假设输入是合法的，计算这个阶乘

var f = factorial(n);

//显示结果

alert(n + "!=" + f);

} catch (ex) {

//如果输入不合法，将执行这里的逻辑

document.write(ex); //告诉用户发送了什么。

}

这里的try/catch语句并不包含finally从句。尽管finally不像catch那样经常使用，但有时候它还是非常有用。然而，我们需要更详尽的解释它的行为。不管try语句块中的代码执行完成了多少，只要try语句中有一部分代码执行了，finally从句就会执行。它通常在try从句的代码后用于清理工作。

关注下面这个例子

La copia del código es la siguiente:

intentar {

print("Outer try running..");

intentar {

print("Nested try running...");

throw "an error";

} catch (e) {

print("Nested catch caught " + e);

throw e + " re-thrown";

} finalmente {

print("Nested finally is running...");

}

} catch (e) {

print("Outer catch caught " + e);

} finalmente {

print("Outer finally running");

}

// Windows Script Host 作出该修改从而得出WScript.Echo(s)

function print(s) {

document.write(s);

}

Producción:

La copia del código es la siguiente:

Outer try running..

Nested try running...

Nested catch caught an error

Nested finally is running...

Outer catch caught an error re-thrown

Outer finally running

7.其它语句类型。

本节讨论剩余的三种javascript语句：width，debugger和use strict

i.with语句

3.10讨论了作用域链（scope chain），一个可以按序检索的对象列表，通过它可以进行变量名的解析。width语句可以用来临时扩展作用域链：它具体有如下语法：

with (object)

declaración

这条语句将object添加到作用域链头部，然后执行statement，最后把作用域链恢复到原始状态。

在严格模式下（5.7.iii）是禁止使用width的，在非严格模式下也是不推荐使用width语句的，尽可能的避免使用width语句。那些使用width语句的javascript非常难优化，而且比没有使用width的语句，它运行速度更慢。

在对象嵌套层次很深的时候，常会使用with语句来简化代码的编写。例如客户端javascript中，可能使用下面的这种表达式来访问表单的一个html元素

document.forms[0].address.value

如果这段代码多次出现，则可以使用with将form对象添加至作用域链的顶层。

La copia del código es la siguiente:

with(document.forms[0]){

//直接访问表单元素

name.value="";

address.value="";

email.value ="";

}

这种方法简化了大量的输入，不用再为每个变量添加document.forms[0]前缀。这个临时对象挂载在作用域链上，当javascript需要解析诸如address标识符时，就会在这个对象中查找。当然，不使用with的语句代码可以写成这样。

La copia del código es la siguiente:

var f = document.forms[0];

f.name.value = "";

f.adress.value = "";

f.email.value = "";

不要忘记，只有在查找标识符的时候才能用到作用域链，创建新的变量时候不使用它，看一下下面的代码：

La copia del código es la siguiente:

with(o) x = 1;

如果对象o有一个属性x，那么这行代码给这个属性赋值1。如果o没有定义属性x，这段代码和不使用with的代码x=1是一模一样的。它给一个局部变量或者全局变量x赋值，或者创建全局对象的一个新属性。with语句提供了一种读取o属性的快捷方法，但并不会创建o的属性。

ii.debugger语句

debugger语句通常什么也不做。然而，在调试程序可用并运行的时候，javascript解释器将会（非必须）以调试模式运行。实际上，这条语句产生一个断点（breakpoint），javascript代码执行会停止在断点的位置，这时可用使用调速器输出变量的值，检查调用栈等。

例如加上调用函数f()的时候使用了未定义的参数，因此f()抛出一个异常，但无法定位到到底哪里出了异常。为了有助于调试这个问题，需要修改f()：

La copia del código es la siguiente:

function f(o){

if (o === undefined) debugger; //这段代码用来临时调试

console.log(1) //函数的其它部分

}

F();

这时候，当调用f()没有传入参数，程序将停止执行，这时候通过调用调速器检测调用栈并找出错误的原因。

在ECMAScirpt5中，debugger语句已经正式加入到专门语言里，但在很长的一段时间里，主浏览器的厂商已经将其实现了。注意，可用的调速器是远远不够的，debugger语句不会启动调试器。但如果调试器已经在运行，这条语句才会正在产生断点。例如，使用Firefox插件firebug，首先启动firebug，这样debugger语句才能工作。

iii.“use strict”

“use strict”是ECMASCript5引入的一条指令。指令不是语句（但非常接近于语句），“use strict”和普通语句之前有两个重要区别：

1.它不包含任何语言的关键字，指令仅仅是一个包含一个特殊字符串直接量的表达式（可以是使用单引号也可以是双引号）。

2.它只能出现在脚本代码的开始或者函数体的开始、任何实体语句之前。但它不必一定出现在脚本的首行或者函数体内的首行。因为“use strict”指令之前之后或之前都可能有其它字符串直接量的表达式语句，并且javascript的具体实现可能将它们解析为解释器自有的指令。在脚本或者函数体内第一条常规语句之后，字符串直接量表达式语句只当做普通的表达式语句对待，它们不做指令解析，它们也没有任何副作用。

使用“use strict”指令的目的是说明（脚本或函数中）后续代码解析为严格代码(strict code)。如果顶层（不在任何函数内）代码使用了“use strict”指令，那么它们就是严格代码。如果函数体定义处的代码是严格代码或者函数体使用了“use strict”指令，那么函数体的代码也是严格代码。如果eval()调用所处的代码是严格代码或者eval()要执行的字符串使用了“scrict code”指令，则eval()内的代码是严格代码。

严格代码以严格模式执行。ECMAScript5中的严格模式是该语言的一个受限的子集。它修正了语言的重要缺陷，并提供健壮的差错功能和增强安全机制。严格模式和非严格模式区别如下（前三条尤其重要）

•严格模式中禁止使用with语句

•严格模式中，所有的变量要先声明，如果给一个未声明的变量、函数、函数参数、catch从句参数或全局的对象的属性赋值。就会抛出一个引用错误异常（在非严格模式中，这种隐式声明全局变量的方法是给全局变量新添加一个新属性）

•严格模式中，调用的函数（不是方法）中的一个this值是undefined。（在非严格模式中，调用的函数中的this值总是全局变量）。可以利用这种特性来判断javascript实现是否支持严格模式。

La copia del código es la siguiente:

var hasStrictMode = (function() {

"use strict";

return this === undefined

}());

•同样，在严格模式中，当通过call()和apply()来调用函数时，其中的this值就是通过call()或apply()传第一个参数（在非严格模式中，null和undefined值被全局对象转换为对象的非对象值锁代替）

•在严格模式中，给只读属性赋值和给不可扩展的对象创建成员都将抛出一个类型错误异常（在非严格模式中，这些操作只是简单的操作失败，不会报错）。

•在严格模式中，传入eval()代码不能再调用辰星所在的上下文中声明变量或定义函数，在非严格模式中是可以这样做的。相反，变量和函数的定义是在eval()创建的作用域中，这个作用域在eval()返回时就弃用了。

•在严格模式中，函数里的arguments对象拥有传入函数值的静态副本。在非严格模式中，agreements对象具有“魔术般”的行为，arguments里的数组元素和函数都指向同一个值的引用。

•在严格模式中，当delete运算符后面跟随非法的标识符（比如变量、函数、函数参数时）将会抛出一个语法错误，（在非严格模式下，这种delete什么也没做，并返回false）

•在严格模式中，在一对象直接量中定义两个或多个同名属性将产生一个语法错误（非严格模式下不会报错）

•在严格模式下，不允许八进制整数直接量。（以0为前缀，而不是0x为前缀）在非严格模式中是允许直接八进制直接量的

•在严格模式下，标识符eval和arguments当做关键字，他们的值是不能更改的。不能给这些标识符赋值，也不能把它们声望为变量，用做函数名，用做函数参数或用做catch块的标识符。

•在严格模式中限制了对调用栈的检测能力，在严格的模式的函数中，arguments，caller和arguments.callee都会抛出一个类型错误异常。严格模式的函数同样具有caller和arguments属性，当访问这两个属性时抛出类型错误异常。

8.javascript语句小结：

javascript语句语法：