Какова логика перебора этого месива таким образом?

Давайте разберем отдельные этапы работы функции, которая ищет минимальное число в массиве, и посмотрим, как именно происходит изменение переменной `min` в процессе выполнения цикла.

Предположим, у нас есть массив:

```javascript
let arr = [3, 5, 1, 2, 12];
```

И функция для нахождения минимального значения может выглядеть следующим образом:

```javascript
function findMin(arr) {
    let min = 12; // Начальное значение
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] < min) {
            min = arr[i]; // Изменяем min на текущее значение arr[i]
        }
    }
    return min;
}
```

### Последовательность действий в цикле:

1. **Инициализация**: Мы устанавливаем `min` равным 12. Это означает, что мы считаем 12, нечто большее, чем любое число, которое мы ожидаем найти в массиве.

2. **Первая итерация (`i = 0`)**:
   - `arr[0]` равен 3.
   - Сравниваем: `3 < 12` (да).
   - Значит, мы устанавливаем `min` равным 3.
   - Теперь `min = 3`.

3. **Вторая итерация (`i = 1`)**:
   - `arr[1]` равен 5.
   - Сравниваем: `5 < 3` (нет).
   - Значит, `min` не меняется, остается 3.

4. **Третья итерация (`i = 2`)**:
   - `arr[2]` равен 1.
   - Сравниваем: `1 < 3` (да).
   - Значит, мы устанавливаем `min` равным 1.
   - Теперь `min = 1`.

5. **Четвертая итерация (`i = 3`)**:
   - `arr[3]` равен 2.
   - Сравниваем: `2 < 1` (нет).
   - Значит, `min` остаётся 1.

6. **Пятая итерация (`i = 4`)**:
   - `arr[4]` равен 12.
   - Сравниваем: `12 < 1` (нет).
   - Значит, `min` остаётся 1.

### Результат

После завершения всех итераций, мы получаем `min`, равным 1, что является минимальным значением в массиве.

### Почему `min` меняется именно на 3?

Во время первой итерации, когда мы сравниваем значения, `min` еще не был изменен, и мы ищем первое число, которое меньше начального значения. Как только мы встречаем 3, оно меньше 12, и мы устанавливаем его как новое значение для `min`. Другие значения (0, 1 и 2) изменить `min` не могли, потому что их просто не было в массиве, когда 3 уже было присвоено в качестве минимального значения. Итерация проходит последовательно, и каждый шаг цикла берет во внимание только текущее значение массива.

Таким образом, `min` будет заменяться только на те значения, которые меньше текущего минимального значения, и это происходит на каждой итерации в зависимости от текущего элемента массива.

i — это индекс массива — номер позиции в нём, считая от 0 . 
 arr[i] — значение , которое лежит в массиве arr в позиции i . 
 
 Последовательность получается примерно такая: 
 min = 12; 
 
 i = 0; arr[i] = 12; arr[i] меньше min? НЕТ. идём дальше 
 i = i + 1 
 i = 1; arr[i] = 5; arr[i] меньше min? ДА. min становится 5; идём дальше 
 i = i + 1 
 i = 2; arr[i] = 8; arr[i] меньше min? НЕТ. идём дальше 
 i = i + 1 
 ... 
 i = 4; arr[i] = 3; arr[i] меньше min? ДА. min становится 3; идём дальше 
 ... 
 for закончил работу, min так и остался равным 3

i у нас 0. но сравнивается то arr[i], т.е arr[0] 
 
 на 1 итерации будет 12 < 12 => false 
 на 2 итерации будет 5 < 12 => true => min = 5 
 на 3 итерации будет 8 < 5 => false 
 на 4 итерации будет 20 < 5 => false 
 на 5 итерации будет 3 < 5 => true => min = 3 
 т.е. на 6 итерации будет 16 < 3 => false

а кто сказал что не перезаписывается? 
 в крайнем случае console.log() в помощь, если отладкой через DevTools воспользоваться не получается 
 
 и ещё, при таком алгоритме обычно начинают итерацию с 1 элемента, пропуская 0, тибо он уже в min 
 

Во-первых, вы путаете индекс массива и значение по этому индексу. Индекс - номер значения в массиве, а сравнение происходит только значений. 
 Кроме того, логика тут следующая: нам надо пройтись по всему массиву и найти минимальное значение, а функция вычисления минимального значения требует два аргумента. С чем и как сравнивать первый элемент массива, ведь он только первый? Это можно сделать только со вторым элементом и так до самого конца, ведь последний элемент массива будет сравниваться с минимальным элементом из предыдущих итераций. Добавлять дополнительную проверку в тело цикла - добавлять эту же проверку для всех итераций, а первый элемент в списке только один. Поэтому логично для первой итерации подготовить первый элемент списка для сравнения до начала цикла, а итерацию прохода по списку начинать со второго элемента. При этом надо будет добавить отдельную проверку для массива единичной длины. В приведённом данном коде как раз тут ошибка: цикл начат с первого элемента и происходит сравнение первого элемента с самим собой на первой итерации, а уже только потом идёт реальная работа. Впрочем, для варианта простейшей операции "сравнение двух чисел" такое решение вполне имеет право на жизнь как упрощение логики и сокращение объёма кода. В реальности в цикле зачастую куда больше работы происходит и эконимить на дополнительной проверке нет смысла. Правильнее будет следующее решение: 
 
function getMin(arr){
    if (arr.length === 1) { return arr[0] }
    let min = arr[0];
    for (i=1;i < arr.length;i++){
        if(arr[i] < min){
            min = arr[i];
        }
    }
    return min;
}