no-unused-expressions

Запрещает неиспользуемые выражения

Неиспользуемое выражение, не влияющее на состояние программы, указывает на логическую ошибку.

Например, n + 1; не является синтаксической ошибкой, но может быть опечаткой: программист мог иметь в виду оператор присваивания n += 1;. Иногда такие неиспользуемые выражения могут удаляться некоторыми инструментами сборки в production-среде, что может нарушить логику приложения.

Подробное описание правила

Это правило предназначено для устранения неиспользуемых выражений, не влияющих на состояние программы.

Это правило не применяется к вызовам функций или конструкторов с оператором new, поскольку они могут иметь побочные эффекты, влияющие на состояние программы.

let i = 0;
function increment() { i += 1; }
increment(); // return value is unused, but i changed as a side effect

let nThings = 0;
function Thing() { nThings += 1; }
new Thing(); // constructed object is unused, but nThings changed as a side effect

Это правило не применяется к директивам (представленным строковыми литералами, например "use strict"; в начале скрипта, модуля или функции) при использовании сред ES5+. В средах ES3 директивы по умолчанию считаются неиспользуемыми выражениями, но это поведение можно изменить с помощью параметра ignoreDirectives.

Последовательные выражения (содержащие запятую, например a = 1, b = 2) всегда считаются неиспользуемыми, если их возвращаемое значение не присваивается, не используется при проверке условия или значение последовательного выражения не передается при вызове функции.

Параметры

По умолчанию этому правилу не требуются аргументы. Чтобы включить одну или несколько перечисленных ниже возможностей, передайте объект с соответствующими параметрами:

• Параметр allowShortCircuit со значением true позволяет использовать в выражениях вычисления с коротким замыканием (по умолчанию: false).
• Параметр allowTernary со значением true позволяет использовать в выражениях тернарные операторы так же, как и вычисления с коротким замыканием (по умолчанию: false).
• Параметр allowTaggedTemplates со значением true позволяет использовать в выражениях помеченные шаблонные литералы (по умолчанию: false).
• Параметр enforceForJSX со значением true включает обнаружение неиспользуемых выражений JSX-элементов (по умолчанию: false).
• Параметр ignoreDirectives со значением true предотвращает сообщение о директивах как о неиспользуемых выражениях при проверке с помощью ecmaVersion: 3 (по умолчанию: false).

Эти параметры разрешают неиспользуемые выражения только в том случае, если все пути выполнения либо напрямую изменяют состояние (например, оператором присваивания), либо могут иметь побочные эффекты (например, вызов функции).

Примеры неправильного кода для параметров { "allowShortCircuit": false, "allowTernary": false } по умолчанию:

/*eslint no-unused-expressions: "error"*/

0

if(0) 0

{0}

f(0), {}

a && b()

a, b()

c = a, b;

a()&&functionnamedFunctionInExpressionContext(){f();}(functionanIncompleteIIFE(){});

injectGlobal`body{ color: red; }`

Примеры правильного кода для параметров { "allowShortCircuit": false, "allowTernary": false } по умолчанию:

/*eslint no-unused-expressions: "error"*/

{} // In this context, this is a block statement, not an object literal

{ myLabel: foo() } // In this context, this is a block statement with a label and expression, not an object literal

function namedFunctionDeclaration () {}

(function aGenuineIIFE () {}());

f()

a = 0

new C

delete a.b

void a

Обратите внимание: одно или несколько строковых выражений (с точками с запятой или без них) считаются неиспользуемыми, только если они находятся не в начале скрипта, модуля или функции (отдельно и без прерывания другими инструкциями). В противном случае они считаются частью «пролога директив» — раздела, который могут использовать движки JavaScript. Сюда входят директивы «строгого режима».

Примеры правильного кода с точки зрения этого правила для директив:

/*eslint no-unused-expressions: "error"*/

"use strict";
"use asm"
"use stricter";
"use babel"
"any other strings like this in the directive prologue";
"this is still the directive prologue";

function foo() {
    "bar";
}

class Foo {
    someMethod() {
        "use strict";
    }
}

Примеры неправильного кода с точки зрения этого правила для директив:

/*eslint no-unused-expressions: "error"*/

doSomething();
"use strict"; // this isn't in a directive prologue, because there is a non-directive statement before it

function foo() {
    "bar" + 1;
}

class Foo {
    static {
        "use strict"; // class static blocks do not have directive prologues
    }
}

allowShortCircuit

Примеры неправильного кода для параметра { "allowShortCircuit": true }:

/*eslint no-unused-expressions: ["error", { "allowShortCircuit": true }]*/

a || b

Примеры правильного кода для параметра { "allowShortCircuit": true }:

/*eslint no-unused-expressions: ["error", { "allowShortCircuit": true }]*/

a && b()
a() || (b = c)

allowTernary

Примеры неправильного кода для параметра { "allowTernary": true }:

/*eslint no-unused-expressions: ["error", { "allowTernary": true }]*/

a ? b : 0
a ? b : c()

Примеры правильного кода для параметра { "allowTernary": true }:

/*eslint no-unused-expressions: ["error", { "allowTernary": true }]*/

a ? b() : c()
a ? (b = c) : d()

allowShortCircuit and allowTernary

Примеры правильного кода для параметров { "allowShortCircuit": true, "allowTernary": true }:

/*eslint no-unused-expressions: ["error", { "allowShortCircuit": true, "allowTernary": true }]*/

a ? b() || (c = d) : e()

allowTaggedTemplates

Примеры неправильного кода для параметра { "allowTaggedTemplates": true }:

/*eslint no-unused-expressions: ["error", { "allowTaggedTemplates": true }]*/

`some untagged template string`;

Примеры правильного кода для параметра { "allowTaggedTemplates": true }:

/*eslint no-unused-expressions: ["error", { "allowTaggedTemplates": true }]*/

tag`some tagged template string`;

enforceForJSX

JSX чаще всего используется в экосистеме React, где он компилируется в выражения React.createElement. Хотя эти вызовы не имеют побочных эффектов, правило no-unused-expression автоматически их не обнаруживает. Если вы используете React или любую другую прагму JSX без побочных эффектов, этот параметр можно включить, чтобы обнаруживать такие выражения.

Примеры неправильного кода для параметра { "enforceForJSX": true }:

/*eslint no-unused-expressions: ["error", { "enforceForJSX": true }]*/

<MyComponent />;

<></>;

Примеры правильного кода для параметра { "enforceForJSX": true }:

/*eslint no-unused-expressions: ["error", { "enforceForJSX": true }]*/

const myComponentPartial = <MyComponent />;

const myFragment = <></>;

ignoreDirectives

Если задано значение false (по умолчанию), это правило сообщает о директивах (например, "use strict") как о неиспользуемых выражениях при проверке с помощью ecmaVersion: 3. Такое поведение по умолчанию предусмотрено потому, что среды ES3 формально не поддерживают директивы, то есть в этом контексте такие строки фактически являются неиспользуемыми выражениями.

Задайте для этого параметра значение true, чтобы директивы не считались неиспользуемыми, даже если указан ecmaVersion: 3. Этот параметр особенно полезен проектам, которым нужно поддерживать единую кодовую базу с директивами одновременно для старых сред ES3 и современных сред (ES5+).

Примечание: В средах ES5+ директивы всегда игнорируются независимо от значения этого параметра.

Примеры неправильного кода для параметра { "ignoreDirectives": false } и ecmaVersion: 3:

/*eslint no-unused-expressions: ["error", { "ignoreDirectives": false }]*/

"use strict";
"use asm"
"use stricter";
"use babel"
"any other strings like this in the directive prologue";
"this is still the directive prologue";

function foo() {
    "bar";
}

Примеры правильного кода для параметра { "ignoreDirectives": true } и ecmaVersion: 3:

/*eslint no-unused-expressions: ["error", { "ignoreDirectives": true }]*/

"use strict";
"use asm"
"use stricter";
"use babel"
"any other strings like this in the directive prologue";
"this is still the directive prologue";

function foo() {
    "bar";
}

Поддержка TypeScript

Это правило поддерживает специфичные для TypeScript выражения и применяет следующие рекомендации:

1. Директивы (например, 'use strict') разрешены в объявлениях модулей и пространств имён
2. Выражения, связанные с типами, считаются неиспользуемыми, если не используются обёрнутые ими выражения-значения:
   • Утверждения типа (x as number, <number>x)
   • Утверждения ненулевого значения (x!)
   • Инстанцирования типов (Set<number>)

Примечание: Хотя выражения типов никогда не имеют побочных эффектов во время выполнения (например, x! эквивалентно x во время выполнения), их можно использовать для проверки типов.

Примеры правильного кода при использовании TypeScript:

/* eslint no-unused-expressions: "error" */

// Type expressions wrapping function calls are allowed
function getSet() {
    return Set;
}
getSet()<number>;
getSet() as Set<unknown>;
getSet()!;

// Directives in modules and namespaces
module Foo {
    'use strict';
    'hello world';
}

namespace Bar {
    'use strict';
    export class Baz {}
}

Примеры неправильного кода при использовании TypeScript:

/* eslint no-unused-expressions: "error" */

// Standalone type expressions
Set<number>;
1 as number;
window!;

// Expressions inside namespaces
namespace Bar {
    123;
}

Версия

Это правило появилось в ESLint v0.1.0.

Ресурсы

• Исходный код правила
• Исходный код тестов