JavaScript Function to Multiply x by y

The multiplication operator (*) is the core of any JavaScript function that computes the product of two values. Below are the most common ways to define such a function, plus optional enhancements.

1. Basic Function Declaration

function multiply(x, y) {
  return x * y;
}

Usage

console.log(multiply(5, 3)); // 15

2. Arrow Function (ES6+)

const multiply = (x, y) => x * y;

Usage

console.log(multiply(7.5, 2)); // 15

3. Function Expression

const multiply = function(x, y) {
  return x * y;
};

Usage

console.log(multiply(-2, 4)); // -8

4. Optional Type‑Checking (defensive programming)

function multiply(x, y) {
  if (typeof x === 'number' && typeof y === 'number') {
    return x * y;
  }
  return 'Pass valid numbers to multiply';
}

Usage

console.log(multiply('a', 3)); // Pass valid numbers to multiply

5. Using the Function Constructor (rarely needed)

const multiply = new Function('x', 'y', 'return x * y');

Usage

console.log(multiply(3, 4)); // 12

Key Points

• Multiplication operator (*): Works with Number and BigInt types ².
• Function syntaxes: Declaration, arrow, expression, and constructor each create a callable that returns x * y.
• Type safety: Adding a simple typeof check prevents accidental string concatenation or NaN results ¹.
• No implicit coercion needed: JavaScript will coerce non‑numeric values to numbers, but explicit checks are recommended for robust code ².

When to Choose Each Syntax

Syntax	When to Use
Function Declaration	Clear, reusable code; hoisted, useful in older codebases
Arrow Function	Concise syntax, especially for one‑liners or callbacks
Function Expression	Useful when you need a named or anonymous function assigned to a variable
Function Constructor	Rare; only when generating functions dynamically from strings
Type‑Checking Wrapper	Production code where input validation matters

---

Example of Full Usage

// Choose any of the definitions above; here we use the arrow version
const multiply = (x, y) => x * y;

console.log(multiply(10, 5));   // 50
console.log(multiply(0.5, 8));  // 4

All of these snippets rely on the same underlying operator, making them interchangeable for simple multiplication tasks.