docs/RULES-fr.md
Ceci est un sommaire des règles du standard JavaScript.
La meilleure façon d'apprendre plus sur standard c'est de l'installer et de l'essayer dans votre code.
Utilisez 2 espaces pour l'indentation.
eslint: indent
function hello (name) {
console.log('hi', name)
}
Utilisez les apostrophes (') pour le texte à part pour éviter un caractère d'échappement.
eslint: quotes
console.log('hello there')
$("<div class='box'>")
Pas de variables non-utilisées.
eslint: no-unused-vars
function myFunction () {
var result = something() // ✗ avoid
}
Ajoutez un espace après les mots clés.
eslint: keyword-spacing
if (condition) { ... } // ✓ ok
if(condition) { ... } // ✗ avoid
Ajoutez un espace avant les parenthèses de déclaration de fonction.
eslint: space-before-function-paren
function name (arg) { ... } // ✓ ok
function name(arg) { ... } // ✗ avoid
run(function () { ... }) // ✓ ok
run(function() { ... }) // ✗ avoid
Utilisez toujours === au lieu de ==.
Exception: obj == null est autorisé pour vérifier null || undefined.
eslint: eqeqeq
if (name === 'John') // ✓ ok
if (name == 'John') // ✗ avoid
if (name !== 'John') // ✓ ok
if (name != 'John') // ✗ avoid
Les opérateurs infixes doivent être espacés.
eslint: space-infix-ops
// ✓ ok
var x = 2
var message = 'hello, ' + name + '!'
// ✗ avoid
var x=2
var message = 'hello, '+name+'!'
Les virgules doivent être suivies d'un espace.
eslint: comma-spacing
// ✓ ok
var list = [1, 2, 3, 4]
function greet (name, options) { ... }
// ✗ avoid
var list = [1,2,3,4]
function greet (name,options) { ... }
Gardez les 'else' sur la même ligne que leurs accolades.
eslint: brace-style
// ✓ ok
if (condition) {
// ...
} else {
// ...
}
// ✗ avoid
if (condition) {
// ...
}
else {
// ...
}
Pour les conditions 'if', utilisez des accolades.
eslint: curly
// ✓ ok
if (options.quiet !== true) console.log('done')
// ✓ ok
if (options.quiet !== true) {
console.log('done')
}
// ✗ avoid
if (options.quiet !== true)
console.log('done')
Gérez toujours le paramètre de fonction err.
eslint: handle-callback-err
// ✓ ok
run(function (err) {
if (err) throw err
window.alert('done')
})
// ✗ avoid
run(function (err) {
window.alert('done')
})
Déclarez les globales de navigateur avec le commentaire /* global */.
Les exceptions sont: window, document et navigator.
Prévenez l'utilisation accidentelle de globales comme open, length, event, et name.
/* global alert, prompt */
alert('hi')
prompt('ok?')
Référencer explicitement la fonction ou propriété sur window est aussi ok, bien que ce code ne marchera pas dans un Worker qui utilise self au lieu de window.
eslint: no-undef
window.alert('hi') // ✓ ok
Plusieurs lignes vides ne sont pas autorisées.
eslint: no-multiple-empty-lines
// ✓ ok
var value = 'hello world'
console.log(value)
// ✗ avoid
var value = 'hello world'
console.log(value)
Pour l'opérateur ternaire sur plusieurs lignes, placez ? et : sur leurs propres lignes.
eslint: operator-linebreak
// ✓ ok
var location = env.development ? 'localhost' : 'www.api.com'
// ✓ ok
var location = env.development
? 'localhost'
: 'www.api.com'
// ✗ avoid
var location = env.development ?
'localhost' :
'www.api.com'
Pour les déclarations var, écrivez chaque déclaration avec leur propre affectation.
eslint: one-var
// ✓ ok
var silent = true
var verbose = true
// ✗ avoid
var silent = true, verbose = true
// ✗ avoid
var silent = true,
verbose = true
Entourez les déclarations conditionelles avec des parenthèses supplémentaires. Cela rend plus clair que l'expression est intentionellement une affectation (=) au lieu d'une typo pour égalité (===).
eslint: no-cond-assign
// ✓ ok
while ((m = text.match(expr))) {
// ...
}
// ✗ avoid
while (m = text.match(expr)) {
// ...
}
Ajoutez des espaces dans les blocs écris sur une ligne.
eslint: block-spacing
function foo () {return true} // ✗ avoid
function foo () { return true } // ✓ ok
Utilisez la syntaxe CamelCase quand vous nommez les variables et fonctions.
eslint: camelcase
function my_function () { } // ✗ avoid
function myFunction () { } // ✓ ok
var my_var = 'hello' // ✗ avoid
var myVar = 'hello' // ✓ ok
Les virgules en fin de ligne ne sont pas autorisées.
eslint: comma-dangle
var obj = {
message: 'hello', // ✗ avoid
}
Les virgules doivent être placées à la fin de la ligne courante.
eslint: comma-style
var obj = {
foo: 'foo'
,bar: 'bar' // ✗ avoid
}
var obj = {
foo: 'foo',
bar: 'bar' // ✓ ok
}
Le point doit être sur la même ligne que la propriété.
eslint: dot-location
console.
log('hello') // ✗ avoid
console
.log('hello') // ✓ ok
Les fichiers doivent finir avec un nouvelle ligne.
eslint: eol-last
Pas d'espace entre les identifiants de fonction et leurs invocations.
eslint: func-call-spacing
console.log ('hello') // ✗ avoid
console.log('hello') // ✓ ok
Ajoutez un espace entre les deux points et la valeur dans les combinaisons clé/valeur.
eslint: key-spacing
var obj = { 'key' : 'value' } // ✗ avoid
var obj = { 'key' :'value' } // ✗ avoid
var obj = { 'key':'value' } // ✗ avoid
var obj = { 'key': 'value' } // ✓ ok
Les noms de constructeur doivent commencer avec une lettre capitale.
eslint: new-cap
function animal () {}
var dog = new animal() // ✗ avoid
function Animal () {}
var dog = new Animal() // ✓ ok
Un constructeur sans argument doit être invoqué avec des parenthèses.
eslint: new-parens
function Animal () {}
var dog = new Animal // ✗ avoid
var dog = new Animal() // ✓ ok
Les objets doivent contenir un 'getter' quand un 'setter' est défini.
eslint: accessor-pairs
var person = {
set name (value) { // ✗ avoid
this._name = value
}
}
var person = {
set name (value) {
this._name = value
},
get name () { // ✓ ok
return this._name
}
}
Les constructeurs de classes dérivées doivent appeler super.
eslint: constructor-super
class Dog {
constructor () {
super() // ✗ avoid
}
}
class Dog extends Mammal {
constructor () {
super() // ✓ ok
}
}
Pour les tableaux (arrays), utilisez les expressions littérales au lieu des constructeurs.
eslint: no-array-constructor
var nums = new Array(1, 2, 3) // ✗ avoid
var nums = [1, 2, 3] // ✓ ok
Évitez d'utiliser arguments.callee et arguments.caller.
eslint: no-caller
function foo (n) {
if (n <= 0) return
arguments.callee(n - 1) // ✗ avoid
}
function foo (n) {
if (n <= 0) return
foo(n - 1)
}
Évitez de modifier les variables dans les déclarations de classes.
eslint: no-class-assign
class Dog {}
Dog = 'Fido' // ✗ avoid
Évitez de modifier les variables declarées avec const.
eslint: no-const-assign
const score = 100
score = 125 // ✗ avoid
Évitez d'utiliser les expressions constantes dans les conditions (à part dans les boucles).
eslint: no-constant-condition
if (false) { // ✗ avoid
// ...
}
if (x === 0) { // ✓ ok
// ...
}
while (true) { // ✓ ok
// ...
}
Pas de charactère de contrôle dans les expressions régulières.
eslint: no-control-regex
var pattern = /\x1f/ // ✗ avoid
var pattern = /\x20/ // ✓ ok
Pas de debugger.
eslint: no-debugger
function sum (a, b) {
debugger // ✗ avoid
return a + b
}
Pas d'opérateur delete sur les variables.
eslint: no-delete-var
var name
delete name // ✗ avoid
Pas d'arguments dupliqués dans les définitions de fonction.
eslint: no-dupe-args
function sum (a, b, a) { // ✗ avoid
// ...
}
function sum (a, b, c) { // ✓ ok
// ...
}
Pas de noms dupliqués dans les membres de classe.
eslint: no-dupe-class-members
class Dog {
bark () {}
bark () {} // ✗ avoid
}
Pas de clés dupliquées dans les objets littéraux.
eslint: no-dupe-keys
var user = {
name: 'Jane Doe',
name: 'John Doe' // ✗ avoid
}
Pas de label case dupliqué dans les blocs switch.
eslint: no-duplicate-case
switch (id) {
case 1:
// ...
case 1: // ✗ avoid
}
Utilisez une seule instruction d'import par module.
eslint: no-duplicate-imports
import { myFunc1 } from 'module'
import { myFunc2 } from 'module' // ✗ avoid
import { myFunc1, myFunc2 } from 'module' // ✓ ok
Pas de classes de charactères vides dans les expressions régulières.
eslint: no-empty-character-class
const myRegex = /^abc[]/ // ✗ avoid
const myRegex = /^abc[a-z]/ // ✓ ok
Pas d'affectation par décomposition vide.
eslint: no-empty-pattern
const { a: {} } = foo // ✗ avoid
const { a: { b } } = foo // ✓ ok
N'utilisez pas eval().
eslint: no-eval
eval( "var result = user." + propName ) // ✗ avoid
var result = user[propName] // ✓ ok
Ne réaffectez pas les exceptions dans les clauses catch.
eslint: no-ex-assign
try {
// ...
} catch (e) {
e = 'new value' // ✗ avoid
}
try {
// ...
} catch (e) {
const newVal = 'new value' // ✓ ok
}
N'étendez pas les objet natifs.
eslint: no-extend-native
Object.prototype.age = 21 // ✗ avoid
Evitez les liens de fonctions inutiles.
eslint: no-extra-bind
const name = function () {
getName()
}.bind(user) // ✗ avoid
const name = function () {
this.getName()
}.bind(user) // ✓ ok
Evitez les modifications de booléens inutiles.
eslint: no-extra-boolean-cast
const result = true
if (!!result) { // ✗ avoid
// ...
}
const result = true
if (result) { // ✓ ok
// ...
}
Pas de parenthèses inutiles autour des expressions de fonction.
eslint: no-extra-parens
const myFunc = (function () { }) // ✗ avoid
const myFunc = function () { } // ✓ ok
Utilisez break pour éviter de continuer dans les cas de switch.
eslint: no-fallthrough
switch (filter) {
case 1:
doSomething() // ✗ avoid
case 2:
doSomethingElse()
}
switch (filter) {
case 1:
doSomething()
break // ✓ ok
case 2:
doSomethingElse()
}
switch (filter) {
case 1:
doSomething()
// fallthrough // ✓ ok
case 2:
doSomethingElse()
}
Pas de nombre décimal sans partie entière.
eslint: no-floating-decimal
const discount = .5 // ✗ avoid
const discount = 0.5 // ✓ ok
Evitez de réaffecter les déclarations de fonction.
eslint: no-func-assign
function myFunc () { }
myFunc = myOtherFunc // ✗ avoid
Ne réaffectez pas les variables globales 'read-only'.
eslint: no-global-assign
window = {} // ✗ avoid
Pas d'eval() implicite.
eslint: no-implied-eval
setTimeout("alert('Hello world')") // ✗ avoid
setTimeout(function () { alert('Hello world') }) // ✓ ok
Pas de déclaration de fonction dans les blocs imbriqués.
eslint: no-inner-declarations
if (authenticated) {
function setAuthUser () {} // ✗ avoid
}
Pas d'expressions régulières invalides dans les constructeurs RegExp.
eslint: no-invalid-regexp
RegExp('[a-z') // ✗ avoid
RegExp('[a-z]') // ✓ ok
Pas d'espace blanc irrégulier.
eslint: no-irregular-whitespace
function myFunc () /*<NBSP>*/{} // ✗ avoid
N'utilisez pas __iterator__.
eslint: no-iterator
Foo.prototype.__iterator__ = function () {} // ✗ avoid
Pas d'étiquette qui partage un nom avec une variable dans le scope.
eslint: no-label-var
var score = 100
function game () {
score: while (true) { // ✗ avoid
score -= 10
if (score > 0) continue score
break
}
}
Pas d'instruction d'étiquette.
eslint: no-labels
label:
while (true) {
break label // ✗ avoid
}
Pas de blocs imbriqués inutiles.
eslint: no-lone-blocks
function myFunc () {
{ // ✗ avoid
myOtherFunc()
}
}
function myFunc () {
myOtherFunc() // ✓ ok
}
Evitez de mélanger les espaces et les tabulations pour l'indentation.
eslint: no-mixed-spaces-and-tabs
N'utilisez pas les espaces multiples à part pour l'indentation.
eslint: no-multi-spaces
const id = 1234 // ✗ avoid
const id = 1234 // ✓ ok
Pas de chaines de charactères multi-lignes.
eslint: no-multi-str
const message = 'Hello \
world' // ✗ avoid
Pas de new sans attribuer un objet à une variable.
eslint: no-new
new Character() // ✗ avoid
const character = new Character() // ✓ ok
N'utilisez pas le constructeur Function.
eslint: no-new-func
var sum = new Function('a', 'b', 'return a + b') // ✗ avoid
N'utilisez pas le constructeur Object.
eslint: no-new-object
let config = new Object() // ✗ avoid
N'utilisez pas new require.
eslint: no-new-require
const myModule = new require('my-module') // ✗ avoid
N'utilisez pas le constructeur Symbol.
eslint: no-new-symbol
const foo = new Symbol('foo') // ✗ avoid
N'utilisez pas les instances d'emballage de types primitifs.
eslint: no-new-wrappers
const message = new String('hello') // ✗ avoid
N'appelez pas les propriétes d'objets globaux en tant que fonctions.
eslint: no-obj-calls
const math = Math() // ✗ avoid
Pas de littéraux en base octal.
eslint: no-octal
const octal = 042 // ✗ avoid
const decimal = 34 // ✓ ok
const octalString = '042' // ✓ ok
Pas de séquence d'echappement octale dans les chaines de charactères littérales.
eslint: no-octal-escape
const copyright = 'Copyright \251' // ✗ avoid
Evitez les concaténations de chaines de charactères quand vous utilisez __dirname et __filename.
eslint: no-path-concat
const pathToFile = __dirname + '/app.js' // ✗ avoid
const pathToFile = path.join(__dirname, 'app.js') // ✓ ok
Evitez d'utiliser __proto__. Utilisez plutôt getPrototypeOf.
eslint: no-proto
const foo = obj.__proto__ // ✗ avoid
const foo = Object.getPrototypeOf(obj) // ✓ ok
Ne redéclarez pas les variables.
eslint: no-redeclare
let name = 'John'
let name = 'Jane' // ✗ avoid
let name = 'John'
name = 'Jane' // ✓ ok
Evitez d'utiliser plusieurs espaces dans les expressions regulières.
eslint: no-regex-spaces
const regexp = /test value/ // ✗ avoid
const regexp = /test {3}value/ // ✓ ok
const regexp = /test value/ // ✓ ok
Les affectations dans les instructions de retour doivent être entre parenthèses.
eslint: no-return-assign
function sum (a, b) {
return result = a + b // ✗ avoid
}
function sum (a, b) {
return (result = a + b) // ✓ ok
}
Evitez d'affecter une variable à elle-même.
eslint: no-self-assign
name = name // ✗ avoid
Evitez de comparer une variable à elle-même.
eslint: no-self-compare
if (score === score) {} // ✗ avoid
Evitez d'utiliser l'opérateur virgule.
eslint: no-sequences
if (doSomething(), !!test) {} // ✗ avoid
Les mots réservés ne doivent pas être affectés.
eslint: no-shadow-restricted-names
let undefined = 'value' // ✗ avoid
Les tableaux avec des valeurs vides ne sont pas autorisés.
eslint: no-sparse-arrays
let fruits = ['apple',, 'orange'] // ✗ avoid
Les tabulations ne devraient pas être utilisées
eslint: no-tabs
Les chaines de charactères normales ne doivent pas contenir de placeholder pour les modèles de libellés.
eslint: no-template-curly-in-string
const message = 'Hello ${name}' // ✗ avoid
const message = `Hello ${name}` // ✓ ok
super() doit être appelé avant d'utiliser this.
eslint: no-this-before-super
class Dog extends Animal {
constructor () {
this.legs = 4 // ✗ avoid
super()
}
}
N'utilisez throw que pour l'objet Error.
eslint: no-throw-literal
throw 'error' // ✗ avoid
throw new Error('error') // ✓ ok
Les espaces blancs ne sont pas autorisés en fin de ligne.
eslint: no-trailing-spaces
Initialiser avec undefined n'est pas autorisé.
eslint: no-undef-init
let name = undefined // ✗ avoid
let name
name = 'value' // ✓ ok
Pas de réutilisation de conditions dans les boucles.
eslint: no-unmodified-loop-condition
for (let i = 0; i < items.length; j++) {...} // ✗ avoid
for (let i = 0; i < items.length; i++) {...} // ✓ ok
Pas d'opérateur ternaire quand d'autres alternatives existent.
eslint: no-unneeded-ternary
let score = val ? val : 0 // ✗ avoid
let score = val || 0 // ✓ ok
Pas de code inaccessible apres les instructions return, throw, continue, et break.
eslint: no-unreachable
function doSomething () {
return true
console.log('never called') // ✗ avoid
}
Pas d'instruction de flow d'opération dans les blocs finally.
eslint: no-unsafe-finally
try {
// ...
} catch (e) {
// ...
} finally {
return 42 // ✗ avoid
}
Dans les opérateurs relationels, l'élément de gauche ne doit pas etre nié.
eslint: no-unsafe-negation
if (!key in obj) {} // ✗ avoid
if (!(key in obj)) {} // ✓ ok
Evitez l'usage inutile de.call() et .apply().
eslint: no-useless-call
sum.call(null, 1, 2, 3) // ✗ avoid
Evitez d'utiliser les propriétés calculées inutiles dans les objets.
eslint: no-useless-computed-key
const user = { ['name']: 'John Doe' } // ✗ avoid
const user = { name: 'John Doe' } // ✓ ok
Pas de constructeur inutile.
eslint: no-useless-constructor
class Car {
constructor () { // ✗ avoid
}
}
Pas d'utilisation inutile de l'idenificateur échappé.
eslint: no-useless-escape
let message = 'Hell\o' // ✗ avoid
Utiliser le même nom pour renommer import, export, et les affectations par décomposition n'est pas autorisé.
eslint: no-useless-rename
import { config as config } from './config' // ✗ avoid
import { config } from './config' // ✓ ok
Pas d'espace blanc avant les propriétés.
eslint: no-whitespace-before-property
user .name // ✗ avoid
user.name // ✓ ok
N'utilisez pas d'instructions avec with.
eslint: no-with
with (val) {...} // ✗ avoid
Soyez consistent dans la structure des propriétés d'objet.
eslint: object-property-newline
const user = {
name: 'Jane Doe', age: 30,
username: 'jdoe86' // ✗ avoid
}
const user = { name: 'Jane Doe', age: 30, username: 'jdoe86' } // ✓ ok
const user = {
name: 'Jane Doe',
age: 30,
username: 'jdoe86'
} // ✓ ok
Pas d'espace a l'intérieur des blocs.
eslint: padded-blocks
if (user) {
// ✗ avoid
const name = getName()
}
if (user) {
const name = getName() // ✓ ok
}
Pas d'espace blanc entre les opérateurs de décomposition and leurs expressions.
eslint: rest-spread-spacing
fn(... args) // ✗ avoid
fn(...args) // ✓ ok
Les point-virgules doivent avoir suivis mais pas précédés d'un espace.
eslint: semi-spacing
for (let i = 0 ;i < items.length ;i++) {...} // ✗ avoid
for (let i = 0; i < items.length; i++) {...} // ✓ ok
Ajoutez un espace avant les blocs.
eslint: space-before-blocks
if (admin){...} // ✗ avoid
if (admin) {...} // ✓ ok
Pas d'espace a l'intérieur des parenthèses.
eslint: space-in-parens
getName( name ) // ✗ avoid
getName(name) // ✓ ok
Les opérateurs unaires doivent être suivis d'un espace.
eslint: space-unary-ops
typeof!admin // ✗ avoid
typeof !admin // ✓ ok
Utilisez des espaces à l'intérieur des commentaires.
eslint: spaced-comment
//comment // ✗ avoid
// comment // ✓ ok
/*comment*/ // ✗ avoid
/* comment */ // ✓ ok
Pas d'espace dans les modèles de libellés.
eslint: template-curly-spacing
const message = `Hello, ${ name }` // ✗ avoid
const message = `Hello, ${name}` // ✓ ok
Utilisez isNaN() pour vérifier NaN.
eslint: use-isnan
if (price === NaN) { } // ✗ avoid
if (isNaN(price)) { } // ✓ ok
typeof doit être comparé à une chaine de charactères valide.
eslint: valid-typeof
typeof name === 'undefimed' // ✗ avoid
typeof name === 'undefined' // ✓ ok
Les expressions de fonction immediatement invoquées (IIFEs) doivent être encadrées par des parenthèses.
eslint: wrap-iife
const getName = function () { }() // ✗ avoid
const getName = (function () { }()) // ✓ ok
const getName = (function () { })() // ✓ ok
Le * dans les expressions yield* doit être précédé et suivi d'un espace.
eslint: yield-star-spacing
yield* increment() // ✗ avoid
yield * increment() // ✓ ok
Evitez les conditions Yoda.
eslint: yoda
if (42 === age) { } // ✗ avoid
if (age === 42) { } // ✓ ok
Pas de point-virgules. (voir: 1, 2, 3)
eslint: semi
window.alert('hi') // ✓ ok
window.alert('hi'); // ✗ avoid
Ne commencez jamais une ligne avec (, [, `, ou autres possibilités improbables.
C'est le seul piège avec l'omission des point-virgules, et standard vous protège contre ce probleme potentiel.
(La liste complète est: [, (, `, +, *, /, -, ,, ., mais la plupart n'apparaitront jamais en début de ligne dans un vrai bloc de code.)
eslint: no-unexpected-multiline
// ✓ ok
;(function () {
window.alert('ok')
}())
// ✗ avoid
(function () {
window.alert('ok')
}())
// ✓ ok
;[1, 2, 3].forEach(bar)
// ✗ avoid
[1, 2, 3].forEach(bar)
// ✓ ok
;`hello`.indexOf('o')
// ✗ avoid
`hello`.indexOf('o')
Note: Si vous écrivez souvent du code comme ça, vous essayez peut-être d'être trop astucieux.
Ce genre de raccourcis est découragé, en faveur d'expressions claires et lisibles, lorsque possible.
Au lieu de:
;[1, 2, 3].forEach(bar)
Ceci est préféré:
var nums = [1, 2, 3]
nums.forEach(bar)
Tous les minificateurs populaires de code utilisés aujourd'hui utilisent la minification basées sur AST, donc ils peuvent manipuler le JavaScript sans point-virgules sans problème (depuis que les point-virgules ne sont pas requis avec JavaScript).
[Compter sur l'insertion automatique de point-virgule] est plutot sur, et est une syntaxe JavaScript parfaitement valide que chaque navigateur comprend. Closure compiler, yuicompressor, packer, et jsmin peuvent tous le minifier proprement. Il n'y a pas d'impact sur la performance.
Je regrette qu'au lieu de vous éduquer, les leaders de cette communauté vous ont mentis. C'est honteux. Je recommende apprendre comment les instructions en JavaScript se terminent (et dans quels cas elles ne se terminent pas), pour que vous puissiez écrire du code qui vous plait.
En general,
\ntermine une instruction sauf si:
- L'instruction a une parenthèse qui n'est pas fermée, un tableau ou objet littéral ou finit d'une facon qui n'est pas valide. (Par exemple, avec un
.ou,.)- La ligne est
--ou++(au quel cas il diminuera ou augmentera l'element qui suit.)- C'est un
for(),while(),do,if(), ouelse, et il n'y a pas de{- La prochaine ligne commence par
[,(,+,*,/,-,,,., ou un autre opérateur binaire qui peut seulement être placé entre deux éléments dans une seule expression.Le premier point est plutôt évident. Même JSLint est ok avec les charactères
\nen format JSON et les constructeurs entre parenthèses, et avec les instructionsvarqui couvrent plusieurs lignes finissant par,.Le second point est super bizarre. Je n'ai jamais vu un cas (en dehors de ce genre de conversations) ou vous voudriez écrire
i\n++\nj, qui, au fait, est analysé commei; ++j, et pasi++; j.Le troisième est bien compris, même si généralement méprisé.
if (x)\ny()est l'equivalent deif (x) { y() }. Le concept ne finit pas jusqu'à ce qu'il atteigne un bloc ou une instruction.
;est une instruction valide, doncif(x);est equivalent àif(x){}ou, “If x, do nothing.” C'est plus couramment appliqué aux boucles ou la boucle vérifie aussi si la fonction est mise à jour. C'est pas courant, mais ça arrive.Le quatrième est généralement le cas “oh non, vous avez besoin de point-virgules!”. Mais, il s'avère qu'il est plutot facile de prefixer ces lignes avec des point-virgules si vous n'avez pas l'intention de les utiliser comme continutions de la ligne précédente. Par exemple, au lieu de ça:
jsfoo(); [1,2,3].forEach(bar);vous pourriez faire ça:
jsfoo() ;[1,2,3].forEach(bar)L'avantage c'est que les prefixes sont plus faciles à remarquer, quand vous êtes habitués à ne jamais voir de lignes commencant par
(ou[sans point-virgules.