1. 简介

一个对象去达到某个目的时可能会面临不同的选择，比如你想出去旅游，可以选择的交通方式有骑车，开车或者坐火车。这些交通方式的选择其实就是达成旅游目的的不同策略，选择哪一个都能达到目的，它们之间其实是对等的，可以互相替换的关系。

2. 常规实现

我们已旅游交通方式的选择为例，常规的实现如下。

"use strict";
class Traveler {
    constructor(name) {
        this.name = name;
    }
    travel(type) {
        switch (type) {
            case 'ride':
                console.log(`${this.name}骑车去旅游`);
                break;
            case 'drive':
                console.log(`${this.name}开车去旅游`);
                break;
            case 'train':
                console.log(`${this.name}乘火车去旅游`);
                break;
            default:
                console.log('请选择正确的出行方式');
                break;
        }
    }
}
const traveler = new Traveler('小明');
traveler.travel('ride'); // 小明骑车去旅游
traveler.travel('drive'); // 小明开车去旅游

这个实现简单，条理清晰，要使用不同的出行方式，传入不同的方式名称即可。但设想一下，如果小明的出行备选方式增加了飞机呢，我们还得修改 travel 这种方式。
用户竟然要去关心出行方法的具体实现，这明显违背开放封闭的法则，对扩展极不友好。事实上，出行者的目的是出行，至于每种出行策略的实现完全可以剥离出去。
另外，在调用出行方法的时候，调用者已经明确了出行方式，那么还要在出行方法中写一大堆逻辑去进行分发，也是完全多余的。你都知道该用什么策略了，直接用就好了。

3. 策略模式

ps：类图太简单了，我就不画了，processon 空间不够了~

interface Stragety {
    execute(name: string): void;
}
class RideStragety implements Stragety {
    execute(name: string): void {
        console.log(`${name}骑车去旅游`);
    }
}
class DriveStragety implements Stragety {
    execute(name: string): void {
        console.log(`${name}开车去旅游`);
    }
}
class TrainStragety implements Stragety {
    execute(name: string): void {
        console.log(`${name}乘火车去旅游`);
    }
}

class Traveler {
    name: string;
    private stragety: Stragety | null;
    constructor(name) {
        this.name = name;
        this.stragety = null;
    }
    setStragety(stragety: Stragety) {
        this.stragety = stragety;
    }
    travel(): void {
        return this.stragety?.execute(this.name);
    }
}

const traveler = new Traveler('小明');
traveler.setStragety(new RideStragety());
traveler.travel(); // 小明骑车去旅游
traveler.setStragety(new DriveStragety());
traveler.travel(); // 小明开车去旅游

我们把具体的实现策略抽到外部专门的策略对象中去实现，扩展起来就很方便。另外，策略的分发直接用 setStragety 来抽取，也能有效减少冗余代码和不需要的判断。