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).