В чем разница между i++ и ++i?

Разница между i++ и ++i

Краткий ответ

i++ (постфиксный инкремент) — возвращает старое значение, затем увеличивает переменную. ++i (префиксный инкремент) — увеличивает переменную, затем возвращает новое значение.

Различие в возвращаемом значении

Это главное различие:

let i = 5;

console.log(i++); // 5 (возвращает старое значение)
console.log(i);   // 6 (переменная увеличена)

let j = 5;

console.log(++j); // 6 (возвращает новое значение)
console.log(j);   // 6 (переменная увеличена)

Визуальное объяснение

i++ (постфиксный):

1. Сохрани текущее значение в временную переменную
2. Увеличь i на 1
3. Верни сохраненное значение

Пример:
let i = 5;
let result = i++;  // result = 5, i = 6

++i (префиксный):

1. Увеличь i на 1
2. Верни новое значение

Пример:
let j = 5;
let result = ++j;  // result = 6, j = 6

Примеры использования

В циклах

В циклах разницы нет — значение используется только для условия итерации:

// Это одинаково
for (let i = 0; i < 5; i++) {
  console.log(i);
}

for (let i = 0; i < 5; ++i) {
  console.log(i);
}

// Оба выведут: 0, 1, 2, 3, 4

В циклах нет разницы, потому что возвращаемое значение не используется.

Когда значение используется

// i++ возвращает старое значение
let arr = [10, 20, 30];
let i = 0;
console.log(arr[i++]); // 10 (используется i=0, потом i становится 1)

// ++i возвращает новое значение
let j = 0;
console.log(arr[++j]); // 20 (j становится 1, потом используется j=1)

Производительность

В классических языках (C++, Java) ++i немного быстрее, потому что:

i++ — создает временную копию старого значения (лишние затраты памяти)

// Внутренне так работает i++
int operator++(int) {
    int oldValue = *this;
    ++(*this);  // Вызывает ++i
    return oldValue;  // Возвращает старое значение
}

++i — просто увеличивает и возвращает

// Внутренне так работает ++i
int& operator++() {
    // Увеличиваем
    // Возвращаем ссылку на новое значение
    return *this;
}

В JavaScript

В современном JavaScript движки (V8, SpiderMonkey) оптимизируют оба варианта одинаково, особенно в циклах. Разницы в производительности практически нет.

console.time(i++);
for (let i = 0; i < 1000000; i++) {}
console.timeEnd(i++); // Примерно одинаково

console.time(++i);
for (let i = 0; i < 1000000; ++i) {}
console.timeEnd(++i); // Примерно одинаково

Когда какой использовать?

Используй ++i если:

• Работаешь с C++ или Java (минимально быстрее)
• Хочешь быть консистентным в стиле
• Пишешь критичный по производительности код

Используй i++ если:

• Это JavaScript (разницы нет)
• Тебе удобнее читается (привычнее)
• Работаешь с объектами (где нужна старая ссылка)

Примеры из реальной жизни

Очередь с постфиксным инкрементом

class Queue {
  constructor() {
    this.items = [];
    this.count = 0;
  }
  
  enqueue(element) {
    this.items[this.count++] = element; // count увеличится на 1 ПОСЛЕ присваивания
  }
  
  size() {
    return this.count;
  }
}

const queue = new Queue();
queue.enqueue(a); // this.items[0] = a, затем count = 1
queue.enqueue(b); // this.items[1] = b, затем count = 2
console.log(queue.size()); // 2

Нумерация с префиксным инкрементом

let id = 0;

function generateId() {
  return ++id;  // Увеличиваем, потом возвращаем
}

console.log(generateId()); // 1
console.log(generateId()); // 2
console.log(generateId()); // 3

// vs

let oldId = 0;

function generateOldId() {
  return oldId++;  // Возвращаем, потом увеличиваем
}

console.log(generateOldId()); // 0
console.log(generateOldId()); // 1
console.log(generateOldId()); // 2

Итог

Главное отличие: i++ возвращает старое значение, ++i возвращает новое. В циклах нет разницы. В JavaScript нет разницы в производительности. Выбирай тот стиль, который тебе удобнее, но будь консистентен в своем коде. В профессиональных проектах часто используют i++ (привычнее большинству), но оба варианта приемлемы.