Mastering Aspect-Oriented Programming in JavaScript: A Practical Guide

Aspect‑Oriented Programming (AOP) lets you inject additional behavior into existing functions or objects without modifying their core logic, making it easy to add cross‑cutting concerns like logging, debugging metadata, or other auxiliary actions.

AOP Overview

AOP provides a way to add code to target functions or objects without changing the original implementation. The injected code, called an aspect, can handle concerns such as logging or metadata collection.

For example, instead of manually adding logging statements to each method, you can define a logging aspect and apply it to all methods with a single line of code.

Aspect, Advice, and Pointcut

Aspect (what) : The behavior you want to inject, represented as a function in JavaScript.

Advice (when) : Specifies when the aspect runs (e.g., before, after, around, whenThrowing).

Pointcut (where) : Defines the locations in the target code where the aspect should be applied, such as all methods, a specific method, or methods matching a pattern like get_*.

With these concepts, you can create an AOP library that replaces target methods with custom wrappers that invoke the aspect at the appropriate times.

Basic Implementation

The following example demonstrates a minimal AOP implementation.

/** Helper to get all methods of an object */
const getMethods = (obj) =>
  Object.getOwnPropertyNames(Object.getPrototypeOf(obj))
    .filter(item => typeof obj[item] === 'function');

/** Replace the original method with a wrapper that calls the aspect according to the advice */
function replaceMethod(target, methodName, aspect, advice) {
  const originalCode = target[methodName];
  target[methodName] = (...args) => {
    if (["before", "around"].includes(advice)) {
      aspect.apply(target, args);
    }
    const returnedValue = originalCode.apply(target, args);
    if (["after", "around"].includes(advice)) {
      aspect.apply(target, args);
    }
    if ("afterReturning" == advice) {
      return aspect.apply(target, [returnedValue]);
    } else {
      return returnedValue;
    }
  };
}

module.exports = {
  // Main method: inject an aspect into the target at the specified time and location
  inject: function(target, aspect, advice, pointcut, method = null) {
    if (pointcut == "method") {
      if (method != null) {
        replaceMethod(target, method, aspect, advice);
      } else {
        throw new Error("Trying to add an aspect to a method, but no method specified");
      }
    }
    if (pointcut == "methods") {
      const methods = getMethods(target);
      methods.forEach(m => {
        replaceMethod(target, m, aspect, advice);
      });
    }
  }
};

The replaceMethod function is the core of the magic: it creates a new wrapper, decides when to invoke the aspect, and handles the return value.

Usage example:

const AOP = require("./aop.js");

class MyBusinessLogic {
  add(a, b) { console.log("Calling add"); return a + b; }
  concat(a, b) { console.log("Calling concat"); return a + b; }
  power(a, b) { console.log("Calling power"); return a ** b; }
}

const o = new MyBusinessLogic();

function loggingAspect(...args) {
  console.log("== Calling the logger function ==");
  console.log("Arguments received: " + args);
}

function printTypeOfReturnedValueAspect(value) {
  console.log("Returned type: " + typeof value);
}

AOP.inject(o, loggingAspect, "before", "methods");
AOP.inject(o, printTypeOfReturnedValueAspect, "afterReturning", "methods");

o.add(2, 2);
o.concat("hello", "goodbye");
o.power(2, 3);

Advantages of AOP

Encapsulates cross‑cutting concerns : Improves readability and maintainability by centralizing reusable code.

Flexible logic : Advice and pointcut mechanisms let you dynamically enable or disable aspects.

Reusable across projects : As independent components, aspects can be shared between different codebases.

Main Drawbacks

Critics argue that AOP can obscure program flow and increase complexity, potentially causing side effects if misused. Without a solid understanding of good programming practices, AOP may lead to tangled code.

With great power comes great responsibility.

When applied correctly, AOP is a powerful tool for modularizing and decoupling logic, especially in JavaScript where its dynamic nature makes implementation straightforward.

Have you tried AOP before? Share your experiences in the comments!