Se ejecutaron ejemplos de salida por consola.

console.log("%cEn ésta sección hay ejemplos de salida por consola:", "background-color:yellow");
console.log("Hola mundo.");
console.info("Mensaje de console.info");
console.error("Mensaje de console.error");
console.warn("Mensaje de console.warn");
//Muestra todos los enlaces de la página
console.dir(document.links);
//Imprime una representación en XML de de los elementos descendientes de objeto.
cosa = [34,25];
console.dirxml(cosa);
//Limpia la ventana de la consola
//console.clear();
//Mensaje formateado
console.log("%cMensaje de color verde y grande", "color: green; font-size: x-large");

En ésta sección trabajamos con variables.

console.log("%cEn ésta sección trabajamos con variables:", "background-color:yellow");
var sumando1 = 23;
let sumando2 = 33;
const sumando3 = "E";
sumatotal= sumando1 + sumando2 + sumando3;
console.log("%cSumamos algunas variables y el resultado es: "+sumatotal, "color: blue; font-size: large");
//Una función
var numero = 2;
function miFuncion (){
var numero = 19;
document.write(numero) //imprime 19;
}
miFuncion();
document.write(numero); //imprime 2

//Usando "let"
for(let i=0; i<3; i++) {
// en este caso, la variable i sólo existe dentro del bucle for
alert(i);
}
// fuera del bloque for no existe la variable i

Si esa variable "i" hubiera sido declarada en la cabecera del bucle for mediante "var", sí que existiría fuera del bloque de código del for.

Ejemplo:
var i;
for(i=0; i<3; i++) {
alert("'Alert' número "+i+" usando VAR fuera del bucle for.");
}
i--;
alert("El último valor de 'alert' usando VAR fuera del bucle for fué "+i);

Caracteres especiales en cadenas de texto:

Salto de línea: \n
Comilla simple: \'
Comilla doble: \"
Tabulador: \t
Retorno de carro: \r
Avance de página: \f
Retroceder espacio: \b
Contrabarra: \\

Las variables no están forzadas a guardar un tipo de datos en concreto, por lo que no se declara un tipo al crearlas.
Incluso podemos ir cambiando el contenido de una variable de un tipo a otro.
Ejemplo:
var nombre_ciudad = "Valencia"
var revisado = true
nombre_ciudad = 32
revisado = "no"

Veamos lo que ocurriría en caso de sumar letras y números:
var sumando1 = 23
var sumando12 = "33"
var suma = sumando1 + sumando12
document.write(suma)

parseInt() y parseFloat()

parseInt() y parseFloat() son funciones creadas para analizar un string y devolver un número si es posible.
Los espacios iniciales y finales se ignoran.

parseInt(string, radix) - Conversión de string a entero

radix es opcional y representa la base en la que estamos trabajando.
El prefijo 0x indica que el número está en hexadecimal aunque no se incluya radix 16.
Algunos ejemplos:

• parseInt("10"); // 10
• parseInt("10.8"); // 10
• parseInt("10 22"); // 10
• parseInt(" 14 "); // 14
• parseInt("20 dias"); // 20
• parseInt("Hace 20 dias"); // NaN
• parseInt("44aa33bb"); // 44
• parseInt("3.14"); // 3
• parseInt("314e-2"); // 314
• parseInt(""); // NaN -> ¡¡el string vacio se convierte a NaN!!
• parseInt(null); // NaN
• parseInt("10",10); // 10
• parseInt("010"); // 10 ¡¡ * 8 en navegadores antiguos * !!
• parseInt("10",8); // 8
• parseInt("0x10"); // 16 0x indica que el número es hexadecimal
• parseInt("10",16); //16

parseFloat(string) - Conversión de string a número en coma flotante

En este caso no existe radix. El número siempre se interpreta como decimal, independientemente de cualquier prefijo que le pongamos (0 para octal ó 0x para hexadecimal).
La diferencia con el anterior, ademas de admitir decimales, es que los números en coma flotante admiten la notación exponencial, del tipo "314e-2" o "0.0314e+2".
Si la función encuentra un carácter que no sea un número (0-9), un signo (+ o -), un punto decimal o un exponente, ignorará todos los caracteres que vengan a continuación.
Ejemplos:

• parseFloat("3.14"); // 3.14
• parseFloat("314e-2"); // 3.14
• parseFloat("0.0314E+2"); // 3.14
• parseFloat("3.14dieciseis"); // 3.14
• parseFloat("A3.14"); // NaN
• parseFloat("tres"); // NaN
• parseFloat("e-2"); // NaN
• parseFloat("0x10"); // 0 -> No admite el prefijo 0x para indicar 'hexadecimal'
• parseFloat(""); // NaN -> ¡¡el string vacio se convierte a NaN!!
• parseFloat(null); // NaN

Number()

A diferencia de los dos métodos anteriores, éste y el siguiente (conversión implícita) son específicamente para conversión de tipos.
En cambio, parseInt() y parseFloat() son para extraer un número de un string.
Number() es un constructor para crear objetos de tipo Number, pero cuando se utiliza sin el new funciona como un conversor a tipo númerico.
Ejemplos:

• como constructor: var myNumber = new Number(14);
• como método: var myNumber = Number("14");

• Number("12"); // 12
• Number("3.14"); // 3.14
• Number("314e-2"); // 3.14
• Number("0.0314E+2"); // 3.14
• Number("e-2"); // NaN
• Number('0x10'); // 16 admite el prefijo 0x para indicar 'hexadecimal'

Conversión implícita '+'

• var myNumberValue = "8" - 0; // number 8
• var myNumberValue = "8" * 1; // number 8
• var myNumberValue = "8" / 1; // number 8
• var myNumberValue = +"8"; // number 8

• parseInt() tiene un parámetro extra para indicar la base del número (radix).
• parseFloat() no admite radix. Todos los números se consideran en base decimal.
• parseInt(), Number() y '+' interpretan el prefijo '0x' como número hexadecimal, parseFloat() no.
• parseInt() y parseFloat() pueden extraer un número al principio de un string.
• Si el string contiene caracteres no numéricos, Number() y '+' no lo convierten, devuelven NaN.
• Cuando el argumento es un objeto, parseInt() y parseFloat() llamarán al método .toString() antes de analizar la cadena. Number() y +var llamarán primero a .valueOf() y despues a .toString() si es necesario.
• parseInt() no entiende la notación exponencial, todos los demás si.
• parseInt() y parseFloat() convierten el string vacio en NaN.
• Number() y '+' convierten el string vacio en 0.
• parseInt() y parseFloat() de un boolean es NaN.
• Number() y '+' de un boolean devuelven 0 para false y 1 para true.