Este documento proporciona una introducción a los fundamentos de JavaScript, incluyendo su historia, sintaxis básica, operadores, tipos de datos, código condicional, bucles, funciones, alcance y más. Explica conceptos clave como variables, objetos, arreglos, funciones y tipos.

1. Fundamentos de
Javascript
Abraham Estrada

2. Historia
Brendan Eich 3WC - DOM
Netscape 1997 ECMA
Mocha > LiveScript ECMAScript
1995 ISO
Microsoft JScript
1996

3. Sintaxis Básica
var foo = ‘hello world’;
var foo = ‘hello world’;
2 * 3 + 5 // 11
2 * (3 + 5) // 16
var foo = function() {
console.log(‘hello);
};

4. Operadores Básicos
var foo = ‘hello’;
var bar = ‘world’;
console.log(foo + ‘ ‘ + bar);
2 * 3;
2 / 3;
var i = 1;
var j = ++i;
var k = i++;

5. Operaciones con Números
y Cadenas de Caracteres
var foo = 1;
var bar = ‘2’;
console.log(foo + bar);
console.log(foo + Number(bar));
console.log(foo + +bar);

6. Operadores Lógicos
var foo = 1;
var bar = 0;
var baz = 2;
foo || bar; // devuelve 1, el cual es verdadero (true)
bar || foo; // devuelve 1, el cual es verdadero (true)
foo && bar; // devuelve 0, el cual es falso (false)
foo && baz; // devuelve 2, el cual es verdadero (true)
baz && foo; // devuelve 1, el cual es verdadero (true)

7. Operadores de Comparación
var foo = 1;
var bar = 0;
var baz = '1';
var bim = 2;
foo == bar; // devuelve falso (false)
foo != bar; // devuelve verdadero (true)
foo == baz; // devuelve verdadero (true)
foo === baz; // devuelve falso (false)
foo !== baz; // devuelve verdadero (true)
foo === parseInt(baz); // devuelve verdadero (true)
foo > bim; // devuelve falso (false)
bim > baz; // devuelve verdadero (true)
foo <= baz; // devuelve verdadero (true)

8. Código Condicional
var foo = true;
var bar = false;
if (bar) {
// este código nunca se ejecutará
console.log('hello!');
}
if (bar) {
// este código no se ejecutará
} else {
if (foo) {
// este código se ejecutará
} else {
// este código se ejecutará si foo y bar son falsos (false)
}
}

9. Elementos Verdaderos y Falsos
'0';
'any string'; // cualquier cadena
[]; // un arreglo vacío
{}; // un objeto vacío
1; // cualquier número distinto a cero
0;
''; // una cadena vacía
NaN; // la variable JavaScript "not-a-number"
null; // un valor nulo
undefined; // puede ser redefinido

10. Variables Condicionales
Utilizando el Operador Ternario
var foo = bar ? 1 : 0;

11. Declaración Switch
switch (foo) {
case 'bar':
alert('el valor es bar');
break;
case 'baz':
alert('el valor es baz');
break;
default:
alert('de forma predeterminada se ejecutará este código');
break;
}

12. var stuffToDo = {
'bar' : function() {
alert('el valor es bar');
},
'baz' : function() {
alert('el valor es baz');
},
'default' : function() {
alert('de forma predeterminada se ejecutará este código');
}
};
if (stuffToDo[foo]) {
stuffToDo[foo]();
} else {
stuffToDo['default']();
}

13. Bucle: For
// muestra en la consola 'intento 0',
// 'intento 1', ..., 'intento 4'
for (var i=0; i<5; i++) {
console.log('intento ' + i);
}

14. Bucle: While
var i = 0;
while (i < 100) {
// Este bloque de código
// se ejecutará 100 veces
console.log('Actualmente en ' + i);
i++; // incrementa la variable i
}

15. Bucle: Do-While
do {
// Incluso cuando la
// condición sea falsa
// el cuerpo del bucle se
// ejecutará al menos una vez.
alert('Hello');
} while(false);

16. Break - Continue
for (var i = 0; i < 10; i++) {
if (something) {
break;
}
}
for (var i = 0; i < 10; i++) {
if (something) {
continue;
}
// La siguiente declaración será ejecutada
// si la condición 'something' no se cumple
console.log('Hello');
}

17. Palabras Reservadas
abstract double in super
boolean else instanceof switch
break enum int synchronized
byte export interface this
case extends long throw
catch final native throws
char finally new transient
class float package try
const for private typeof
continue function protected var
debugger goto public void
default if return volatile
delete implements short while
do import static with

18. Arreglos
var myArray = [ 'hello', 'world' ];
var myArray = [ 'hello', 'world', 'foo'];
console.log(myArray[2]);
console.log(myArray.length);
myArray[1] = ‘changed’;
myArray.push(‘new’);

19. Arreglos
var myArray = [ 'h', 'e', 'l', 'l', 'o' ];
var myString = myArray.join(''); // 'hello'
var mySplit = myString.split('');
// [ 'h', 'e', 'l', 'l', 'o' ]

20. Objetos
var myObject = {
sayHello : function() {
console.log('hello');
},
myName : 'Rebecca'
};
myObject.sayHello();
console.log(myObject.myName);

21. Funciones
function foo() { /* hacer algo */ }
var foo = function() { /* hacer algo */ }
http://kangax.github.com/nfe/

22. var greet = function(person, greeting) {
var text = greeting + ', ' + person;
console.log(text);
};
greet('Rebecca', 'Hello');
// muestra en la consola 'Hello, Rebecca'

23. var greet = function(person, greeting) {
var text = greeting + ', ' + person;
return text;
};
console.log(greet('Rebecca','hello'));
// la función devuelve 'Hello, Rebecca',
la cual se muestra en la consola

24. var greet = function(person, greeting) {
var text = greeting + ', ' + person;
return function() { console.log(text); };
};
var greeting = greet('Rebecca', 'Hello');
greeting();
// se muestra en la consola 'Hello, Rebecca'

25. Funciones Anónimas
Autoejecutables
(function(){
var foo = 'Hello world';
})();
console.log(foo);
// indefinido (undefined)

26. var myFunction = function() {
console.log('hello');
};
var myObject = {
foo : 'bar'
};
var myArray = [ 'a', 'b', 'c' ];
var myString = 'hello';
var myNumber = 3;

27. typeof myFunction; // devuelve 'function'
typeof myObject; // devuelve 'object'
typeof myArray; // devuelve 'object'
typeof myString; // devuelve 'string'
typeof myNumber; // devuelve 'number'
typeof null; // devuelve 'object'
if (myArray.push && myArray.slice && myArray.join) {
// probablemente sea un arreglo
// (este estilo es llamado, en inglés, "duck typing")
}
if (Object.prototype.toString.call(myArray) === '[object
Array]') {
// definitivamente es un arreglo;
// esta es considerada la forma más robusta
// de determinar si un valor es un arreglo.
}

28. Alcance (scope)
var foo = 'hello';
var sayHello = function() {
console.log(foo);
};
sayHello(); // muestra en la consola 'hello'
console.log(foo); // también muestra en la
consola 'hello'

29. Alcance (scope)
var sayHello = function() {
var foo = 'hello';
console.log(foo);
};
sayHello(); // muestra en la consola 'hello'
console.log(foo); // no muestra nada en
la consola

30. Alcance (scope)
var foo = 'world';
var sayHello = function() {
var foo = 'hello';
console.log(foo);
};
sayHello(); // muestra en la consola 'hello'
console.log(foo); // muestra en la
consola 'world'