在观看视频教程时,主持人建议使用可组合的工厂函数,而不是使用bind或arrow函数,但是我想我已经看到了一个问题,想知道我是否正确理解了,下面是代码: / p>
if(current->next.value == searched_value)
这种使用类语法的缺点是,现在newDragon对象将永远设置为“ fire”作为元素,要更改它,您必须创建一个新对象?
仿佛这是一个具有element属性的类实例一样,那么您可以为该属性重新分配一个新值,我明白吗?
答案 0 :(得分:0)
是的,使用工厂参数的闭包(并且不提供setter方法),element
本质上是一个常数。这种模式非常适合在函数式编程中创建不可变对象。对于传统的OOP而言,它就不那么多了。
答案 1 :(得分:0)
“ ......对象将永远设置为“射击”,因为要永久更改它,您必须创建一个新对象吗?” < / p>
听起来像物体的组成。尽管对象是不可变的,但使用工厂功能可以很容易地将对象摇出。
工厂函数summonDragon()
有一个名为dragon
的对象,该对象类似于 a contructor()
(当然不是因为类涉及原型)
课程:
constructor(name) { this.name = name; }
工厂:
let dragon = { name: name };
Concatenative inheritance可以由Object.assign()
使用。对象powers
具有方法:.breath()
和.flight()
,它们将由dragon
对象继承。
const powers = dragon => ({
breath: () => {
const damage = dragon.element;
switch (damage) {
case 'fire':
return `${dragon.name} breathes fire causing ${dragon.attack * 3} damage`;
case 'ice':
return `${dragon.name} breathes ice causing ${dragon.attack * 2} damage`;
default:
return;
}
},
flight: () => {
if (dragon.age >= 300) {
return `${dragon.name} flies fast`;
}
if (dragon.age < 300 && dragon.age >= 150) {
return `${dragon.name} flies average`;
}
if (dragon.age < 150) {
return `${dragon.name} flies slow`;
}
}
});
const summonDragon = (name, age, element) => {
let dragon = {
name: name,
age: age,
element: element,
defense: age * 10,
attack: age * 15
};
return Object.assign(dragon, powers(dragon));
};
const redDragon = summonDragon('smaug', 761, 'fire');
const whiteDragon = summonDragon('fröst', 101, 'ice');
redDragon.breath();
redDragon.flight();
whiteDragon.breath();
whiteDragon.flight();
console.log(`${redDragon.name} - Attack: ${redDragon.attack}`);
console.log(`${whiteDragon.name} - Attack: ${whiteDragon.attack}`);
console.log(redDragon.flight());
console.log(whiteDragon.flight());
console.log(redDragon.breath());
console.log(whiteDragon.breath());