Cosa significa (+ var) significa

Question

Sono nuovo nel mondo javascript e non ho trovato alcuna informazione su questa notazione. L'ho trovato in quell'argomento (vedi la risposta): Convert HH:MM:SS string to seconds only in javascript.

// minutes are worth 60 seconds. Hours are worth 60 minutes. 
var seconds = (+a[0]) * 60 * 60 + (+a[1]) * 60 + (+a[2]); 

Inoltre, desideravo utilizzare quel codice per convertire la stringa "HH: MM: SS" in secondi. Ma sembra pericoloso per me. Se l'utente inserisce 'XX: 03: SS', il valore sarà NaN che non è corretto (almeno per me). Così ho deciso di migliorato con:

function convertHHMMSSToSeconds(time) { 

// initialize seconds 
var seconds = 0; 

//ensure time 
if (!time) { 
    return seconds; 
} 


try { 
    var hmsTab = time.split(':'); // split it at the colons 

    // ensure that the hmsTab contains 3 values (hh,mm,ss) 
    if (!hmsTab || hmsTab.length !== 3) { 
     return seconds; 
    } 

    // initialize hh, mm and ss 
    var hh = hmsTab[0] > 0 && hmsTab[0] < 60? +hmsTab[0] : 0; 
    var mm = hmsTab[1] > 0 && hmsTab[1] < 60 ? +hmsTab[1] : 0; 
    var ss = hmsTab[2] > 0 && hmsTab[2] < 60 ? +hmsTab[2] : 0; 

    // return 0 if one variable is not valid 
    if(+hmsTab[0] !== hh ||+hmsTab[1] !== mm || +hmsTab[2] !== ss) { 
     return seconds; 
    } 

    // minutes are worth 60 seconds. Hours are worth 60 minutes. 
    seconds = (hh * 60 * 60) + (mm * 60) + ss; 
}catch (error) 
{ 
    seconds = 0; 
} 
return seconds && seconds>0 ? seconds : 0; 

}

Quindi la mia domanda rimane ancora, che cosa fa (+ var) significa.

saluti,

Answer 1

Il + segno di fronte di una variabile, che getteranno variabile per un numero. Esempio:

var x = "3"; 
var y = x + 10; // 310 
var z = +x + 10 // 13 

Answer 2

sua forma più breve per convertire una variabile al numero

Answer 3

Un modo di conversione al numero:

+n === Number(n) 

Answer 4

+var è l'applicazione del unario identity operator al valore di var. L'operatore identità può essere pensato come simile a una funzione che restituisce unico parametro:

function identity(operand) { 
    return operand; 
} 

Tuttavia, l'operatore identità agisce solo valori numerici. Poiché Javascript è un linguaggio tipizzato debole, l'applicazione di una funzione numerica a un valore non numerico causerà la forzatura del valore non numerico in un valore numerico equivalente. Nel caso più comune di coercizione utilizzando l'operatore di identità, una stringa contenente un numero viene analizzata in un numero.

Mentre veloce da digitare e facile da ricordare, la coercizione con l'operatore di identità non è molto solida. Ecco alcuni esempi di uscite:

+'150' // 150 
+'150z' // NaN 
+'z150' // NaN 
+'015' // 15 -- note that it doesn't interpret as octal* 
+'015z' // NaN 
+'z015' // NaN 
+'0xf' // 15 -- note that it interprets as hexadecimal 
+'0xfz' // NaN 
+'z0xf' // NaN 
+'NaN' // NaN 
+'undefined' // NaN 

Confrontare gli stessi input con parseInt:

parseInt('150') // 150 
parseInt('150z') // 150 
parseInt('z150') // NaN 
parseInt('015') // 15 -- note that it still doesn't interpret as octal* 
parseInt('015z') // 15 
parseInt('z015') // NaN 
parseInt('0xf') // 15 -- note that it still interprets as hexadecimal 
parseInt('0xfz') // 15 
parseInt('z0xf') // NaN 
parseInt('NaN') // NaN 
parseInt('undefined') // NaN 

parseInt ti dà anche un maggiore controllo sul risultato:

parseInt('015', 8) // 13 
parseInt('z0xf', 36) // 1634163 
parseInt('1010', 2) // 10 

* In script EMCAScript 5. Precedente le versioni sarebbero di default ottale quando si tratta di zeri iniziali.

Le stringhe non sono l'unica cosa che può essere forzata in numeri con l'operatore di identità, sebbene siano le più comuni e la conversione sia la più sensata. Altre coercizioni potrebbero avere senso o potrebbero non esserlo. Esempio:

+[]  // 0 
+[150]  // 150 
+['150'] // 150 
+['150z'] // NaN 
+[1, 2] // NaN 
+{}  // NaN 
+null  // 0 
+true  // 1 
+false  // 0 
+NaN  // NaN 
+undefined // NaN 
+function(){} // NaN