简单工厂模式(Simple Factory):又叫静态工厂方法，由一个工厂对象决定创建某一种产品对象类的实例。主要用来创建同一类对象。

场景一

假设我们需要计算圆形和矩形的面积

    function Circle(radius) {
        this.radius = radius;
    }

    Circle.prototype.getArea = function() {
        return Math.PI * this.radius * this.radius;
    };

    // 定义矩形构造函数
    function Rectangle(width, height) {
        this.width = width;
        this.height = height;
    }

    Rectangle.prototype.getArea = function() {
        return this.width * this.height;
    };

    // 定义简单工厂函数
    function ShapeFactory(shapeType, params) {
        var shape;
        if (shapeType === 'circle') {
            shape = new Circle(params.radius);
        } else if (shapeType === 'rectangle') {
            shape = new Rectangle(params.width, params.height);
        } else {
            throw new Error('请重新选择');
        }
        return shape;
    }

    // 使用简单工厂函数创建形状对象
    var circle = ShapeFactory('circle', { radius: 5 });
    var rectangle = ShapeFactory('rectangle', { width: 4, height: 10 });

    // 计算并打印形状的面积
    console.log('Circle area:', circle.getArea()); // 输出: Circle area: 78.53981633974483
    console.log('Rectangle area:', rectangle.getArea()); // 输出: Rectangle area: 40

两个构造函数Circle和Rectangle，它们分别表示圆形和矩形，并且都拥有一个getArea方法来计算面积。ShapeFactory是简单工厂函数，它接收一个形状类型shapeType和一个包含形状参数的params对象。根据shapeType的不同，工厂函数会创建并返回相应类型的形状对象。最后用ShapeFactory函数来创建圆形和矩形对象，并调用它们的getArea方法来计算面积。

场景二

创建不同类型的动物对象狗、猫。

    // 定义动物基类
    class Animal {
        constructor(name) {
            this.name = name;
        }
        speak() {
            console.log(`${this.name} 叫`);
        }
    }
    // 定义狗类
    class Dog extends Animal {
        speak() {
            console.log(`${this.name} 狗`);
        }
    }
    // 定义猫类
    class Cat extends Animal {
        speak() {
            console.log(`${this.name} 猫`);
        }
    }
    // 定义简单工厂类
    class AnimalFactory {
        static createAnimal(type, name) {
            let animal;
            switch (type) {
                case 'dog':
                    animal = new Dog(name);
                    break;
                case 'cat':
                    animal = new Cat(name);
                    break;
                default:
                    throw new Error('Invalid animal type');
            }
            return animal;
        }
    }

    // 使用简单工厂创建动物对象
    let dog = AnimalFactory.createAnimal('dog', '旺财');
    let cat = AnimalFactory.createAnimal('cat', '小花');

    // 让动物发声
    dog.speak(); // 输出: 旺财 狗
    cat.speak(); // 输出: 小花 猫

定义了一个Animal基类，以及两个继承自Animal的子类Dog和Cat。然后，我们创建了一个AnimalFactory简单工厂类，它有一个静态方法createAnimal，根据传入的类型参数type来创建并返回相应的动物对象。最后使用AnimalFactory来创建狗和猫的对象，并调用它们的speak方法。

场景三

创建不同类型的汽车对象

// 定义汽车构造函数
function Car(model, year, color) {
  this.model = model;
  this.year = year;
  this.color = color;
}

// 定义简单工厂函数
function CarFactory() {}

// 工厂函数的原型上添加创建汽车的方法
CarFactory.prototype.createCar = function (type) {
  switch (type) {
    case 'SUV':
      return new Car('SUV', 2022, 'black');
    case 'Sedan':
      return new Car('Sedan', 2021, 'white');
    case 'Hatchback':
      return new Car('Hatchback', 2020, 'blue');
    default:
      throw new Error('Invalid car type.');
  }
};

// 使用简单工厂创建汽车对象
var factory = new CarFactory();
var suv = factory.createCar('SUV');
var sedan = factory.createCar('Sedan');
var hatchback = factory.createCar('Hatchback');

console.log(suv);
console.log(sedan);
console.log(hatchback);

最终输入

  Car 构造函数用于创建汽车对象，而 CarFactory 则是一个简单工厂，用于根据指定的类型创建不同的汽车对象。

场景四

        比如说体育商品店卖体育器材，里面有很多体育用品，及其相关介绍等。当你来到体育用品店买一个篮球和足球等，你只需要问售货员，他会帮你找到你所要的东西。

    //蓝球
    let basketball=function(){
        this.intor="蓝球运动"
    }
    basketball.prototype={
        getMember:function () {
            console.log("需要的队员")
        },
        getBallsize:function () {
            console.log("蓝球很大")
        }
    }
    //足球
    let football=function () {
        this.intro="足球"
    }
    football.prototype={
        getMember:function () {
            console.log("需要11名队员")
        },
        getBallsize:function () {
            console.log("足球很大")
        }
    }
    //网球
    let tennis=function () {
        this.intro="每年有很多网球比赛"
    }
    tennis.prototype={
        getMember:function () {
            console.log("网球比赛很精彩")
        },
        getBallsize:function () {
            console.log("网球很好玩")
        }
    }
    //运动工大
    let sportsFactory=function (name) {
        switch (name) {
            case 'NAB':
                return new Basketball();
            case 'wordcup':
                return new football();
            case 'frenchopen':
                return new tennis()
        }
    }
    //进行使用 创建一个足球
    let footnall = sportsFactory('wordcup')
    console.log(footnall.intro)
    footnall.getMember()//需要11名队员

场景五

如果想创建一些书，那么这些书都有一些相似的地方，比如目录、页码等。也有一些不相似的地方，如书名、出版时间、书的类型等，对于创建的对象相似的属性好处理，对于不同的属性就要有针对性地进行处理了，比如我们将不同的属性作为参数传递进行处理。

    function createBook(name,time,type) {
        //创建一个对象，并对对象拓展属性和方法
        let o = new Object()
        o.name=name
        o.time=time
        o.type=type
        o.getName=function () {
            console.log(this.name,this.time,this.type)
        }
        //将对象返回
        return o
    }
    let book1=createBook('语文',2024,'海')
    let book2=createBook('国学',2024,'论语')
    book1.getName()//语文 2024 海
    book2.getName()//国学 2024 论语

总结：通过对简单工厂模式来创建一些对象，可以让这些对象共用一些资源而又私有一些资源。不过对于简单工厂模式，它的使用场合通常也就限制在创建单一对象。