JSLint


Introducción

Cuando C era un lenguaje de programación joven, se producian errores comunes de programación que no eran detectados por los compiladores primitivos de esa epoca, entonces se utilizo un programa accesorio llamado lint que fue desarrollado para analizar los archivos fuente, en busca de problemas.

Como C maduró, la definición del lenguaje se fortaleció para eliminar algunas inseguridades, y los compiladores mejoraron su emisión de advertencias. Lint ya no era necesario.

"Para su edad" JavaScript es un lenguaje joven. Fue pensado originalmente para hacer pequeñas tareas en páginas web, tareas para las que Java era demasiado pesado y torpe.  Pero JavaScript es un lenguaje muy capaz, y ahora se utiliza en proyectos de mayor envergadura. Muchas de las características que pretendian que el lenguaje fuera fácil de usar son problematicas para los proyectos de mayor envergadura. Se necesita de lint  en JavaScript: JSLint, un comprobador de sintaxis JavaScript y verificador. 

JSLint es una herramienta de análisis de código estático utilizado en el desarrollo de software para comprobar si el código fuente JavaScript cumple con las normas de codificación.  Se proporciona principalmente como una herramienta en-línea, pero también hay adaptaciones de línea de comandos. Fue desarrollado por Douglas Crockford.

JSLint es una herramienta de la calidad del código JavaScript. Toma un texto fuente y lo examina. Si encuentra algún problema, devuelve un mensaje en el que se describe el problema y una ubicación aproximada dentro de la fuente. El problema no es necesariamente un error de sintaxis, aunque a menudo lo es. JSLint analiza algunas convenciones de estilo así como los problemas estructurales. No demuestra que el programa sea correcto. Simplemente ofrece otro par de ojos para ayudar a descubrir problemas de codificación más no de lógica en la programación.

JSLint define un subconjunto profesional de JavaScript, un lenguaje más estricto que el definido por la tercera edición de la especificación del lenguaje ECMAScript. El subconjunto está estrechamente relacionado con las recomendaciones de estilo de Capítulo 9.
JavaScript es un lenguaje descuidado, pero por dentro es elegante, un lenguaje mejor. JSLint le ayuda a programar mejor en este lenguaje y para evitar la mayor parte de la decantación. 
JSLint se puede encontrar en http://www.JSLint.com/.

Variables y funciones no definidas

El mayor problema de JavaScript es su dependencia de las variables globales, particularmente implica variables globales. Si una variable no se declara explícitamente (por lo general con la sentencia var), entonces JavaScript asume que la variable fue global. Esto puede  nmascarar los nombres mal escritas y otros problemas.

JSLint espera que se declaran todas las variables y funciones antes de ser utilizadas o invocadas. Esto le permite detectar las variables globales implicadas. También es una buena práctica, porque hace a los programas más fáciles de leer.

A veces un archivo depende de variables globales y funciones que se definen en otro lugar. Puede identificar estos en JSLint incluyendo un comentario en su archivo que lista las funciones globales y objetos del que el programa depende, pero que no está definido en su programa o archivo de comandos.

/*global getElementByAttribute, breakCycles, hanoi */

Una declaración global comienza con /* global.  Observe que no hay ningún espacio antes de la g. Puedes tener tantos comentarios /*global como quieras. Deben comparecer ante el uso de las variables que especifican. 

Algunas funciones globales pueden ser predefinidos por usted (consulte la sección "Opciones" ). Seleccione la opción "Asumir un navegador" ( navegador ) para predefinir las propiedades globales estándar que se suministran por los navegadores web, tales como window y document y alert. Seleccione la opción "Asumir Rhino" (rhino ) para predefinir las propiedades globales de Rhino. Seleccione la opción "Asumir un Yahoo Widget" ( widget ) para predefinir las propiedades globales proporcionadas por el entorno de Yahoo! Widgets.

Miembros

Ya que JavaScript es un lenguaje dinámico de objetos débilmente tipado, no es posible determinar en tiempo de compilación si los nombres de las propiedades se ha escrito correctamente. JSLint ofrece cierta ayuda con esto.

En la parte inferior de su informe, JSLint muestra un comentario /*membrers*/. Contiene todos los nombres y los literales de cadena que se utilizaron con la notación de puntos, la notación de subíndice, y objetos literales para nombrar a los miembros de los objetos. Usted puede mirar la lista de errores ortográficos. Los nombres de los miembros que se han utilizado sólo una vez aparecen en cursiva. Esto es para detectar los errores ortográficos más fácilmente.

Puede copiar el comentario /*membrers*/ en el archivo script. JSLint revisará la ortografía de todos los nombres de propiedades en la lista. De esa manera, usted puede tener JSLint buscar errores ortográficos para usted:

/*members doTell, iDoDeclare, mercySakes,
myGoodness, ohGoOn, wellShutMyMouth */

Opciones

La implementación JSLint acepta una opción objeto que le permite determinar el subconjunto de JavaScript que es aceptable para usted. También es posible configurar las opciones dentro de la fuente de un script.
Una especificación de opción puede tener este aspecto:

/*jslint nomen: true, evil: false */

Una especificación de opciones se inicia con /*jslint. Ten en cuenta que no hay ningún espacio antes de la j.La especificación contiene una secuencia de pares nombre/valor, donde los nombres son opciones de JSLint y los valores son true o false. Una especificación de las opciones tiene prioridad sobre el objeto de opción. Todas las opciones por defecto son false.  En la tabla C-1 se enumeran las opciones disponibles con el uso JSLint.

Punto y coma

JavaScript utiliza una sintaxis similar a la de C, que requiere el uso de punto y coma para delimitar las declaraciones. JavaScript intenta hacer opcional el uso del punto y coma con un mecanismo de inserción del punto y coma. Esto es peligroso.

Al igual que en C, JavaScript tiene  operadores como son  el  ++ y -- y ( , que pueden ser prefijos o sufijos. La desambiguación se realiza por el punto y coma.

En JavaScript, un avance de línea puede ser un espacio en blanco, o puede actuar como un punto y coma. Esto reemplaza una ambigüedad con otro. 

JSLint espera que cada declaración este seguida de ; excepto para el for, function, if, switch, try, y while. JSLint no espera ver puntos y comas o declaraciones vacías innecesarios.

Saltos de línea

Como una defensa contra el enmascaramiento de errores por el punto y coma mecanismo de inserción, JSLint espera declaraciones largas que se dividan sólo después de uno de estos signos de puntuación u operadores:

, . ; : { } ( [ = < > ? ! + - * / % ~ ^ | &
== != <= >= += -= *= /= %= ^= |= &= << >> || &&
=== !== <<= >>= >>> >>>=

JSLint no espera ver una declaración larga después de un identificador, una cadena, un número, un closer, o un operador de sufijo:

) ] ++ --

JSLint te permite activar la opción "Tolerar los saltos de línea descuidados".

La inserción de un punto y coma puede enmascarar errores al copiar/pegar. Si siempre romper las líneas después de operadores, entonces JSLint puede hacer un mejor trabajo de búsqueda de errores.

Coma

El operador coma puede conducir a expresiones excesivamente complicadas. También puede enmascarar algunos errores de programación. 

JSLint espera ver el uso de la coma como separador, pero no como un operador (excepto en la inicialización y incremento de las piezas de la exposición). No esperes ver elementos recortados en los literales de una matriz. Las comas adicionales no se deben utilizar. No debe aparecer una coma después del último elemento de una matriz literal u objeto literal porque puede ser malinterpretado por algunos navegadores.

Bloques necesarios

JSLint espera que las declaraciones if y for se realicen en bloques es decir, con las declaraciones encerradas entre llaves ( {} ). JavaScript permite que un if se escriba así:

if (condición)
    declaración;

Esa forma contribuye a que se cometan errores en proyectos en los que muchos programadores están trabajando sobre el mismo código. Es por esto que JSLint espera que se utilice la forma de bloque:

if (condition) {
    statements;
}

Bloques prohibidos

En muchos idiomas, un bloque introduce un alcance. Las variables introducidas en un bloque no son visibles fuera del bloque.
En JavaScript los bloques no dan un alcance. Sólo hay alcance en la función. Una variable introducida en una función es visible en todas partes de la función. Los bloques de JavaScript confunden a los programadores experimentados e inducen a errores porque la sintaxis familiar hace una falsa promesa.
JSLint espera bloques en una función, if, switch, while, for, do, y declaraciones try y en ninguna otra parte. Se hace una excepción de utilizar bloques en el caso de una declaración if en un else o un for in.

Declaraciones de expresión

Se espera que una declaración de expresión sea una asignación, una llamada a  una función/método, o delete. Todas las demás declaraciónes de expresiones son consideradas errores.

Declaración for in

La declaración for in permite recorrer por medio de un bucle los nombres de todas las propiedades de un objeto. Desafortunadamente, también pasa a través de todos los miembros que fueron heredados a través de la cadena de prototipo. Esto tiene un efecto secundario malo de servir a funciones de método cuando el interés está en los miembros de datos. El cuerpo de cada sentencia for in debe estar envuelto en una sentencia if que hace el filtrado. if puede seleccionar un determinado tipo o rango de valores, puede excluir funciones, o puede excluir propiedades del prototipo. Por ejemplo:

for (name in object) {
    if (object.hasOwnProperty(name)) {
        ....
    }
}

Declaración switch

Un error común en una declaración switch es olvidarse de colocar una sentencia break después de cada caso lo que resulta en caidas no intencionales. JSLint espera la declaración antes del siguiente caso o por defecto uno de estos: break, return, o throw.

Declaración var

JavaScript permite que las definiciones var ocurran en cualquier lugar dentro de una función. JSLint es más estricta.

JSLint espera que:

  • Un var será declarado sólo una vez, y que será declarado antes de ser usado. 
  • Una función será declarada antes de ser usado. 
  • Los parámetros no serán declarados como vars.

JSLint no espera: 

  • La matriz de argumentos sea declarada como un var. 
  • Que una variable sea declarada en un bloque. Esto se debe a que los bloques de JavaScript no tienen ámbito de bloque. Esto puede traer consecuencias inesperadas, Así que define todas las variables en la parte superior del cuerpo de la función.

Declaración with

La declaración with tenía la finalidad de dar un atajo que permitiera acceder a los miembros de objetos anidados. Desafortunadamente, se comporta muy mal al establecer nuevos miembros. Nunca utilices el with. Utilizar un var en su lugar.
JSLint no esperan a ver un with.

=

JSLint no esperar ver una declaración de asignación en la parte condicional de un if o un while. Esto se debe a que es más probable que:

if (a = b) {
   ...
}
estaba destinado a ser: 
if (a == b) { ... } 

Si realmente piensa una asignación, envuélvalo en otro conjunto de paréntesis:

if ((a = b)) {
    ...
}

== y != 

Los operadores == y ! = hacen conversión de tipo antes de comparar. Esto es malo porque ' \f\r \n\t ' == 0 hace que sea true. Esto puede enmascarar errores de tipo.

Cuando se compara con cualquiera de los siguientes valores, utiliza siempre los operadores === o !==, que no hacen conversión de tipos:

0 '' undefined null false true

Si quieres el tipo de conversión, entonces utiliza la forma corta. En lugar de:

(foo != 0)

simplemente decir:

(foo)

Y en lugar de:

(foo == 0)

decir:

(!foo)

Siempre es preferible utilizar los operadores === y !== . Hay una opción de "Disallow == y != " ( eqeqeq ), que requiere el uso de === y !== en todos los casos.

Etiquetas

JavaScript permite que cualquier declaración tenga una etiqueta, y las etiquetas tienen un espacio de nombres separado. 
JSLint es más estricto.

JSLint espera etiquetas sólo en las declaraciones que interactúan con un break: switch, while, do, y forJSLint espera que las etiquetas sean distintas a las variables y parámetros.

Código inaccesible

JSLint espera que una declaración return, break, continue, o throw sea seguida por un } o case o default.

Confuso Ventajas y Desventajas

JSLint espera que + no sea seguido de un + o ++, y que - no sea seguido de un - ó --. Un espacio fuera de lugar puede convertir + + en ++, un error que es dificil de ver. Utiliza paréntesis para evitar confusiones.

++ y --

Los operadores de ++ (incremento) y -- (decremento) han sido conocidos por contribuir al mal código alentando astucia excesiva. Ellos sólo son superadas por la arquitectura defectuosa en permitir los virus y otras amenazas de seguridad. La opción plusplus JSLint prohíbe el uso de estos operadores.

 

Añadir nuevo comentario

CAPTCHA
Esta pregunta es para comprobar si usted es un visitante humano y prevenir envíos de spam automatizado.
4 + 15 =
Resuelva este simple problema matemático y escriba la solución; por ejemplo: Para 1+3, escriba 4.