Dovrei usare JSLint o JSHint JavaScript convalida? [chiuso]

https://stackoverflow.com/questions/6803305

25-10-2019
|

Domanda

Al momento sto convalidando la mia JavaScript contro JSLint e facendo progressi su, mi sta aiutando a scrivere meglio JavaScript -., In particolare, in collaborazione con la libreria jQuery

Ora ho incontrato JSHint , un fork di JSLint .
Quindi mi chiedo per le applicazioni web, che sono molto è stato guidato JavaScript, che è la più strumento di convalida applicabile meglio o al lavoro contro:

JSLint o JSHint?

Voglio decidere ora su un meccanismo di convalida e andare avanti, lo uso per la validazione lato client.

E Differenza tra jshint e JSLint? Si prega di spiegare in solo esempio javascript.

Link:

jshint - http://www.jshint.com/
JSLint - http://jslint.com/

Soluzione

[EDIT]
Questa risposta è stato modificato. Lascio la risposta originale al di sotto per il contesto (altrimenti i commenti non avrebbe senso).

Quando questa domanda è stato originariamente chiesto, JSLint era lo strumento principale per il rilascio di fibre JavaScript. JSHint era un nuovo fork di JSLint, ma non era ancora discostato molto da quello originale.

Da allora, JSLint è rimasto più o meno statico, mentre JSHint è cambiato moltissimo - ha buttato via molte delle regole più antagoniste del JSLint, ha aggiunto un intero carico di nuove regole, ed è generalmente diventato più flessibile. Inoltre, un altro strumento ESLint è ora disponibile, che è ancora più flessibile e ha più opzioni regola.

Nella mia risposta originale, ho detto che non si deve sforzarsi di attenersi a regole di JSLint; fino a quando si è capito perché stava gettando un avvertimento, si potrebbe fare un giudizio per te sull'opportunità di modificare il codice per risolvere l'avviso oppure no.

Con il set di regole ultra-rigida di JSLint dal 2011, questo era consiglio ragionevole - Ho visto pochissimi set di codici JavaScript che potrebbe passare un test JSLint. Tuttavia, con le regole più pragmatici disponibili in strumenti JSHint e ESLint di oggi, si tratta di una proposta molto più realistico per cercare di ottenere il codice passa attraverso di loro con zero avvisi.

Ci possono ancora essere occasionalmente casi in cui un linter sarà lamentarsi di qualcosa che hai fatto intenzionalmente - per esempio, si sa che si dovrebbe sempre usare ===, ma solo questa volta si ha una buona ragione per usare ==. Ma anche allora, con ESLint si ha la possibilità di specificare eslint-disable attorno alla linea in questione, in modo da poter ancora avere un test di passaggio pelucchi con zero avvisi, con il resto del codice obbedire alla regola. (Basta non fare questo genere di cose troppo spesso!)

[risposta iniziale SEGUE]

Con tutti i mezzi utilizzare JSLint. Ma non ottenere appeso sui risultati e sulla fissazione tutto ciò che mette in guardia. Essa vi aiuterà a migliorare il tuo codice, e vi aiuterà a trovare potenziali bug, ma non tutto ciò che si lamenta JSLint circa si rivela essere un problema reale, in modo da non sentire come si deve completare il processo con zero avvisi.

Praticamente qualsiasi codice Javascript con qualsiasi lunghezza significativa o la complessità produrrà avvertimenti in JSLint, non importa quanto ben scritto che è. Se non mi credete, provare a eseguire alcune biblioteche popolari come JQuery attraverso di essa.

Alcune avvertenze JSLint sono più importanti di altri: imparare quelli da guardare fuori per, e quelli che sono meno importanti. Ogni avviso dovrebbe essere presa in considerazione, ma non si sentono obbligati a fissare il codice per cancellare ogni dato avvertimento; è perfettamente bene a guardare il codice e si decide sei felice con esso; ci sono momenti in cui le cose che JSLint non piace sono in realtà la cosa giusta da fare.

Altri suggerimenti

tl; dr asporto :

Se siete alla ricerca di uno standard molto elevato per voi o per squadra, JSLint. Ma la sua non necessariamente della norma, solo uno standard, alcuni dei quali ci viene dogmaticamente da un dio di nome Doug Crockford JavaScript. Se si vuole essere un po 'più flessibile, o avere alcuni vecchi professionisti della tua squadra che non comprano nelle opinioni di JSLint, o stanno andando avanti e indietro tra JS ed altri linguaggi C-famiglia su base regolare, provare JSHint.

versione lunga :

Il ragionamento alla base della forcella spiega abbastanza bene il motivo per cui esiste JSHint:

http://badassjs.com/post/ 3364925033 / jshint-un-community-driven-fork-di-JSLint http://anton.kovalyov.net/2011/02/20/why-i-forked-jslint-to-jshint /

Quindi credo che l'idea è che si tratta di "community-driven", piuttosto che Crockford-driven. In praticità, JSHint è generalmente un po 'più favorevole (o almeno configurabile o agnostico) su pochi stilistiche e minori sintattici "opinioni" che JSLint è un pignolo su.

Per fare un esempio, se si pensa sia la A e B sotto vanno bene, o se si vuole scrivere il codice con uno o più degli aspetti di A che non sono disponibili in B, JSHint è per voi. Se si pensa che B è l'unica opzione corretta ... JSLint. Sono sicuro che ci sono altre differenze, ma questo mette in evidenza alcune.

A) Passa JSHint fuori dalla scatola - non riesce JSLint

(function() {
  "use strict";
  var x=0, y=2;
  function add(val1, val2){
    return val1 + val2;
  }
  var z;
  for (var i=0; i<2; i++){
    z = add(y, x+i);
  }
})();

B) Passi Sia JSHint e JSLint

(function () {
    "use strict";
    var x = 0, y = 2, i, z;
    function add(val1, val2) {
       return val1 + val2;
    }
    for (i = 0; i < 2; i += 1) {
        z = add(y, x + i);
    }
}());

Personalmente trovo codice JSLint molto piacevole da guardare, e le caratteristiche dei soli dischi di essa che sono in disaccordo con la sua sono odio più dichiarazioni var in una funzione e di for-loop dichiarazioni var i = 0 , e alcuni dei rinforzi spazi bianchi per dichiarazioni di funzione .

Alcune delle cose spazi bianchi che impone JSLint, trovo a non essere necessariamente un male, ma fuori sincrono con alcune convenzioni piuttosto standard di spazio bianco per le altre lingue della famiglia (C, Java, Python, ecc ...), che sono spesso seguiti da convenzioni in Javascript pure. Dal momento che sto scrivendo in varie di queste lingue per tutto il giorno, e lavorare con i membri del team che non lo fanno come gli spazi bianchi in stile Lint nel nostro codice, trovo JSHint di essere un buon equilibrio. Raggiunge roba che è un bug legittimo o sotto forma davvero male, ma non abbaia a me come JSLint fa (a volte, in modi non posso disabilitare) per le opinioni stilistiche o nitpicks sintattiche che non si preoccupano per.

Un sacco di buone biblioteche non sono Lint'able, che per me dimostra che c'è qualche verità l'idea che alcuni dei JSLint è semplicemente solo di spingere 1 versione di "buon codice" (che è, in effetti, buon codice ). Ma poi di nuovo, le stesse librerie (o altri buoni) probabilmente non sono Hint'able o, così, Touché.

C'è un altro maturare e attivamente sviluppato "giocatore" sul rilascio di fibre javascript anteriore - ESLint :

ESLint è uno strumento per rilevare e sui modelli si trovano in codice ECMAScript / JavaScript. In molti modi, è simile al JSLint e JSHint con alcune eccezioni:

ESLint utilizza Esprima per l'analisi JavaScript.

ESLint utilizza un AST per valutare i modelli in codice.

ESLint è completamente plug, ogni singola regola è un plugin ed è possibile aggiungere più in fase di esecuzione.

Ciò che conta veramente è che si tratta di estendibile tramite plugin / regole personalizzati. Ci sono già più plugin scritti per scopi diversi. Tra altri , ci sono:

eslint-plugin-angolare (fa rispettare alcune delle linee guida da John Papa Guida angolare Style )
eslint-plugin-gelsomino
eslint-plugin-dorsale

E, naturalmente, è possibile utilizzare il tool di creazione di scelta ai ESLint run:

Ho avuto la stessa domanda un paio di settimane fa e stava valutando sia JSLint e JSHint.

A differenza delle risposte in questa domanda, la mia conclusione non è stato:

Con tutti i mezzi utilizzano JSLint.

Se siete alla ricerca di uno standard molto elevato per te o di squadra, JSLint.

Come è possibile configurare quasi le stesse regole in JSHint come in JSLint. Quindi direi che non c'è molta differenza nelle regole si potrebbe ottenere.

Così i motivi per scegliere uno sopra l'altro sono più politico che tecnico.

Abbiamo finalmente deciso di andare con JSHint a causa dei seguenti motivi:

sembra essere più configurabile che JSLint.
sembra decisamente più community-driven piuttosto che uno-man-show (non importa quanto freddo L'uomo è).
JSHint abbinato il nostro stile OOTB codice migliore che JSLint.

mi piacerebbe fare un terzo suggerimento, Google Closure Compiler (e anche il Chiusura Linter ). Si può provare on-line qui .

La chiusura Compiler è uno strumento per fare scaricare Javascript e correre più veloce. Si tratta di un vero e proprio compilatore per JavaScript. Invece di compilazione da una lingua di partenza in codice macchina, si compila da JavaScript a una migliore JavaScript. Si analizza il tuo JavaScript, lo analizza, rimuove codice morto e riscritture e minimizza quello che è rimasto. Inoltre i controlli di sintassi, riferimenti variabili e tipi, e mette in guardia sui problemi comuni JavaScript.

Foreword: Well, that escalated quickly. But decided to pull it through. May this answer be helpful to you and other readers.

Code Hinting

While JSLint and JSHint are good tools to use, over the years I've come to appreciate what my friend @ugly_syntax calls:

smaller design space.

This is a general principle, much like a "zen monk", limiting the choices one has to make, one can be more productive and creative.

Therefore my current favourite zero-config JS code style:

StandardJS.

UPDATE:

Flow has improved a lot. With it, you can add types to your JS with will help you prevent a lot of bugs. But it can also stay out of your way, for instance when interfacing untyped JS. Give it a try!

Quickstart / TL;DR

Add standard as a dependency to you project

npm install --save standard

Then in package.json, add the following test script:

"scripts": {
    "test": "node_modules/.bin/standard && echo put further tests here"
},

For snazzier output while developing, npm install --global snazzy and run it instead of npm test.

Note: Type checking versus Heuristics

My friend when mentioning design space referred to Elm and I encourage you to give that language a try.

Why? JS is in fact inspired by LISP, which is a special class of languages, which happens to be untyped. Language such as Elm or Purescript are typed functional programming languages.

Type restrict your freedom in order for the compiler to be able to check and guide you when you end up violation the language or your own program's rules; regardless of the size (LOC) of your program.

We recently had a junior colleague implement a reactive interface twice: once in Elm, once in React; have a look to get some idea of what I'm talking about.

Compare Main.elm (typed) ⇔ index.js (untyped, no tests)

(ps. note that the React code is not idiomatic and could be improved)

One final remark,

the reality is that JS is untyped. Who am I to suggest typed programming to you?

See, with JS we are in a different domain: freed from types, we can easily express things that are hard or impossible to give a proper type (which can certainly be an advantage).

But without types there is little to keep our programs in check, so we are forced to introduce tests and (to a lesser extend) code styles.

I recommend you look at LISP (e.g. ClojureScript) for inspiration and invest in testing your codes. Read The way of the substack to get an idea.

Peace.

Well, Instead of doing manual lint settings we can include all the lint settings at the top of our JS file itself e.g.

Declare all the global var in that file like:

/*global require,dojo,dojoConfig,alert */

Declare all the lint settings like:

/*jslint browser:true,sloppy:true,nomen:true,unparam:true,plusplus:true,indent:4 */

Hope this will help you :)

There is also an another actively developed alternative - JSCS — JavaScript Code Style:

JSCS is a code style linter for programmatically enforcing your style guide. You can configure JSCS for your project in detail using over 150 validation rules, including presets from popular style guides like jQuery, Airbnb, Google, and more.

It comes with multiple presets that you can choose from by simply specifying the preset in the .jscsrc configuration file and customize it - override, enable or disable any rules:

{
    "preset": "jquery",
    "requireCurlyBraces": null
}

There are also plugins and extensions built for popular editors.

Also see:

Perfect code, zero effort

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow