for循环判断条件如果写的表达式，会不会重复计算

如for语句的：sizeof(arr)/sizeof(arr[0])

写了个demo ， 搞成了汇编 你看一下吧 ，我只看到了一个sub
如果我没记错的，这个操作会因为编译器版本不同会有不同的优化

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;

    int j = 3;

    for( int i = 0; i < j - 0; ++i){
        std::cout<< "-----"<<std::endl;
    }
    return 0;
}

__libc_start_main:
    push   %r14
    push   %r13
    push   %r12
    push   %rbp
    mov    %rcx,%rbp
    push   %rbx
    sub    $0x90,%rsp
    mov    0x3a491f(%rip),%rax        ; 0x7ffff75b3d98
    mov    %rdi,0x18(%rsp)
    mov    %esi,0x14(%rsp)
    mov    %rdx,0x8(%rsp)
    test   %rax,%rax
    je     0x7ffff720f55c             ; <__libc_start_main+252>
    mov    (%rax),%eax
    xor    %edx,%edx
    test   %eax,%eax
    sete   %dl
    lea    0x3a4be0(%rip),%rax        ; 0x7ffff75b4080 <__libc_multiple_libcs>
    test   %r9,%r9
    mov    %edx,(%rax)
    je     0x7ffff720f4b3             ; <__libc_start_main+83>
    xor    %edx,%edx
    xor    %esi,%esi
    mov    %r9,%rdi
    callq  0x7ffff7226f30             ; <__cxa_atexit_internal>
    mov    0x3a498e(%rip),%rdx        ; 0x7ffff75b3e48
    mov    (%rdx),%eax
    and    $0x2,%eax
    movslq %eax,%rbx
    test   %rbx,%rbx
    jne    0x7ffff720f604             ; <__libc_start_main+420>
    test   %rbp,%rbp
    je     0x7ffff720f4e5             ; <__libc_start_main+133>
    mov    0x3a49c1(%rip),%rax        ; 0x7ffff75b3e98
    mov    0x8(%rsp),%rsi
    mov    0x14(%rsp),%edi
    mov    (%rax),%rdx
    callq  *%rbp
    mov    0x3a495c(%rip),%rax        ; 0x7ffff75b3e48
    mov    0x178(%rax),%ebp
    test   %ebp,%ebp
    jne    0x7ffff720f5c3             ; <__libc_start_main+355>
    test   %rbx,%rbx
    jne    0x7ffff720f5a0             ; <__libc_start_main+320>
    lea    0x20(%rsp),%rdi
    callq  0x7ffff72231d0             ; <_setjmp>
    test   %eax,%eax
    jne    0x7ffff720f563             ; <__libc_start_main+259>
    mov    %fs:0x300,%rax
    mov    %rax,0x68(%rsp)
    mov    %fs:0x2f8,%rax
    mov    %rax,0x70(%rsp)
    lea    0x20(%rsp),%rax
    mov    %rax,%fs:0x300
    mov    0x3a4956(%rip),%rax        ; 0x7ffff75b3e98
    mov    0x8(%rsp),%rsi
    mov    0x14(%rsp),%edi
    mov    (%rax),%rdx
    mov    0x18(%rsp),%rax
    callq  *%rax
    mov    %eax,%edi
    callq  0x7ffff7226d20             ; <exit>
    xor    %edx,%edx
    jmpq   0x7ffff720f499             ; <__libc_start_main+57>
    mov    0x3aaa26(%rip),%rax        ; 0x7ffff75b9f90 <__libc_pthread_functions+400>
    ror    $0x11,%rax
    xor    %fs:0x30,%rax
    callq  *%rax
    mov    0x3aaa00(%rip),%rax        ; 0x7ffff75b9f80 <__libc_pthread_functions+384>
    ror    $0x11,%rax
    xor    %fs:0x30,%rax
    lock decl (%rax)
    sete   %dl
    xor    %eax,%eax
    test   %dl,%dl
    jne    0x7ffff720f555             ; <__libc_start_main+245>
    xor    %edi,%edi
    callq  0x7ffff72dc350             ; <__exit_thread>
    mov    0x8(%rsp),%rax
    mov    0x3a489c(%rip),%rdx        ; 0x7ffff75b3e48
    lea    0x16561c(%rip),%rdi        ; 0x7ffff7374bcf
    mov    (%rax),%rsi
    xor    %eax,%eax
    callq  *0x120(%rdx)
    jmpq   0x7ffff720f503             ; <__libc_start_main+163>
    mov    0x170(%rax),%r13
    mov    0x3a47ff(%rip),%rax        ; 0x7ffff75b3dd0
    xor    %r12d,%r12d
    mov    (%rax),%r14
    mov    0x18(%r13),%rax
    test   %rax,%rax
    je     0x7ffff720f5f2             ; <__libc_start_main+402>
    mov    %r12d,%edx
    add    $0x46,%rdx
    shl    $0x4,%rdx
    lea    0x8(%r14,%rdx,1),%rdi
    callq  *%rax
    add    $0x1,%r12d
    mov    0x40(%r13),%r13
    cmp    %r12d,%ebp
    jne    0x7ffff720f5d7             ; <__libc_start_main+375>
    jmpq   0x7ffff720f4fa             ; <__libc_start_main+154>
    mov    0x8(%rsp),%rax
    lea    0x1655a5(%rip),%rdi        ; 0x7ffff7374bb5
    mov    (%rax),%rsi
    xor    %eax,%eax
    callq  *0x120(%rdx)
    jmpq   0x7ffff720f4cb             ; <__libc_start_main+107>

不会，因为他只能除一次，除一次之后就变成一个常量。比如下面程序就运行三次
#include
using namespace std;
int main()
{
int a[] = { 1,2,3 };
for (int i = 0; i < sizeof(a) / sizeof(int); i++)
{
cout << a[i] << " ";
}
return 0;
}

当然会，每个周期都会执行
但是一般电脑cpu 都是2.0GHz以上
也就是说每秒可以进行2x10的9次方次计算
计算一次1ns
你就别省那么一点时间了

会，每次都算一遍但是影响一般不大，除非每次运算很复杂
比如你要是写过前端肯定熟悉一种规范写法

for(let i=0,l=list1.length;i<l;i++){ 
    //业务代码
}