阿里笔试题

var origin = [
    {id:1,title:'title1'},
    {id:2,title:'abcd'},
    {id:3,title:'title2'},
    {id:4,title:'efg'}
];

var find = function(data){
    // your code here
}

var result = find(origin).where({'title':/\d$/}).order('id','desc'); //desc 非递增
console.log(result);  //  [{id:3,title:'title2'},{id:1,title:'title1'}]

写了10分钟左右：随便A了一下

var origin = [
    {id: 1, title: 'title1'},
    {id: 2, title: 'abcd'},
    {id: 3, title: 'title2'},
    {id: 4, title: 'efg'}
];

var find = function (data) {
    // your code here
    function jquery(data) {

        this.where = function (obj) {

            var arr = [];
            var self = this;
            var key = Object.keys(obj)[0];
            var temp = self.data;

            for (var j = 0; j < temp.length; j++) {


                if (obj[key].test(temp[j][key])) {

                    arr.push(temp[j]);

                }
            }

            this.data = arr;

            return this;
        };
        this.order = function (name, desc) {
               var self =this;
            //降序
            if (desc === "desc") {
                for (var i = 1; i < self.data.length; i++) {

                    var j = i - 1;
                    var key = self.data[i][name];
                    while (j >= 0 && self.data[j][name] < key) {
                        self.data[j + 1][name] = self.data[j][name];
                        j--;
                    }

                    self.data[j + 1][name] = key;

                }

            }


            return self.data;
        };
        this.data = data;

    }

    return new jquery(data);

};

var result = find(origin).where({'title': /\d$/}).order('id', 'desc'); //desc 非递增
console.log(result);  //  [{id:3,title:'title2'},{id:1,title:'title1'}]

 

唉，取属性的时候，hasOwnPrototype我忘记怎么写了，后来查了一下，原来他是用来确认的，我了个，后来机智的我想起来es5好像出了keys这个方法，然后试了试果然用这个，然后就这样咯。排序我用的插入排序，你可以选择冒泡，选择，快排，归并，计数，堆排序等等，不会的可以看我的算法博客。我看了下别人的代码，原来js有sort这个方法。大家自己去了解吧。其实链式调用就是返回this咯，没什么大不了的。反正写的不怎么样，将就看一下吧，完美的话，个人认为在Object.keys()上面做文章。比如我在where方法里传的参数可以有很多keys:

{'title':/\d$/,
 'id:'/[2-4]/,
...
}
那这个时候，就要在做好多次筛选了，怎么做大家自己动脑筋吧。还有就是这个排序。我们现在是只可以传入desc. 其实我们知道有降序就会有升序(asc)，当然还有乱序。 阿里啊，这不是考我们mongodb吗。熟悉mongodb的同学这里是不是看起来很像。

// ali-for
var items = [
    {name:'item1'},
    {name:'item2'}
];
var str = '<div ali-for="item in items">{{item.name}}<div>';

var ParseDom = function(str){
    // your code here
}

// 对应生成的dom
// <div>item1</div>
// <div>item2</div>

 

这题目，我是没做出来，我认为，起码是不能直接认为是div的，一定是匹配html标签。下面填一个别人写的，主要考察的是正则表达式

var items = [  
    {name:'item1'},  
    {name:'item2'}  
];  
var str = '<div ali-for="item in items">{{item.name}}<div>';  
  
var ParseDom = function(str){  

    var reg1 = /\sali-for=\"[a-zA-Z\s]+\"/gi,
        reg2 = /\{{2}[a-zA-Z\.]+\}{2}/gi,
        reg3 = /\.[a-zA-Z]+/gi,
        len = items.length;
    
    var temp = str.replace(reg1,''),
        fill = str.match(reg2)[0],
        key = str.match(reg2)[0].match(reg3)[0].slice(1),
        clone_temp ='',
        str = '';

    for(var i=0;i<len;i++){
        clone_temp = temp;
        str+=clone_temp.replace(fill,items[i][key]);
    }

    console.log(str);

}  

 

这个答案我是不满意的，最近也准备写一些正则方面的文章，等有时间了，自己好好的实现一下，不过有看到的博友，有好的想法，可以在评论里共享一下，好的话就用你的作为解法，给大家参考。


今天自己写了一个版本，进步也挺多的，附上我的代码：

var obj = {
    rformat: /\{\{([^{}]+)\}\}/gm, //匹配所有{{ res.key }}
    resobj: /\..*/,  //对.key进行处理
    // repeat1: /(?!\sali-for=)\".*\"/gi,
    repeat1: /\sali-for=(\".*\")/gi,
    repeat2: /\sali-for=\".*\"/gi,
    htmlstr: '<div ali-for="item in items">{{item.name}}</div>',
    getinfo: function () {
        var str = this.repeat1.exec(this.htmlstr)[1];
        str = str.slice(1, str.length - 1); //去除两端双引号
        return str.split(" ");
    },
    items: {
        one: {
            name: "小明"
        },
        two: {
            name: "小王"
        }
    },
    replaceAll: function (str, regexp, sptr) {

        while (regexp.test(str)) {
            str = str.replace(regexp, sptr);

            return str;
        }

    },

    change4dom: function () {
        var arr = this.getinfo();
        var res = this[arr[2]] || {}; //资源对象 items
        var res_child = arr[0]; //资源子对象 item
        var htmldom = "";
        var keyname = /(?!\.).*/i;
        var ItemRegexp = /\w*(?=\.)/i; //检查时候是否item

        for (var key in  res) {
            //将 {{ item.key }} 替换掉
            htmldom += this.htmlstr.replace(this.rformat, function ($0, $1) {
                // all：{{ item.key }} , $1：item.key
                try {
                    
                     var A = $1.split(".");
                    var isItem = A[0];
                    var value = A[1];

                    if (isItem === res_child) {
                        return res[key][value];

                    } else {
                        throw new Error('不匹配');
                    }
                } catch (e) {

                    return $0; //错误原样返回
                }
            });
            htmldom = this.replaceAll(htmldom, this.repeat2, function ($0, $1) {
                return "";
            });

        }


        return htmldom;
    }
};


console.log(obj.change4dom());

主要是进步在于原来replace只替换第一个匹配的，我们可以迭代实现replaceAll,还有就是

 

  虽然这些在上面用不到，还有就是js不支持(?<=pattern)