JS设计模式

// 各种生成器
class VegBurger extends Burger {
  price() {
    return 25.0
  }
  name() {
    return "Veg Burger"
  }
}

class ChickenBurger extends Burger {
  price() {
    return 50.0
  }
  name() {
    return "Chicken Burger"
  }
}

class Coke extends Drink {
  price() {
    return 3.0
  }
  name() {
    return "Coke"
  }
}

class VlcPlayer {
  playVlc(fileName) {
    console.log(`Vlc file:${fileName} is playing`)
  }
}

class Mp3Player {
  playMp3(fileName) {
    console.log(`Mp3 file:${fileName} is playing`)
  }
}

class Mp4Player {
  playMp4(fileName) {
    console.log(`Mp4 file:${fileName} is playing`)
  }
}

class MediaAdapter {
  constructor(audioType) {
    switch(audioType) {
      case 'vlc':
        MediaAdapter.MusicPlayer = new VlcPlayer()
        break;
      case 'mp3':
        MediaAdapter.MusicPlayer = new Mp3Player()
        break;
      case 'mp4':
        MediaAdapter.MusicPlayer = new Mp4Player()
        break;
    }
  }
  play(audioType, fileName) {
    switch(audioType) {
      case 'vlc':
        MediaAdapter.MusicPlayer.playVlc(fileName)
        break;
      case 'mp3':
        MediaAdapter.MusicPlayer.playMp3(fileName)
        break;
      case 'mp4':
        MediaAdapter.MusicPlayer.playMp4(fileName)
        break;
    }
  }
}

class AudioPlayer {
  play(audioType, fileName) {
    switch(audioType) {
      case 'vlc':
      case 'mp3':
      case 'mp4':
        AudioPlayer.mediaAdapter = new MediaAdapter(audioType)
        AudioPlayer.mediaAdapter.play(audioType, fileName)
        break;
      default:
        console.log(`sorry this type is not supported yet`)
        break;
    }
  }
}

const audioPlayer = new AudioPlayer();

audioPlayer.play('mp3', 'fly me to the moon.mp3')  // Mp3 file: fly me to the moon.mp3 is playing
audioPlayer.play('vlc', 'high way to hell.vlc')  // Vlc file: high way to hell.vlc is playing
audioPlayer.play('mp4', 'help.mp4')  // Mp4 file: help.mp4 is playing

// 实现类 的接口
interface Device {
    isEnabled(): boolean;
    enable(): void;
    disable(): void;
    getVolume(): number;
    setVolume(number): void;
    getChannel(): number;
    setChannel(number): void;
    getName(): string;
}

// 实现类1
class Tv implements Device {
    private name: "Tv";
    private state: "close" | "open";
    private volume: number;
    private channel: number;
    constructor() {
        this.name = "Tv";
        this.state = "close";
        this.volume = 0;
        this.channel = 0;
    }
    isEnabled(): boolean {
        return this.state === "open";
    }
    enable(): void {
        this.state = "open";
    }
    disable(): void {
        this.state = "close";
    }
    getVolume(): number {
        return this.volume;
    }
    setVolume(number: any): void {
        this.volume += number;
        this.volume = this.volume > 100 ? 100 : this.volume;
        this.volume = this.volume < 0 ? 0 : this.volume;
    }
    getChannel(): number {
        return this.channel;
    }
    setChannel(number: any): void {
        this.channel += number;
        this.channel = this.channel < 0 ? 0 : this.channel;
    }
    getName(): string {
        return this.name;
    }
}

// 实现类2
class Radio implements Device {
    private name: "Radio";
    private state: "close" | "open";
    private volume: number;
    private channel: number;
    constructor() {
        this.name = "Radio";
        this.state = "close";
        this.volume = 0;
        this.channel = 0;
    }
    isEnabled(): boolean {
        return this.state === "open";
    }
    enable(): void {
        this.state = "open";
    }
    disable(): void {
        this.state = "close";
    }
    getVolume(): number {
        return this.volume;
    }
    setVolume(number: any): void {
        this.volume += number;
        this.volume = this.volume > 100 ? 100 : this.volume;
        this.volume = this.volume < 0 ? 0 : this.volume;
    }
    getChannel(): number {
        return this.channel;
    }
    setChannel(number: any): void {
        this.channel += number;
        this.channel = this.channel < 0 ? 0 : this.channel;
    }
    getName(): string {
        return this.name;
    }
}

// 抽象类
// 它定义了两个类层次结构中“控制”部分的接口。
// 它管理着一个指向实现类对象的引用，并会将所有真实工作委派给该对象。
// 它扮演了一个桥梁的作用，将用户和device连接起来
class RemoteControl {
    private device: Device;
    constructor(device: Device) {
        this.device = device;
    }

    togglePower() {
        console.log(`toggle ${this.device.getName()} power`);
        if (this.device.isEnabled()) this.device.disable();
        else this.device.enable();
    }

    volumeDown() {
        this.device.setVolume(this.device.getVolume() - 10);
    }

    volumeUp() {
        this.device.setVolume(this.device.getVolume() + 10);
    }

    channelDown() {
        this.device.setChannel(this.device.getChannel() - 10);
    }

    channelUp() {
        this.device.setChannel(this.device.getChannel() + 10);
    }
}

const tv = new Tv();
const tvRemote = new RemoteControl(tv);

tvRemote.togglePower(); // toggle Tv power

const radio = new Radio();
const radioRemote = new RemoteControl(radio);

radioRemote.togglePower(); // toggle Radio power

// 被过滤对象
class Person {
  constructor(name, gender, maritalStatus) {
    this.name = name;
    this.gender = gender;
    this.maritalStatus = maritalStatus;
  }
  getName() {
    return this.name
  }
  getGender() {
    return this.gender
  }
  getMaritalStatus() {
    return this.maritalStatus
  }
}

interface Criteria {
    /**
     * meetCriteria
     */
    meetCriteria(persons: Array<Person>): Array<Person>;
}

class CriteriaMale implements Criteria {
    public meetCriteria(persons: Array<Person>) {
        return persons.filter((person: Person) => {
            if (person.getGender().toUpperCase() === "MALE") {
                return true;
            }
        });
    }
}

class CriteriaFemale implements Criteria {
    public meetCriteria(persons: Array<Person>) {
        return persons.filter((person: Person) => {
            if (person.getGender().toUpperCase() === "FEMALE") {
                return true;
            }
        });
    }
}

class CriteriaSingle implements Criteria {
    public meetCriteria(persons: Array<Person>): Person[] {
        return persons.filter((person: Person) => {
            if (person.getMaritalStatus().toUpperCase() === "SINGLE") {
                return true;
            }
        });
    }
}

// 与筛选
class AndCriteria implements Criteria {
    private criteria: Criteria;
    private otherCriteria: Criteria;
    constructor(criteria: Criteria, otherCriteria: Criteria) {
        this.criteria = criteria;
        this.otherCriteria = otherCriteria;
    }

    public meetCriteria(persons: Array<Person>): Person[] {
        const middleArray = this.criteria.meetCriteria(persons);
        return this.otherCriteria.meetCriteria(middleArray);
    }
}

// 或筛选
class OrCriteria implements Criteria {
    private criteria: Criteria;
    private otherCriteria: Criteria;

    constructor(criteria: Criteria, otherCriteria: Criteria) {
        this.criteria = criteria;
        this.otherCriteria = otherCriteria;
    }

    public meetCriteria(persons: Array<Person>): Person[] {
        const result: Array<Person> = [];
        const firstArray = this.criteria.meetCriteria(persons);
        const secondArray = this.otherCriteria.meetCriteria(persons);

        firstArray.forEach((person: Person) => {
            result.push(person);
        });

        secondArray.forEach((person: Person) => {
            result.push(person);
        });

        return result
    }
}

const showPersons = (persons: Array<Person>) => {
    persons.forEach((person, index) => {
        console.log(person.getName());
    });
};

const personList = new Array<Person>();

personList.push(new Person("Robert", "Male", "Single"));
personList.push(new Person("John", "Male", "Married"));
personList.push(new Person("Laura", "Female", "Married"));
personList.push(new Person("Diana", "Female", "Single"));
personList.push(new Person("Mike", "Male", "Single"));
personList.push(new Person("Bobby", "Male", "Single"));

const maleCriteria = new CriteriaMale();
const femaleCriteria = new CriteriaFemale();
const singleCriteria = new CriteriaSingle();
const singleAndMale = new AndCriteria(singleCriteria, maleCriteria);
const singleOrFemale = new OrCriteria(singleAndMale, femaleCriteria);

console.log("Males: ");
showPersons(maleCriteria.meetCriteria(personList));
/**
 * Males:
 * Robert
 * John
 * Mike
 * Bobby
 */
console.log("Females: ");
showPersons(femaleCriteria.meetCriteria(personList));
/**
 * Females:
 * Laura
 * Diana
 */
console.log("Singles: ");
showPersons(singleCriteria.meetCriteria(personList));
/**
 * Singles:
 * Robert
 * Diana
 * Mike
 * Bobby
 */
console.log("Single And Males: ");
showPersons(singleAndMale.meetCriteria(personList));
/**
 * Single And Males:
 * Robert
 * Mike
 * Bobby
 */
console.log("Single Or Females: ");
showPersons(singleOrFemale.meetCriteria(personList));
/**
 * Robert
 * Mike
 * Bobby
 * Laura
 * Diana
 */

// 组件接口
interface Component {
    getName(): string;
    getSize(): number;
    // 缩进数量
    display(indentation: number): void;
}

// 叶子节点：文件
class MyFile implements Component {
    private name: string;
    private size: number;
    constructor(name: string, size: number) {
        this.name = name;
        this.size = size;
    }
    getName(): string {
        return this.name;
    }

    getSize(): number {
        return this.size;
    }

    display(indentation: number): void {
        let tabLine = "";
        for (let i = 0; i < indentation; i++) tabLine += " ";
        console.log(tabLine + this.name, " Size: " + this.getSize());
    }
}

// 组合节点：文件夹
class Folder implements Component {
    private name: string;
    private size: number;
    private children: Array<Component> = [];

    constructor(name: string, children: Array<Component> = []) {
        this.name = name;
        this.children = children;
        this.size = this.getSize();
    }

    getName(): string {
        return this.name;
    }

    getSize(): number {
        this.size = this.children.reduce((pre, cur) => pre + cur.getSize(), 0);
        return this.size;
    }

    add(child: Component): void {
        this.children.push(child);
    }

    remove(child: Component): void {
        const childIndex = this.children.indexOf(child);
        if (childIndex !== -1) {
            this.children.splice(childIndex, 1);
        }
    }

    display(indentation: number): void {
        let tabLine = "";
        for (let i = 0; i < indentation; i++) tabLine += " ";
        console.log(tabLine + this.name, " Size: " + this.getSize());
        this.children.forEach((component: Component, index) => {
            component.display(indentation + 4);
        });
    }
}

// 部件 （Component）: 数据源
// 声明封装器和被封装对象的公用接口。
interface DataSource {
    writeData(data: string): void;
    readData(): string;
}

// 具体部件 （Concrete Component） 类：文件数据源
// 被封装对象所属的类。 它定义了基础行为， 但装饰类可以改变这些行为。
class FileDataSource implements DataSource {
    private filename: string;
    constructor(filename: string) {
        this.filename = filename;
    }

    writeData(data: string): void {
        console.log(data + " 数据已写入");
    }

    readData(): string {
        return this.filename;
    }
}

// 装饰器基类
class DataSourceDecorator implements DataSource {
    protected wrapper: DataSource;
    constructor(wrapper: DataSource) {
        this.wrapper = wrapper;
    }

    writeData(data: string): void {
        this.wrapper.writeData(data);
    }

    readData(): string {
        return this.wrapper.readData();
    }
}

// 具体装饰器: 加密器
class EncryptionDecorator extends DataSourceDecorator {
    writeData(data: string): void {
        data = data + " 数据已加密";
        this.wrapper.writeData(data);
        // this.wrapper.writeData(data)
    }

    readData(): string {
        let readData = this.wrapper.readData();
        readData = readData + " 数据已解密";
        return readData;
    }
}

// 具体装饰器: 压缩器
class CompressionDecorator extends DataSourceDecorator {
    writeData(data: string): void {
        data = data + " 数据已压缩";
        this.wrapper.writeData(data);
    }

    readData(): string {
        let zipData = this.wrapper.readData();
        zipData = zipData + " 数据已解压";
        return zipData;
    }
}

// 具体引用类：薪资文件管理
class SalaryManager {
    private source: DataSource;
    constructor(source: DataSource) {
        this.source = source;
    }

    load() {
        return this.source.readData();
    }

    save(salaryRecords: string) {
        this.source.writeData(salaryRecords);
    }
}

const getDataSource = (
    enabledEncryption: boolean,
    enabledCompression: boolean
) => {
    let source: DataSource = new FileDataSource("data.txt");
    if (enabledEncryption) {
        source = new EncryptionDecorator(source);
    }
    if (enabledCompression) {
        source = new CompressionDecorator(source);
    }
    return source;
};

// 构造薪资管理器，要求在存储之前进行加密和压缩，在读取之前进行解密和解压缩
const salaryLogger = new SalaryManager(getDataSource(true, true));

salaryLogger.save("salary"); // salary 数据已压缩 数据已加密 数据已写入
console.log(salaryLogger.load()); // data.txt 数据已解密 数据已解压

class VideoFile {
  private name: string
  constructor(name: string) {
    this.name = name
  }
  read(): string {
    return this.name
  }
}

interface Compression {
  compression(buffer: string): string
}

class MPEG4Compression implements Compression {
  compression(buffer: string): string {
    console.log("MPEG4编码文件： ", file.read())
    return "MPEG4编码文件"
  }
}

class OggCompression implements Compression {
  compression(buffer: string): string {
    console.log("OGG编码文件： ", file.read())
    return "OGG编码文件"
  }
}

// 读取视频源码
class CodeFactory {
  extract(file: VideoFile): string {
    console.log("读取视频源码: ", file.read())
    return file.read() + "的源码"
  }
}

// 读取bit流
class BitrateReader {
  static read(filename: string, source: string): string {
    console.log("将名为: ", filename,",的源码: ", source, ",读取为比特流")
    return filename + "的二进制代码"
  }

  static convert(buffer: string, compression: Compression): string {
    let result = compression.compression(buffer)
    console.log("将文件: ", buffer, ", 编码为: ", result)
    return "编码后的" + filename
  }
}

// 混音类
class AudioMixer {
  fix(codeFile: string): string {
    console.log("对文件: ", codeFile, " 进行混音")
    return "混音后的文件" + codeFile
  }
}

class VideoConvert {
  convert(filename: string, format: string): string {
    let file = new VideoFile(filename)
    let sourceCode = (new CodeFactory()).extract(file)
    let compression = null
    if(format === "mp4") {
      compression = new MPEG4Compression()
    } else {
      compression = new OggCompression()
    }
    let buffer = BitrateReader.read(filename, sourceCode)
    let res = BitrateReader.convert(buffer, compression)
    res = (new AudioMixer()).fix(res)
    return res
  }
}

// 使用

convert = new VideoConvert()
mp4 = convert.convert("funny-cats-video.ogg", "mp4")
console.log(mp4)