E 'questo IF annidata, o no?

Su edit: non importa, mi darete ragione ero wronfg su questo.

Non è, perché nessuno ifviene testato all'interno di un altro ifche ha testato true.

In particolare, il tuo esempio:

if (0 <= X and X < 49) output "abc"

else if (50 <= X and X < 70) output "def"

else if (70 <= X and X < 85) output "ghi"

else if (85 <= X and X < 100) output "jkl"

endif

potrebbe essere riscritto come:

if (0 <= X and X < 49) output "abc"; return; end if

if (50 <= X and X < 70) output "def"; return; end if

if (70 <= X and X < 85) output "ghi"; return; end if

if (85 <= X and X < 100) output "jkl"; return; end if

// X < 0 or X >= 100

Commento:

Un if non deve essere nidificato all'interno di un altro, se per essere nidificate. Si può essere nidificato all'interno di un altro -Bill Lizard

Punto preso; Sono d'accordo che mi sbaglio su questo.

Si potrebbe pensare ad esso come logicamente equivalente a quanto segue:

if(a) {
    // code
} else {
    if(b) {
        // code
    } else {
        // code
    }
}

Quindi, in questo senso, si potrebbe chiamare nidificato. In C e lingue simili, questo è esattamente come funziona poiché non c'è "elseif" dichiarazioni disponibili. Le parentesi graffe sono opzionali però, ho appena li incluso per renderlo più chiaro.

Potrebbe essere implementato come un ciclo nidificato, a seconda della lingua. Tuttavia, il modo in cui logicamente scritto fuori, non sarebbe stato considerato uno.

Essi sono annidati, ma formattati come non lo sono.

Il tuo codice è lo stesso:

if (0 <= X and X < 49)
    output "abc"
else
    if (50 <= X and X < 70)
        output "def"
    else
        if (70 <= X and X < 85)
            output "ghi"
        else
            if (85 <= X and X < 100)
                output "jkl"
            endif
        endif
    endif
endif

Questo non è nidificato:

if (0 <= X and X < 49)
    output "abc"
endif
if (50 <= X and X < 70)
    output "def"
endif
if (70 <= X and X < 85)
    output "ghi"
endif
if (85 <= X and X < 100)
    output "jkl"
endif

Questo è valido in tutti (?) Lingue che hanno istruzioni if ​​(ignorando le cose come l'utilizzo di {} invece di endif)

Tuttavia, alcune lingue hanno un comando (o "elif") "elseif" vero e proprio, nel qual caso si non nido, ma scritto come "else if" si può supporre che è solo un nido diverso formato.

Essa dipende dalla lingua vera e propria, e come è scritto.

Ad esempio, utilizzando VB, queste Ifaffermazioni non sono annidate:

If 0 <= x And x < 49 Then
    output("abc")
ElseIf 50 <= x And x < 70 Then
    output("def")
ElseIf 70 <= x And x < 85 Then
    output("ghi")
ElseIf 85 <= x And x < 100 Then
    output("jkl")
End If

Mentre queste Ifaffermazioni sono annidati:

If 0 <= x And x < 49 Then
    output("abc")
Else
    If 50 <= x And x < 70 Then
        output("def")
    Else
        If 70 <= x And x < 85 Then
            output("ghi")
        Else
            If 85 <= x And x < 100 Then
                output("jkl")
            End If
        End If
    End If
End If

Direi di sì che sono annidati. Il tuo codice è esattamente equivalente a

if (0 <= X and X < 49)
    output "abc"
else
    if (50 <= X and X < 70)
        output "def"
    else
        if (70 <= X and X < 85)
            output "ghi"
        else
            if (85 <= X and X < 100)
                output "jkl"
endif

Notate che ho cambiato solo gli spazi. Quando una lingua valuta if...else if...elseclausole, mette alla prova ognuno finché non trova il vero punto (o colpisce il finale else). I nidificate ifs valutano esattamente nello stesso modo. Si noti inoltre che questo non è necessariamente il caso se v'è un esplicito elsifparola chiave.

Un'altra cosa che noto, il seguente è non è equivalente al codice:

if (0 <= X and X < 49)
    output "abc"

if (50 <= X and X < 70)
    output "def"

if (70 <= X and X < 85)
    output "ghi"

if (85 <= X and X < 100)
    output "jkl"

La nidificazione è necessaria per mantenere tutto il testo di essere stampata quando tutte le condizioni sono vere.

Data la sintassi mostrata, credo che la risposta deve essere "No", in contrasto con la saggezza accumulata delle altre risposte.

Si mostrano:

if (0 <= X and X < 49)
    output "abc"
else if (50 <= X and X < 70)
    output "def"
else if (70 <= X and X < 85)
    output "ghi"
else if (85 <= X and X < 100)
    output "jkl"
endif

Si tratta chiaramente di una singola if... endifdichiarazione, e quindi non v'è alcuna nidificazione. Se ci fossero più endifdichiarazioni, sarebbe essere nidificato:

if (0 <= X and X < 49)
    output "abc"
else
    if (50 <= X and X < 70)
        output "def"
    else
        if (70 <= X and X < 85)
            output "ghi"
        else
            if (85 <= X and X < 100)
                output "jkl"
            endif
        endif
    endif
endif

Così, nella vostra lingua, sembra che la parola chiave elif(utilizzata dalla shell Bourne) e elsif(usato da Perl) e ElseIf(utilizzato da Visual Basic) è scritto else if.

Se non ci fosse esplicito endifper segnare la fine della dichiarazione, allora sarei d'accordo con le altre risposte - che le ifdichiarazioni (! Plurale) sono annidati, anche se il layout è perfettamente ragionevole e consigliato.

No non lo è.

Una dichiarazione nidificato è quella che appare all'interno di una stessa dichiarazione, come se ... se. Se ... ElseIf è tutti nella stessa "dichiarazione".

Questo è un gioco un po 'inutile della semantica; dipende dalla sintassi del linguaggio in questione.

Ad esempio in una sintassi C-like solito sarebbe considerato annidata nelle clausole altro, con le bretelle omesse per oscurare questo fatto. In questo caso l'esempio di Turnor è giusto.

In alcune altre lingue, come Python e VB, 'else-if' è una costruzione atomica propria. In quel caso il 'se' non può essere considerato all'interno della 'altro', per cui non potrebbe essere chiamato “annidati”.

if (0 <= X and X < 49)
    output "abc"
else if (50 <= X and X < 70)
    output "def"
endif

Non hai definito la sintassi del pseudocodice sufficientemente per dirlo con certezza, ma il finale 'endif' è sospetto. La sua esistenza non si adatta con lo stile C-bretelle-omessi; e il fatto che c'è solo uno di loro e non di più -

else
    if (50 <= X and X < 70)
        output "def"
    endif
endif

- significa che non corrisponde ai con graffe (o iniziare / fine) modello sia. Quindi, a giudicare da quella sintassi mi avrebbe messo la lingua pseudocodice nel 'else-if atomica' campo, e dire tutto arbitrariamente: No, il tuo, se-dichiarazione non è nidificato.

(Ma si può sempre stato definito un linguaggio in cui endifs sono opzionali o spazi-dipendente. In alternativa, si potrebbe avere definito un linguaggio in cui il programma stampa di cui sopra “Ciao mondo” cancella quindi tutti i file. E ha un lettore integrato di posta elettronica. )