小程序：期刊杂志♢

海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@期刊杂志♢@{"last_chapter_rule":"","title":"期刊杂志♢","author":"Joker","url":"hiker://empty","version":2,"col_type":"movie_3","class_name":"","type":"other","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\naddListener('onClose', $.toString(() => {\n    deleteFile(\"data1\");\n    deleteFile(\"data2\");\n}));\nlet d = [];\nlet now = getItem('now', '推荐期刊');\nlet arr = ['推荐期刊', '期刊大全', '报纸列表', '收藏'];\nfor (let it of arr) {\n    d.push({\n        title: now == it ? '““””' + it.fontcolor('red') : it,\n        col_type: 'scroll_button',\n        url: $('').lazyRule((it) => {\n            setItem(\"now\", it);\n            refreshPage();\n            return 'hiker://empty';\n        }, it)\n    })\n}\nd.push({\n    title: '规则设置',\n    col_type: 'scroll_button',\n    url: 'hiker://page/setting'\n});\nif (now == '期刊大全') {\n    let rescode = readFile('data1', '');\n    if (!rescode || !rescode.startsWith('{')) {\n        rescode = request('http://new-qk.lifves.com/getQikanCategory.php');\n        saveFile('data1', rescode);\n    }\n    let data = JSON.parse(rescode).qikan_category_list;\n    let nowqk = getMyVar('nowqk', data[0].name);\n    d.push({\n        col_type: 'blank_block'\n    });\n    for (let it of data) {\n        d.push({\n            title: it.name == nowqk ? '““””' + it.name.fontcolor('red') : it.name,\n            col_type: 'scroll_button',\n            url: $().lazyRule((it) => {\n                putMyVar('nowqk', it);\n                refreshPage();\n                return 'hiker://empty';\n            }, it.name)\n        })\n    }\n    let list = data.find(it => it.name == nowqk);\n    for (let it of list._child) {\n        d.push({\n            title: it.name,\n            col_type: 'text_4',\n            url: 'hiker://empty#' + it.name\n        })\n    }\n} else if (now == '推荐期刊' || now == '报纸列表') {\n    let rescode = readFile('data2', '');\n    if (!rescode || !rescode.startsWith('{')) {\n        rescode = request('http://new-qk.lifves.com/public/js/index.js');\n        saveFile('data2', rescode);\n    }\n    eval('let fun =' + rescode.split(\",'created'\")[0].split(\"'data':\")[1]);\n    let data = fun();\n    if (now == '推荐期刊') {\n        let qk_list = data.data_list.qk_list;\n        for (let it of qk_list) {\n            d.push({\n                title: it.title,\n                col_type: 'text_4',\n                url: 'hiker://empty#' + it.title\n            });\n        }\n    } else {\n        let bz_list = data.data_list.bz_list;\n        for (let it of bz_list) {\n            d.push({\n                title: it.title,\n                col_type: 'movie_3',\n                img: it.img,\n                url: 'hiker://empty#noLoading#@lazyRule=.js:\"x5://' + it.href + '\"'\n            })\n        }\n    }\n} else if (now == '收藏') {\n    let collection = JSON.parse(readFile('collection') || '{}');\n    for (let i in collection) {\n        let it = collection[i];\n        d.push({\n            title: i,\n            col_type: 'movie_3',\n            img: it.img,\n            url: 'hiker://page/qk?name=' + i + '&img=' + it.img,\n            extra: {\n                href: it.url\n            }\n        })\n    }\n}\nsetResult(d);","search_url":"http://new-qk.lifves.com/search.php?keyword=**;get;utf-8;{User-Agent@MOBILE_UA}","group":"①推荐","searchFind":"js:\nlet d = [];\neval(parseDomForHtml(getResCode(), \"body&&script,2&&Html\"));\nfor (let item of data_list.data_list) {\n    d.push({\n        title: item.title,\n        url: 'hiker://page/qk?name=' + item.title + '&img=' + item.img,\n        img: item.img,\n        extra:{\n            href:\"http://new-qk.lifves.com/\" + item.href\n        }\n    });\n}\nsetResult(d);","detail_col_type":"movie_3","detail_find_rule":"js:\nlet d = [];\nif (MY_URL.startsWith('hiker://empty#')) {\n    let html = request('http://new-qk.lifves.com/search.php?keyword=' + MY_URL.split('#')[1]);\n    eval(parseDomForHtml(html, \"body&&script,2&&Html\"));\n    for (let item of data_list.data_list) {\n        d.push({\n            title: item.title,\n            url: 'hiker://page/qk?name=' + item.title + '&img=' + item.img,\n            img: item.img,\n            extra:{\n                href:\"http://new-qk.lifves.com/\" + item.href\n            }\n        });\n    }\n} else {}\nsetResult(d);","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"","pages":"[{\"col_type\":\"movie_3\",\"name\":\"期刊分期列表\",\"path\":\"qk\",\"rule\":\"js:\\naddListener('onClose', 'clearVar(\\\"year\\\")');\\n\\nlet d = [];\\nlet url = MY_PARAMS.href,\\n    name = getParam('name'),\\n    img = getParam('img');\\nlet collection = JSON.parse(readFile('collection') || '{}');\\nlet isCollected = !!(collection[name] && collection[name].url == url);\\nd.push({\\n    title: isCollected ? '♥已收藏' : '♡添加收藏',\\n    url: $().lazyRule((is, url, name, img) => {\\n        let collection = JSON.parse(readFile('collection') || '{}');\\n        if (is) {\\n            delete collection[name];\\n            saveFile('collection', JSON.stringify(collection));\\n            refreshPage();\\n            return 'toast://已取消收藏'\\n        } else {\\n            collection[name] = {\\n                url: url,\\n                img: img\\n            };\\n            saveFile('collection', JSON.stringify(collection));\\n            refreshPage();\\n            return 'toast://已添加收藏'\\n        }\\n    }, isCollected, url, name, img),\\n    col_type: \\\"scroll_button\\\",\\n});\\n\\neval(parseDomForHtml(request(url), \\\"body&&script,2&&Html\\\"));\\nlet items = {};\\nlet now = getVar('year', String(data_list.data_list[0].year));\\nfor (let list of data_list.data_list) {\\n    if (now == list.year) items = list.list;\\n    d.push({\\n        title: '““””' + (list.year == now ? '<font color=red>' + list.year + '</font>' : list.year),\\n        col_type: 'scroll_button',\\n        url: $().lazyRule((year) => {\\n            putVar('year', String(year));\\n            refreshPage();\\n            return 'hiker://empty'\\n        }, list.year)\\n    });\\n}\\nfor (let item of items) {\\n    d.push({\\n        title: item.span,\\n        url: 'hiker://page/qkqk#immersiveTheme#',\\n        img: item.img,\\n        extra:{\\n            href:\\\"http://new-qk.lifves.com/\\\" + item.href\\n        }\\n    });\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"期刊目录\",\"path\":\"qkqk\",\"rule\":\"js:\\naddListener('onClose', $.toString(() => {\\n    clearVar('item');\\n    deleteFile('stroge');\\n}));\\nlet fullTheme = getItem('fullTheme', 'true') == 'true' ? '#fullTheme#' : '';\\nlet nowItem = getVar('item', '');\\n\\nlet url = MY_PARAMS.href;\\n\\neval(parseDomForHtml(request(url), \\\"body&&script,2&&Html\\\").match(/let\\\\s*data_list.*JSON\\\\.parse\\\\(.*\\\\)/)[0]);\\nlet d = [];\\nif (data_list.data_list.length == 0) {\\n    d.push({\\n        title: '没有内容呦,不信点我去网页看看',\\n        col_type: 'movie_1_vertical_pic_blur',\\n        url: url\\n    })\\n} else {\\n    d.push({\\n        title: data_list.data_list.intro.title,\\n        desc: data_list.data_list.intro.intro,\\n        img: data_list.data_list.intro.img,\\n        col_type: 'movie_1_vertical_pic_blur',\\n        url: url\\n    })\\n    d.push({\\n        title: '目录'.big().bold(),\\n        col_type: 'rich_text'\\n    })\\n\\n\\n    let stroge = {};\\n    for (let i in data_list.data_list.ml) {\\n        let it = data_list.data_list.ml[i];\\n        for (let item in it) {\\n            stroge[it[item].title] = \\\"http://new-qk.lifves.com/\\\" + it[item].href;\\n        }\\n    }\\n    saveFile('stroge', JSON.stringify(stroge));\\n    let star = Object.keys(stroge);\\n\\n    for (let item in data_list.data_list.ml) {\\n        d.push({\\n            title: '““””' + (nowItem == item ? '▼ ' : '▶ ') + '<strong>' + item + '</strong>',\\n            col_type: 'text_1',\\n            url: $('hiker://empty#noLoadind#').lazyRule((item) => {\\n                if (getVar('item', '') == item) {\\n                    clearVar('item');\\n                    refreshPage(false);\\n                    return 'toast://已收起 ' + item;\\n                } else {\\n                    putVar('item', item);\\n                    refreshPage(false);\\n                    return 'toast://已展开 ' + item;\\n                }\\n            }, item),\\n            extra: {\\n                lineVisible: false\\n            }\\n        })\\n\\n        if (nowItem && nowItem == item) {\\n            data_list.data_list.ml[nowItem].forEach(e => {\\n                let index = star.indexOf(e.title);\\n                d.push({\\n                    title: '““””<small>' + e.title + '</small>',\\n                    desc: '““””<small>' + e.intro + '</small>',\\n                    col_type: 'text_1',\\n                    url: 'hiker://page/text' + fullTheme + '?title=' + e.title + '&index=' + index,\\n                    extra: {\\n                        href: \\\"http://new-qk.lifves.com/\\\" + e.href\\n                    }\\n                })\\n            })\\n        }\\n    }\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"设置\",\"path\":\"setting\",\"rule\":\"js:\\nlet d = [];\\nlet fontsize = parseInt(getItem('fontsize', String(15)));\\nlet indent = parseInt(getItem('indent', String(7)));\\nlet indents = '';\\nfor (let i = 0; i < indent; i++) {\\n    indents += '&nbsp;';\\n}\\nlet fullTheme = getItem('fullTheme', 'true');\\nlet click = getItem('click', 'true');\\n\\nd.push({\\n    title: '全屏模式' + (fullTheme == 'true' ? '✔' : '✘'),\\n    col_type: 'text_2',\\n    url: $('hiker://empty#noLoading#').lazyRule((i) => {\\n        setItem('fullTheme', i == 'true' ? 'false' : 'true');\\n        refreshPage();\\n        return 'hiker://empty';\\n    }, fullTheme)\\n})\\nd.push({\\n    title: '点击翻页' + (click == 'true' ? '✔' : '✘'),\\n    col_type: 'text_2',\\n    url: $('hiker://empty#noLoading#').lazyRule((i) => {\\n        setItem('click', i == 'true' ? 'false' : 'true');\\n        refreshPage();\\n        return 'hiker://empty';\\n    }, click)\\n})\\n\\nd.push({\\n    title: '调整字号'.big().bold(),\\n    col_type: 'rich_text'\\n})\\nd.push({\\n    title: '字号➕',\\n    col_type: 'flex_button',\\n    url: $(\\\"hiker://empty#noLoading#\\\").lazyRule((s) => {\\n        setItem('fontsize', String(s + 1));\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\"\\n    }, fontsize)\\n}, {\\n    title: '字号➖',\\n    col_type: 'flex_button',\\n    url: $(\\\"hiker://empty#noLoading#\\\").lazyRule((s) => {\\n        setItem('fontsize', String(s - 1));\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\"\\n    }, fontsize)\\n})\\n\\nd.push({\\n    col_type: 'line'\\n})\\n\\nd.push({\\n    title: '调整缩进'.big().bold(),\\n    col_type: 'rich_text'\\n})\\nd.push({\\n    title: '缩进➕',\\n    col_type: 'flex_button',\\n    url: $(\\\"hiker://empty#noLoading#\\\").lazyRule((s) => {\\n        setItem('indent', String(s + 1));\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\"\\n    }, indent)\\n}, {\\n    title: '缩进➖',\\n    col_type: 'flex_button',\\n    url: $(\\\"hiker://empty#noLoading#\\\").lazyRule((s) => {\\n        setItem('indent', String(s - 1));\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\"\\n    }, indent)\\n})\\n\\nd.push({\\n    col_type: 'line'\\n})\\n\\nd.push({\\n    title: '预览'.big() + '(字号:' + fontsize + ',缩进:' + indent + ')',\\n    col_type: 'rich_text'\\n}, {\\n    title: '<p>小棉袄帅吗?</p><p>小棉袄怎么这么帅？</p><p>小棉袄真是超超超超超超超超级帅!!!!帅炸了好不好？举世颜无双!!!!</p>'.replace(/\\\\<p\\\\>/g, '<p>' + indents),\\n    col_type: 'rich_text',\\n    extra: {\\n        textSize: fontsize\\n    }\\n})\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"文章\",\"path\":\"text\",\"rule\":\"js:\\naddListener('onClose', $.toString(() => {\\n    clearVar('texthref');\\n    clearVar('texttitle');\\n    clearVar('textindex');\\n}));\\nlet fontsize = parseInt(getItem('fontsize', String(15)));\\nlet indent = parseInt(getItem('indent', String(7)));\\nlet indents = '';\\nfor (let i = 0; i < indent; i++) {\\n    indents += '&nbsp;';\\n}\\nlet fullTheme = getItem('fullTheme', 'true') == 'true' ? '#fullTheme#' : '';\\nlet click = !!(getItem('click', 'true') == 'true');\\nlet stroge = JSON.parse(readFile('stroge'));\\nlet star = Object.keys(stroge);\\n\\nlet href = getVar('texthref', '') || MY_PARAMS.href,\\n    title = getVar('texttitle') || getParam('title'),\\n    index = parseInt(getVar('textindex') || getParam('index'));\\n\\nlet html = request(href, {});\\nlet text = parseDom(html, '.text&&Html');\\nlet author = parseDomForHtml(html, '.author&&Text');\\nlet d = [];\\nd.push({\\n    title: '““””<h2>' + title + '</h2>' + '<small><font color=grey>' + author + '</font> </small>',\\n    col_type: 'text_center_1',\\n    url: href,\\n    extra: {\\n        lineVisible: false\\n    }\\n}, {\\n    title: text.replace(/\\\\>[a-zA-Z0-9+=\\\\/]*\\\\</g, '><').replace(/\\\\<p\\\\>/g, '<p>' + indents),\\n    col_type: 'rich_text',\\n    extra: {\\n        textSize: parseInt(getItem('fontsize', String(15))),\\n        click: click\\n    }\\n})\\nif (index != 0) {\\n    let title = star[index - 1];\\n    let href = stroge[title];\\n    d.push({\\n        title: '上一篇:' + title,\\n        col_type: 'text_center_1',\\n        url: $('hiker://empty#noLoading#').lazyRule((href, title, index) => {\\n            putVar('texthref', href);\\n            putVar('texttitle', title);\\n            putVar('textindex', String(index - 1));\\n            refreshPage();\\n            return 'hiker://empty'\\n        }, href, title, index), //'hiker://page/text' + fullTheme + '?title=' + title + '&index=' + (index - 1),\\n        extra: {\\n            href: href,\\n            lineVisible: false\\n        }\\n    })\\n}\\nif (index != star.index) {\\n    let title = star[index + 1];\\n    let href = stroge[title];\\n    d.push({\\n        title: '下一篇:' + title,\\n        col_type: 'text_center_1',\\n        url: $('hiker://empty#noLoading#').lazyRule((href, title, index) => {\\n            putVar('texthref', href);\\n            putVar('texttitle', title);\\n            putVar('textindex', String(index + 1));\\n            refreshPage();\\n            return 'hiker://empty'\\n        }, href, title, index), // 'hiker://page/text' + fullTheme + '?title=' + title + '&index=' + (index + 1),\\n        extra: {\\n            href: href,\\n            lineVisible: false\\n        }\\n    })\\n}\\nfor (let i = 0; i < 10; i++) {\\n    d.push({\\n        col_type: 'blank_block'\\n    })\\n}\\nsetResult(d);\"}]","icon":"https://www.lifves.com/favicon.ico","proxy":""}