Swift - Как цикл for заканчивается до строки под ним?

Ваш код выполняется последовательно.

Если вы хотите, чтобы вычисления не задерживали основной поток, используйте другой поток.

DispatchQueue.global().async {
    for num in 1...10000000 {

        if num == 10000000 {
            print("why does this print") // the for-loop has to iterate 10 million times for it to print
        }
    }
}

print("before this prints")

Выход:

before this prints
why does this print

Принципиально все операции выполняются последовательно, как указано в ответе Олега.

Что вы должны понимать, так это то, что специальные вещи, такие как операторы for loop или if statements или другие, являются своего рода инструкциями для среды выполнения. И когда выполнение кода доходит до точки, где встречается инструкция for loop, оно продолжается и продолжается внутри цикла for. Он просто знает, что эта вещь внутри цикла for {} должна быть выполнена n раз, прежде чем она сможет продолжиться. Поэтому, когда цикл for завершается, он переходит к следующей строке кода и выполняет любую указанную там инструкцию.

Это не очень глубокое объяснение, но я пытался упростить. Надеюсь, поможет.

Программы выполняются последовательно на языке программирования, обучаются начиная с языка Си. Только условные операторы могут изменить поток выполнения, в противном случае он выполняется построчно.

В iOS есть понятие closure, closure — это кусок кода, который занял время для execution. Closure не держит программу и запускается отдельно, пока она не будет закончена. Другие строки кода будут выполняться параллельно. Вот почему ваше утверждение печатается перед loop. если вы хотите печатать после цикла, вы должны сделать это:

    DispatchQueue.main.sync {
       for num in 1...10000000 {

           if num == 10000000 {
            print("why does this print") // the for-loop has to iterate 10 million times for it to print
            }
        }
    }
    print("before this prints")

Есть веская причина, по которой for, while, do-while называются петля, потому что управление выполнением продолжает зацикливаться внутри блока цикла for или while до тех пор, пока не будет выполнено одно из его условий...

Например

for num in 1...4 {

    print("line"\(num))
}
print("line5")

но для компилятора Так что это последовательно, как

line1

line2

line3

line4


line5

Дело не в том, что последняя функция печати работает медленнее, чем цикл for. Если вы запустите цикл for и последнюю функцию print() одновременно, вы сможете это увидеть. В приведенном выше коде это просто вопрос последовательности. Позвольте мне попытаться изложить это перед вами на простом примере ниже.

Предположим, вы находитесь в точке A и хотите пройти в точку B на расстоянии 10 км. Вы начали пешком, чтобы добраться до места назначения (местоположение B). Теперь, находясь в пути, вы можете принимать следующие решения:

1. Вы можете завершить всю поездку и добраться до места B пешком (это займет больше времени).

2. В любой момент вашего путешествия вы можете воспользоваться транспортным средством и пройти оставшуюся часть пути (быстрее, чем № 1).

3. В любой момент во время вашего путешествия в точку B вы можете полностью отменить поездку.

Могут быть и другие сценарии. Однако в любом случае сможете ли вы добраться до точки B до того, как преодолеете расстояние между точкой A и точкой B?

Рассмотрим здесь цикл for как путешествие между точками A и B, а функцию print — банку сладких леденцов, которую вы получите в точке B.

Я надеюсь, что это ясно. Спасибо.

Все циклы (например, for, while, do-while и т. д.) являются синхронными, а поток управления идет сверху вниз. Цикл будет продолжать работать до тех пор, пока не будет достигнуто его условие завершения. Вот почему выполнение первого цикла завершится, а затем будет выполнен ваш внешний оператор печати. Теперь, чтобы контроллер понял, что какое-то задание, которое вы хотите запустить асинхронно, вы можете сделать так:

DispatchQueue.global().async {
    for num in 1...10000000 {

        if num == 10000000 {
            print("why does this print") // the for-loop has to iterate 10 million times for it to print
        }
    }
}

print("before this prints")

Выход:

до этого печатает

почему это печатает

В этой приведенной выше строке кода DispatchQueue.global().async вы сообщаете контроллеру, что блок кода, который вы можете запустить в фоновом режиме, и когда вы закончите, просто скажите мне ответ, поэтому вы можете увидеть, как ниже оператор печати выполняется раньше, чем отображается результат миллиона циклов.

Я попытался дать вам идею настолько просто, насколько это возможно, в моем комментарии к вашему вопросу. Это должно ответить на ваш вопрос. У вас есть и другие ответы, хотя некоторые из них довольно расплывчаты по сравнению с вашим уровнем понимания.

Для полноты и пояснения использования for (или любого другого цикла) я расширяю идею в этом ответе настолько просто, насколько это возможно.

for — это сокращенный синтаксис для многократного выполнения операторов. Код в вашем вопросе может быть записан без этого сокращенного синтаксиса как:

/// checkpoint #1: variable initialization
var num = 1

/// checkpoint #2: condition checking
if num <= 10000000 { //condition true
    if num == 10000000 { //at this point, num equals to 1, so condition is false
        print("why does this print") //doesn't execute
    }
    /// checkpoint #3: increment value of the variable
    num = num + 1 //at this point, num equals to 2
}

if num <= 10000000 { //condition true
    if num == 10000000 { //at this point, num equals to 2, so condition is false
        print("why does this print") //doesn't execute
    }
    num = num + 1 //at this point, num equals to 3
}

if num <= 10000000 { //condition true
    if num == 10000000 { //at this point, num equals to 3, so condition is false
        print("why does this print") //doesn't execute
    }
    num = num + 1 //at this point, num equals to 4
}

. . .
// upto the point where the above repeated lines reach 10000000 if counted
. . .

if num <= 10000000 { //condition true
    if num == 10000000 { //at this point, num equals to 10000000, so condition is true
        print("why does this print") //this time it executes
    }
    num = num + 1 //at this point, num equals to 10000000 + 1
}

if num <= 10000000 { //condition false
    //doesn't execute anything inside this conditional block
    if num == 10000000 {
        print("why does this print")
    }
    num = num + 1
}

// this is the termination point if loop was used

//after executing the previous statements, this line will be executed
print("before this prints") 

Как программисты, мы умеем идентифицировать повторяющиеся операторы. И мы достаточно умны, чтобы сделать приведенный выше код короче и проще. Это когда мы представляем loop. Найдите повторяющийся блок и поместите его в цикл.

Вы заметили повторяющиеся утверждения выше? Давайте поместим это здесь еще раз:

if num <= 10000000 {
    if num == 10000000 {
        print("why does this print")
    }
    num = num + 1
}

Посмотрите этот код в Быстрый:

for num in 1...10000000 {
    if num == 10000000 {
        print("why does this print")
    }
}
print("before this prints")

можно написать на другом языке (скажем, С):

for(int num = 1; num <= 10000000; num++) {
    if (num == 10000000) {
        printf("why does this print");
    }
}
printf("before this prints");

Приведенный выше цикл в С можно разбить на части, которые вы можете сравнить с контрольными точками, упомянутыми в первом блоке кода:

for(int num = 1/*checkpoint #1*/; num <= 10000000/*checkpoint #2*/; num++/*checkpoint #3*/)

Теперь, когда контрольные точки выполняются самим синтаксисом цикла for, остается только одна часть:

if num == 10000000 {
    print("why does this print")
}

И вы помещаете эту часть в фигурные скобки { ... } цикла for.

Я надеюсь, что это подробное объяснение даст вам общее представление о цикле. И теперь вы должны понять поток управления выполнения кода.