JavaScript Public Method

A public method in JavaScript is a function exposed as a property on an object or class instance, making it accessible and invocable from outside the object’s internal lexical scope. By default, all methods defined within JavaScript classes, constructor functions, and object literals are public unless explicitly encapsulated using private field syntax (#) or closures.

Class Syntax (ES6+)

In modern JavaScript classes, methods defined without the # prefix are implicitly public. They are attached to the class’s prototype rather than the individual instance, optimizing memory allocation.

class DataProcessor {
  constructor(data) {
    this.data = data;
  }

  // Public method (attached to DataProcessor.prototype)
  process() {
    return this.data.map(item => item * 2);
  }
}

const processor = new DataProcessor([1, 2, 3]);
processor.process(); // Accessible externally

Constructor Functions and Prototypes (Pre-ES6)

Before the introduction of the class keyword, public methods were defined either by attaching them directly to the instance context (this) or by mutating the constructor’s prototype object.

function DataProcessor(data) {
  this.data = data;
  
  // Public method (attached directly to the instance)
  this.clear = function() {
    this.data = [];
  };
}

// Public method (attached to the prototype chain)
DataProcessor.prototype.process = function() {
  return this.data.map(item => item * 2);
};

const processor = new DataProcessor([1, 2, 3]);
processor.process(); // Resolved via prototype chain
processor.clear();   // Resolved directly on the instance

Object Literals

Methods defined within object literals are inherently public properties of that specific object.

const processor = {
  data: [1, 2, 3],
  
  // ES6 Method Shorthand
  process() {
    return this.data.map(item => item * 2);
  },
  
  // Standard property-function syntax
  clear: function() {
    this.data = [];
  }
};

processor.process();

Technical Characteristics

Invocation and Context: Public methods are invoked using property accessors (dot . or bracket [] notation). During invocation, the execution context (this) is dynamically bound to the object preceding the dot, unless the method is an arrow function (which retains its lexical this) or the context is explicitly overridden using .bind(), .call(), or .apply().
Enumerability:
- Public methods defined via ES6 class syntax are non-enumerable by default. They will not appear in for...in loops or Object.keys().
- Public methods attached directly to this in a constructor or defined in an object literal are enumerable by default.
Mutability: Unless the object or its prototype is explicitly frozen (Object.freeze()), public methods can be overwritten, deleted, or monkey-patched at runtime by external scripts.