javascript - jshintrc - jslint vs jshint

Error JSLint: Inesperado ''esto''

Question

Tengo problemas para entender por qué JSLint está sorprendido por mi uso de this en el siguiente código:

function testConstr (x) {
''use strict'';
this.joker = "Whyyy sooo seriousss?";
this.x = x;
}

Para ambas asignaciones de propiedades, JSLint dice: Inesperado ''esto''. ¿Cómo corrijo mi código?

Answer 1

En un modo estricto, this referencia se establece en undefined .

Por lo tanto, ambas declaraciones harán que se lean las propiedades del objeto undefined , lo que dará lugar a una excepción.

¿Cómo corrijo mi código?

Elimina ambas líneas.

UPD: lo que declaro más arriba es cómo JSLint trata su código, no cómo lo hago.

Answer 2

Su código podría ser perfectamente correcto (también podría ser problemático, dependiendo de cómo llame a testConstr ).

Mi sugerencia es: dile a JSLint que se calle

O no use JSLint en absoluto.

Answer 3

''use strict'';
var SudoConstructor = (function () {
/* We need bind, < IE9 needs a (tiny) polyfill */
function protoEsqDeclare(sudoThis) {
return sudoThis;
}
function protoEsqSet(sudoThis, newValA, newValB) {
sudoThis.valA = newValA;
sudoThis.valB = newValB;
}
function instanceCreator(valA, valB) {
var sudoThis = {
valA: valA,
valB: valB
};
return {
declare: protoEsqDeclare.bind(null, sudoThis),
set: protoEsqSet.bind(null, sudoThis)
};
}
return instanceCreator;
}());

Answer 4

JSLint dice: Inesperado ''esto''. ¿Cómo corrijo mi código?

No hay necesidad de corregir tu código.

En la página de ayuda de JSLint , en la sección de la directiva /*jslint*/ , se agregó una opción " Tolerar this " a la tabla de opciones disponibles:

+---------------+------+---------------------------------+
| Tolerate this | this | true if this should be allowed. |
+---------------+------+---------------------------------+

Por lo tanto, para suprimir las quejas sobre el uso de this , coloque la siguiente directiva en su archivo fuente antes de la primera declaración:

/*jslint
this
*/

(Tenga en cuenta que otras opciones /*jslint*/ pueden seguir this al insertar una coma entre las opciones. Consulte la página de ayuda de JSLint.)

También vea la respuesta de @Oriol para habilitar la opción "Tolerar this " en la interfaz de usuario para JSLint.

Answer 5

Entonces, en otras palabras, ¿JSLint no espera automáticamente que use un patrón de constructor?

Ya sabes, creo que tienes razón. Su pregunta me molestó, y me inscribí en el grupo de discusión JSLint de Crockford y le pregunté . Él respondió, pero ignoró la solución que voy a presentar, a continuación, que creo que significa que está bien, de la misma manera que JSLint no se queja si algo pasa.

_{(Todavía estoy esperando un Good Parts actualizado, sin embargo).}

Dejando eso de lado, esto es lo que sugiero que hagas para OO JavaScript que pasa Beta JSLint (a partir de hoy, de todos modos).

Voy a reescribir un ejemplo de la página de MDN, " Introducción a la Programación Orientada a Objetos ", que a su vez lo usa generosamente.

Con this

Aquí está el ejemplo original, no etiquetado de MDN de la sección vinculada, arriba:

var Person = function (firstName) {
this.firstName = firstName;
};
Person.prototype.sayHello = function() {
console.log("Hello, I''m " + this.firstName);
};
var person1 = new Person("Alice");
var person2 = new Person("Bob");
// call the Person sayHello method.
person1.sayHello(); // logs "Hello, I''m Alice"
person2.sayHello(); // logs "Hello, I''m Bob"

Eso sigue las convenciones que conocemos y amamos.

Sin this

Es bastante fácil descubrir cómo crear "constructores" que no sigan ese patrón, pero perdemos el uso del prototype , si no nos falta algo, y tenemos que incluir todos los métodos del objeto en nuestro constructor que queramos todos nuestros Peep s para compartir

/*jslint white:true, devel:true */
var Peep = function(firstName) {
"use strict";
var peep = {};
peep.firstName = firstName;
peep.innerSayHello = function() {
console.log("Hello, I''m " + peep.firstName + ".");
};
return peep;
};
var peep1 = new Peep("Bob");
var peep2 = new Peep("Doug");
peep1.innerSayHello();
peep2.innerSayHello();

Entonces hay una alternativa imprimible. Eso sí, aparte del return peep; y la definición interna de métodos, haga que JavaScript actúe como muchos lenguajes originales de OO que pueda encontrar. No está mal , al menos.

No tener acceso al prototype no es horrible; es realmente una mala noticia cambiar el prototype algún lugar que no esté justo al lado del constructor, ya que su código iría al spaghetti. " Algunas Person sayGoodbye() y otras no, dependiendo de si modificamos el prototipo en el momento de su construcción " . Eso es horrible. Entonces esta convención alternativa tiene sus ventajas.

Todavía puede, por supuesto, agregar funciones a una sola instanciación de Peep más tarde, pero no estoy seguro de cómo accedería a FirstName sin usar this , por lo que quizás quiera que detengamos el corte de objetos después de la construcción.

person1.sayGoodbye = function (other) {
console.log("Goodbye, " + other + ".");
};

(Quiero decir, también podríamos ponerle parche a Peep para cambiarlo a mitad de proceso, pero esa es una programación horrible, estúpida. Usualmente ) .

Herencia (sin this )

Y la herencia es bastante fácil, creo.

var PeepWithGoodbye = function (firstName) {
"use strict";
var peepWithGoodbye = new Peep(firstName);
peepWithGoodbye.innerSayGoodbye = function (otherPeep) {
if (undefined === otherPeep) {
otherPeep = { firstName: "you" };
}
console.log("This is " + firstName
+ " saying goodbye to " + otherPeep.firstName + ".");
};
return peepWithGoodbye;
};
var pwg1 = new PeepWithGoodbye("Fred");
pwg1.innerSayHello(); // Hello, I''m Fred.
pwg1.innerSayGoodbye(peep1); // This is Fred saying goodbye to Bob.
pwg1.innerSayGoodbye(); // This is Fred saying goodbye to you.

EDITAR: Vea también esta respuesta donde el consultante más tarde encontró los medios sugeridos por Crockford para crear OO javascript. Estoy tratando de convencer a ese tipo para que elimine esa Q & A y mueva la A aquí. Si no lo hace, probablemente agregue sus cosas y la wiki de la comunidad aquí.

EDITAR: Mire esto de MDN para saber por qué funciona:

(Normalmente, los constructores no devuelven un valor, pero pueden optar por hacerlo si desean anular el proceso normal de creación de objetos).