Eslint -Regel, um explizite Nullprüfungen zu erzwingen ⇐ JavaScript

[Anonymous]

Ich suche nach einer Eslint-Regel/einem Plugin, um diese Art von Ausdruck zu verbieten:

Code: Select all

if (!something) {
return // can be anything here, but it's often a return
}

// Or the other way equivalent
if (something) {
// Use the variable here because we checked it is not null nor undefined
}

if (someBoolean) {
// This one is okay since it's a boolean
}

Das Problem ist in einigen Fällen, wenn der Wert auf false, aber nicht und definierte/null bewertet wird, nicht das, was wir wollten:

Code: Select all

const something: number | undefined = 0
if (!something) {
return // Will return as 0 is falsy, but we actually wanted to check if it was undefined but forgot about this case!
}
< /code>
Ich möchte also explizite Schecks erzwingen (außer wenn der Typ ein reines Boolescher ist). Es würde: < /p>
if (something === undefined || something === null) { // Or for short `== null`
return // can be anything here, but it's often a return
}

if (something !== undefined && something !== null) { // Or for short `!= null`
// Use the variable here because we checked it is not null nor undefined
}

if (someBoolean) { // This is typed boolean so it stays the same

}
< /code>
Die Regel würde auch auf den ternären Ausdruck angewendet und in anderen Fällen wird diese Art von Scheck so geschrieben, als wäre es ein Booleschen (aber es ist nicht so und kann zu Problemen führen). Wenn man also bereits hergestellt ist, nehme ich es!import * as tsutils from "tsutils"
import * as ts from "typescript"

export default {
meta: {
type: "problem",
docs: {
description: "Disallow implicit falsy checks; require explicit null/undefined checks.",
recommended: true
},
schema: [],
messages: {
implicitFalsy: "Use explicit null/undefined checks instead of '!{{name}}'."
}
},
create(context) {
if (!context.parserServices?.program?.getTypeChecker) return {} // Exit if type information is unavailable
const checker = context.parserServices.program.getTypeChecker()

return {
UnaryExpression(node) {
if (node.operator === "!" && node.argument.type === "Identifier") {
const tsNode = context.parserServices.esTreeNodeToTSNodeMap.get(node.argument)
const type = checker.getTypeAtLocation(tsNode)
const isNullable = tsutils.isTypeFlagSet(type, ts.TypeFlags.Null) ||
tsutils.isTypeFlagSet(type, ts.TypeFlags.Undefined)

if (isNullable) context.report({
node,
messageId: "implicitFalsy",
data: {name: node.argument.name}
})
}
}
}
}
}