Конструктор против объектного литерала против шаблона модуля raveling

Question

Прошло некоторое время, когда я пишу код спагетти с помощью javascript. Я попытался организовать свой код, но я смущен, какой из них использовать и когда использовать определенный шаблон.

конструктор модель

function foods(food){ 
    this.food = food; 
    this.eat = function(){ 
    return 'I"m eating ' + this.food; 
    } 
} 

var eatApple = new foods("apple"); 
console.log(eatApple.eat()); 

var eatBanana = new foods("banana"); 
console.log(eatBanana.eat()); 

литерал объекта

var foods = { 
    food : null, 
    eat : function(){ 
    return 'I"m eating ' + this.food; 
    } 
}; 

foods.food = 'apple'; 
console.log(foods.eat()); 

foods.food = 'banana'; 
console.log(foods.eat()); 

раскрывая модуль

var foods = function(){ 
    var defaultFood = "default food"; 
    function eat(food){ 
    //this is ugly 
    if(food){ 
     food = food; 
    }else{ 
     food = defaultFood; 
    } 
    return 'I\"m eating ' + food; 
    } 

    return { 
    eat: eat 
    }; 
}(); 

var justEating = foods.eat(); 
var eatingApple = foods.eat('apple'); 
var eatingBanana = foods.eat('banana'); 

console.log(justEating); 
console.log(eatingApple); 
console.log(eatingBanana); 

Я думаю, что литерал объекта является наиболее часто используемым, почему не все просто использовать это? И показывает ли модуль еще актуальным в 2016 году? большинство людей просто будут делать module.exports.

Answer 1

Я не буду рекомендовать шаблон объектного литерала, потому что его трудно использовать в качестве шаблона. Я не знаю о раскрытии модуля, но стиль кодирования выглядит уродливым и громоздким.

Рассмотрим пример,

Object буквальное:

var Fruit = { 
    type: "Banana", 
    getType: function(){ 
    alert("My type is " + this.type); 
    } 
} 

Fruit.type = banana; 
Fruit.type = mango; 
Fruit.getType(); // displays My type is Mango 

Теперь, если вы хотите добавить тип фруктов, как «Манго», то опять придется писать весь объект или изменить выше одного. Другими словами, он не ведет себя как экземпляр класса, поэтому становится трудно его использовать.

Если бы это был шаблон конструктора, то это было бы очень легко.

Constructor картина:

var Fruit = function(type){ 
    this.type = type 
} 

Fruit.prototype.getType = function(){ 
    alert("My type is " + this.type); 
} 

var banana = new Fruit("Banana"); 
var mango = new Fruit("Mango"); 
banana.getType(); // displays My type is Banana 
mango.getType(); // displays My type is Mango 

Все это действует как класс (шаблон) и становится легко создавать различные экземпляры одного и того же. Также становится очень легко наследовать.

Checkout ES6, the syntax is sweet

Update:

Раскрытие шаблон модуль:

Это один использует замыкание и он склонен к ошибкам, если не использовать осторожно. Например,

var Fruit = function(){ 
    var type = null; 
    var getType = function(){ 
    return "My type is " + type; 
    }; 

    return { 
    type: type, 
    getType: getType 
    } 
} 

var newFruit = Fruit(); 
newFruit.getType(); // My type is null 

newFruit.type = "Banana"; 
newFruit.getType(); // My type is null 

В данном конкретном случае, даже если вы измените тип, функция GetType() обыкновение выполнять, как и ожидалось, как он до сих пор помнит переменные из внешней функции фруктам(). Такое поведение является следствием замыканий.