Merge pull request #1 from adambard/master

update

1 files changed, 25 insertions, 25 deletions

diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
index a1348508..31512dc4 100644
--- a/es-es/javascript-es.html.markdown
+++ b/es-es/javascript-es.html.markdown
@@ -16,22 +16,23 @@ con Java para aplicaciones más complejas. Debido a su integracion estrecha con
 web y soporte por defecto de los navegadores modernos se ha vuelto mucho más común 
 para front-end que Java.
 
-JavaScript no sólo se limita a los navegadores web:
-* Node.js: Un proyecto que provee con un ambiente para el motor V8 de Google Chrome.
+Sin embargo, JavaScript no sólo se limita a los navegadores web: Node.js, un proyecto que proporciona un entorno de ejecución independiente para el motor V8 de Google Chrome, se está volviendo más y más popular.
 
 ¡La retroalimentación es bienvenida! Puedes encontrarme en: 
 [@adambrenecki](https://twitter.com/adambrenecki), o
 [adam@brenecki.id.au](mailto:adam@brenecki.id.au).
 
 ```js
-// Los comentarios son como en C. Los comentarios de una sola línea comienzan con //,
+// Los comentarios en JavaScript son los mismos como comentarios en C. 
+
+//Los comentarios de una sola línea comienzan con //,
 /* y los comentarios multilínea comienzan
    y terminan con */
 
 // Cada sentencia puede ser terminada con punto y coma ;
 hazAlgo();
 
-// ... aunque no es necesario, ya que el punto y coma se agrega automaticamente
+// ... aunque no es necesario, ya que el punto y coma se agrega automáticamente
 // cada que se detecta una nueva línea, a excepción de algunos casos.
 hazAlgo()
 
@@ -49,6 +50,7 @@ hazAlgo()
 
 // Toda la aritmética básica funciona como uno esperaría.
 1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
 8 - 1; // = 7
 10 * 2; // = 20
 35 / 5; // = 7
@@ -80,13 +82,13 @@ false;
 !true; // = false
 !false; // = true
 
-// Para comprobar una igualdad se usa ==
-1 == 1; // = true
-2 == 1; // = false
+// Para comprobar una igualdad se usa ===
+1 === 1; // = true
+2 === 1; // = false
 
-// Para comprobar una desigualdad se usa !=
-1 != 1; // = false
-2 != 1; // = true
+// Para comprobar una desigualdad se usa !==
+1 !== 1; // = false
+2 !== 1; // = true
 
 // Más comparaciones
 1 < 10; // = true
@@ -102,12 +104,14 @@ false;
 
 // Los tipos no importan con el operador ==...
 "5" == 5; // = true
+null == undefined; // = true
 
 // ...a menos que uses ===
 "5" === 5; // = false
+null === undefined; // false
 
 // Los Strings funcionan como arreglos de caracteres
-// Puedes accesar a cada caracter con la función charAt()
+// Puedes acceder a cada caracter con la función charAt()
 "Este es un String".charAt(0);  // = 'E'
 
 // ...o puedes usar la función substring() para acceder a pedazos más grandes
@@ -122,11 +126,11 @@ undefined; // usado para indicar que un valor no está presente actualmente
            // (aunque undefined es un valor en sí mismo)
 
 // false, null, undefined, NaN, 0 y "" es false; todo lo demás es true.
-// Note que 0 is false y "0" es true, a pesar de que 0 == "0".
+// Note que 0 es false y "0" es true, a pesar de que 0 == "0".
 // Aunque 0 === "0" sí es false.
 
 ///////////////////////////////////
-// 2. Variables, Arreglos y Objetos
+// 2. Variables, Arrays y Objetos
 
 // Las variables se declaran con la palabra var. JavaScript cuenta con tipado dinámico,
 // así que no se necesitan aplicar tipos. La asignación se logra con el operador =.
@@ -184,7 +188,7 @@ miObjeto.miLlave; // = "miValor"
 // agregar nuevas llaves.
 miObjeto.miTerceraLlave = true;
 
-// Si intentas accesar con una llave que aún no está asignada tendrás undefined.
+// Si intentas acceder con una llave que aún no está asignada tendrás undefined.
 miObjeto.miCuartaLlave; // = undefined
 
 ///////////////////////////////////
@@ -220,7 +224,6 @@ for (var i = 0; i < 5; i++){
 }
 
 // && es un "y" lógico, || es un "o" lógico
-var casa = {tamano:"grande",casa:"color"};
 if (casa.tamano == "grande" && casa.color == "azul"){
     casa.contiene = "oso";
 }
@@ -300,7 +303,7 @@ i; // = 5 - en un lenguaje que da ámbitos por bloque esto sería undefined, per
 //inmediatamente", que preveé variables temporales de fugarse al ámbito global
 (function(){
     var temporal = 5;
-    // Podemos accesar al ámbito global asignando al 'objeto global', el cual
+    // Podemos acceder al ámbito global asignando al 'objeto global', el cual
     // en un navegador siempre es 'window'. El objeto global puede tener
     // un nombre diferente en ambientes distintos, por ejemplo Node.js .
     window.permanente = 10;
@@ -320,7 +323,7 @@ function decirHolaCadaCincoSegundos(nombre){
         alert(texto);
     }
     setTimeout(interna, 5000);
-    // setTimeout es asíncrono, así que la funcion decirHolaCadaCincoSegundos 
+    // setTimeout es asíncrono, así que la función decirHolaCadaCincoSegundos 
     // terminará inmediatamente, y setTimeout llamará a interna() a los cinco segundos
     // Como interna está "cerrada dentro de" decirHolaCadaCindoSegundos, interna todavía tiene
     // acceso a la variable 'texto' cuando es llamada.
@@ -338,7 +341,7 @@ var miObjeto = {
 };
 miObjeto.miFuncion(); // = "¡Hola Mundo!"
 
-// Cuando las funciones de un objeto son llamadas, pueden accesar a las variables 
+// Cuando las funciones de un objeto son llamadas, pueden acceder a las variables 
 // del objeto con la palabra clave 'this'.
 miObjeto = {
     miString: "¡Hola Mundo!",
@@ -400,11 +403,11 @@ var MiConstructor = function(){
 miNuevoObjeto = new MiConstructor(); // = {miNumero: 5}
 miNuevoObjeto.miNumero; // = 5
 
-// Todos los objetos JavaScript tienen un 'prototipo'. Cuando vas a accesar a una
+// Todos los objetos JavaScript tienen un 'prototipo'. Cuando vas a acceder a una
 // propiedad en un objeto que no existe en el objeto el intérprete buscará en
 // el prototipo.
 
-// Algunas implementaciones de JavaScript te permiten accesar al prototipo de 
+// Algunas implementaciones de JavaScript te permiten acceder al prototipo de 
 // un objeto con la propiedad __proto__. Mientras que esto es útil para explicar
 // prototipos, no es parte del estándar; veremos formas estándar de usar prototipos
 // más adelante.
@@ -439,7 +442,7 @@ miPrototipo.sentidoDeLaVida = 43;
 miObjeto.sentidoDeLaVida; // = 43
 
 // Mencionabamos anteriormente que __proto__ no está estandarizado, y que no 
-// existe una forma estándar de accesar al prototipo de un objeto. De todas formas.
+// existe una forma estándar de acceder al prototipo de un objeto. De todas formas.
 // hay dos formas de crear un nuevo objeto con un prototipo dado.
 
 // El primer método es Object.create, el cual es una adición reciente a JavaScript,
@@ -475,10 +478,7 @@ typeof miNumero; // = 'number'
 typeof miNumeroObjeto; // = 'object'
 miNumero === miNumeroObjeyo; // = false
 if (0){
-    // Este código no se ejecutara porque 0 es false.
-}
-if (Number(0)){
-    // Este código sí se ejecutara, puesto que Number(0) es true.
+    // Este código no se ejecutará porque 0 es false.
 }
 
 // Aún así, los objetos que envuelven y los prototipos por defecto comparten