Lesson 26-Deep Understanding of Code Reuse Patterns

Basic Concepts and Importance of Code Reuse

Definition and Value of Code Reuse

Code reuse refers to the practice of using existing code snippets, components, or modules in new contexts during software development. This approach significantly enhances development efficiency and delivers multiple benefits:

1. Improved Development Efficiency: Avoids rewriting similar functionality, saving time and effort.
2. Enhanced Code Consistency: Using the same implementation for identical functionality reduces bugs and improves maintainability.
3. Reduced Maintenance Costs: Changes made in one place automatically propagate to all areas using the code.
4. Promotes Team Collaboration: Standardized code structures make it easier for team members to understand and contribute.

// Example without reuse - duplicated code
function calculateAreaOfCircle(radius) {
  return Math.PI * radius * radius;
}

function calculateAreaOfSquare(side) {
  return side * side;
}

// Although the functionality differs, the computation logic shares similarities

// Example without reuse - duplicated code
function calculateAreaOfCircle(radius) {
  return Math.PI * radius * radius;
}

function calculateAreaOfSquare(side) {
  return side * side;
}

// Although the functionality differs, the computation logic shares similarities

Levels of Code Reuse

Code reuse can be implemented at various levels, from low-level code snippets to high-level system architectures:

1. Code Snippet Level: Copy-pasting or extracting common functions.
2. Function/Method Level: Encapsulating reusable functionality.
3. Class/Component Level: Object-oriented or component-based reuse.
4. Module/Package Level: Reusing third-party or internal modules via dependency management.
5. Architecture Level: Reusing design patterns and architectural styles.

Function-Level Code Reuse Patterns

Pure Functions and Functional Programming

Pure functions are foundational for code reuse, producing the same output for the same input without side effects, making them highly reusable.

// Pure function example - highly reusable
function add(a, b) {
  return a + b;
}

function multiply(a, b) {
  return a * b;
}

// Composing pure functions to create complex functionality
function calculateTotal(price, quantity, taxRate) {
  const subtotal = multiply(price, quantity);
  const tax = multiply(subtotal, taxRate);
  return add(subtotal, tax);
}

// Pure function example - highly reusable
function add(a, b) {
  return a + b;
}

function multiply(a, b) {
  return a * b;
}

// Composing pure functions to create complex functionality
function calculateTotal(price, quantity, taxRate) {
  const subtotal = multiply(price, quantity);
  const tax = multiply(subtotal, taxRate);
  return add(subtotal, tax);
}

Advantages of Pure Functions:

• Easy to test.
• Results can be cached.
• Suitable for parallel execution.
• No side effects, ideal for reuse.

Higher-Order Functions and Function Composition

Higher-order functions (HOFs) are functions that accept functions as arguments or return functions, providing powerful abstraction for code reuse.

// Higher-order function example - map function
function map(array, transformFn) {
  const result = [];
  for (let i = 0; i < array.length; i++) {
    result.push(transformFn(array[i]));
  }
  return result;
}

// Using higher-order function
const numbers = [1, 2, 3, 4];
const doubled = map(numbers, x => x * 2);
console.log(doubled); // [2, 4, 6, 8]

// Function composition
function compose(f, g) {
  return function(x) {
    return f(g(x));
  };
}

const square = x => x * x;
const double = x => x * 2;
const squareThenDouble = compose(double, square);
console.log(squareThenDouble(3)); // 18 (squares first, then doubles)

// Higher-order function example - map function
function map(array, transformFn) {
  const result = [];
  for (let i = 0; i < array.length; i++) {
    result.push(transformFn(array[i]));
  }
  return result;
}

// Using higher-order function
const numbers = [1, 2, 3, 4];
const doubled = map(numbers, x => x * 2);
console.log(doubled); // [2, 4, 6, 8]

// Function composition
function compose(f, g) {
  return function(x) {
    return f(g(x));
  };
}

const square = x => x * x;
const double = x => x * 2;
const squareThenDouble = compose(double, square);
console.log(squareThenDouble(3)); // 18 (squares first, then doubles)

Currying and Partial Application

Currying transforms a function with multiple parameters into a series of single-parameter functions, while partial application fixes some parameters to create a new function. Both techniques enhance function reusability.

// Currying example
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    } else {
      return function(...moreArgs) {
        return curried.apply(this, args.concat(moreArgs));
      };
    }
  };
}

// Original function
function sum(a, b, c) {
  return a + b + c;
}

// Curried function
const curriedSum = curry(sum);

// Creating partially applied function
const addFive = curriedSum(2, 3); // Fixes first two parameters
console.log(addFive(4)); // 9 (2 + 3 + 4)

// More flexible currying implementation
function sum(a) {
  return function(b) {
    return function(c) {
      return a + b + c;
    };
  };
}

console.log(sum(1)(2)(3)); // 6
const addOne = sum(1);
const addOneAndTwo = addOne(2);
console.log(addOneAndTwo(3)); // 6

// Currying example
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    } else {
      return function(...moreArgs) {
        return curried.apply(this, args.concat(moreArgs));
      };
    }
  };
}

// Original function
function sum(a, b, c) {
  return a + b + c;
}

// Curried function
const curriedSum = curry(sum);

// Creating partially applied function
const addFive = curriedSum(2, 3); // Fixes first two parameters
console.log(addFive(4)); // 9 (2 + 3 + 4)

// More flexible currying implementation
function sum(a) {
  return function(b) {
    return function(c) {
      return a + b + c;
    };
  };
}

console.log(sum(1)(2)(3)); // 6
const addOne = sum(1);
const addOneAndTwo = addOne(2);
console.log(addOneAndTwo(3)); // 6