Что есть у класса чего нет у переменной?

Различия между классом и переменной в JavaScript

Главные отличия

Класс и переменная — это фундаментально разные сущности. У класса есть особенности, которых нет у обычной переменной:

1. Методы (Methods)

У класса есть методы — функции, которые описывают поведение объекта.

// Переменная - просто значение
const age = 25;
age.sayHello();  // ОШИБКА! У числа нет методов sayHello

// Класс - описывает сущность с поведением
class Person {
  constructor(name) {
    this.name = name;
  }

  sayHello() {  // МЕТОД - поведение
    console.log(`Hello, I'm ${this.name}`);
  }
}

const person = new Person('John');
person.sayHello();  // Работает! Вывод: Hello, I'm John

2. Состояние (Properties)

У класса есть свойства (state), которые хранят информацию об объекте.

// Переменная - хранит один простой тип
const name = 'John';  // Только строка

// Класс - может хранить множество свойств
class User {
  constructor(name, email, age) {
    this.name = name;    // Свойство 1
    this.email = email;  // Свойство 2
    this.age = age;      // Свойство 3
  }
}

const user = new User('John', 'john@mail.com', 25);
console.log(user.name);   // John
console.log(user.email);  // john@mail.com
console.log(user.age);    // 25

3. Инкапсуляция (Encapsulation)

У класса может быть приватные данные, которые скрыты от внешнего доступа.

// Переменная полностью доступна
let account = 100;  // Любой может изменить
account = -999;     // Можно установить отрицательное значение

// Класс может контролировать доступ
class BankAccount {
  #balance = 0;  // ПРИВАТНОЕ свойство (# символ)

  deposit(amount) {  // ПУБЛИЧНЫЙ метод
    if (amount > 0) {
      this.#balance += amount;
    }
  }

  withdraw(amount) {  // ПУБЛИЧНЫЙ метод
    if (amount > 0 && amount <= this.#balance) {
      this.#balance -= amount;
    }
  }

  getBalance() {  // ПУБЛИЧНЫЙ метод для доступа
    return this.#balance;
  }
}

const account = new BankAccount();
account.deposit(100);
account.#balance = -999;  // ОШИБКА! Не могу обратиться к приватному свойству

4. Наследование (Inheritance)

Класс может наследовать свойства и методы от другого класса.

// Переменная не может наследовать
const animal = 'dog';  // Просто строка

// Класс может наследовать
class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a sound`);
  }
}

class Dog extends Animal {  // НАСЛЕДОВАНИЕ
  bark() {
    console.log(`${this.name} barks: Woof!`);
  }
}

const dog = new Dog('Buddy');
dog.speak();  // Buddy makes a sound (унаследовано)
dog.bark();   // Buddy barks: Woof! (свой метод)

5. Полиморфизм (Polymorphism)

Класс может переопределять методы родительского класса.

// Переменная не может переопределяться
const value = 10;

// Класс может переопределять методы
class Animal {
  speak() {
    return 'Some sound';
  }
}

class Cat extends Animal {
  speak() {  // ПЕРЕОПРЕДЕЛЕНИЕ метода
    return 'Meow!';
  }
}

class Dog extends Animal {
  speak() {  // ПЕРЕОПРЕДЕЛЕНИЕ метода
    return 'Woof!';
  }
}

const animals = [new Cat(), new Dog()];
animals.forEach(animal => {
  console.log(animal.speak());  // Meow!, Woof! - разные реализации
});

6. Конструктор (Constructor)

У класса есть конструктор — специальный метод инициализации.

// Переменная просто присваивается
const name = 'John';  // Готово

// Класс инициализируется через конструктор
class Person {
  constructor(name, age) {  // КОНСТРУКТОР
    this.name = name;
    this.age = age;
    this.createdAt = new Date();  // Инициализация
  }
}

const person = new Person('John', 25);
console.log(person.createdAt);  // Дата создания

7. this контекст

У класса есть this — ссылка на текущий объект.

// Переменная не имеет контекста
const count = 5;
this.count;  // undefined

// Класс имеет контекст
class Counter {
  constructor() {
    this.count = 0;  // this указывает на объект
  }

  increment() {
    this.count++;  // this сохраняет состояние
  }
}

const counter = new Counter();
counter.increment();
counter.increment();
console.log(counter.count);  // 2

8. instanceof проверка

Класс может быть проверен через instanceof.

// Переменная не может быть проверена через instanceof
const name = 'John';
name instanceof String;  // false (это примитив)

// Класс может быть проверен
class User {}
const user = new User();
user instanceof User;  // true
user instanceof Object;  // true

9. Статические методы и свойства

У класса могут быть статические члены, которые принадлежат классу, а не экземпляру.

// Переменная не может быть статической
const MAX_AGE = 120;

// Класс может иметь статические методы
class Math {
  static PI = 3.14159;

  static multiply(a, b) {
    return a * b;
  }
}

Math.multiply(3, 4);  // 12
Math.PI;              // 3.14159

const math = new Math();
math.multiply(3, 4);  // ОШИБКА! Статический метод только на классе

Сравнение: класс vs переменная

Практический пример

// Переменная - просто данные
const userAge = 25;
const userName = 'John';
const userEmail = 'john@mail.com';

// Класс - данные + поведение
class User {
  constructor(name, email, age) {
    this.name = name;
    this.email = email;
    this.age = age;
  }

  isAdult() {
    return this.age >= 18;
  }

  updateEmail(newEmail) {
    if (newEmail.includes('@')) {
      this.email = newEmail;
      return true;
    }
    return false;
  }

  getInfo() {
    return `${this.name} (${this.email})`;
  }
}

const user = new User('John', 'john@mail.com', 25);
console.log(user.isAdult());      // true
console.log(user.getInfo());      // John (john@mail.com)
user.updateEmail('john@newmail.com');

Резюме

У класса есть, чего нет у переменной:

• Методы - функции, описывающие поведение
• Множество свойств - структурированное состояние
• Инкапсуляция - контроль доступа к данным
• Наследование - повторное использование кода
• Полиморфизм - переопределение методов
• Конструктор - инициализация объекта
• this контекст - ссылка на объект
• instanceof проверка - определение типа
• Статические члены - данные на самом классе

Класс — это шаблон для создания объектов с данными и поведением, переменная — это просто хранилище значения.