How to fix Parameter 'x' implicitly has an 'any' type in TypeScript

// BEFORE - Error: Parameter 'name' implicitly has an 'any' type
function greet(name) {
  return `Hello ${name}`;
}

// AFTER - Add explicit string type
function greet(name: string) {
  return `Hello ${name}`;

// Arrow function example
// BEFORE
const multiply = (a, b) => a * b;

// AFTER
const multiply = (a: number, b: number): number => a * b;

// Method in class
class Calculator {
  // BEFORE
  add(x, y) {
    return x + y;
  }

  // AFTER
  add(x: number, y: number): number {
    return x + y;
  }
}

// TypeScript infers 'count' is number from default value
function repeatMessage(message: string, count = 1) {
  return message.repeat(count);
}

// TypeScript infers 'enabled' is boolean
const toggleFeature = (enabled = true) => {
  return !enabled;
};

// For optional parameters with defaults
function createUser(name: string, isAdmin = false) {
  // 'isAdmin' is inferred as boolean
  return { name, isAdmin };
}

// Works with destructuring too
function formatDate({ date = new Date() } = {}) {
  // 'date' is inferred as Date
  return date.toISOString();
}

const numbers = [1, 2, 3, 4, 5];

// BEFORE - Error on 'n' parameter
const doubled = numbers.map(n => n * 2);

// AFTER - Add number type
const doubled = numbers.map((n: number) => n * 2);

// For objects in arrays
interface User {
  id: number;
  name: string;
}

const users: User[] = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' }
];

// Type the callback parameter
const names = users.map((user: User) => user.name);

// For filter with index parameter
const evenNumbers = numbers.filter((n: number, index: number) => n % 2 === 0);

// Using generic type parameter (alternative)
const squared = numbers.map<number>((n) => n * n);

// tsconfig.json
{
  "compilerOptions": {
    // Disable noImplicitAny (not recommended for new projects)
    "noImplicitAny": false,

    // Alternative: Use strict mode which includes noImplicitAny
    "strict": true,  // Enables all strict type-checking options

    // Or control individual strict options
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictBindCallApply": true,
    "strictPropertyInitialization": true,
    "noImplicitThis": true,
    "alwaysStrict": true
  }
}

// BEFORE - Implicit any (causes error with noImplicitAny)
function parseData(data) {
  return JSON.parse(data);
}

// AFTER - Explicit any (no error)
function parseData(data: any) {
  return JSON.parse(data);
}

// Better: Use unknown for type-safe parsing
function parseData(data: string): unknown {
  return JSON.parse(data);
}

// For callback functions where type doesn't matter
const callbacks: Array<(arg: any) => void> = [];

// Using type assertion for specific cases
function handleEvent(event: any) {
  const mouseEvent = event as MouseEvent;
  // Use mouseEvent with proper typing
}

// Suppress error for single line (use sparingly)
// @ts-ignore
function legacyFunction(param) {
  return param;
}

// React event handlers
// BEFORE
function Button({ onClick }) {
  return <button onClick={onClick}>Click me</button>;
}

// AFTER
interface ButtonProps {
  onClick: (event: React.MouseEvent<HTMLButtonElement>) => void;
}

function Button({ onClick }: ButtonProps) {
  return <button onClick={onClick}>Click me</button>;
}

// Express.js route handlers
// BEFORE
app.get('/users', (req, res) => {
  res.json({ users: [] });
});

// AFTER
import { Request, Response } from 'express';

app.get('/users', (req: Request, res: Response) => {
  res.json({ users: [] });
});

// Node.js callbacks
// BEFORE
fs.readFile('file.txt', (err, data) => {
  // Handle file
});

// AFTER
import fs from 'fs';

fs.readFile('file.txt', (err: NodeJS.ErrnoException | null, data: Buffer) => {
  // Handle file
});

// Generic functions
// BEFORE
function identity(value) {
  return value;
}

// AFTER
function identity<T>(value: T): T {
  return value;
}