Prototypes are useful if you have some shared logic among your object instances, such as
Person.prototype.getName = function () {
return this.firstname + ' ' + this.lastname
}
But for mere property assignments (like in your code) that wouldn't make much sense as such properties are usually specific to the object instances anyway -- there's no shared firstname property, say.
If however the object instantiation itself requires some further logic, a mixin might be an option; for example something like
const nameMixin = function (firstname, lastname) {
this.firstname = firstname
this.lastname = lastname
this.fullname = firstname + ' ' + lastname
}
const Person = function (firstname, lastname, age, eyeColor) {
this.age = age
this.eyeColor = eyeColor
nameMixin.call(this, firstname, lastname)
}
(This example is of course contrived as a getter for fullname would be much more appropriate here -- which would be possible from a mixin too.)
Another approach would be the use of factory functions for specific aspects of your objects:
const name = (
firstname,
lastname
) => ({
firstname,
lastname,
fullname: firstname + ' ' + lastname
})
const person = (
age,
eyeColor,
health = 100
) => ({
age,
eyeColor,
health
})
const mutant = (
looks,
power,
healingFactor = 0
) => ({
looks,
power,
healingFactor
})
Which you would then combine like
const myFather = Object.assign(
name('John', 'Doe'),
person(42, 'blue')
)
const xMen1 = Object.assign(
name('Scott', 'Summers'),
mutant('handsome', 'laser')
)
One might then abstract away the actual composition in another factory like
const createPerson = (
firstname,
lastname,
age,
eyeColor
) => Object.assign(
name(firstname, lastname),
person(age, eyeColor)
)
const createMutant = (
firstname,
lastname,
looks,
power
) => Object.assign(
name(firstname, lastname),
mutant(looks, power)
)
const myMother = createPerson(/* ... */)
const xMen2 = createMutant(/* ... */)
So as long as there are no shared methods among the object instances, there's no need for prototypical inheritance -- quite the contrary, it is often advocated to prefer composition over inheritance.
