# Factory Function in JavaScript

In JavaScript, factory functions provide an alternative way to create objects and are commonly used as a pattern for object creation. A factory function is a function that returns an object when invoked. It encapsulates the object creation process and allows for customization and configuration of the created objects. Here's an explanation of factory functions with an example:

```javascript
function createPerson(name, age) {
  // Create a new object
  const person = {};

  // Set properties
  person.name = name;
  person.age = age;

  // Define methods
  person.sayHello = function() {
    console.log(`Hello, my name is ${this.name}.`);
  };

  person.getAge = function() {
    return this.age;
  };

  // Return the object
  return person;
}

// Create instances using the factory function
const john = createPerson("John", 30);
const jane = createPerson("Jane", 25);

// Access properties and call methods
console.log(john.name); // Output: John
john.sayHello(); // Output: Hello, my name is John.
console.log(jane.getAge()); // Output: 25
```

In this example, we have a `createPerson` factory function that accepts `name` and `age` as parameters.

Inside the function:

* We create an empty `person` object using an empty object literal (`{}`).
    
* We set the `name` and `age` properties of the `person` object.
    
* We define methods (`sayHello` and `getAge`) on the `person` object, which can access the object's properties using the `this` keyword.
    

Finally, we return the `person` object from the factory function.

To create instances using the factory function, we invoke the `createPerson` function and assign the returned object to variables (`john` and `jane`).

We can then access the properties (`name`) and call the methods (`sayHello`, `getAge`) on the created objects using the dot notation.

The benefit of using factory functions is that they provide encapsulation and allow for object customization during creation. Each invocation of the factory function creates a new object with its own properties and methods. This pattern is flexible and allows for dynamic object creation and configuration.

Factory functions are an alternative to using classes in JavaScript and are often used in functional programming and object composition scenarios.