Gli operatori unari

Gli operatori unari necessitano di un solo operando, o prima o dopo l'operatore stesso.

Operatore + unario

L'operatore + unario si posiziona prima della variabile e ne converte il valore in numero, se questo non è possibile lo converte in NaN.

var a;
var b = null;
var c = true;
var d = false;
var e = "0";
var f = "1";
var g = "2.5";
var h = "2,5";
var i = "00100";
var j = "-3";
var k = "";
var l = [];
var m = {};
var n = NaN;
var o = function() {};

console.log(+a); //NaN
console.log(+b); //0
console.log(+c); //1
console.log(+d); //0
console.log(+e); //0
console.log(+f); //1
console.log(+g); //2.5
console.log(+h); //NaN
console.log(+i); //100
console.log(+j); //-3
console.log(+k); //0
console.log(+l); //0
console.log(+m); //NaN
console.log(+n); //NaN
console.log(+o); //NaN

Operatore - unario

L'operatore - unario si posiziona prima della variabile e ne converte il valore in numero negativo, se questo non è possibile lo converte in NaN.

var a;
var b = null;
var c = true;
var d = false;
var e = "0";
var f = "1";
var g = "2.5";
var h = "2,5";
var i = "00100";
var j = "-3";
var k = "";
var l = [];
var m = {};
var n = NaN;
var o = function() {};

console.log(-a); //NaN
console.log(-b); //-0
console.log(-c); //-1
console.log(-d); //-0
console.log(-e); //-0
console.log(-f); //-1
console.log(-g); //-2.5
console.log(-h); //NaN
console.log(-i); //-100
console.log(-j); //3
console.log(-k); //-0
console.log(-l); //-0
console.log(-m); //NaN
console.log(-n); //NaN
console.log(-o); //NaN

Operatore di negazione

L'operatore di negazione ! si posiziona prima della variabile e ne converte il valore nel booleano opposto. E' anche possibile usare la doppia negazione !! per convertire un valore nel suo corrispondente booleano.

var a;
var b = null;
var c = true;
var d = false;
var e = 0;
var f = "0";
var g = 1;
var h = "1";
var i = "";
var j = [];
var k = {};
var l = NaN;
var m = function() { return false};

console.log(!a); //true
console.log(!b); //true
console.log(!c); //false
console.log(!d); //true
console.log(!e); //true
console.log(!f); //false
console.log(!g); //false
console.log(!h); //false
console.log(!i); //true
console.log(!j); //false
console.log(!k); //false
console.log(!l); //true
console.log(!m); //false

console.log(!!a); //false
console.log(!!b); //false
console.log(!!c); //true

Operatori di incremento/decremento

L'operatore ++ aumenta di 1 il valore dell'operando e ritorna il risultato. Se posizionato prima della variabile ritorna il valore già incrementato, se posizionato dopo ritorna il valore ancora da incrementare.

var a = 5;
console.log(a++); //5, ritorna il valore non ancora incrementato ma adesso a vale 6
a++; //ritorna il valore non ancora incrementato (6) ma non lo stiamo loggando, adesso a vale 7
var b = a++; //ritorna il valore non ancora incrementato, quindi b vale 7 e a vale 8
console.log(b); //7
console.log(a); //8


var c = 7;
console.log(++c); //8, ritorna il valore già incrementato, adesso c vale 8
++c; //ritorna il valore già incrementato (9) ma non lo stiamo loggando, adesso c vale 9
var d = ++c; //ritorna il valore già incrementato, quindi d vale 10 e c vale 10
console.log(d); //10
console.log(c); //10

L'operatore -- funziona allo stesso modo ma invece di aumentare diminuisce il valore della variabile di 1.

L'operatore delete

L'operatore delete rimuove una proprietà da un oggetto ma non lo rimuove dalla memoria direttamente, verrà poi fatto automaticamente dal garbage collector. Ritorna true se l'operazione va a buon fine o se la proprietà non esiste e false se la proprietà non è eliminabile. Non va utilizzato per rimuovere un elemento da un array.

var persona = {
    nome: "Mario",
    cognome: "Rossi",
    anni: 20,
    amici: ["Luca", "Giovanni"]
}

delete persona.anni;
console.log(persona); //{nome: "Mario", cognome: "Rossi", amici: ["Luca", "Giovanni"]}
console.log(delete persona.lavoro); //true anche se la proprietà lavoro non esiste
console.log(delete persona.amici.length); //false, non si può cancellare la proprietà length di un array

var aaaaa = "variabile nell'oggetto window";
console.log(window); //l'oggetto window ha la proprietà aaaaa;
delete window.aaaaa;
console.log(window); //l'oggetto window ha ancora la proprietà aaaaa, non può essere eliminata in quanto creata con l'utilizzo della keyword var (oppure let o const)

class Cat {
  constructor(color) {
    this.color= color;
  }
  greet() {
    return "meow!"
  }
}

class Lion extends Cat {
  constructor(color, speed) {
    super(color);
    this.speed= speed;
  }
}
var simba = new Lion();
console.log(simba.greet()); //"meow!" simba è un Lion, non ha il metodo greet ma lo eredita da Cat
delete simba.greet; //provo a eliminare una proprietà che sta nel prototype

class Tiger extends Cat{
    constructor(color, height) {
        super(color);
        this.height= height;
    }
}
var tigro = new Tiger();
console.log(tigro.greet()); //"meow!" l'operazione delete non ha avuto effetto sulla proprietà ereditata

var colori= ["rosso", "verde", "blu"];
delete colori[2];
console.log(colori); //["rosso", "verde", empty]
console.log(colori.length); //3 la lunghezza è ancora 3

Un altro modo per rimuovere una proprietà da un oggetto è usare il destructuring.

let auto = {
    colore: "rosso",
    porte: 5,
    velocita: 300
};

let { colore, ...altreProprieta } = auto;
console.log(altreProprieta); //{ "porte": 5, "velocita":300 }

//altro metodo se la proprietà è dinamica
let moto = {
    colore: "nero",
    gomme: "Pirelli",
    velocita: 300
};
let prop = 'gomme';
let { [prop]: value, ...altreProprieta} = moto;
console.log(altreProprieta); //{ "colore": "nero", "velocita":300 }