Naming Conventions

Naming Convention Fixes

Fixes for variable naming issues. Good names are searchable, self-documenting, and follow consistent conventions.

Quick Start

1. Identify the naming issue (unused var, single letter, abbreviation)
2. Determine if the variable is truly needed
3. Apply appropriate fix (rename, remove, or prefix)
4. Verify no regressions

Priority Matrix

Workflows

Unused Variables (#5 - 123 occurrences)

Detection: @typescript-eslint/no-unused-vars

Pattern: Variable declared but never used.

// PROBLEM - unused variables
const { data, error, status } = await fetchData();
console.log(data);
// error and status never used

Fix Strategy 1: Underscore prefix (documents intent).

// SOLUTION - underscore prefix
const { data, error: _error, status: _status } = await fetchData();
console.log(data);

Fix Strategy 2: Omit from destructuring.

// SOLUTION - don't destructure unused
const { data } = await fetchData();
console.log(data);

Decision Guide:

Underscore Convention:

• _error - Intentionally ignored
• _unused - Known unused, kept for signature
• _ - Single underscore for completely ignored

Single-Letter Variable Names (#19 - 12 occurrences)

Detection: Variable name is single character (except standard exceptions).

Pattern: Short names in array methods.

// PROBLEM - single letters
users.map(u => u.name);
items.filter(i => i.active);
orders.reduce((a, o) => a + o.total, 0);

Fix Strategy: Use descriptive contextual names.

// SOLUTION - descriptive names
users.map(user => user.name);
items.filter(item => item.active);
orders.reduce((sum, order) => sum + order.total, 0);

Acceptable Single Letters:

Naming Patterns:

Reduce Accumulator Names:

Non-Standard Abbreviations (#30 - 15 occurrences)

Detection: Project-specific abbreviations that aren't universally understood.

Pattern: Abbreviated variable names.

// PROBLEM - non-standard abbreviations
const cwd = process.cwd();
const dir = path.dirname(file);
const env = process.env.NODE_ENV;
const cfg = loadConfig();

Fix Strategy: Expand non-standard, keep standard.

// SOLUTION
const currentWorkingDirectory = process.cwd();
const directory = path.dirname(file);
const environment = process.env.NODE_ENV;
const config = loadConfig();

// KEEP (universally understood)
const url = new URL(input);
const userId = params.id;
const apiKey = env.API_KEY;

Standard Abbreviations (KEEP):

Non-Standard Abbreviations (EXPAND):

Exception: Framework/library conventions (e.g., Express req/res).

Unused Destructuring Pattern (#29 - 1 occurrence)

Pattern: Rest element captures unused properties.

// PROBLEM - rest captures unused
const { used, ...rest } = object;
// rest never used

Fix Strategy: Remove rest or use it.

// SOLUTION - just destructure what's needed
const { used } = object;

// OR - if you need to exclude properties
const { excluded: _excluded, ...rest } = object;
passToFunction(rest);

Scripts

Check Naming Issues

node scripts/check-naming.js /path/to/src

Find Single-Letter Variables

node scripts/find-short-names.js /path/to/file.ts

ESLint Configuration

Unused Variables Rule

// eslint.config.js
{
  rules: {
    '@typescript-eslint/no-unused-vars': ['error', {
      argsIgnorePattern: '^_',
      varsIgnorePattern: '^_',
      caughtErrorsIgnorePattern: '^_',
      destructuredArrayIgnorePattern: '^_',
    }],
  },
}

Naming Convention Rule

{
  rules: {
    '@typescript-eslint/naming-convention': [
      'error',
      // Variables: camelCase
      {
        selector: 'variable',
        format: ['camelCase', 'UPPER_CASE'],
        leadingUnderscore: 'allow',
      },
      // Functions: camelCase
      {
        selector: 'function',
        format: ['camelCase'],
      },
      // Types/Interfaces: PascalCase
      {
        selector: 'typeLike',
        format: ['PascalCase'],
      },
      // Constants: UPPER_CASE or camelCase
      {
        selector: 'variable',
        modifiers: ['const'],
        format: ['camelCase', 'UPPER_CASE'],
      },
    ],
  },
}

Naming Best Practices

Be Specific

// BAD
const data = fetchData();
const result = process(data);
const value = calculate(result);

// GOOD
const userProfile = fetchUserProfile();
const validatedProfile = validateProfile(userProfile);
const profileScore = calculateProfileScore(validatedProfile);

Use Verb Prefixes for Booleans

// BAD
const visible = true;
const admin = user.role === 'admin';

// GOOD
const isVisible = true;
const isAdmin = user.role === 'admin';
const hasPermission = checkPermission(user);
const canEdit = isAdmin && hasPermission;

Use Verb Prefixes for Functions

// BAD
const user = async (id) => { ... };
const validation = (input) => { ... };

// GOOD
const getUser = async (id) => { ... };
const validateInput = (input) => { ... };
const createOrder = (items) => { ... };
const updateProfile = (data) => { ... };
const deleteRecord = (id) => { ... };

Avoid Redundant Context

// BAD (in User class)
class User {
  userName: string;
  userEmail: string;
  getUserAge(): number;
}

// GOOD
class User {
  name: string;
  email: string;
  getAge(): number;
}

Collection Naming

// Plural for collections
const users: User[] = [];
const orderMap: Map<string, Order> = new Map();
const productIds: Set<string> = new Set();

// Singular for single items
const user = users[0];
const order = orderMap.get(id);