no-return-assign

Disallow assignment operators in return statements

no-return-assign

Assignment in return statements can be confusing - it’s often unclear whether the developer meant to return the assignment or use a comparison operator.

Rule Type: Suggestion
Fixable: No

Why This Rule Exists

Code like this is ambiguous:

function doSomething() {
    return foo = bar + 2;
}

Did the developer mean:

• Return the result of bar + 2 (and assign it to foo)?
• Use == for comparison instead of =?

Rule Details

This rule disallows assignments in return statements.

Options

"except-parens" (default)

Disallow assignments unless enclosed in parentheses.

Incorrect:

function doSomething() {
    return foo = bar + 2;
}

function doSomethingElse() {
    return foo += 2;
}

const foo = (a, b) => a = b;

const bar = (a, b, c) => (a = b, c == b);

function doSomethingMore() {
    return foo = bar && foo > 0;
}

Correct:

function doSomething() {
    return foo == bar + 2;
}

function doSomethingElse() {
    return foo === bar + 2;
}

function doSomethingMore() {
    return (foo = bar + 2);
}

const foo = (a, b) => (a = b);

const bar = (a, b, c) => ((a = b), c == b);

function doAnotherThing() {
    return (foo = bar) && foo > 0;
}

"always"

Disallow all assignments in return statements, even with parentheses.

Incorrect:

function doSomething() {
    return foo = bar + 2;
}

function doSomethingElse() {
    return foo += 2;
}

function doSomethingMore() {
    return (foo = bar + 2);
}

Correct:

function doSomething() {
    return foo == bar + 2;
}

function doSomethingElse() {
    return foo === bar + 2;
}

Examples

Common Mistake: = vs ==

The most common bug is using = when you meant == or ===.

// Bug: Assignment instead of comparison
function isAdult(age) {
    return age = 18; // Always returns 18!
}

// Fixed: Comparison
function isAdult(age) {
    return age >= 18;
}

Intentional Assignment

// Confusing: Returns and assigns
function getAndCache(id) {
    return cache[id] = fetchData(id);
}

// Clearer: Separate operations
function getAndCache(id) {
    const data = fetchData(id);
    cache[id] = data;
    return data;
}

// Or with parentheses if you insist
function getAndCache(id) {
    return (cache[id] = fetchData(id));
}

Common Patterns

Caching Pattern

// Confusing
function getUser(id) {
    return userCache[id] = fetchUser(id);
}

// Better
function getUser(id) {
    if (!userCache[id]) {
        userCache[id] = fetchUser(id);
    }
    return userCache[id];
}

// Or memoization
const getUser = memoize(id => fetchUser(id));

Conditional Assignment

// Confusing
function process(value) {
    return result = value > 10 ? 'big' : 'small';
}

// Clearer
function process(value) {
    const result = value > 10 ? 'big' : 'small';
    return result;
}

// Or just return directly
function process(value) {
    return value > 10 ? 'big' : 'small';
}

Chained Assignment

// Wrong
function setAndReturn(val) {
    return x = y = val;
}

// Right
function setAndReturn(val) {
    x = val;
    y = val;
    return val;
}

Configuration Examples

// Default: Allow with parentheses
{
  "rules": {
    "no-return-assign": "error"
  }
}

// Explicit default
{
  "rules": {
    "no-return-assign": ["error", "except-parens"]
  }
}

// Always disallow
{
  "rules": {
    "no-return-assign": ["error", "always"]
  }
}

When Not to Use It

Disable this rule if you:

• Commonly use assignment in return statements
• Have a team convention that accepts this pattern
• Use parentheses to make intent clear

However, for most teams, this rule helps prevent bugs and improves clarity.

Best Practices

Separate Concerns

Separate assignment from return for better readability.

// Compact but unclear
return state = newState;

// Verbose but clear
state = newState;
return state;

Use Descriptive Variables

// Less clear
return (result = calculateValue());

// More clear
const result = calculateValue();
return result;

Consider Immutability

// Mutating and returning
function addItem(array, item) {
    return array[array.length] = item;
}

// Immutable approach
function addItem(array, item) {
    return [...array, item];
}

Related Rules

• no-cond-assign
• no-return-await