Web BizarroWeb Bizarro

Suscríbete a nuestro Newsletter

X

Únete a nuestra lista de correos para recibir semanalmente actualizaciones de nuestro contenido.

Cinco cosas que no debes hacer en JavaScript

Cinco cosas que no debes hacer en JavaScript 06.DEC.13

Alvaro José Rios Ch
Fundador WebBizarro

JavaScript esta cumpliendo 18 años y es un lenguaje que cada día aporta más soluciones al mundo del desarrollo web, y por esto queremos que los desarrolladores sean cada día mejores, por esta razón queremos mostrarles algunas cosas que probablemente haces y no deberías al programar en JavaScript.

1. Usar Variables Globales.

Cuando comenzamos en el desarrollo de JavaScript usar variables globales parece algo genial podemos acceder a las variables desde cualquier archivo JavaScript importado en el HTML, pero la verdad esto no es bueno, lo que puede pasar es que por error se sobrescriba una variable que no debemos modificar y el código termine funcionando mal, ¿cómo podemos solucionar esto? Bueno hay dos maneras, la primera declarar una función anónima como se muestra a continuación:

(function(){
    var precio= 100, cantidad = 10;
}());

Esto esta bien si quieres hacer algo puntual pero si necesitas hacer algo más grande es mejor usar un patrón modular en tu código JavaScript.

var item_factura = (function(){
    var precio= 100, cantidad = 10;
    return {
        incrementar_cantidad: function(incremento){}
    };
}());

Otra cosa que debes tomar en cuenta sobre las variables globales es lo siguiente:

(function(){
    cantidad = 10;
}());

cantidad = cantidad * 100;

En este caso la variable cantidad se incrementa porque cuando fue declarada no se coloco la palabra var así que cuidado con esto.

 

2. No usar punto y coma

Todas las sentencias en JavaScript deben terminar en punto y coma (;), el problema es que si no lo colocamos el compilador se encarga de colocarlo por nosotros. Bien se que deben estar pensando y cuales el problema entonces, hay muchas discusiones en si debería hacerse o no pero bueno les dejo este caso en el que podria ser un problema que el compilador decida donde terminar la sentencia.

function(){
    return
    {
        nombre : "Webbizarro",
        tipo: "blog"
    };
}

Bien entonces es una simple función que retorna un objeto, pero el problema aquí es que el compilador puede interpretar que debería ir un punto y coma después del return lo que haría que la funcion retorne un valor vacío, la solución a esto es simplemente colocar el código de la siguiente manera.

 

function(){
    return {
        nombre : "Webbizarro",
        tipo: "blog"
    };
}

Yo votaría por usar punto y coma en el código que se escriba en JavaScript es algo que no quita para nada tiempo y se hace un habito que después ni notaremos.

 

3. Usar ==

Esto puede ser discutible no digamos que no debemos hacerlo pero debemos hacerlo con cuidado, el principal problema con esto es el siguiente

if (1 == 1){
    console.log("Es Verdad");
}

if (1 == "1"){
    console.log("Es Verdad");
}

 

El resultado en los dos casos es el mismo, así es los dos son verdaderos y la razón es que el operador == no compara los tipos de datos por lo que es mejor usar===, y lo mismo aplica para !=y!==, también deberías tener en cuenta esto.

'' == '0' // false
'0' == '' // true
false == '0' // true
' \t\r\n ' == 0 // true

 

4. Definir objetos para tipos primitivos

El problema con esto es que cuando defines un objeto es que el typeOf de ese objeto que defines es object lo que puede causarte problemas cuando trates de hacer comparaciones o alguna otra operación, así que lo más recomendado es no instanciar objetos para tipos de datos primitivos.

En ves de hacer esto:

new Number(10);
new String("hello");
new Boolean(true);
new Object();
new Array("one", "two", "three");

Mejor hacemos esto

10;
"hello";
true;
{};
["one", "two", "three"];

 

5. Usar with o eval

Por suerte actualmente el material para aprender JavaScript descarta el uso de estas dos funciones pero si usas algún material viejo o hace mucho que los usas te digo que no es recomendable.

Primero veamos with, los principales problemas con esto son, primero que la ejecución del JavaScript se hace más lenta y segundo que no deja claro que es lo que estas haciendo.

Veamos este ejemplo

var person = { name: "Joe", age : 10 };

with (person) {
    console.log(name); // Joe
    console.log(age); // 10
}

Todo bien pero veamos que pasa si agregamos algunas variables

var person = { name: "Joe", age : 10 },
name = "Billy";

with (person) {
    console.log(name); // Billy
    job = "Designer";
}

console.log(person.job); // undefined;
console.log(job); // Designer

Ahora veamos eval, con esta función puedes ejecutar código JavaScript de un string lo que puede parecer muy bueno pero no es recomendable por lo siguiente, primero no hay razón para ejecutar código JavaScript desde un string cuando puedes simplemente escribir el código y segunda la ejecución con eval es mucho más lenta.

Finalmente quiero decirles que todo esto que les digo son solo recomendaciones y las reglas están para romperse, hay casos en que debemos hacer cosas que no son muy elegantes para conseguir una solución mejor para nuestros problemas,