文件内容排名算法，输入排名函数，返回排名后的文件名

缓存优化查询

const fs=require('fs');
//比较字符基类大小 相同返回0，str1>str2 返回1，str1<str2 返回-1，
function str_compare(str1,str2){
    let index=0;
    let dis=0;
    while (dis===0&&index<str1.length){
        if(str1.charCodeAt(index)>str2.charCodeAt(index)){
            dis=1
        }else if(str1.charCodeAt(index)<str2.charCodeAt(index)){
            dis=-1
        }else{
            index++;
            if(index>str2.length){
                dis=1;
            }
        }
    }
    if(dis===0&&index<str2.length){
        dis=-1
    }
    return dis;
}
//查找
function find(str,hasSortArr,callback) {
    let l=0,r=hasSortArr.length;
    let index=-1;
    if(hasSortArr.length>0){
        const ri=callback(str,hasSortArr[r-1]);
        if(ri===1){
            return [r,-1]
        }else if(ri===0){
            return [r-1,r-1]
        }else{
            r=r-1;
        }
        const li=callback(str,hasSortArr[0]);
        if(li===-1){
            return [0,-1]
        }else if(li===0){
            return [0,0]
        }else{
            l=l+1;
        }
        while(r-l>0){
            const m=(l+r)>>1;
            //比较下坐标大小
            const order=callback(str,hasSortArr[m])
            if(order===1){
                l=Math.max(l+1,m)
            }else if(order===-1){
                r=Math.min(r-1,m)
            }else{
                l=r=m;
                index=m;
            }
        }
    }
    return [(l+r)>>1,index]
}
//输入排名函数，返回-1,0,1
function sort(list,compare){
    const hasSortArr=[]
    for(let i=0;i<list.length;i++){
        const [n,index]=find(list[i],hasSortArr,compare)
        if(index===-1){
            //增加、插入
            hasSortArr.splice(n,0,list[i])
        }
    }
    return hasSortArr;
}
let cacheArr=[]
const cacheLen=10;
//用缓存优化查询
function getValByCache(obj,callback) {
    const keys=Object.keys(obj);
    const arr=[]
    let len=0;
    for(let i=0;i<cacheArr.length;i++){
        for(let j=0;j<keys.length;j++){
            if(cacheArr[i].name===keys[j]){
                arr[j]=i;
                len++;
            }
        }
        if(len===keys.length){
            break;
        }
    }
    for(let i=0;i<keys.length;i++){
        const key=keys[i]
        if(arr[i]>-1){
            cacheArr[arr[i]].time=Date.now();
            obj[key]=cacheArr[arr[i]].val;
        }else{
            const val=callback(key)
            obj[key]=val;
            cacheArr.unshift({
                name:key,
                val:val,
                time:Date.now()
            })
        }
    }
    //清理
    if(len>0&&cacheArr.length>cacheLen){
        //按照时间排序
        cacheArr.sort(function (p1,p2) {
            if(p1.time<p2.time){
                return 1;
            }else{
                return -1
            }
        })
        cacheArr.splice(cacheLen,cacheArr.length-cacheLen)
    }
}
/* demo
文件内容排名算法，输入排名函数，返回排名后的文件名
 */
const dir=__dirname+'/data/';
const list=fs.readdirSync(dir);

const hasSortArr=sort(list,function (name1,name2) {

    const obj={}
    obj[name1]=null;
    obj[name2]=null;
    getValByCache(obj,function (name1) {
        return fs.readFileSync(dir+name1).toString();
    })
    const cont1=obj[name1];
    const cont2=obj[name2]
    return str_compare(cont1,cont2)
})
console.log(hasSortArr)