Visualizzazione dei risultati da 1 a 5 su 5
  1. #1

    comportamento compilatore con confronto interi e booleani

    Ciao a tutti ragazzi, spero che qualcuno possa levarmi il dubbio . Ho scritto il seguente semplice codice per testare le mie conoscenze:

    vara = 4;

    varrisultato = (a && true); // restituisce true

    console.log(risultato);

    varb = 0;

    varrisultato2 = (b && true); // restituisce 0



    Qui qualcosa mi sfugge: come mai nel primo caso restituisce true e nell'altro restituisce 0 ?
    So che l'interprete javascript effettua una conversione di tipo ...
    nel primo caso il valore della variabile a , è stato convertito come true e fin qui ci siamo... nel secondo esempio mi aspettavo un false ed invece non è così. Qualcuno sa spiegarmi il motivo di questo comportamento dell'interprete? E' come se quel true fosse stato convertito in 1 e, successivamente , sia stato fatto un and logico fra i due operatori...
    Grazie mille!

    P.S.: non me ne vogliano alcuni... ho erroneamente scritto "compilatore" nel titolo, anzichè interprete
    Ultima modifica di diegodavide; 06-05-2019 a 20:35

  2. #2
    Utente di HTML.it L'avatar di vic53
    Registrato dal
    Oct 2010
    residenza
    Fonte Nuova (Roma)
    Messaggi
    590
    true è diverso da zero...
    false è zero
    Vic53

  3. #3
    Quote Originariamente inviata da vic53 Visualizza il messaggio
    true è diverso da zero...
    false è zero
    Si , siamo d'accordo.. ma non ho chiaro perchè stampa 0 anzichè false. Nelle parentesi c'è un controllo fra un numero ed un valore booleano ovvero 0 e true messi in cortocircuito con && . Andando a logica dovrebbe convertire lo zero in false e successivamente fatto il controllo con true. E' giusto un dettaglio il mio

  4. #4
    Moderatore di CSS L'avatar di KillerWorm
    Registrato dal
    Apr 2004
    Messaggi
    5,684
    Ciao, in linea di massima l'interprete JavaScript per gli operatori logici "esegue" (e quindi valuta) il valore di ogni singolo membro dell'espressione da sinistra a destra, quindi esce dalla serie di verifiche non appena il risultato dell'espressione è stabilito; a quel punto restituisce il valore dell'ultimo membro eseguito, quello che rende inequivocabile il risultato.

    Prendiamo il tuo primo caso:
    codice:
    console.log(4 && true); // output: true
    L'operatore è un AND logico per cui, per stabilire il valore del risultato, entrambi i membri devono avere un valore equivalente a true.

    L'omino JS esegue il controllo sul primo membro, 4, e stabilisce che equivale a true; siccome dopo c'è un operatore logico AND (&&), ha bisogno che anche il successivo membro sia equivalenti a true per poter capire se è possibile proseguire con la valutazione dell'espressione ed ottenere quindi un risultato certo. Per cui passa al controllo del secondo membro true; ora il risultato è chiaro (anche perché l'espressione è terminata; non c'è altro da controllare), quindi esce dalla serie di verifiche restituendo true, cioè il valore dell'ultimo membro "eseguito".

    Prendiamo il secondo caso:
    codice:
    console.log(0 && true); // output: 0
    L'omino JS esamina il primo membro, 0, e stabilisce che è uguale a false (ai fini della valutazione logica); dal momento che l'espressione prosegue con &&, col primo valore false il risultato dell'espressione è già stabilito; quindi l'esecuzione dell'espressione si interrompe restituendo il valore 0.

    Poniamo un altro esempio:
    codice:
    console.log(1 && "" && true); // output: ""
    Ora, in termini logici:
    1 equivale a true
    "" (stringa vuota) equivale a false
    true equivale chiaramente a true

    L'omino JS esegue il valore 1, vedendo che dopo c'è un && quel valore non gli basta per stabilire il risultato dell'intera espressione; esegue quindi il valore "" (false); in questo caso, vedendo che dopo c'è un &&, il risultato è stabilito perché per poter proseguire con la valutazione sarebbe necessario che anche quel valore sia true; l'esecuzione quindi termina qui e viene restituito il valore "" (stringa vuota).

    Ovviamente lo stesso procedimento viene usato per tutti gli altri operatori logici.

    Ad esempio con || (operatore logico OR):
    codice:
    console.log(1 || false); // output: 1
    console.log(0 || false); // output: false
    L'operatore || richiede che almeno uno tra i due membri abbia un valore equivalente a true perché l'espressione sia vera; altrimenti sarà falsa;

    Nel primo caso il primo membro eseguito è sufficiente per stabilire il risultato, quindi viene restituito il relativo valore 1; mentre nel secondo caso, il primo valore non è sufficiente, per cui viene eseguito (e restituito) il secondo, false, che determina il risultato.
    Installa Forum HTML.it Toolset per una fruizione ottimale del Forum

  5. #5
    Quote Originariamente inviata da KillerWorm Visualizza il messaggio
    Ciao, in linea di massima l'interprete JavaScript per gli operatori logici "esegue" (e quindi valuta) il valore di ogni singolo membro dell'espressione da sinistra a destra, quindi esce dalla serie di verifiche non appena il risultato dell'espressione è stabilito; a quel punto restituisce il valore dell'ultimo membro eseguito, quello che rende inequivocabile il risultato.

    Prendiamo il tuo primo caso:
    codice:
    console.log(4 && true); // output: true
    L'operatore è un AND logico per cui, per stabilire il valore del risultato, entrambi i membri devono avere un valore equivalente a true.

    L'omino JS esegue il controllo sul primo membro, 4, e stabilisce che equivale a true; siccome dopo c'è un operatore logico AND (&&), ha bisogno che anche il successivo membro sia equivalenti a true per poter capire se è possibile proseguire con la valutazione dell'espressione ed ottenere quindi un risultato certo. Per cui passa al controllo del secondo membro true; ora il risultato è chiaro (anche perché l'espressione è terminata; non c'è altro da controllare), quindi esce dalla serie di verifiche restituendo true, cioè il valore dell'ultimo membro "eseguito".

    Prendiamo il secondo caso:
    codice:
    console.log(0 && true); // output: 0
    L'omino JS esamina il primo membro, 0, e stabilisce che è uguale a false (ai fini della valutazione logica); dal momento che l'espressione prosegue con &&, col primo valore false il risultato dell'espressione è già stabilito; quindi l'esecuzione dell'espressione si interrompe restituendo il valore 0.

    Poniamo un altro esempio:
    codice:
    console.log(1 && "" && true); // output: ""
    Ora, in termini logici:
    1 equivale a true
    "" (stringa vuota) equivale a false
    true equivale chiaramente a true

    L'omino JS esegue il valore 1, vedendo che dopo c'è un && quel valore non gli basta per stabilire il risultato dell'intera espressione; esegue quindi il valore "" (false); in questo caso, vedendo che dopo c'è un &&, il risultato è stabilito perché per poter proseguire con la valutazione sarebbe necessario che anche quel valore sia true; l'esecuzione quindi termina qui e viene restituito il valore "" (stringa vuota).

    Ovviamente lo stesso procedimento viene usato per tutti gli altri operatori logici.

    Ad esempio con || (operatore logico OR):
    codice:
    console.log(1 || false); // output: 1
    console.log(0 || false); // output: false
    L'operatore || richiede che almeno uno tra i due membri abbia un valore equivalente a true perché l'espressione sia vera; altrimenti sarà falsa;

    Nel primo caso il primo membro eseguito è sufficiente per stabilire il risultato, quindi viene restituito il relativo valore 1; mentre nel secondo caso, il primo valore non è sufficiente, per cui viene eseguito (e restituito) il secondo, false, che determina il risultato.
    Grazie davvero per la spiegazione chiara e coincisa.Sei stato molto gentile. . Adesso ho capito.

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.