admin – 第 54 页 – 随身笔记

解决:ttf字体文件cdn跨域问题以及ttf字体文件转base64

解决方法：

需要将字体文件统一转化成base64

按照步骤操作即可。

最后得到：

https://blog.csdn.net/xllily_11/article/details/54585199

Apache服务器解决方法（在conf、或者.htaccess 添加均可）

<FilesMatch "\.(ttf|otf|eot|woff|woff2)$">
 <IfModule mod_headers.c>
    Header set Access-Control-Allow-Origin "*"
 </IfModule>
</FilesMatch>

注意： LoadModule headers_module modules/mod_headers.so 这个模块一定要存在且加载成功的

如果以上模块不加载，单纯的配置 Header 将会报错，亲测踩坑，网上查的很多资料，都没有提及这个模块。

Header set Access-Control-Allow-Origin "*"

注意：线上操作一定要先备份原有的配置文件，修改完配置文件之后一定要将配置文件进行语法检查。

Nginx服务器解决方法（在conf文件修改）

location ~* \.(eot|otf|ttf|woff|woff2)$ {
  add_header Access-Control-Allow-Origin *;
}

2020 06.11

解决：net::ERR_BLOCKED_BY_CLIENT

现象是自己浏览器访问正常，同事浏览器访问有问题，应该是对方浏览器安装了类似广告拦截的插件造成。

2020 06.05

如何让xshell与远程服务器保持连接不断开

1，编辑vi命令打开/etc/ssh/sshd_config

2，找到以下两个字段

ClientAliveInterval 用来指定服务器向客户端发送消息的时间间隔。默认是0，即不发送。
ClientAliveCountMax 用来指定服务器向客户端发送消息的次数。若到达指定的次数，客户端一次也没有回复，那么连接就要断开。

3，

ClientAliveInterval 60 //每隔60秒，服务器就要向客户端发送一次消息，客户端响应后，连接才会保持，否则，断开。
ClientAliveCountMax 3 //可以使用默认值3

4，重启sshd服务：

service sshd restart
或者
/etc/init.d/sshd restart

5，客户端的配置

让客户端每29秒向服务器发一次请求。

https://blog.csdn.net/haijiaoqihao20160106/article/details/50623431

2020 05.16

js数字索引转换字母

// 数字 转 字母
var str = '123'
function options(item){
 let num = ''
 for(let i = 0; i<item.length;++i){
  num+=String.fromCharCode(Number(str[i])+65)
 }
 return num
}
var str1 = options(str)
console.log(str1)//BCD

数字和字母也可以相互转换

// 字母 转 数字
var str = 'ABC'
function options(item){
 let num = ''
 for(let i = 0; i<item.length;++i){
  num+=item.charCodeAt(i)-65
 }
 return num
}
var str1 = options(str)
console.log(str1)//012

https://blog.csdn.net/qq_45074127/article/details/104554339

2020 05.11

js根据id递归获取节点

 var array = [
     {
         id: 1,
         children:[{
             id:2,
             children:[]
         }]
     },

     {
         id:3,
         children:[]
     },

     {
         id:4,
         children:[
             {
                 id:5,
                 children:[
                     {
                         id:6,
                         children:[],
                         path:'aaa',
                     },

                     {
                         id:7,
                         path:'xxx',
                         children:[
                             {
                                 id:187,
                                 path:'zxxx',
                             }
                         ]
                     }
                 ]
             }
         ]
     }
 ]


//根据id找到对应的树节点
 var returnedItem
 var find = function(arr, id){

     for(let i=0;i<arr.length;i++){
         if( arr[i].id==id ){
             returnedItem = arr[i]
             break
         }else if(arr[i].children && arr[i].children.length > 0){
             find(arr[i].children, id);  //递归调用
         }
     }
     return  returnedItem

     // arr.forEach((item) => { //利用foreach循环遍历
     //     if(item.id==id)//判断递归结束条件
     //     {
     //         returnedItem = item;
     //         return item;
     //     }
     //     else if(item.children.length > 0) //判断chlidren是否有数据
     //     {
     //         find(item.children, id);  //递归调用
     //     }
     // })
 }

// var item = find(array, 187);
 console.log(find(array, 6))

 // 获取到
 // {
 //     id:6,
 //         children:[],
 //     path:'aaa',
 // },

//找到树中最大的id
var tempid=0
function findmaxValue(arr){

    for(let i=0;i<arr.length;i++){
        if(arr[i].id>tempid){
            tempid=arr[i].id
        }

        if(arr[i].children && arr[i].children.length > 0){
            findmaxValue(arr[i].children);
        }else{
            // break
        }

    }
    return tempid
}

findmaxValue(array)

//根据子节点，找到该子节点所有祖父的id
function treeFindPath(tree,func,path=[]){
    if(!tree)return[]
    for(const data of tree){

        //记得修改这里，你想要的字段
        path.push(data.id)
        if(func(data)) return path
        if(data.children){
            const findChildren=treeFindPath(data.children,func,path)
            if(findChildren.length)return findChildren
        }
        path.pop()
    }


    return[]
}

console.log(treeFindPath(array,data=>data['id']===187))
//[4, 5, 7, 187]

//根据子节点，向上找到该子节点整个祖父树
function findson_parents(vdata,key,value){
    function treeFindPath(tree,func,path=[]){
        if(!tree)return[]
        for(const data of tree){

            //记得修改这里，你想要的字段
            path.push({
                id:data.id,
                path:data.path,
                children:[]
            })
            if(func(data)) return path
            if(data.children){
                const findChildren=treeFindPath(data.children,func,path)
                if(findChildren.length)return findChildren
            }
            path.pop()
        }


        return[]
    }


    var temarry=treeFindPath(vdata,data=>data[key]===value)

    for(let i=0;i<temarry.length;i++){
        if( temarry[i+1] ){
            temarry[i].children.push(temarry[i+1])
        }

    }

    return temarry[0]
}

console.log(  findson_parents(array,'id',187) )

构建树

let source = [
    {id:1,parentId:0,name:"一级菜单A",rank:1},
    {id:2,parentId:0,name:"一级菜单B",rank:1},
    {id:3,parentId:0,name:"一级菜单C",rank:1},
    {id:4,parentId:1,name:"二级菜单A-A",rank:2},
    {id:5,parentId:1,name:"二级菜单A-B",rank:2},
    {id:6,parentId:2,name:"二级菜单B-A",rank:2},
    {id:7,parentId:4,name:"三级菜单A-A-A",rank:3},
    {id:8,parentId:7,name:"四级菜单A-A-A-A",rank:4},
    {id:9,parentId:8,name:"五级菜单A-A-A-A-A",rank:5},
    {id:10,parentId:9,name:"六级菜单A-A-A-A-A-A",rank:6},
    {id:11,parentId:10,name:"七级菜单A-A-A-A-A-A-A",rank:7},
    {id:12,parentId:11,name:"八级菜单A-A-A-A-A-A-A-A",rank:8},
    {id:13,parentId:12,name:"九级菜单A-A-A-A-A-A-A-A-A",rank:9},
    {id:14,parentId:13,name:"十级菜单A-A-A-A-A-A-A-A-A-A",rank:10},
];

function setTreeData(source){
    let cloneData = JSON.parse(JSON.stringify(source))      // 对源数据深度克隆
    return  cloneData.filter(father=>{                      // 循环所有项，并添加children属性
        let branchArr = cloneData.filter(child=>father.id == child.parentId);       // 返回每一项的子级数组
        branchArr.length>0 ? father.children=branchArr : ''   //给父级添加一个children属性，并赋值
        return father.parentId==0;      //返回第一层
    });
}
console.log(setTreeData(source),1111111)   // 树形数据

/* 封装函数 */
/* 字段名以字符串的形式传入 */
function treeData(source, id, parentId, children){
    let cloneData = JSON.parse(JSON.stringify(source))
    return cloneData.filter(father=>{
        let branchArr = cloneData.filter(child => father[id] == child[parentId]);
        branchArr.length>0 ? father[children] = branchArr : ''
        return father[parentId] == 0
    })
}
// 调用
console.log(treeData(source,'id','parentId','children'),22222222222)

//树转列表
let tree = [
    {
        id: 1,
        name: 'text1',
        parentId: 1,
        children: [
            {
                id: 2,
                name: 'text2',
                parentId: 1,
                children: [
                    {
                        id: 4,
                        name: 'text4',
                        parentId: 2
                    }
                ]
            },
            {
                id: 3,
                name: 'text3',
                parentId: 1
            }
        ]
    }
]
function untieTree(tree, children_key='children') {
    if(!!!tree || Object.prototype.toString.call(tree) !== '[object Array]' || tree.length<=0) return [];
    const temp = [];
    tree.forEach(item => {
        temp.push(item, ...untieTree(item[children_key], children_key))
    });
    return temp;
}

//搜集指定层级的所有数据

var data5 = [{
        i:'a1',
        children: [{
            i:'a2',
            children: [{
                i:'a3',
            }, {
                i:'a4',
            }]
        }, {
            i:'a5',
            children: [{
                i:'a6',
            }, {
                i:'a7',
            }]
        }]
    },
        {
            i:'a8',
            children: [
                {
                    i:'a9',
                },
                {
                    i:'a10',
                }
            ]
        }
    ];
    var a1 = []
    function dfs(list, level=1) {
        list.forEach(item => {
            item.level = level;
            if(item.children) dfs(item.children, level+1)
            if(item.level == 3){  //搜集第三级 的所有数据
                var tem = JSON.parse(JSON.stringify(item))
                delete tem.children
                a1.push(tem)
            }
        })
        return list;
    }
    dfs(data5)
    console.log(a1)

        [
            {
                "i": "a3",
                "level": 3
            },
            {
                "i": "a4",
                "level": 3
            },
            {
                "i": "a6",
                "level": 3
            },
            {
                "i": "a7",
                "level": 3
            }
        ]

//找到当前子节点的当前父节点

var arr0=
        {

            children:[
                {
                    "children": [
                        {
                            "children": [
                                {
                                    "children": [],
                                    "jgdm": "460202",
                                    "jglx": "3",
                                    "jgmc": "三亚医院"
                                },

                            ],
                            "jgdm": "460201",
                            "jglx": "2",
                            "jgmc": "海棠区"
                        },

                    ],
                    "jgdm": "460200",
                    "jglx": "1",
                    "jgmc": "三亚市"
                },

            ]
        }


    function findParentNode(data, id,attrName) {
        //设置结果
        let result;
        if (!data) {
            return;//如果data传空，直接返回
        }
        for (var i = 0; i < data.children.length; i++) {
            let item = data.children[i];
            if (item[attrName] == id) {
                result = data;
                return result; //这里是实际返回的值，你可以只返回当前对象，或者指定当前对象的某个字段。
            } else if (item.children && item.children.length > 0) {
                //如果有子集，则把子集作为参数重新执行本方法
                result = findParentNode(item, id,attrName);
                //关键，千万不要直接return本方法，不然即使没有返回值也会将返回return，导致最外层循环中断，直接返回undefined,要有返回值才return才对
                if (result) {
                    return result;
                }
            }
        }
        //如果执行循环中都没有return，则在此return
        return result;
    }


    var nodeEl = findParentNode(arr0, 460202,'jgdm');  //找到{"jgdm":460202}当前节点的父节点
    console.log(nodeEl)

//树一共有多少层级，并返回最先找到最小的节点

function getMaxFloor (treeData) {
     let max = 0
     let childrenObj = null
     function each (data, floor) {
         data.forEach(e => {
             // e.floor = floor //顺便附加层级
             if (floor > max) {
                 max = floor
                 childrenObj = e
             }

             if (e.children && e.children.length > 0) {
                 each(e.children, floor + 1)
             }
         })
     }
     each(treeData,1)
     return {max,childrenObj}
 }

 const treeData = [
     {
         title: 'parent 1',
         key: '0-0',
         children: [
             {
                 title: 'parent 1-0',
                 key: '0-0-0',
                 disabled: true,
                 children: [
                     {
                         title: 'leaf2222',
                         key: '0-0-0-0',
                         disableCheckbox: true,
                         children: [
                             {
                                 title: 'lea666',
                                 key: '0-0-0-5',
                                 disableCheckbox: true,
                                 children: [
                                     {
                                         title: 'lea6776',
                                         key: '0-0-0-5',
                                         disableCheckbox: true,
                                     },
                                 ],
                             },
                         ],
                     },
                 ],
             }
         ],
     }
 ];

 //调用以上封装好的方法
 const maxNum = getMaxFloor(treeData)
 console.log(maxNum)

2020 04.30

作者： admin

解决:ttf字体文件cdn跨域问题以及ttf字体文件转base64

解决：net::ERR_BLOCKED_BY_CLIENT

如何让xshell与远程服务器保持连接不断开

js数字索引转换字母

js根据id递归获取节点