How does the "if" work?

Good.

High-level ifs are not the same as low-level ifs. An if is not compared in ram, the processor loads the data from Ram memory to registers (EAX, EDX, etc. These are like "variables" that the processor has physically by means of transistors and electronic elements) Then it compares these registers with CMP instruction and flow control instructions like JNZ, JG, JL, JO. These instructions are symbolic names of binary values, this is so that the programmer can understand the program, but an assembler development environment usually looks like this:

Where you see a structure like:

[ memory address ] [ instruction code ] [ mnemonic code ][ ; and sometimes comments ]

Then the CMP instruction compares two registers and sets the corresponding [FLAGS] flags . Then a jump instruction such as JE (jump if equal) determines where the program flow continues according to the corresponding flag by moving the EIP pointer (Instruction pointer register). After this, the corresponding instruction blocks are executed.

You can see the full high-level vs. low-level code example in this question I answered a long time ago. This is a part of the code, they both do the same thing:

asm

mov     CX, offset texto1       ; Carga de variables en registros
mov     BX, offset texto1
mov     DX, offset texto1       
add     DX, largoTexto         

ip_for:                         
cmp     CX, DX                  ; Comparacion de registros CX y DX esto activa todas las banderas que correspondan
jge     ip_forend               ; Si CX es mayor o igual que DX sale del ciclo o sea salta a la direccion de ip_forend
inc     CX                      ; Si no se cumple la condicion de salto, la rutina sigue en la siguiente instruccion

ip_if1:                        
mov     DI, CX                 
mov     AL, byte ptr[DI]       
cmp     AL, 32                 
jne     ip_if2                  ; otro ejemplo de If aqui!
cmp     CX, offset texto1      
je      ip_if2                  ; y aqui
mov     SI, BX                 
mov     DI, CX                 
dec     DI                     
mov     BX, CX                 
inc     BX                     
jmp     ip_while               ; este es un salto incondicional, siempre salta

ip_if2:                         
mov     AX, DX                  
dec     AX                      
cmp     CX, AX                  
jne     ip_for                 ; otra comparacion aqui
mov     SI, BX                  
mov     DI, CX                  

ip_while:                      
cmp     SI, DI 
jge     ip_for
mov     AL, byte ptr[SI]
xchg    AL, byte ptr[DI]
xchg    AL, byte ptr[SI]
inc     SI
dec     DI
jmp     ip_while

ip_forend:

Java

for (int CX = 0, BX = 0, DX = largoTexto; CX < DX; CX++) {
    if (texto1[CX] == ' ' && CX != 0) {
        SI = BX;
        DI = CX;
        DI--;
        BX = CX;
        BX++;
    } else if (CX == DX - 1) {
        SI = BX;
        DI = CX;
    } else {
        continue;
    }

    while (SI < DI) {
        char AL = texto1[SI];
        texto1[SI] = texto1[DI];
        texto1[DI] = AL;
        SI++;
        DI--;
    }
}