Java Script

Esta declaración le dice al navegador que escriba "Hello Dolly." Dentro de un elemento HTML con id="demo" :
Ejemplo
document.getElementById("demo").innerHTML = "Hello Dolly.";

La mayoría de los programas JavaScript contienen muchas sentencias de JavaScript.

Las instrucciones se ejecutan, uno por uno, en el mismo orden en que se escriben.

En este ejemplo x, y , y z son valores dados, y, finalmente, z se muestra:

Ejemplo
var x = 5;
var y = 6;
var z = x + y;
document.getElementById("demo").innerHTML = z;

Punto y coma separan sentencias de JavaScript.

Añadir un punto y coma al final de cada instrucción ejecutable:

a = 5;
b = 6;
c = a + b;
Punto y coma separan sentencias de JavaScript.

Añadir un punto y coma al final de cada instrucción ejecutable:

a = 5;
b = 6;
c = a + b;

JavaScript ignora múltiples espacios. Puede agregar espacio en blanco a su script para que sea más legible.

Las siguientes líneas son equivalentes:

var person = "Hege";
var person="Hege";
Una buena práctica es poner espacios alrededor de los operadores ( = + - * / ) :

var x = y + z;

Para un mejor legibilidad, los programadores a menudo como para evitar las líneas de código de más de 80 caracteres.

Si una instrucción JavaScript no cabe en una línea, el mejor lugar para romperlo, es después de un operador:

Ejemplo
document.getElementById("demo").innerHTML =
"Hello Dolly.";

sentencias de JavaScript se pueden agrupar en bloques de código, entre llaves {...}.

El propósito de los bloques de código es definir sentencias que se ejecutan en conjunto.

Un lugar que usted encontrará declaraciones agrupadas en bloques, están en funciones de JavaScript:

Ejemplo
function myFunction() {
document.getElementById("demo").innerHTML = "Hello Dolly.";
document.getElementById("myDIV").innerHTML = "How are you?";
}
sentencias de JavaScript se pueden agrupar en bloques de código, entre llaves {...}.

El propósito de los bloques de código es definir sentencias que se ejecutan en conjunto.

Un lugar que usted encontrará declaraciones agrupadas en bloques, están en funciones de JavaScript:

Ejemplo
function myFunction() {
document.getElementById("demo").innerHTML = "Hello Dolly.";
document.getElementById("myDIV").innerHTML = "How are you?";
}

Sentencias JavaScript menudo comienzan con una palabra clave para identificar la acción JavaScript a realizar.

Aquí está una lista de algunas de las palabras clave que usted aprenderá acerca de este tutorial:

break: Termina un interruptor o un bucle
continue: Salta de un bucle y comienza en la parte superior
debugger: Detiene la ejecución de JavaScript, y las llamadas (si está disponible) la función de depuración
do ... while: Ejecuta un bloque de instrucciones, y repite el bloque, mientras que una condición es verdadera
for: Marca un bloque de instrucciones a ejecutar, siempre que se cumpla una condición
function: Declara una función
if ... else: Marca un bloque de sentencias que se ejecutará, en función de una condición
return: Sale de una función
switch: Marca un bloque de sentencias que se ejecutará, en función de los diferentes casos
try ... catch: Implementa la gestión de errores para un bloque de instrucciones
var Declara una variable

En el ámbito superior (fuera de cualquier función y bloque), las declaraciones var ponen un
elemento en el objeto global. no lo let
var x = 4;
let y = 7;
console.log(this.x); // >> 4
console.log(this.y); // >> undefined

Declarar una variable dos veces usando var no produce un error (aunque es equivalente a
declararlo una vez):
var x = 4;
var x = 7;
Con let , esto produce un error:
let x = 4;
let x = 7;
TypeError: el identificador x ya ha sido declarado
Lo mismo es cierto cuando y se declara con var :
var y = 4;
let y = 7;
TypeError: el identificador y ya ha sido declarado
Sin embargo, las variables declaradas con let se pueden reutilizar (no volver a declarar) en un
bloque anidado
let i = 5;
{
let i = 6;
console.log(i); // >> 6
}
console.log(i); // >> 5
Dentro del bloque se puede acceder a la i externa, pero si el bloque interior tiene una declaración
de let para i , no se puede acceder a la i externa y lanzará un ReferenceError si se usa antes de
que se declare la segunda.
let i = 5;
{
i = 6; // outer i is unavailable within the Temporal Dead Zone
let i;
}
Error de referencia: no está definido

Variables declaradas ambas con var y let son izadas . La diferencia es que se puede hacer
referencia a una variable declarada con var antes de su propia asignación, ya que se asigna
automáticamente (con undefined como su valor), pero let puede: requiere específicamente que se
declare la variable antes de ser invocada:
console.log(x); // >> undefined
console.log(y); // >> "ReferenceError: `y` is not defined"
//OR >> "ReferenceError: can't access lexical declaration `y` before initialization"
var x = 4;
let y = 7;
El área entre el inicio de un bloque y una declaración let o const se conoce como la Zona Muerta
Temporal , y cualquier referencia a la variable en esta área causará un ReferenceError . Esto
sucede incluso si la variable se asigna antes de ser declarada :
y=7; // >> "ReferenceError: `y` is not defined"
let y;
En el modo no estricto, al asignar un valor a una variable sin ninguna declaración, se declara
automáticamente la variable en el ámbito global .

Cuando se declara una función, las variables en el contexto de su declaración se capturan en su alcance. Por ejemplo, en el código a continuación, la variable x está vinculada a un valor en el
ámbito externo, y luego la referencia a x se captura en el contexto de la bar :
var x = 4; // declaration in outer scope
function bar() {
console.log(x); // outer scope is captured on declaration
}
bar(); // prints 4 to console
Salida de muestra: 4
Este concepto de "capturar" el alcance es interesante porque podemos usar y modificar variables
desde un alcance externo incluso después de que el alcance externo finalice. Por ejemplo,
considere lo siguiente:
function foo() {
var x = 4; // declaration in outer scope
function bar() {
console.log(x); // outer scope is captured on declaration
}
return bar;
// x goes out of scope after foo returns
}
var barWithX = foo();
barWithX(); // we can still access x
Salida de muestra: 4

Esto nos permite hacer algunas cosas interesantes, como definir variables "privadas" que son
visibles solo para una función específica o un conjunto de funciones. Un ejemplo artificial (pero
popular):
function makeCounter() {
var counter = 0;
return {
value: function () {
return counter;
},
increment: function () {
counter++;
}
};
}
var a = makeCounter();
var b = makeCounter();
a.increment();
console.log(a.value());
console.log(b.value());
Salida de muestra:
1
0
Cuando se llama a makeCounter() , se guarda una instantánea del contexto de esa función. Todo el
código dentro de makeCounter() usará esa instantánea en su ejecución. Dos llamadas de
makeCounter() crearán dos instantáneas diferentes, con su propia copia del counter .

En la programación, los tipos de datos son un concepto importante. Para poder operar sobre variables, es importante saber algo sobre el tipo. Sin tipos de datos, una computadora no puede solucionarlo con seguridad

JavaScript tiene tipos dinámicos. Esto significa que la misma variable se puede utilizar para contener diferentes tipos de datos:
Ejemplo
var x; // Now x is undefined
var x = 5; // Now x is a Number
var x = "John"; // Now x is a String

JavaScript tiene sólo un tipo de números. Los números se pueden escribir con o sin decimales:
Ejemplo
var x1 = 34.00; // Written with decimals
var x2 = 34; // Written without decimals

Los booleanos sólo pueden tener dos valores: verdadero o falso.
Ejemplo
var x = true;
var y = false;
Los booleanos se usan a menudo en las pruebas condicionales. Más adelante aprenderá más sobre las pruebas condicionales en este tutorial.

Los arrays de JavaScript se escriben con corchetes.
Los elementos de la matriz están separados por comas.
El siguiente código declara (crea) una matriz llamada coches, que contiene tres elementos (nombres de automóviles):
Ejemplo var cars = ["Saab", "Volvo", "BMW"];

Se puede utilizar el operador typeof JavaScript para encontrar el tipo de una variable de JavaScript. El operador typeof devuelve el tipo de una variable o una expresión:
Ejemplo
typeof "" // Returns "string"
typeof "John" // Returns "string"
typeof "John Doe" // Returns "string"
typeof "John" + "Doe" // Returns "string"

Un valor vacío no tiene nada que ver con indefinido. Una variable de cadena vacía tiene un valor y un tipo.
Ejemplo: var car = ""; // The value is "", the typeof is "string"

En JavaScript, null es "nada". Se supone que es algo que no existe. Desafortunadamente, en JavaScript, el tipo de datos de null es un objeto. Puedes considerarlo un error en JavaScript que typeof null es un objeto. Debe ser nulo. Puede vaciar un objeto estableciéndolo en null:
Ejemplo
var person = null; // Value is null, but type is still an object