Leetcode.71.栈.简化路径.策略模式

题目描述：

要求：

1. 返回的路径必须以/开头
2. 两个目录名之间必须只有一个/
3. 最后一个目录名不能以/结尾
4. 不能出现两个..相连

标准答案

  let result = [];
  // 注意使用转义字符，其实没有转义字符也能分割开
  let pathArr = path.split("\/");
//  遍历数组，如果有两个`.`相连，删除上级目录
//  如果两个`/`之间有一个`.`，跳过，不处理
//  如果有两个`/`相连（分割后，两个`/`之间会产生一个空数组元素），
  pathArr.forEach(val => {
    if (val === "..")
      result.pop();
    else if (val !== "" && val !== ".")
      result.push(val)
  })
  return "/" + result.join("/")
};

效率：

策略模式实现

    // Leetcode.71.简化路径.策略模式
    // 要求：使用策略模式
    // 选择策略与策略实现分离
    // 可复用，弹性充足
    // 输入一个字符串，选择策略，对字符串进行筛选

    /**
     * @param {string} path
     * @return {string}
     */


    /*
    * 策略模式，分为两个部分，一部分是存放策略，一部分是存放策略的挑选，执行代码。
    * 策略的挑选执行要单独设置一个类，存放挑选出来的
    * */




    var simplifyPath = function(path) {
        let stageties = {

            // 必须以斜杠" / "开头
            isStartSprit(value,errMsg){
                // 字符串有startwith方法
                if(!value.startsWith("/")){
                    let cache = value.split("");
                    cache.unshift("/");
                    return cache.join("");
                }

                return value;

            },
            // 两个目录名之间必须只有一个斜杠
            interSoleSprit(value,errMsg){
                let cache = value.split("");
                if(cache.length===0||cache.length===1){return value}

                let test = cache[0];
                for(let i = 1;i<cache.length;i++){
                    // console.log(`test:${test},cache[${i}]:${cache[i]}`);
                    if(test===cache[i] && cache[i]==="/"){
                        cache.splice(i,1)
                    }
                    stageties = cache[i];
                }

                return cache.join("");

            },
            // 最后一个目录名如果存在，不能以斜杠" / "结尾
            isEndSprit(value,errMsg){
                // 字符串有endWidth方法
                if(!value.endsWith("/")){
                    return value;
                }else{
                    let cache = value.split("");
                    cache.pop();
                    return cache.join("");
                }

            },

            //规范路径必须是表示绝对路径的最短字符
            isShortest(value,errMsg){
                // 字符串中是否有返回上一级的 " ../ "
                let cache = value.split("");
                if(cache.length===0||cache.length===1){return value}

                let test = cache[0];
                for(let i = 1;i<cache.length;i++){

                    if(stageties===cache[i] && cache[i]==="."){
                        cache.splice(i,1);
                    }
                    stageties = cache[i];
                }

                return cache.join("");

            }
        };
        function Validator(path){
            this.fnc = [];
            this.path = path;
        }

        Validator.prototype.addRule = function(rule,errMsg){

            this.fnc.push({rule,errMsg});

        };

        Validator.prototype.start = function(){
            for(let i = 0;i < this.fnc.length;++i){
                let obj = this.fnc;
                console.log(i, this.fnc[i]);
                this.path = stageties[obj[i].rule](this.path,obj[i].errMsg);

            }
        };

        //  向实例中添加将要调用的规则
        let test = new Validator(path);
        test.addRule("isStartSprit",'必须以斜杠" / "开头');
        test.addRule("interSoleSprit","两个目录名之间必须只有一个斜杠");
        test.addRule("isEndSprit","最后一个目录名如果存在，不能以斜杠结尾");
        test.addRule("isShortest","规范路径必须是表示绝对路径的最短字符");

        console.log(test.fnc);
        test.start();

        return test.path



    };

    console.log(simplifyPath("/home/"));
    // 问题： 106行 start方法中出现错误 error: Cannot read property 'isEndSprit' of undefined
    //

虽然出了一个自己一直没有办法解决的错，但是在实现的过程中，还是对策略模式有了更深的体会。
可以随时向stageties中添加要校验的策略规则，并通过Vadidator实例中的方法调用校验规则。

• 校验规则可以随时替换
• 避免了使用多重条件判断语句
• 程序的扩展性良好
• 代码复用性高