restrict-plus-operands

Require both operands of addition to be the same type and be bigint, number, or string.

✅

Extending "plugin:@typescript-eslint/recommended-type-checked" in an ESLint configuration enables this rule.

💭

This rule requires type information to run.

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.

.eslintrc.cjs

module.exports = {
  "rules": {
    "@typescript-eslint/restrict-plus-operands": "error"
  }
};

Try this rule in the playground ↗

Examples

❌ Incorrect

let foo = 1n + 1;
let fn = (a: string, b: never) => a + b;

Open in Playground

✅ Correct

let foo = 1n + 1n;
let fn = (a: string, b: string) => a + b;

Open in Playground

Options

This rule accepts the following options, and has more strict settings in the strict and strict-type-checked configs.

type Options = [
  {
    /** Whether to allow `any` typed values. */
    allowAny?: boolean;
    /** Whether to allow `boolean` typed values. */
    allowBoolean?: boolean;
    /** Whether to allow potentially `null` or `undefined` typed values. */
    allowNullish?: boolean;
    /** Whether to allow `bigint`/`number` typed values and `string` typed values to be added together. */
    allowNumberAndString?: boolean;
    /** Whether to allow `regexp` typed values. */
    allowRegExp?: boolean;
    /** Whether to skip compound assignments such as `+=`. */
    skipCompoundAssignments?: boolean;
  },
];

const defaultOptionsRecommended: Options = [
  {
    allowAny: true,
    allowBoolean: true,
    allowNullish: true,
    allowNumberAndString: true,
    allowRegExp: true,
    skipCompoundAssignments: false,
  },
];

// These options are merged on top of the recommended defaults
const defaultOptionsStrict: Options = [
  {
    allowAny: false,
    allowBoolean: false,
    allowNullish: false,
    allowNumberAndString: false,
    allowRegExp: false,
  },
];

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.

  console.log('The result is ' + true);
  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;

Open in Playground

✅ Correct

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

Open in Playground

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;

Open in Playground

✅ Correct

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

Open in Playground

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;

Open in Playground

✅ 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;

Open in Playground

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;

Open in Playground

✅ Correct

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

Open in Playground

allowRegExp

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

❌ Incorrect

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

Open in Playground

✅ Correct

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

Open in Playground

skipCompoundAssignments

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

❌ Incorrect

let foo: bigint = 0n;
foo += 1;

let bar: number[] = [1];
bar += 1;

Open in Playground

✅ Correct

let foo: bigint = 0n;
foo += 1n;

let bar: number = 1;
bar += 1;

Open in Playground

When Not To Use It

If you don't mind a risk of "[object Object]" or incorrect type coercions in your values, then you will not need this rule.

Related To

• no-base-to-string
• restrict-template-expressions

Further Reading

• Object.prototype.toString() MDN documentation

---

Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.

See Troubleshooting > Linting with Type Information > Performance if you experience performance degredations after enabling type checked rules.

Resources

• Rule source
• Test source