Create new type javascript

A bold request!

In JavaScript, we can create a new type by defining a constructor function and using the prototype property to add methods and properties to the new type. Here's an example of how to create a new type called Person:

// Define the constructor function
function Person(name, age) {
  this.name = name;
  this.age = age;
}

// Add methods and properties to the prototype
Person.prototype.sayHello = function() {
  console.log(`Hello, my name is ${this.name} and I'm ${this.age} years old.`);
};

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

// Create an instance of the new type
const person = new Person('John', 30);

// Use the new type
person.sayHello(); // Output: Hello, my name is John and I'm 30 years old.
console.log(person.getAge()); // Output: 30

In this example, we define a constructor function Person that takes two arguments, name and age. We then add two methods, sayHello and getAge, to the prototype property of the Person constructor function. These methods can be called on instances of the Person type.

Note that in JavaScript, we don't need to explicitly declare the type of a variable. Instead, we can assign an object to a variable and then use the instanceof operator to check if the variable is an instance of a particular type:

const person = new Person('John', 30);
console.log(person instanceof Person); // Output: true

This is because the instanceof operator checks if the object is an instance of the constructor function that was used to create it.

You can also use the Object.create() method to create a new type that inherits from an existing type:

function Employee(name, age, department) {
  Person.call(this, name, age);
  this.department = department;
}

Employee.prototype = Object.create(Person.prototype);
Employee.prototype.constructor = Employee;

const employee = new Employee('Jane', 25, 'Sales');
employee.sayHello(); // Output: Hello, my name is Jane and I'm 25 years old.
console.log(employee.getAge()); // Output: 25
console.log(employee.department); // Output: Sales

In this example, we define a new type Employee that inherits from the Person type using the Object.create() method. We then add a new property department to the Employee type.