La palabra clave nueva

Si llamas a una función con new, se crea un objeto nuevo que usa la función llamada como "constructor" para ese objeto:

function MyFunction() {}
const myObject = new MyFunction();

typeof myObject;
> "object"`

Esto permite que una "función de constructor" proporcione una plantilla para la creación de objetos que siguen el mismo patrón estructural:

function MyFunction() {
  this.myProperty = true;
}
const myObject = new MyFunction();

myObject.myProperty;
> true

El valor de this dentro de una función de constructor se refiere al objeto que se crea, lo que permite que este se propague con propiedades y métodos en el momento de la creación. Esto permite la creación de objetos que contengan valores de datos y cualquier método necesario para actuar sobre esos datos como una sola unidad portátil, un concepto llamado "encapsulamiento":

function MyFunction( myArgument ) {
    this.myValue = myArgument;
    this.doubleMyValue = () => myArgument * 2;
}
const myObject = new MyFunction( 10 );

myObject.myValue;
> 10

myObject.doubleMyValue();
> 20

this hace referencia al contexto de ejecución actual de una función, lo que significa que una función de constructor sigue las mismas reglas para el valor de this que cualquier otra función. Por ejemplo, una función destinada a ser un constructor usa la vinculación global para el valor de this cuando se invoca de forma independiente:

function MyFunction() {
    console.log( this  );
}
const myObject = new MyFunction();
> MyFunction { }

MyFunction(); // Global `this` binding outside of strict mode is `globalThis`
> Window { … }

(function() {
    "use strict";
    function MyFunction() {
            console.log( this );
    }
    MyFunction();  // Global `this` binding inside of strict mode is `undefined`
}());
> undefined

Es común usar mayúsculas en el primer carácter del identificador de una función de constructor, siguiendo el patrón de nomenclatura establecido por las funciones de fábrica integradas de JavaScript. Aunque es posible que a veces veas los términos que se usan de forma indistinta, las funciones de constructor (funciones destinadas a actuar sobre un objeto recién construido cuando se invocan con la palabra clave new) difieren de las "funciones de fábrica", que explícitamente return un objeto cuando se invocan con normalidad:

function myFunction( myArgument = false ) {
  return { "myProperty" : myArgument };
}
const myObject = myFunction( true );

myObject;
> Object { myProperty: true }

Si bien los principios subyacentes son los mismos, los casos de uso para funciones de constructor personalizadas se entregan mejor con la sintaxis Class, que tiene todas las funciones y se presenta en ES6.