Variables de JavaScript. Constantes

Trabajando en Javascript, podemos ingresar valores numéricos, de cadena y booleanos, pero funcionan si el programa contiene la información necesaria. Para ello, se han creado variables que permiten almacenar diversos tipos de información en sí mismas y representar como una especie de contenedor al que podemos acudir en cualquier momento y obtener la información que se encuentra en él.

Creación de variables

Una variable se crea en dos pasos: declarar la variable y asignarle un nombre.

Primero debemos declarar una variable, es decir, declararla, esto se hace usando la palabra clave var. A continuación, escribimos la instrucción, este es el nombre de la variable, su nombre como nos referiremos a ella, por ejemplo escribiré dwstv.

Cómo nombrar las variables, por supuesto, depende de usted, pero hay varias reglas que deben seguirse para que funcione JavaScript:

• primera regla, evitar el uso de palabras reservadas... Ciertas palabras en JavaScript se utilizan en el propio sistema, como la palabra var con la que declaramos una variable. Además, algunas palabras como alerta, documento, ventana se consideran propiedades especiales de una página web. Si intenta utilizarlos como variables, obtendrá un mensaje de error. Aquí puede ver la lista de palabras reservadas.
• segunda regla, el nombre de la variable debe comenzar con una letra, $ o _... Es decir, la variable no puede comenzar con un número o un signo de puntuación: el nombre 1dwstv y & dwstv no funcionarán, pero los nombres $ dwstv y _dwstv sí.
• tercera regla, los nombres de las variables pueden contener letras, números, símbolos $ y _, y no se pueden utilizar espacios ni otros caracteres especiales en el nombre.: dws & tv y dws tv son nombres inválidos, pero este formato puede ser dws_tv y dwstv1 o dws_tv_1.
• cuarta regla, los nombres de las variables distinguen entre mayúsculas y minúsculas... El intérprete de JavaScript interpreta las letras minúsculas y mayúsculas de manera diferente, es decir, la variable DWSTV difiere de la variable dwstv, así como de las variables DwStv y Dwstv.
• quinta regla, n no se recomienda utilizar caracteres que no sean latinosLas variables escritas en cirílico, aunque funcionarán, no están garantizadas, además, no serán comprendidas por colegas de otros países.

Estas son las cinco reglas principales que recomiendo seguir, además de las que también quiero decir, asigna nombres claros y expresivos a tus variables. Nombra las variables de acuerdo con el tipo de datos que almacenas en ellas, esto te ayudará a comprender mejor lo que está escrito y, al observar dichas variables, quedará claro de qué se trata el discurso.

Al nombrar variables, intente que sean fáciles de leer. Cuando use varias palabras, agregue un guión bajo entre ellas o comience cada palabra después de la primera con una letra mayúscula. Por ejemplo, dwsTv o dws_tv.

Usando variables

Al comienzo de la lección, clasificamos en qué consiste una variable, ahora, cuando sabemos cómo crearla, podemos almacenar cualquier tipo de datos en ella a nuestra discreción.

Para poner datos en una variable, se usa un símbolo especial, el signo igual (\u003d), se llama una operación de asignaciónporque se usa para asignar un valor a una variable.

Por ejemplo, pongamos un valor digital en la variable dwstv, el número de suscriptores es 8500, declare la variable var dwstv; y en la segunda línea ponemos el valor dwstv \u003d 8500;

Var dwstv; dwstv \u003d 7200;

Y así, en la primera línea creamos una variable y en la segunda le guardamos el valor. También podemos crear una variable y almacenar valores en ella con una sola instrucción, por ejemplo:

Var dwstv \u003d 7200;

En una variable, podemos almacenar cualquier tipo de datos que analizamos en lecciones anteriores, estos pueden ser valores numéricos, de cadena y booleanos:

Var dwstv \u003d 7200; var lecciones \u003d "JavaScript"; var youtubeKanal \u003d 'DwsTV'; var suscriptores \u003d "7700"; var content \u003d true;

También podemos ahorrar espacio y tiempo declarando variables con una tecla var, por ejemplo:

Var lecciones \u003d "JavaScript", youtubeKanal \u003d "DwsTV", suscriptores \u003d "7700", contenido \u003d verdadero;

Una vez que hayamos almacenado los valores en variables, tenemos la oportunidad de acceder a estos datos. Para hacer esto, simplemente use el nombre de la variable en sí.

Por ejemplo, si necesitamos abrir un diálogo de alerta y mostrar el valor almacenado en la variable kanal, solo necesitamos escribir el nombre de la variable en la función de alerta.

Alerta (kanal);

Tenga en cuenta que no incluimos las variables entre comillas; son solo para cadenas, por lo que no escribimos alert ('kanal'), ya que en este caso obtenemos las palabras kanal, no el valor almacenado en la variable.

Ahora creo que ha descubierto por qué las cadenas deben estar entre comillas: el intérprete de javaScript trata las palabras sin comillas como objetos especiales (por ejemplo, el comando alert ()) o como nombres de variables.

Y también hay un momento en el que declaramos una variable con la palabra clave var, y queremos cambiar el valor en la variable, no es necesario volver a declararlo escribiendo la palabra var, basta con llamar al nombre de la variable y asignarle un nuevo valor.

Suscriptores \u003d "10000";

Al final de esta lección, quiero decir que al aprender cualquier idioma, no aprenderá a programar. Sin duda, aprenderás algo nuevo, pero lo más probable es que tu cerebro no recuerde esta información, ya que no trabajas con ella. Es imposible aprender un idioma sin práctica, por lo que de esta lección obtienes una pequeña tarea para que la información brindada encaje contigo y puedas trabajar con ella.

Tarea práctica:

Cree tres variables, una con un valor numérico, la segunda con un valor de cadena y la tercera con un valor booleano. Declare todas las variables con una palabra clave var y muéstrelas en la página. Luego anule la variable con un valor numérico y muestre el resultado usando la función alert ().

Al comienzo del siguiente video, analizaremos este problema, compartiremos sus resultados en los comentarios, escribiremos si alguien tiene alguna pregunta. A quien le haya gustado la lección y quiera apoyar el proyecto, simplemente compártelo en las redes sociales.

En la siguiente lección, veremos más de cerca cómo trabajar con tipos de datos y variables, nos familiarizaremos con las operaciones matemáticas y el orden de su ejecución, y también analizaremos métodos para combinar cadenas y valores numéricos.

La lección fue preparada por Denis Gorelov.

Las variables son un bloque de construcción fundamental de muchos lenguajes de programación; son uno de los conceptos más importantes para los aspirantes a programadores. JavaScript tiene muchas propiedades diferentes para las variables, así como algunas reglas a seguir al nombrarlas. JavaScript tiene tres palabras clave que se utilizan para declarar una variable: var, let y const, y cada una de ellas afecta la forma en que se interpreta la variable en su código.

Este tutorial le presentará las variables, cómo declararlas y nombrarlas, y explicará la diferencia entre var, let y const. Además, aprenderá qué es la elevación de variables y cómo afecta el alcance al comportamiento de las variables.

Que son las variables

Una variable es un fragmento de memoria con nombre que se utiliza para almacenar diferentes valores. Una información a la que se puede hacer referencia varias veces se puede almacenar en una variable para su uso o modificación posterior. En JavaScript, el valor contenido dentro de una variable puede ser cualquier tipo de datos, incluido un número, cadena u objeto.

Antes de la especificación del lenguaje ECMAScript 2015 (ES6), en la que se basa actualmente JavaScript, solo había una forma de declarar una variable: utilizando la palabra clave var. Por lo tanto, la mayoría de los códigos y manuales antiguos usan solo var para declarar variables. Echemos un vistazo a las diferencias entre var, let y const.

La palabra clave var le permite demostrar el concepto de la variable en sí. En el siguiente ejemplo, declaramos una variable y le asignamos un valor.

// Asignar el valor de cadena 8host al identificador de nombre de usuario
var username \u003d "8host_blog";

Esta expresión tiene varias partes:

• Declarar una variable usando la palabra clave var;
• Nombre de variable (o identificador), nombre de usuario;
• El operador de asignación, representado por la sintaxis \u003d;
• El valor asignado es "8host_blog".

Ahora puede usar la variable de nombre de usuario en su código. JavaScript recordará que el nombre de usuario representa el valor 8host_blog.

// Comprueba si la variable es igual al valor
if (nombre de usuario \u003d\u003d\u003d "8host_blog") (
console.log (verdadero);
}
cierto

Como se mencionó anteriormente, las variables se pueden expresar con cualquier tipo de datos de JavaScript. En este ejemplo, las variables se expresan como cadena, número, objeto, booleano y nulo.

// Asignación de varias variables
var name \u003d "Morty";
var espartanos \u003d 300;
var reinos \u003d ["mamíferos", "pájaros", "peces"];
var poema \u003d (rosas: "rojo", violetas: "azul");
var éxito \u003d verdadero;
var nada \u003d nulo;

Con console.log, puedes ver el valor de cualquier variable:

// Envía la variable spartans a la consola
console.log (espartanos);
300

Las variables almacenan datos en la memoria que luego se pueden usar o modificar. Las variables también se pueden reasignar y asignar un nuevo valor. El ejemplo simple a continuación demuestra cómo se puede almacenar una contraseña en una variable y luego actualizarla.

// Asignar valor a la variable de contraseña
var contraseña \u003d "hunter2";
// Reasignar el valor de la variable con un nuevo valor
contraseña \u003d "hunter3";
console.log (contraseña);
"hunter3"

En un programa real, es probable que la contraseña se almacene de forma segura en la base de datos. Sin embargo, este sencillo ejemplo ilustra una situación en la que puede actualizar el valor de una variable. El valor de la contraseña era hunter2, pero se le asignó un nuevo valor, hunter3, y ahora JavaScript usará el nuevo valor.

Denominación variable

En JavaScript, los nombres de variables se denominan identificadores. En el manual se pueden encontrar varias reglas para nombrar identificadores. Aquí están en breve:

• Los nombres de las variables solo pueden contener letras, números (0-9), signo de dólar ($) y guión bajo (_).
• Los nombres de las variables no pueden contener espacios en blanco.
• Los nombres de las variables no deben comenzar con un número.
• Hay varias palabras clave reservadas que no se pueden utilizar como nombres de variables.
• Los nombres de las variables distinguen entre mayúsculas y minúsculas.

JavaScript también tiene una convención camelCase para los nombres de funciones y variables declarados con var o let. En este caso, la primera palabra se escribe en minúsculas y cada palabra siguiente comienza con una letra mayúscula (las palabras se escriben sin espacios entre ellas). La mayoría de las variables que no son constantes seguirán esta convención, con algunas excepciones. Los nombres de variables que son constantes (declaradas con la palabra clave const) generalmente se escriben en mayúsculas.

Parece haber bastantes reglas, pero lo parece solo a primera vista. Cuando trabaje con JavaScript a menudo, los recordará rápidamente.

Diferencia entre var, let y const

JavaScript usa tres palabras clave diferentes para declarar variables, lo que agrega una capa adicional de complejidad. Estas palabras clave difieren en los alcances variables, elevación y reasignación.

Quizás se pregunte cuál de las tres palabras clave debería utilizar en sus programas. Es una práctica común usar const tan a menudo como sea posible, y dejar entrar bucles y para reasignaciones. Normalmente, var se usa en código heredado.

Alcance de JavaScript

El alcance en JavaScript se refiere al contexto actual del código que determina la accesibilidad de las variables. El alcance puede ser local y global:

• Las variables globales son aquellas que se declaran fuera del bloque.
• Las variables locales son aquellas que se declaran dentro de un bloque.

En el siguiente ejemplo, crearemos una variable global.

var criatura \u003d "lobo";

Sabes que las variables se pueden reasignar. En el ámbito local, puede crear nuevas variables con el mismo nombre que las variables en el ámbito externo sin modificar ni anular el valor original.

El siguiente ejemplo crea una especie variable global. Dentro de la función, hay una variable local con el mismo nombre. Al enviarlos a la consola, verá que el valor de la variable difiere según el alcance, pero el valor original no cambia.

// Inicializar una variable global
var especie \u003d "humano";
función transform () (
// Inicializar una variable local con ámbito de función
var especies \u003d "hombre lobo";
console.log (especie);
}
// Registrar la variable global y local
console.log (especie);
transform ();
console.log (especie);
humano
hombre-lobo
humano

En este ejemplo, la variable local tiene un alcance en el nivel de función. Las variables declaradas con la palabra clave var siempre pertenecen a este ámbito (es decir, reconocen que las funciones tienen un ámbito separado). Entonces, la variable local no está disponible en el ámbito global.

Sin embargo, las nuevas palabras clave let y const tienen un alcance de bloque. Esto significa que se crea un nuevo ámbito local a partir de cualquier bloque, incluidos los bloques de función, las instrucciones if y los bucles for y while.

Para ilustrar la diferencia entre las variables de nivel de función y de bloque, cree una nueva variable en el bloque if usando let.

var fullMoon \u003d true;
// Inicializar una variable global
dejar especie \u003d "humano";
si (luna llena) (
// Inicializar una variable de ámbito de bloque
let especie \u003d "hombre lobo";

}


No es luna llena. Lupin es actualmente un ser humano.

En este ejemplo, la variable especie tiene un valor global (humano) y un valor local (hombre lobo). Sin embargo, si usa var, obtiene un resultado diferente.

// Usa var para inicializar una variable
var especie \u003d "humano";
si (luna llena) (
// Intenta crear una nueva variable en un bloque
var especies \u003d "hombre lobo";
console.log (`Es luna llena. Lupin es actualmente una $ (especie) .`);
}
console.log (`No es luna llena. Lupin es actualmente una $ (especie) .`);
Es luna llena. Lupin es actualmente un hombre lobo.
No es luna llena. Lupin es actualmente un hombre lobo.

Como resultado, tanto la variable global como la variable de nivel de bloque devuelven el mismo valor, hombre lobo. Esto se debe a que en lugar de crear una nueva variable local, var reasignará la misma variable en el mismo ámbito. var no entiende que debe ser parte de un nuevo alcance diferente. Por lo general, es una buena idea declarar las variables a nivel de bloque, ya que esto reduce el riesgo de invalidar inadvertidamente los valores de las variables.

Elevando variables

La mayoría de los ejemplos hasta ahora han utilizado la palabra clave var para declarar una variable, y la variable se ha inicializado con un valor. Una vez declarado e inicializado, puede acceder al valor o reasignar la variable.

Si intenta utilizar una variable antes de que se declare e inicialice, devolverá undefined.

console.log (x);
// Asignación de variable
var x \u003d 100;
indefinido

Sin embargo, si omite la palabra clave var, la variable no se declarará, solo se inicializará. Esto devolverá un ReferenceError y detendrá la ejecución del script.

// Intenta usar una variable antes de declararla
console.log (x);
// Asignación de variable sin var
x \u003d 100;
ReferenceError: x no está definido

Esto tiene que ver con la elevación: este es un comportamiento de JavaScript que mueve las declaraciones de variables y funciones a la parte superior de su alcance. Dado que solo se eleva la declaración real y no la inicialización, se devuelve undefined en el primer ejemplo.

Para demostrar mejor este concepto, escribimos el siguiente código y explicamos cómo lo lee JavaScript:

// El código que escribimos
console.log (x);
var x \u003d 100;
// Cómo lo interpretó JavaScript
var x;
console.log (x);
x \u003d 100;

JavaScript almacena x en la memoria como una variable antes de ejecutar el script. Dado que la variable se llamó antes de que se definiera, el resultado se devuelve sin definir y no 100. Sin embargo, esto no genera un ReferenceError ni detiene el script. Si bien la palabra clave var no ha cambiado realmente la ubicación de var, demuestra cómo funciona la elevación. Este comportamiento puede causar problemas porque el programador que escribió este código probablemente espera que la salida de x sea verdadera y no indefinida.

Además, levantar puede llevar a resultados impredecibles, como en el siguiente ejemplo:

var x \u003d 100;
función polipasto () (
// Una condición que no debería afectar el resultado del código
si (falso) (
var x \u003d 200;
}
console.log (x);
}
polipasto ();
indefinido

En este ejemplo, la variable global x es 100. Dependiendo de la instrucción if, x puede cambiar a 200, pero como la condición era falsa, no debería afectar el valor de x. En cambio, x se elevó antes del inicio de la función hoist () y el valor se volvió indefinido.

Este comportamiento impredecible puede provocar errores de programa. Dado que let y const se definen a nivel de bloque, no se izarán de la misma forma que en el ejemplo siguiente.

// Inicializar x en el ámbito global
sea \u200b\u200bx \u003d verdadero;
función polipasto () (
// Inicializar x en el alcance de la función
si (3 \u003d\u003d\u003d 4) (
sea \u200b\u200bx \u003d falso;
}
console.log (x);
}
polipasto ();
cierto

Las declaraciones de variables duplicadas que son posibles con var arrojarán un error con let y const.

// Intenta sobrescribir una variable declarada con var
var x \u003d 1;
var x \u003d 2;
console.log (x);
2
// Intenta sobrescribir una variable declarada con let
sea \u200b\u200by \u003d 1;
sea \u200b\u200by \u003d 2;
console.log (y);

Error de sintaxis no detectado: el identificador 'y' ya ha sido declarado
Entonces, las variables declaradas con var pueden verse afectadas por la elevación. La elevación es un mecanismo en JavaScript donde las declaraciones de variables se almacenan en la memoria. Esto puede llevar a variables indefinidas en su código. Las palabras clave let y const resuelven este problema arrojando un error cuando intenta usar una variable antes de declararla o declara una variable más de una vez.

Constantes

Muchos lenguajes de programación usan constantes, estos son valores que no se pueden cambiar. Es decir, los valores asignados a una constante no se pueden reasignar.

Por convención general, los identificadores constantes están en mayúsculas. Esto los diferencia de otras variables.

En el siguiente ejemplo, la variable SPECIES se inicializa como una constante usando la palabra clave const. Intentar reasignar una variable resultará en un error.

// Asignar valor a const
const ESPECIES \u003d "humano";
// Intenta reasignar valor
ESPECIES \u003d "hombre lobo";
console.log (ESPECIES);
Error de tipo no detectado: asignación a variable constante.

Dado que los valores constantes no se pueden reasignar, deben declararse e inicializarse al mismo tiempo, o se producirá un error.

// Declarar pero no inicializar una constante
const TODO;
console.log (TODO);
Error de sintaxis no detectado: falta el inicializador en la declaración const

Los valores que no se pueden cambiar durante la programación se denominan inmutables y los valores que se pueden cambiar se denominan mutables (esto es obvio). Los valores constantes no se pueden reasignar, pero son mutables porque las propiedades de los objetos declarados con const se pueden cambiar.

// Crea un objeto CAR con dos propiedades
const CAR \u003d (
color azul",
precio: 15000
}
// Modificar una propiedad de CAR
Precio del coche \u003d 20000;
console.log (CAR);
(color: "azul", precio: 20000)

Las constantes le permiten informar a otros programadores que trabajan en un proyecto y a usted mismo que una variable determinada no debe reasignarse. Para declarar una variable que se puede reasignar, use let.

Conclusión

En este tutorial, aprendió qué es una variable, se familiarizó con las reglas para nombrar variables y aprendió cómo reasignar sus valores. También aprendió sobre el alcance y la elevación de variables, las limitaciones de la palabra clave var y cómo let y const solucionan estos problemas.

Las variables sirven como "contenedores" para almacenar información.

¿Te acuerdas de álgebra escolar?

¿Recuerdas el álgebra de la escuela? x \u003d 5, y \u003d 6, z \u003d x + y

¿Recuerda que una letra (por ejemplo, x) podría haberse utilizado para almacenar un valor (por ejemplo, 5) y que podría utilizar la información anterior para calcular que z es 11?

Estas letras se llaman variables, y las variables se pueden usar para almacenar valores (x \u003d 5) o expresiones (z \u003d x + y).

Variables de JavaScript

Al igual que en álgebra, las variables de JavaScript se utilizan para almacenar valores o expresiones.

Una variable puede tener un nombre corto, como x, o un nombre más descriptivo, como carname.

Reglas para nombres de variables de JavaScript:

• Los nombres de las variables distinguen entre mayúsculas y minúsculas (y e Y son dos variables diferentes)
• Los nombres de las variables deben comenzar con una letra o un guión bajo

Comentario: Dado que JavaScript distingue entre mayúsculas y minúsculas, los nombres de variables también distinguen entre mayúsculas y minúsculas.

Ejemplo

El valor de una variable puede cambiar durante la ejecución del script. Puede hacer referencia a una variable por su nombre para mostrar o cambiar su valor.

Declaración (creación) de variables de JavaScript

La creación de variables en JavaScript se conoce más comúnmente como "declaración" de variables.

Está declarando variables de JavaScript utilizando la palabra clave var:

Después de ejecutar las sugerencias anteriores, la variable x contendrá el valor 5 y carname contendrá el valor Mercedes.

Comentario: Al asignar un valor de texto a una variable, escríbalo entre comillas.

Comentario: Si vuelve a declarar una variable, no perderá su valor.

Variables locales de JavaScript

Una variable declarada dentro de una función de JavaScript se convierte en LOCAL y solo estará disponible dentro de esta función. (la variable tiene alcance local).

Puede declarar variables locales con el mismo nombre en diferentes funciones, porque las variables locales se reconocen en la función en la que se declaran.

Las variables locales se destruyen cuando la función sale.

Aprenderá más sobre las funciones en lecciones posteriores de JavaScript.

Variables globales de JavaScript

Las variables declaradas fuera de una función se convierten en GLOBAL, y todos los scripts y funciones de la página pueden acceder a ellos.

Las variables globales se destruyen cuando cierra la página.

Si declara una variable sin usar "var", la variable siempre se convierte en GLOBAL.

Asignar valores a variables de JavaScript no declaradas

Si asigna valores a variables que aún no se han declarado, las variables se declararán automáticamente como variables globales.

Estas sugerencias:

Aprenderá más sobre los operadores en el próximo tutorial de JavaScript.

Este capítulo cubre gramática básica, declaraciones de variables, tipos de datos y literales.

Los basicos

JavaScript toma prestada la mayor parte de su sintaxis de Java, pero también ha sido influenciado por lenguajes como Awk, Perl y Python.

JavaScript distingue mayúsculas y minúsculas y usa codificación de caracteres Unicode... Por ejemplo, la palabra Früh (principios del alemán) se puede utilizar como nombre de variable.

Var Früh \u003d "foobar";

Pero la variable früh no es la misma que Früh porque JavaScript distingue entre mayúsculas y minúsculas.

Comentarios

Sintaxis comentarios es el mismo que en C ++ y muchos otros lenguajes:

// Comenta en una línea. / * Comentario que abarca varias líneas. * / / * No puedes anidar / * comentar en un comentario * / Error de sintaxis * /

anuncios

Hay tres tipos de declaraciones en JavaScript:

var Declara una variable, la inicialización de la variable con un valor es opcional. dejar Declara una variable local en el alcance de un bloque, inicializar la variable a un valor es opcional. constante Declara una constante con nombre de solo lectura.

Variables

Puede usar variables como nombres simbólicos para valores en su aplicación. Los nombres de las variables se denominan identificadores y deben seguir ciertas reglas.

Un identificador de JavaScript debe comenzar con una letra, un guión bajo (_) o un signo de dólar ($); los caracteres siguientes también pueden ser números (0-9). Debido a que JavaScript distingue entre mayúsculas y minúsculas, las letras incluyen los caracteres de la "A" a la "Z" (mayúsculas) y los caracteres de la "a" a la "z" (minúsculas).

Puede utilizar letras ISO 8859-1 o Unicode en identificadores como å o ü. También puede utilizar ambos caracteres en identificadores.

Algunos ejemplos de nombres válidos: Number_hits, temp99, _name.

Declaración de variable

Puede declarar una variable de tres formas:

• Usando la palabra clave var. Por ejemplo var x \u003d 42. Esta sintaxis se puede utilizar para declarar variables tanto locales como globales.
• Simplemente asigne un valor a la variable. Por ejemplo, x \u003d 42. Las variables declaradas de esta forma son globales. Tal declaración genera un modo estricto. No se recomienda este método.
• Usando la palabra clave let. Por ejemplo, sea y \u003d 13. Esta sintaxis se puede utilizar para declarar una variable local en el ámbito de un bloque.

Asignar valores

Una variable declarada mediante var o let sin que se le asigne un valor inicial no está definida.

Si intenta acceder a una variable no declarada o variable antes de que se declare, se lanzará una excepción ReferenceError:

Var a; console.log ("El valor de a es" + a); // El valor de la variable a no está definido console.log ("El valor de b es" + b); // Error de referencia no detectado: b no definido console.log ("El valor de c es" + c); // El valor de la variable c no está definido var c; console.log ("El valor de x es" + x); // Error de referencia no detectado: x no está definido let x;

Puede usar undefined para determinar si una variable tiene un valor. En el siguiente ejemplo, a la entrada de la variable no se le asigna un valor y la instrucción if se evalúa como verdadera:

var input; si (entrada \u003d\u003d\u003d indefinido) (hacer esto ( ); ) más (hacer eso ( ) ; }

El valor indefinido se comporta como falso cuando se usa en un contexto booleano. Por ejemplo, el siguiente código ejecuta myFunction porque El elemento myArray no está definido:

var myArray \u003d; if (! myArray [0]) (myFunction ( ) ; }

El valor indefinido se convierte a NaN cuando se usa en un contexto numérico:

var a; a + 2; // NaN

Si se crea una matriz utilizando un literal en el script de nivel superior, JavaScript interpreta la matriz cada vez que evalúa una expresión que contiene el literal. Además, el literal utilizado en la función se crea cada vez que se llama a la función.

Comas adicionales en literales de matriz

No es necesario incluir todos los elementos en el literal de matriz. Si coloca dos comas seguidas, los elementos que faltan no estarán definidos. Por ejemplo:

var fish \u003d ["León" ,, "Ángel"]; // ["León", indefinido, "Ángel"]

Esta matriz tiene 2 elementos con valores y uno vacío (pez es "León", pez no está definido y pez es "Ángel").

Si coloca una coma al final de la lista de elementos, se ignorará. En el siguiente ejemplo, la longitud de la matriz es 3. No myList. Todas las demás comas de la lista indican un elemento nuevo.

Comentario: Las comas adicionales pueden causar errores en las versiones anteriores de los navegadores, por lo que es mejor evitar su uso.

var myList \u003d ["casa" ,, "escuela",]; // ["casa", indefinido, "escuela"]

En el siguiente ejemplo, la longitud de la matriz es cuatro y los elementos myList y myList no están definidos:

var myList \u003d [, "hogar" ,, "escuela"]; //

En el siguiente ejemplo, la longitud de la matriz es cuatro y los elementos myList y myList no están definidos. Solo se ignora la última coma.

var myList \u003d ["hogar" ,, "escuela" ,,]; // ["hogar", indefinido, "escuela", indefinido]

Comprender el comportamiento de las comas adicionales es importante para comprender JavaScript como lenguaje. Sin embargo, cuando escriba su propio código, tenga en cuenta que declarar explícitamente los elementos faltantes como indefinidos mejora la claridad y la facilidad de mantenimiento.

Literales lógicos

El tipo booleano tiene dos valores literales: verdadero y falso.

No confunda los valores booleanos primitivos verdadero y falso con los valores verdadero y falso de un objeto booleano. El objeto booleano es un objeto contenedor sobre una primitiva booleana. Para obtener más detalles, lea Boolean.

Literal entero

Los números enteros se pueden escribir en sistemas decimal, hexadecimal, octal y binario.

• Un literal entero decimal consta de una secuencia de dígitos sin un cero inicial.
• Un cero a la izquierda en un literal entero indica que está en octal. Los enteros octales constan solo de los dígitos 0-7.
• Los caracteres iniciales 0x (o 0X) indican que el número es hexadecimal. Los números enteros hexadecimales pueden constar de los dígitos 0-9 y las letras a-f y A-F.
• Los caracteres iniciales 0b (o 0B) indican que el número es binario. Los números binarios solo pueden incluir los dígitos 0 y 1.

Algunos ejemplos de literales enteros:

0, 117 y -345 (decimal) 015, 0001 y -077 (octal) 0x1123, 0x00111 y -0xF1A7 (hex) 0b11, 0b0011 y -0b11 (binario)

Literal de punto flotante

Los números de coma flotante pueden constar de las siguientes partes:

• Un entero decimal que puede tener un signo (el carácter "+" o "-" que precede al número),
• Punto decimal ("."),
• Parte fraccionaria (otro número decimal),
• Expositor.

El exponente consta de una "e" o "E" seguida de un número entero, que puede tener signo. Un número de coma flotante debe constar de al menos un dígito y un punto decimal o el carácter "e" (o "E").

En una forma más concisa, la sintaxis es la siguiente:

[(+ | -)] [. dígitos] [(E | e) [(+ | -)] dígitos]

3.14 -3.1E + 12 -.3333333333333333333 .1e-23

Objeto literal

Un objeto literal es una lista de cero o más pares de nombres de propiedad y valores asociados, encerrados entre llaves (()). No debe utilizar un objeto literal al principio de una expresión, ya que esto dará como resultado un error o comportamiento inesperado, porque "(" se interpretará como el inicio de un bloque.

El siguiente ejemplo asigna la cadena "Saturno" a la propiedad myCar del objeto coche, establece la propiedad getCar en el resultado de llamar a la función CarTypes ("Honda") y establece la propiedad especial en el valor de la variable Sales:

var Sales \u003d "Toyota"; función CarTypes ( name) (if (name \u003d\u003d "Honda") (return name;) else (return "Lo siento, no vendemos" + nombre + "." ; )) var car \u003d (myCar: "Saturno", getCar: CarTypes ( "Honda"), especial: Ventas); consola. Iniciar sesión ( coche. mi coche); // Consola Saturno. Iniciar sesión ( coche. getCar); // Consola Honda. Iniciar sesión ( coche. especial); // Toyota

Además, puede utilizar literales numéricos o de cadena en los nombres de las propiedades o anidar un objeto dentro de otro. Por ejemplo:

var car \u003d (manyCars: (a: "Saab", "b": "Jeep"), 7: "Mazda"); consola. Iniciar sesión ( coche. Muchos carros. si); // Consola Jeep. Iniciar sesión ( coche [7]); // Mazda

El nombre de la propiedad del objeto puede ser cualquier cadena, incluida una cadena vacía. Si el nombre de la propiedad no es un identificador de JavaScript válido, debe ir entre comillas. Para hacer referencia a estos nombres, utilice corchetes () en lugar de un punto (.):

var inusualPropertyNames \u003d ("": "Una cadena vacía", "!": "¡Bang!") consola. Iniciar sesión ( inusualPropertyNames. ""); // SyntaxError: Cadena inesperadaconsola. Iniciar sesión ( inusualPropertyNames [""]); // Consola "Una cadena vacía". Iniciar sesión ( inusualPropertyNames. ! ); // ¡Error de sintaxis: símbolo inesperado!consola. Iniciar sesión ( inusualPropertyNames ["!" ]); // "¡Bang!"

En ES2015, los literales de objeto se extienden para admitir la configuración del prototipo en la construcción abreviada de foo: configurar foo, definir métodos, realizar super llamadas y evaluar nombres de propiedad en expresiones. Juntos, hacen que los objetos literales y las declaraciones de clases sean similares y permiten que el diseño de objetos aproveche las mismas capacidades.

Var obj \u003d (// __proto__ __proto__: theProtoObj, // Notación corta para el controlador 'handler: handler', // Métodos toString () (// Super llamadas devuelven "d" + super.toString ();), // Dynamic cálculo de nombres de propiedad ["prop_" + (() \u003d\u003e 42) ()]: 42);

Eche un vistazo al siguiente ejemplo:

var foo \u003d (a: "alpha", 2: "dos"); consola. Iniciar sesión ( foo. una); // consola alfa. Iniciar sesión ( foo [2]); // dos // console.log (foo.2); // SyntaxError: número inesperado// console.log (foo [a]); // ReferenceError: a no está definidoconsola. Iniciar sesión ( foo ["a"]); // consola alfa. Iniciar sesión ( foo ["2"]); // dos

Literal de expresión regular

El literal regexp es un patrón entre barras. El siguiente ejemplo es una expresión regular literal:

Var re \u003d / ab + c /;

Literal de cadena

Un literal de cadena es cero o más caracteres encerrados entre comillas dobles (") o simples ("). La cadena debe estar delimitada con comillas simples, es decir ambos sencillos o ambos dobles. Por ejemplo:

"foo" "bar" "1234" "una línea \\ n otra línea" "El gato de John"

Puede llamar a cualquiera de los métodos del objeto String en un literal de cadena: JavaScript convertirá automáticamente el literal de cadena en un objeto String temporal, llamará al método y luego destruirá el objeto String temporal. También puede usar la propiedad String.length con un literal de cadena:

Consola. Iniciar sesión ( "John" s cat. Longitud); // El número de caracteres en la cadena, incluido el espacio.// En este caso, la longitud de la cadena es 10.

Las plantillas de cadenas también están disponibles en ES2015. Los patrones de cadena son un azúcar sintáctico para construir cadenas. Esto es similar a las capacidades de interpolación de cadenas en Perl, Python y otros. Además, se puede agregar una etiqueta para personalizar la construcción de cadenas, evitando ataques de inyección y construyendo estructuras de datos de alto nivel a partir del contenido de la cadena.

// Creación simple de cadenas a través de una cadena literal `En JavaScript" \\ n "es un avance de línea. // Cadenas de varias líneas` En JavaScript esto no es legal. // Interpolación de cadenas var name \u003d" Bobby ", time \u003d" today "; `Hola $ (nombre), ¿cómo estás $ (hora)?` // Construye el prefijo de solicitud HTTP usado para interpretar reemplazos y construir POST`http: //foo.org/bar? A \u003d $ (a) & b \u003d $ ( b) Tipo de contenido: application / json X-Credentials: $ (credentials) ("foo": $ (foo), "bar": $ (bar)) `(myOnReadyStateChangeHandler);

Debe usar cadenas literales a menos que necesite específicamente un objeto String. Para obtener más información sobre el objeto String, lea String.

Usar caracteres especiales en cadenas

Además de los caracteres ordinarios, también puede incluir caracteres especiales en cadenas.

"una línea \\ n otra línea"

La siguiente tabla enumera los caracteres especiales que puede utilizar.

Caracteres especiales en JavaScript

Símbolo	Valor
\\ b	Retroceso
\\ f	Traducción o alimentación de página (alimentación de formulario)
\\ n	Salto de línea (nueva línea)
\\ r	Retorno de carro
\\ t	Ficha (ficha)
\\ v	Pestaña vertical
\"	Apóstrofo o comilla simple
\"	Cotización doble
\\	Barra invertida (barra invertida)
\XXX	Carácter latino-1 representado por tres números octales XXX de 0 a 377. Por ejemplo, \\ 251 (símbolo ©).
\\ X XX	Carácter latino-1 representado por dos números hexadecimales XX 00 a FF. Por ejemplo, \\ xA9 (carácter ©).
\\ u XXXX	Carácter Unicode representado por cuatro números hexadecimales XXXX... Por ejemplo, \\ u00A9 (carácter ©).
\\ u (XXXXX)	El personaje está en UTF-32BE. Por ejemplo, \\ u (2F804) significa lo mismo que \\ uD87E \\ uDC04 normal.

Escapar personajes

Para los caracteres que no figuran en la tabla anterior, se ignora la barra invertida inicial. Este uso está desaprobado y debe evitarlo.

Puede insertar comillas en una cadena precediéndola con una barra invertida. Esto se llama comillas de escape. Por ejemplo:

var quote \u003d "Él leyó \\" La cremación de Sam McGee \\ "por R.W. Service".; consola. Iniciar sesión ( citar); // Leyó "La cremación de Sam McGee" de R.W. Servicio.

Para incluir una barra invertida en una cadena, debe precederla con otra barra invertida. Por ejemplo:

var home \u003d "c: \\\\ temp"; // c: \\ temp

También puede escapar del salto de línea. La barra invertida y el avance de línea se eliminarán del contenido de la cadena. Por ejemplo:

var str \u003d "esta cadena \\ está rota \\ en varias \\ líneas." consola. Iniciar sesión ( str); // esta cadena se divide en varias líneas.

Aunque JavaScript no admite la sintaxis "heredoc" (texto formateado en una sola variable de cadena), puede emularlo agregando una nueva línea y una barra invertida al final de cada línea:

var poem \u003d "Las rosas son rojas, \\ n \\ Las violetas son azules. \\ n \\ Soy esquizofrénico, \\ n \\ Y yo también".

Información Adicional

Este capítulo se centra en la sintaxis básica de declaraciones y tipos. Para obtener más información sobre las construcciones de JavaScript, lea:

El próximo capítulo cubre las construcciones de control y el manejo de errores.

Última actualización: 05.04.2018

Las variables se utilizan para almacenar datos en el programa. Las variables están diseñadas para almacenar algunos datos temporales o datos que pueden cambiar su valor durante la operación. Las palabras clave var y let se utilizan para crear variables. Por ejemplo, declaremos la variable myIncome:

Var myIncome; // otra opción deja myIncome2;

Cada variable tiene un nombre. El nombre es un conjunto arbitrario de caracteres alfanuméricos, guión bajo (_) o signo de dólar ($), y los nombres no deben comenzar con caracteres numéricos. Es decir, podemos usar letras, números, guiones bajos en el título. Sin embargo, todos los demás personajes están prohibidos.

Por ejemplo, los nombres correctos de las variables son:

$ comision someVariable product_Store income2 myIncome_from_deposit

Los siguientes nombres son incorrectos y no se pueden utilizar:

222lol @someVariable my% percent

Además, no puede dar nombres de variables que coincidan con las palabras clave reservadas. No hay muchas palabras clave en JavaScript, por lo que esta regla no es difícil de seguir. Por ejemplo, el siguiente nombre sería incorrecto porque for es una palabra clave de JavaScript:

Var para;

Lista de palabras reservadas en JavaScript:

resumen, booleano, descanso, byte, caso, captura, char, clase, const, continuar, depurador, predeterminado, eliminar, hacer, doble, más, enumeración, exportar, extiende, falso, final, finalmente, flotar, para, función, goto, if, implements, import, in, instanceof, int, inteface, long, native, new, , package, private, protected, public, return, short, static, super, switch, synchronized, this, throw, throws, transitorio, verdadero, intento, tipo de, var, volátil, vacío, mientras, con

Al nombrar variables, tenga en cuenta que JavaScript es distingue mayúsculas y minúsculas language, es decir, el siguiente código declara dos variables diferentes:

Var myIncome; var MyIncome;

Puede definir varias variables a la vez, separadas por comas:

Var myIncome, procent, sum; sea \u200b\u200ba, b, c;

Usando el signo igual (también llamado operador de asignación) puede asignar un valor a una variable:

Var renta \u003d 300; sea \u200b\u200bprecio \u003d 76;

El proceso de inicialización de una variable se denomina inicialización.

Ahora, la renta variable almacenará el número 300 y el precio variable almacenará el número 76.

La característica distintiva de las variables es que podemos cambiar su valor:

Var renta \u003d 300; ingresos \u003d 400; console.log (ingresos); sea \u200b\u200bprecio \u003d 76; precio \u003d 54; console.log (precio);

Constantes

La palabra clave const se puede utilizar para definir una constante que, como una variable, almacena un valor, pero este valor no se puede cambiar.

Tasa constante \u003d 10;

Si intentamos cambiar su valor, nos encontraremos con un error:

Tasa constante \u003d 10; tasa \u003d 23; // error, la tasa es constante, por lo que no podemos cambiar su valor

También vale la pena señalar que dado que no podemos cambiar el valor de una constante, se debe inicializar, es decir, cuando la definamos, debemos darle un valor inicial. Si no hacemos esto, nuevamente nos enfrentaremos a un error:

Tasa constante; // error, la tasa no se inicializa