assign()
Il metodo statico assign(target, source) copia tutte le enumerable own properties da uno (o più) oggetti ad un oggetto target e poi ritorna quest'ultimo. Se l'oggetto target ha già delle proprietà con le stesse chiavi queste vengono sovrascritte. Se durante la copia viene generato un errore il processo si interrompe.
var secchi = {
farina: 500,
zucchero: 300
};
var liquidi = {
latte: 200,
uova: 3
};
var torta = Object.assign({}, secchi, liquidi);
console.log(torta); // {farina: 500, zucchero: 300, latte: 200, uova: 3}
var cappuccino = {
latte: 200
}
Object.assign(cappuccino, { caffe: 1 });
console.log(cappuccino); //{latte: 200, caffe: 1} Object.assign modifica l'oggetto target e lo ritorna
//ma non è necessario utilizzare l'oggetto ritornato
var verdure = {
cipolla: 1,
carota: 1
}
var frittata = Object.assign({ uova: 3 }, verdure);
console.log(frittata); //{uova: 3, cipolla: 1, carota: 1}
let condimenti = {
mozzarella: true,
verdure: {
zucchine: 1,
peperoni: 1
}
};
let pizza = Object.assign({}, condimenti);
console.log(pizza); //{mozzarella: true, verdure: {zucchine: 1, peperoni: 1}}
condimenti.mozzarella = false; //questa modifica non ha effetto sull'oggetto creato
console.log(pizza);//{mozzarella: true, verdure: {zucchine: 1, peperoni: 1}}
condimenti.verdure.zucchine = 2; //questa modifica invece ha effetto perchè viene passato il riferimento all'oggetto verdure
console.log(pizza); //{mozzarella: true, verdure: {zucchine: 2, peperoni: 1}}
class Dog {
constructor(color) {
this.color = color;
}
}
var doberman = new Dog("nero");
var alano = Object.assign({}, doberman);
console.log(alano); //{color: nero}
console.log(alano instanceof Dog); //false sono solo state assegnate le proprietà ma rimane comunque un oggetto normale
//se invece che passare un oggetto come source passiamo un tipo primitivo
//questo non ha effetto tranne nel caso della stringa
var resultUnd = Object.assign({}, undefined);
console.log(resultUnd); //{}
var resultNl = Object.assign({}, null);
console.log(resultNl); //{}
var resultBool = Object.assign({}, true);
console.log(resultBool); //{}
var resultNum = Object.assign({}, 3);
console.log(resultNum); //{}
var resultStr = Object.assign({}, "ciao");
console.log(resultStr); //{0: "c", 1: "i", 2: "a", 3: "o"}Nel contesto della programmazione funzionale questo è il metodo che viene usato (assieme allo spread operator) per copiare un oggetto senza incorrere nei problemi causati dal passaggio di valori per riferimento.
create()
Il metodo statico create() crea un nuovo oggetto a partire dal prototype di uno già esistente ed eventualmente assegna proprietà mancanti nell'oggetto di partenza.
class Animal {
constructor(type) {
this.type = type;
}
}
var bugsBunny = new Animal("rabbit");
var duffyDuck = Object.create(bugsBunny);
console.log(duffyDuck instanceof Animal); //true
console.log(duffyDuck.type); //"rabbit"
var titti = Object.create(bugsBunny, {
color: {
writable: true,
enumerable: true,
configurable: true,
value: 'yellow'
},
legs: {
writable: false,
enumerable: false,
configurable: false,
value: 2
}
});
console.log(titti.type); //"rabbit"
console.log(titti.color); //"yellow"
console.log(titti.legs); //2
var silvestro = Object.create(titti);
console.log(silvestro.type); //"rabbit"
console.log(silvestro.color); //"yellow"
console.log(silvestro.legs); //2
silvestro.type = "cat";
silvestro.color = "black&white";
silvestro.legs = 4;
console.log(silvestro.type); //"cat"
console.log(silvestro.color); //"black&white"
console.log(silvestro.legs); //2 la proprietà legs è non writablegetPrototypeOf()
Il metodo statico getPrototypeOf() ritorna il prototype di un oggetto:
var literal = {};
var date = new Date();
var set = new Set();
class Cat {
constructor(breed) {
this.breed = breed;
}
}
var fuffi = new Cat("soriano");
console.log(Object.getPrototypeOf(literal)); //il prototype di un oggetto
console.log(Object.getPrototypeOf(date)); //il prototype di una data
console.log(Object.getPrototypeOf(set)); //il prototype di un set
console.log(Object.getPrototypeOf(fuffi)); //ilprototype della classe Cat setPrototypeOf()
Il metodo statico setPrototypeOf() assegna il prototype di un oggetto ad un altro.
class Car {
constructor(brand) {
this.brand = brand;
}
roar() {
console.log("brum brum");
}
}
var giulietta = new Car("Alfa Romeo");
var miTo = Object.setPrototypeOf({}, giulietta);
console.log(miTo instanceof Car); //true
miTo.roar(); //"brum brum"isPrototypeOf()
Il metodo isPrototypeOf() serve per sapere se un dato prototype sta nella prototype chain di un altro oggetto.
class Person { }
class Woman extends Person { }
var maria = new Woman();
console.log(Person.prototype.isPrototypeOf(maria)); //trueis()
Il metodo statico is() serve per confrontare due valori e restituisce gli stessi risultati dell'operatore === tranne nei casi in cui si confrontino +0 e -0 e due NaN.
console.log(Object.is(+0, -0)); //false
console.log(+0 === -0); //true
console.log(Object.is(NaN, NaN)); //true
console.log(NaN === NaN); //falsekeys()
Il metodo statico keys() serve per ottenere un array con i nomi delle enumerable own properties di un oggetto, per poi poter iterare su di esse.
var persona = {
nome: "Mario",
cognome: "Rossi",
anni: 20
}
var chiavi = Object.keys(persona);
console.log(chiavi); //["nome", "cognome", "anni"]
chiavi.forEach(prop => {
console.log(persona[prop]); //stampa i valori "Mario", "Rossi" e 20
});
values()
Il metodo statico values() serve per ottenere un array con i valori delle enumerable own properties di un oggetto, per poi poter iterare su di esse.
var persona = {
nome: "Mario",
cognome: "Rossi",
anni: 20
}
var valori = Object.values(persona);
console.log(valori); //["Mario", "Rossi", 20]entries()
Il metodo statico entries() ritorna un array di coppie array contenenti i nomi e i valori delle enumerable own properties di un oggetto.
var persona = {
nome: "Mario",
cognome: "Rossi",
anni: 20
}
var entries = Object.entries(persona);
console.log(entries); //[["nome", "Mario"], ["cognome", "Rossi"], ["anni", 20]]fromEntries()
Il metodo statico fromEntries() crea un oggetto a partire da una lista di coppie chiave-valore.
var persona = Object.fromEntries([["nome", "Mario"], ["cognome", "Rossi"], ["anni", 20]]);
console.log(persona); //{nome: "Mario", cognome: "Rossi", anni: 20}
//si può passare qualunque iterable
var persona2 = Object.fromEntries(new Map([
["nome", "Maria"],
["cognome", "Bianchi"],
["anni", 30]
]));
console.log(persona2);//{nome: "Maria", cognome: "Bianchi", anni: 30}
preventExtensions() / isExtensible()
freeze() / isFrozen()
Il metodo statico freeze() "congela" un oggetto, cioè:
- non si possono aggiungere (non è estensibile) o togliere proprietà
- non si può cambiare il valore di una proprietà esistente
- tutte le sue proprietà sono non configurable e non writable
- non si possono cambiare le proprietà enumerable, writable e configurable delle proprietà dell'oggetto
- non si può cambiare il prototype dell'oggetto
tentare queste modifiche a volte porta ad un errore, a volte fallisce silenziosamente.
Il metodo statico isFrozen() ritorna true se l'oggetto è "congelato".
var persona = {
nome: "Mario",
cognome: "Rossi",
anni: 20
}
Object.freeze(persona);
console.log(Object.isFrozen(persona)); //true
persona.nome = "Giuseppe"; //fallisce silenziosamente
persona.lavoro = "operaio"; //fallisce silenziosamente
delete persona.anni; //ritorna false
console.log(persona); //{nome: "Mario", cognome: "Rossi", anni: 20}
console.log(Object.getOwnPropertyDescriptors(persona)); //
{
anni: {
configurable: false
enumerable: true
value: 20
writable: false
}
cognome: {
configurable: false
enumerable: true
value: "Rossi"
writable: false
}
nome: {
configurable: false
enumerable: true
value: "Mario"
writable: false
}
}
persona = {};
console.log(persona); //{} si può riassegnare anche se "congelato"
var fido = {
zampe: 4,
coda: 1,
verso: "abbaia"
}
Object.freeze(fido);
var pluto = fido;
pluto.verso = "parla"; //fallisce silenziosamente
console.log(pluto); //{zampe: 4, coda: 1, verso: "abbaia"}
var pluto2 = Object.assign({}, pluto);
pluto2.verso = "parla"; //questa modifica ha effetto
console.log(pluto2); //{zampe: 4, coda: 1, verso: "parla"}
seal() / isSealed()
Il metodo statico seal() è un po' meno restrittivo del freeze(), cioè:
- non si possono aggiungere (non è estensibile) o rimuovere proprietà
- si possono modificare proprietà esistenti se esse sono writable
- tutte le sue proprietà sono non configurable
hasOwnProperty()
defineProperties() / defineProperty()
getOwnPropertyDescriptor() / getOwnPropertyDescriptors()
getOwnPropertyNames()
getOwnPropertySymbols()
propertyIsEnumerable()
toString()
Il metodo toString() restituisce una rappresentazione in stringa dell'oggetto. Non è molto utile, infatti spesso viene ridefinito.
class Fish {
constructor(colors) {
this.colors = colors;
}
}
var nemo = new Fish(["arancione", "bianco", "nero"]);
console.log(nemo.toString()); "[object Object]"
Fish.prototype.toString = function() {
return "Sono un pesciolino tanto carino!";
}
console.log(nemo.toString()); //"Sono un pesciolino tanto carino!"toLocaleString()
valueOf()
Il metodo valueOf() ritorna il valore primitivo associato ad un oggetto, se c'è, se no ritorna l'oggetto stesso. Funziona solo per quegli oggetti delle classi Number, String, Boolean, che possono essere espressi come primitivi o come oggetti.
Di solito non si chiama direttamente questo metodo ma viene usato internamente da JavaScript.
var a = new Boolean(true);
var b = new String("a");
var c = new Number(3);
var d = { nome: "Pippo"}
console.log(a.valueOf()); //true
console.log(b.valueOf()); //"a"
console.log(c.valueOf()); //3
console.log(d.valueOf()); //{nome: "Pippo"}