Classes & Inheritance

1// Traditional constructor function
2function PersonOld(name, age) {
3    this.name = name;
4    this.age = age;
5}
6
7PersonOld.prototype.greet = function() {
8    return `Hello, I'm ${this.name}`;
9};
10
11PersonOld.prototype.getAge = function() {
12    return this.age;
13};
14
15// ES6 Class syntax
16class Person {
17    constructor(name, age) {
18        this.name = name;
19        this.age = age;
20    }
21    
22    greet() {
23        return `Hello, I'm ${this.name}`;
24    }
25    
26    getAge() {
27        return this.age;
28    }
29    
30    // Getter method
31    get displayName() {
32        return `${this.name} (Age: ${this.age})`;
33    }
34    
35    // Setter method
36    set age(value) {
37        if (value < 0) {
38            throw new Error('Age cannot be negative');
39        }
40        this._age = value;
41    }
42    
43    get age() {
44        return this._age;
45    }
46    
47    // Static method
48    static createAdult(name) {
49        return new Person(name, 18);
50    }
51}
52
53// Usage
54const person = new Person('Alice', 30);
55console.log(person.greet()); // "Hello, I'm Alice"
56console.log(person.displayName); // "Alice (Age: 30)"
57
58const adult = Person.createAdult('Bob');
59console.log(adult.getAge()); // 18

1class BankAccount {
2    constructor(accountNumber, initialBalance = 0, accountType = 'savings') {
3        // Public properties
4        this.accountNumber = accountNumber;
5        this.accountType = accountType;
6        this.createdAt = new Date();
7        
8        // Private-like properties (convention)
9        this._balance = initialBalance;
10        this._transactions = [];
11        
12        // Validation
13        this._validateAccountNumber(accountNumber);
14        this._validateBalance(initialBalance);
15    }
16    
17    // Private methods (convention with underscore)
18    _validateAccountNumber(number) {
19        if (!number || typeof number !== 'string') {
20            throw new Error('Valid account number is required');
21        }
22    }
23    
24    _validateBalance(balance) {
25        if (balance < 0) {
26            throw new Error('Initial balance cannot be negative');
27        }
28    }
29    
30    _addTransaction(type, amount, description) {
31        this._transactions.push({
32            type,
33            amount,
34            description,
35            timestamp: new Date(),
36            balance: this._balance
37        });
38    }
39    
40    // Public methods
41    deposit(amount) {
42        if (amount <= 0) {
43            throw new Error('Deposit amount must be positive');
44        }
45        
46        this._balance += amount;
47        this._addTransaction('deposit', amount, `Deposit of $${amount}`);
48        return this._balance;
49    }
50    
51    withdraw(amount) {
52        if (amount <= 0) {
53            throw new Error('Withdrawal amount must be positive');
54        }
55        
56        if (amount > this._balance) {
57            throw new Error('Insufficient funds');
58        }
59        
60        this._balance -= amount;
61        this._addTransaction('withdrawal', -amount, `Withdrawal of $${amount}`);
62        return this._balance;
63    }
64    
65    // Getter for balance
66    get balance() {
67        return this._balance;
68    }
69    
70    // Getter for transaction history
71    get transactionHistory() {
72        return [...this._transactions]; // Return copy
73    }
74    
75    // Method to get account summary
76    getAccountSummary() {
77        return {
78            accountNumber: this.accountNumber,
79            accountType: this.accountType,
80            balance: this._balance,
81            transactionCount: this._transactions.length,
82            createdAt: this.createdAt
83        };
84    }
85    
86    // Static method to validate account number format
87    static isValidAccountNumber(number) {
88        return /^\d{10,12}$/.test(number);
89    }
90}
91
92// Usage
93const account = new BankAccount('1234567890', 1000);
94account.deposit(500);
95account.withdraw(200);
96console.log(account.balance); // 1300
97console.log(account.getAccountSummary());

1// Named class expression
2const User = class UserClass {
3    constructor(name) {
4        this.name = name;
5    }
6    
7    toString() {
8        return `User: ${this.name}`;
9    }
10};
11
12// Anonymous class expression
13const createModelClass = (modelName) => {
14    return class {
15        constructor(data) {
16            this.modelName = modelName;
17            this.data = data;
18            this.id = Math.random().toString(36).substr(2, 9);
19        }
20        
21        save() {
22            console.log(`Saving ${this.modelName} with ID: ${this.id}`);
23            return this;
24        }
25        
26        static find(id) {
27            console.log(`Finding ${modelName} with ID: ${id}`);
28            return new this({ id });
29        }
30    };
31};
32
33// Dynamic class creation
34const Product = createModelClass('Product');
35const Category = createModelClass('Category');
36
37const product = new Product({ name: 'Laptop', price: 999 });
38product.save();

1// Base class
2class Animal {
3    constructor(name, species) {
4        this.name = name;
5        this.species = species;
6        this.isAlive = true;
7    }
8    
9    speak() {
10        return `${this.name} makes a sound`;
11    }
12    
13    move() {
14        return `${this.name} moves`;
15    }
16    
17    getInfo() {
18        return {
19            name: this.name,
20            species: this.species,
21            isAlive: this.isAlive
22        };
23    }
24    
25    static getKingdom() {
26        return 'Animalia';
27    }
28}
29
30// Derived class
31class Dog extends Animal {
32    constructor(name, breed) {
33        super(name, 'Canine'); // Call parent constructor
34        this.breed = breed;
35        this.tricks = [];
36    }
37    
38    // Override parent method
39    speak() {
40        return `${super.speak()} - Woof!`;
41    }
42    
43    // Override parent method
44    move() {
45        return `${super.move()} by running on four legs`;
46    }
47    
48    // New methods specific to Dog
49    learnTrick(trick) {
50        this.tricks.push(trick);
51        return `${this.name} learned to ${trick}!`;
52    }
53    
54    performTrick(trick) {
55        if (this.tricks.includes(trick)) {
56            return `${this.name} performs ${trick}!`;
57        }
58        return `${this.name} doesn't know how to ${trick}`;
59    }
60    
61    // Override getInfo to include breed
62    getInfo() {
63        return {
64            ...super.getInfo(),
65            breed: this.breed,
66            tricks: [...this.tricks]
67        };
68    }
69}
70
71// Further inheritance
72class ServiceDog extends Dog {
73    constructor(name, breed, serviceType) {
74        super(name, breed);
75        this.serviceType = serviceType;
76        this.isWorking = false;
77        this.certifications = [];
78    }
79    
80    startWork() {
81        this.isWorking = true;
82        return `${this.name} is now working as a ${this.serviceType} dog`;
83    }
84    
85    stopWork() {
86        this.isWorking = false;
87        return `${this.name} is off duty`;
88    }
89    
90    addCertification(cert) {
91        this.certifications.push({
92            name: cert,
93            dateEarned: new Date()
94        });
95        return `${this.name} earned ${cert} certification`;
96    }
97    
98    getInfo() {
99        return {
100            ...super.getInfo(),
101            serviceType: this.serviceType,
102            isWorking: this.isWorking,
103            certifications: [...this.certifications]
104        };
105    }
106}
107
108// Usage
109const buddy = new ServiceDog('Buddy', 'Golden Retriever', 'Guide');
110console.log(buddy.speak()); // "Buddy makes a sound - Woof!"
111console.log(buddy.learnTrick('sit'));
112console.log(buddy.addCertification('Guide Dog Training'));
113console.log(buddy.startWork());
114console.log(buddy.getInfo());

1class QueryBuilder {
2    constructor() {
3        this.query = {
4            select: [],
5            from: '',
6            where: [],
7            orderBy: [],
8            limit: null
9        };
10    }
11    
12    select(...fields) {
13        this.query.select.push(...fields);
14        return this; // Return this for chaining
15    }
16    
17    from(table) {
18        this.query.from = table;
19        return this;
20    }
21    
22    where(condition) {
23        this.query.where.push(condition);
24        return this;
25    }
26    
27    orderBy(field, direction = 'ASC') {
28        this.query.orderBy.push(`${field} ${direction}`);
29        return this;
30    }
31    
32    limit(count) {
33        this.query.limit = count;
34        return this;
35    }
36    
37    build() {
38        const parts = [];
39        
40        if (this.query.select.length > 0) {
41            parts.push(`SELECT ${this.query.select.join(', ')}`);
42        }
43        
44        if (this.query.from) {
45            parts.push(`FROM ${this.query.from}`);
46        }
47        
48        if (this.query.where.length > 0) {
49            parts.push(`WHERE ${this.query.where.join(' AND ')}`);
50        }
51        
52        if (this.query.orderBy.length > 0) {
53            parts.push(`ORDER BY ${this.query.orderBy.join(', ')}`);
54        }
55        
56        if (this.query.limit) {
57            parts.push(`LIMIT ${this.query.limit}`);
58        }
59        
60        return parts.join(' ');
61    }
62    
63    clone() {
64        const cloned = new QueryBuilder();
65        cloned.query = JSON.parse(JSON.stringify(this.query));
66        return cloned;
67    }
68}
69
70// Extended query builder
71class AdvancedQueryBuilder extends QueryBuilder {
72    constructor() {
73        super();
74        this.query.joins = [];
75        this.query.groupBy = [];
76        this.query.having = [];
77    }
78    
79    join(table, condition, type = 'INNER') {
80        this.query.joins.push(`${type} JOIN ${table} ON ${condition}`);
81        return this;
82    }
83    
84    leftJoin(table, condition) {
85        return this.join(table, condition, 'LEFT');
86    }
87    
88    groupBy(...fields) {
89        this.query.groupBy.push(...fields);
90        return this;
91    }
92    
93    having(condition) {
94        this.query.having.push(condition);
95        return this;
96    }
97    
98    build() {
99        let sql = super.build();
100        
101        if (this.query.joins.length > 0) {
102            const parts = sql.split(' WHERE ');
103            const beforeWhere = parts[0];
104            const afterWhere = parts[1] || '';
105            
106            sql = beforeWhere + ' ' + this.query.joins.join(' ');
107            if (afterWhere) {
108                sql += ' WHERE ' + afterWhere;
109            }
110        }
111        
112        if (this.query.groupBy.length > 0) {
113            sql += ` GROUP BY ${this.query.groupBy.join(', ')}`;
114        }
115        
116        if (this.query.having.length > 0) {
117            sql += ` HAVING ${this.query.having.join(' AND ')}`;
118        }
119        
120        return sql;
121    }
122}
123
124// Usage
125const query = new AdvancedQueryBuilder()
126    .select('u.name', 'u.email', 'COUNT(o.id) as order_count')
127    .from('users u')
128    .leftJoin('orders o', 'o.user_id = u.id')
129    .where('u.active = 1')
130    .groupBy('u.id')
131    .having('COUNT(o.id) > 0')
132    .orderBy('order_count', 'DESC')
133    .limit(10)
134    .build();
135
136console.log(query);

1class MathUtils {
2    // Static properties
3    static PI = 3.14159;
4    static E = 2.71828;
5    
6    // Static methods
7    static add(a, b) {
8        return a + b;
9    }
10    
11    static multiply(a, b) {
12        return a * b;
13    }
14    
15    static factorial(n) {
16        if (n <= 1) return 1;
17        return n * MathUtils.factorial(n - 1);
18    }
19    
20    static randomInRange(min, max) {
21        return Math.random() * (max - min) + min;
22    }
23    
24    // Static method with validation
25    static distance(point1, point2) {
26        if (!point1 || !point2) {
27            throw new Error('Both points are required');
28        }
29        
30        const dx = point2.x - point1.x;
31        const dy = point2.y - point1.y;
32        return Math.sqrt(dx * dx + dy * dy);
33    }
34    
35    // Static factory method
36    static createCircle(radius) {
37        return {
38            radius,
39            area: MathUtils.PI * radius * radius,
40            circumference: 2 * MathUtils.PI * radius
41        };
42    }
43}
44
45// Usage - no need to instantiate
46console.log(MathUtils.add(5, 3)); // 8
47console.log(MathUtils.factorial(5)); // 120
48console.log(MathUtils.distance({x: 0, y: 0}, {x: 3, y: 4})); // 5
49
50const circle = MathUtils.createCircle(10);
51console.log(circle); // { radius: 10, area: 314.159, circumference: 62.832 }

1class BankAccountSecure {
2    // Private fields
3    #balance;
4    #accountNumber;
5    #transactions;
6    
7    // Private static field
8    static #bankCode = 'BANK001';
9    
10    constructor(accountNumber, initialBalance = 0) {
11        this.#accountNumber = accountNumber;
12        this.#balance = initialBalance;
13        this.#transactions = [];
14        this.accountType = 'checking'; // Public field
15        this.createdAt = new Date();
16    }
17    
18    // Private method
19    #validateAmount(amount) {
20        if (typeof amount !== 'number' || amount <= 0) {
21            throw new Error('Amount must be a positive number');
22        }
23    }
24    
25    #recordTransaction(type, amount, description) {
26        this.#transactions.push({
27            id: Math.random().toString(36).substr(2, 9),
28            type,
29            amount,
30            description,
31            timestamp: new Date(),
32            balanceAfter: this.#balance
33        });
34    }
35    
36    // Public methods
37    deposit(amount) {
38        this.#validateAmount(amount);
39        this.#balance += amount;
40        this.#recordTransaction('deposit', amount, `Deposit of $${amount}`);
41        return this.#balance;
42    }
43    
44    withdraw(amount) {
45        this.#validateAmount(amount);
46        
47        if (amount > this.#balance) {
48            throw new Error('Insufficient funds');
49        }
50        
51        this.#balance -= amount;
52        this.#recordTransaction('withdrawal', -amount, `Withdrawal of $${amount}`);
53        return this.#balance;
54    }
55    
56    // Getter for balance (read-only access to private field)
57    get balance() {
58        return this.#balance;
59    }
60    
61    // Getter for account number (read-only)
62    get accountNumber() {
63        return this.#accountNumber;
64    }
65    
66    // Get transaction history (returns copy)
67    getTransactionHistory(limit = 10) {
68        return this.#transactions
69            .slice(-limit)
70            .map(transaction => ({ ...transaction }));
71    }
72    
73    // Static method using private static field
74    static getBankCode() {
75        return BankAccountSecure.#bankCode;
76    }
77    
78    // Static method to create account with validation
79    static createAccount(accountNumber, initialDeposit = 0) {
80        if (!BankAccountSecure.isValidAccountNumber(accountNumber)) {
81            throw new Error('Invalid account number format');
82        }
83        
84        return new BankAccountSecure(accountNumber, initialDeposit);
85    }
86    
87    static isValidAccountNumber(number) {
88        return /^\d{10,12}$/.test(number);
89    }
90}
91
92// Usage
93const account = BankAccountSecure.createAccount('1234567890', 1000);
94console.log(account.balance); // 1000
95account.deposit(500);
96
97// These would throw errors (private fields not accessible):
98// console.log(account.#balance); // SyntaxError
99// account.#recordTransaction('fake', 100); // SyntaxError
100
101console.log(account.getTransactionHistory());
102console.log(BankAccountSecure.getBankCode());

1// Mixin factory function
2const Timestamped = (Base) => class extends Base {
3    constructor(...args) {
4        super(...args);
5        this.createdAt = new Date();
6        this.updatedAt = new Date();
7    }
8    
9    touch() {
10        this.updatedAt = new Date();
11        return this;
12    }
13    
14    getAge() {
15        return Date.now() - this.createdAt.getTime();
16    }
17};
18
19// Another mixin
20const Identifiable = (Base) => class extends Base {
21    constructor(...args) {
22        super(...args);
23        this.id = Math.random().toString(36).substr(2, 9);
24    }
25    
26    equals(other) {
27        return this.id === other?.id;
28    }
29    
30    toString() {
31        return `${this.constructor.name}(${this.id})`;
32    }
33};
34
35// Validation mixin
36const Validatable = (Base) => class extends Base {
37    constructor(...args) {
38        super(...args);
39        this.errors = [];
40    }
41    
42    validate() {
43        this.errors = [];
44        this._runValidations();
45        return this.errors.length === 0;
46    }
47    
48    _runValidations() {
49        // Override in subclasses
50    }
51    
52    addError(field, message) {
53        this.errors.push({ field, message });
54    }
55    
56    isValid() {
57        return this.validate();
58    }
59    
60    getErrors() {
61        return [...this.errors];
62    }
63};
64
65// Base class
66class User {
67    constructor(name, email) {
68        this.name = name;
69        this.email = email;
70    }
71    
72    greet() {
73        return `Hello, I'm ${this.name}`;
74    }
75}
76
77// Apply multiple mixins
78class EnhancedUser extends Validatable(Timestamped(Identifiable(User))) {
79    constructor(name, email) {
80        super(name, email);
81    }
82    
83    _runValidations() {
84        if (!this.name || this.name.length < 2) {
85            this.addError('name', 'Name must be at least 2 characters');
86        }
87        
88        if (!this.email || !this.email.includes('@')) {
89            this.addError('email', 'Valid email is required');
90        }
91    }
92    
93    updateProfile(name, email) {
94        this.name = name;
95        this.email = email;
96        this.touch();
97        return this;
98    }
99}
100
101// Usage
102const user = new EnhancedUser('Alice Johnson', '[email protected]');
103console.log(user.toString()); // EnhancedUser(randomId)
104console.log(user.isValid()); // true
105console.log(user.getAge()); // milliseconds since creation
106
107user.updateProfile('Alice Smith', '[email protected]');
108console.log(user.updatedAt); // Updated timestamp

1// Abstract base class pattern
2class Shape {
3    constructor(name) {
4        if (new.target === Shape) {
5            throw new Error('Shape is abstract and cannot be instantiated directly');
6        }
7        this.name = name;
8    }
9    
10    // Abstract methods (must be overridden)
11    getArea() {
12        throw new Error('getArea() must be implemented by subclass');
13    }
14    
15    getPerimeter() {
16        throw new Error('getPerimeter() must be implemented by subclass');
17    }
18    
19    // Concrete method
20    describe() {
21        return `${this.name}: Area = ${this.getArea()}, Perimeter = ${this.getPerimeter()}`;
22    }
23    
24    // Template method pattern
25    draw() {
26        this.setupDrawing();
27        this.renderShape();
28        this.finishDrawing();
29    }
30    
31    setupDrawing() {
32        console.log(`Setting up to draw ${this.name}`);
33    }
34    
35    renderShape() {
36        throw new Error('renderShape() must be implemented by subclass');
37    }
38    
39    finishDrawing() {
40        console.log(`Finished drawing ${this.name}`);
41    }
42    
43    static isShape(obj) {
44        return obj instanceof Shape;
45    }
46}
47
48class Rectangle extends Shape {
49    constructor(width, height) {
50        super('Rectangle');
51        this.width = width;
52        this.height = height;
53    }
54    
55    getArea() {
56        return this.width * this.height;
57    }
58    
59    getPerimeter() {
60        return 2 * (this.width + this.height);
61    }
62    
63    renderShape() {
64        console.log(`Rendering rectangle: ${this.width} x ${this.height}`);
65    }
66}
67
68class Circle extends Shape {
69    constructor(radius) {
70        super('Circle');
71        this.radius = radius;
72    }
73    
74    getArea() {
75        return Math.PI * this.radius * this.radius;
76    }
77    
78    getPerimeter() {
79        return 2 * Math.PI * this.radius;
80    }
81    
82    renderShape() {
83        console.log(`Rendering circle with radius: ${this.radius}`);
84    }
85}
86
87// Usage
88const rectangle = new Rectangle(5, 3);
89const circle = new Circle(4);
90
91console.log(rectangle.describe());
92console.log(circle.describe());
93
94rectangle.draw();
95circle.draw();
96
97// This would throw an error:
98// const shape = new Shape('Generic'); // Error: Shape is abstract

1// Factory base class
2class DatabaseConnection {
3    constructor(config) {
4        this.config = config;
5        this.isConnected = false;
6    }
7    
8    connect() {
9        throw new Error('connect() must be implemented by subclass');
10    }
11    
12    disconnect() {
13        throw new Error('disconnect() must be implemented by subclass');
14    }
15    
16    query(sql) {
17        throw new Error('query() must be implemented by subclass');
18    }
19}
20
21class MySQLConnection extends DatabaseConnection {
22    constructor(config) {
23        super(config);
24        this.type = 'MySQL';
25    }
26    
27    connect() {
28        console.log(`Connecting to MySQL: ${this.config.host}:${this.config.port}`);
29        this.isConnected = true;
30        return this;
31    }
32    
33    disconnect() {
34        console.log('Disconnecting from MySQL');
35        this.isConnected = false;
36        return this;
37    }
38    
39    query(sql) {
40        if (!this.isConnected) {
41            throw new Error('Not connected to MySQL database');
42        }
43        return `MySQL Query: ${sql}`;
44    }
45}
46
47class PostgreSQLConnection extends DatabaseConnection {
48    constructor(config) {
49        super(config);
50        this.type = 'PostgreSQL';
51    }
52    
53    connect() {
54        console.log(`Connecting to PostgreSQL: ${this.config.host}:${this.config.port}`);
55        this.isConnected = true;
56        return this;
57    }
58    
59    disconnect() {
60        console.log('Disconnecting from PostgreSQL');
61        this.isConnected = false;
62        return this;
63    }
64    
65    query(sql) {
66        if (!this.isConnected) {
67            throw new Error('Not connected to PostgreSQL database');
68        }
69        return `PostgreSQL Query: ${sql}`;
70    }
71}
72
73// Factory class
74class DatabaseFactory {
75    static connectionTypes = {
76        mysql: MySQLConnection,
77        postgresql: PostgreSQLConnection
78    };
79    
80    static createConnection(type, config) {
81        const ConnectionClass = DatabaseFactory.connectionTypes[type.toLowerCase()];
82        
83        if (!ConnectionClass) {
84            throw new Error(`Unsupported database type: ${type}`);
85        }
86        
87        return new ConnectionClass(config);
88    }
89    
90    static registerConnectionType(type, ConnectionClass) {
91        if (!(ConnectionClass.prototype instanceof DatabaseConnection)) {
92            throw new Error('Connection class must extend DatabaseConnection');
93        }
94        
95        DatabaseFactory.connectionTypes[type.toLowerCase()] = ConnectionClass;
96    }
97    
98    static getSupportedTypes() {
99        return Object.keys(DatabaseFactory.connectionTypes);
100    }
101}
102
103// Usage
104const mysqlConfig = { host: 'localhost', port: 3306, database: 'myapp' };
105const pgConfig = { host: 'localhost', port: 5432, database: 'myapp' };
106
107const mysqlConn = DatabaseFactory.createConnection('mysql', mysqlConfig);
108const pgConn = DatabaseFactory.createConnection('postgresql', pgConfig);
109
110mysqlConn.connect();
111console.log(mysqlConn.query('SELECT * FROM users'));
112
113pgConn.connect();
114console.log(pgConn.query('SELECT * FROM products'));

1// Observer pattern implementation
2class EventEmitter {
3    constructor() {
4        this._events = {};
5    }
6    
7    on(event, listener) {
8        if (!this._events[event]) {
9            this._events[event] = [];
10        }
11        this._events[event].push(listener);
12        return this;
13    }
14    
15    off(event, listenerToRemove) {
16        if (!this._events[event]) return this;
17        
18        this._events[event] = this._events[event].filter(
19            listener => listener !== listenerToRemove
20        );
21        return this;
22    }
23    
24    emit(event, data) {
25        if (!this._events[event]) return this;
26        
27        this._events[event].forEach(listener => {
28            try {
29                listener(data);
30            } catch (error) {
31                console.error('Event listener error:', error);
32            }
33        });
34        return this;
35    }
36    
37    once(event, listener) {
38        const onceListener = (data) => {
39            this.off(event, onceListener);
40            listener(data);
41        };
42        return this.on(event, onceListener);
43    }
44}
45
46// Observable model class
47class Model extends EventEmitter {
48    constructor(data = {}) {
49        super();
50        this._data = { ...data };
51        this._changes = {};
52    }
53    
54    get(key) {
55        return this._data[key];
56    }
57    
58    set(key, value) {
59        const oldValue = this._data[key];
60        this._data[key] = value;
61        
62        this._changes[key] = { oldValue, newValue: value };
63        
64        this.emit('change', { key, oldValue, newValue: value });
65        this.emit(`change:${key}`, { oldValue, newValue: value });
66        
67        return this;
68    }
69    
70    update(updates) {
71        Object.entries(updates).forEach(([key, value]) => {
72            this.set(key, value);
73        });
74        return this;
75    }
76    
77    toJSON() {
78        return { ...this._data };
79    }
80    
81    getChanges() {
82        return { ...this._changes };
83    }
84    
85    clearChanges() {
86        this._changes = {};
87        return this;
88    }
89}
90
91// User model with validation
92class User extends Model {
93    constructor(data) {
94        super(data);
95        this.on('change', this._validate.bind(this));
96    }
97    
98    _validate() {
99        const errors = [];
100        
101        if (!this.get('name') || this.get('name').length < 2) {
102            errors.push('Name must be at least 2 characters');
103        }
104        
105        if (!this.get('email') || !this.get('email').includes('@')) {
106            errors.push('Valid email is required');
107        }
108        
109        if (errors.length > 0) {
110            this.emit('validation:error', errors);
111        } else {
112            this.emit('validation:success');
113        }
114    }
115    
116    save() {
117        return new Promise((resolve, reject) => {
118            const errors = this._getValidationErrors();
119            if (errors.length > 0) {
120                reject(new Error(`Validation failed: ${errors.join(', ')}`));
121                return;
122            }
123            
124            // Simulate API save
125            setTimeout(() => {
126                this.set('id', Math.random().toString(36).substr(2, 9));
127                this.emit('saved', this.toJSON());
128                this.clearChanges();
129                resolve(this);
130            }, 100);
131        });
132    }
133    
134    _getValidationErrors() {
135        const errors = [];
136        
137        if (!this.get('name') || this.get('name').length < 2) {
138            errors.push('Name must be at least 2 characters');
139        }
140        
141        if (!this.get('email') || !this.get('email').includes('@')) {
142            errors.push('Valid email is required');
143        }
144        
145        return errors;
146    }
147}
148
149// Usage
150const user = new User({ name: 'Alice', email: '[email protected]' });
151
152user.on('change', (data) => {
153    console.log(`Property changed: ${data.key} = ${data.newValue}`);
154});
155
156user.on('validation:error', (errors) => {
157    console.log('Validation errors:', errors);
158});
159
160user.on('saved', (data) => {
161    console.log('User saved:', data);
162});
163
164user.set('name', 'Alice Johnson');
165user.update({ email: '[email protected]', age: 30 });
166
167user.save().then(() => {
168    console.log('Save successful');
169}).catch(error => {
170    console.error('Save failed:', error.message);
171});