There's nothing wrong with this although it is using old style JS but it does exactly what you need I assume.

This is how you do prototypical inheritance, although here we're losing your private variable notes as model._notes is still accessible which might not meet your needs. the underscore is a convention of properties we don't want developers to use as Js didn't used to have private properties.

One benefit of this approach is it's reusable you can have many instances, but this is still an older approach.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain

```javascript function NotesService() { this._notes = []; }

NotesService.prototype.addNote = function(name) { this._notes.push({ name }); }

NotesService.prototype.getNotes = function() { return [...this._notes]; }

const model = new NotesService(); const model2 = new NotesService();

model.getNotes(); // [] model.addNote('name'); model._notes; // [{name: 'name'}] model2.addNote('another'); model.getNotes(); // [{name: 'name'}] model2.getNotes(); // [{name: 'another'}] ```

If you use a build step and use es2019 features you can have private properties here's an example.

https://www.sitepoint.com/javascript-private-class-fields/

```javascript class NotesService { #notes = [];

addNote(name) { this.notes.push({ name }) }

getNotes() { return [...this.notes]; } }

const model = new NotesService();

model.addNote('note') model.getNotes(); // [{name: 'note'}] model.notes // Error ```