Skip to content

Latest commit

 

History

History
208 lines (144 loc) · 4.66 KB

restrict-plus-operands.md

File metadata and controls

208 lines (144 loc) · 4.66 KB
Raw
description
Require both operands of addition to be the same type and be `bigint`, `number`, or `string`.

🛑 This file is source code, not the primary documentation location! 🛑

See https://typescript-eslint.io/rules/restrict-plus-operands for documentation.

TypeScript allows + adding together two values of any type(s). However, adding values that are not the same type and/or are not the same primitive type is often a sign of programmer error.

This rule reports when a + operation combines two values of different types, or a type that is not bigint, number, or string.

Examples

❌ Incorrect

let foo = '5.5' + 5;
let foo = 1n + 1;

✅ Correct

let foo = parseInt('5.5', 10) + 10;
let foo = 1n + 1n;

Options

:::caution We generally recommend against using these options, as they limit which varieties of incorrect + usage can be checked. This in turn severely limits the validation that the rule can do to ensure that resulting strings and numbers are correct.

Safer alternatives to using the allow* options include:

  • Using variadic forms of logging APIs to avoid needing to + values. 
    // Remove this line
console.log('The result is ' + true);
// Add this line
console.log('The result is', true);
  • Using .toFixed() to coerce numbers to well-formed string representations: 
    const number = 1.123456789;
const result = 'The number is ' + number.toFixed(2);
// result === 'The number is 1.12'
  • Calling .toString() on other types to mark explicit and intentional string coercion: 
    const arg = '11';
const regex = /[0-9]/;
const result =
  'The result of ' +
  regex.toString() +
  '.test("' +
  arg +
  '") is ' +
  regex.test(arg).toString();
// result === 'The result of /[0-9]/.test("11") is true'

:::

allowAny

Examples of code for this rule with { allowAny: true }:

❌ Incorrect

let fn = (a: number, b: []) => a + b;
let fn = (a: string, b: []) => a + b;

✅ Correct

let fn = (a: number, b: any) => a + b;
let fn = (a: string, b: any) => a + b;

allowBoolean

Examples of code for this rule with { allowBoolean: true }:

❌ Incorrect

let fn = (a: number, b: unknown) => a + b;
let fn = (a: string, b: unknown) => a + b;

✅ Correct

let fn = (a: number, b: boolean) => a + b;
let fn = (a: string, b: boolean) => a + b;

allowNullish

Examples of code for this rule with { allowNullish: true }:

❌ Incorrect

let fn = (a: number, b: unknown) => a + b;
let fn = (a: number, b: never) => a + b;
let fn = (a: string, b: unknown) => a + b;
let fn = (a: string, b: never) => a + b;

✅ Correct

let fn = (a: number, b: undefined) => a + b;
let fn = (a: number, b: null) => a + b;
let fn = (a: string, b: undefined) => a + b;
let fn = (a: string, b: null) => a + b;

allowNumberAndString

Examples of code for this rule with { allowNumberAndString: true }:

❌ Incorrect

let fn = (a: number, b: unknown) => a + b;
let fn = (a: number, b: never) => a + b;

✅ Correct

let fn = (a: number, b: string) => a + b;
let fn = (a: number, b: number | string) => a + b;

allowRegExp

Examples of code for this rule with { allowRegExp: true }:

❌ Incorrect

let fn = (a: number, b: RegExp) => a + b;

✅ Correct

let fn = (a: string, b: RegExp) => a + b;

skipCompoundAssignments

Examples of code for this rule with { skipCompoundAssignments: false }:

❌ Incorrect

let foo: string | undefined;
foo += 'some data';

let bar: string = '';
bar += 0;

✅ Correct

let foo: number = 0;
foo += 1;

let bar = '';
bar += 'test';

When Not To Use It

If you don't mind "[object Object]" in your strings, then you will not need this rule.

Related To

Further Reading