示例：

# 这是一级标题
## 这是二级标题
### 这是三级标题
#### 这是四级标题
##### 这是五级标题
###### 这是六级标题

效果如下：

这是一级标题

这是二级标题

这是三级标题

这是四级标题

这是五级标题

这是六级标题

二、字体

示例：

**这是加粗的文字**
*这是倾斜的文字*
***这是斜体加粗的文字***
~~这是加删除线的文字~~

效果如下： 这是加粗的文字

这是倾斜的文字

这是斜体加粗的文字

这是加删除线的文字

三、引用

示例：

>这是引用的内容
>>这是引用的内容
>>>>>>>>>>这是引用的内容

效果如下：

这是引用的内容

这是引用的内容

这是引用的内容

四、分割线

示例：

---
----
***
*****

效果如下：

五、图片

示例：

![blockchain](https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/
u=702257389,1274025419&fm=27&gp=0.jpg "区块链")

效果如下：

六、超链接

示例：

[超链接名](超链接地址 "超链接title")
title可加可不加
[简书](http://jianshu.com)
[百度](http://baidu.com)

效果如下：

简书

百度

七、列表

无序列表

语法： 无序列表用 - + * 任何一种都可以 示例：

- 列表内容
+ 列表内容
* 列表内容

注意：- + * 跟内容之间都要有一个空格

效果如下：

• 列表内容
• 列表内容
• 列表内容

###有序列表

语法： 数字加点 示例：

1. 列表内容
2. 列表内容
3. 列表内容

注意：序号跟内容之间要有空格

效果如下：

1. 列表内容
2. 列表内容
3. 列表内容

列表嵌套

上一级和下一级之间敲三个空格即可

• 一级无序列表内容
  • 二级无序列表内容

八、表格

语法：

表头|表头|表头
---|:--:|---:
内容|内容|内容
内容|内容|内容

第二行分割表头和内容。
- 有一个就行，为了对齐，多加了几个
文字默认居左
-两边加：表示文字居中
-右边加：表示文字居右
注：原生的语法两边都要用 | 包起来。此处省略

示例：

姓名|技能|排行
--|:--:|--:
刘备|哭|大哥
关羽|打|二哥
张飞|骂|三弟

九、代码

语法： 单行代码：代码之间分别用一个反引号包起来

    `代码内容`

代码块：代码之间分别用三个反引号包起来，且两边的反引号单独占一行

(```)
  代码...
  代码...
  代码...
(```)

注：为了防止转译，前后三个反引号处加了小括号，实际是没有的。这里只是用来演示，实际中去掉两边小括号即可。

十、流程图

(```)
flow
st=>start: 开始
op=>operation: My Operation
cond=>condition: Yes or No?
e=>end
st->op->cond
cond(yes)->e
cond(no)->op
&
(```)

// 替换成你想镜像的站点
const upstream = 'www.google.com'

// 如果那个站点有专门的移动适配站点，否则保持和上面一致
const upstream_mobile = 'www.google.com'

// 你希望禁止哪些国家访问
const blocked_region = ['RU']

// 禁止自访问
const blocked_ip_address = ['0.0.0.0', '127.0.0.1']

// 替换成你想镜像的站点
const replace_dict = {
    '$upstream': '$custom_domain',
    '//www.google.com': ''
}

//以下内容都不用动
addEventListener('fetch', event => {
    event.respondWith(fetchAndApply(event.request));
})

async function fetchAndApply(request) {

    const region = request.headers.get('cf-ipcountry').toUpperCase();
    const ip_address = request.headers.get('cf-connecting-ip');
    const user_agent = request.headers.get('user-agent');

    let response = null;
    let url = new URL(request.url);
    let url_host = url.host;

    if (url.protocol == 'http:') {
        url.protocol = 'https:'
        response = Response.redirect(url.href);
        return response;
    }

    if (await device_status(user_agent)) {
        upstream_domain = upstream
    } else {
        upstream_domain = upstream_mobile
    }

    url.host = upstream_domain;

    if (blocked_region.includes(region)) {
        response = new Response('Access denied: WorkersProxy is not available in your region yet.', {
            status: 403
        });
    } else if(blocked_ip_address.includes(ip_address)){
        response = new Response('Access denied: Your IP address is blocked by WorkersProxy.', {
            status: 403
        });
    } else{
        let method = request.method;
        let request_headers = request.headers;
        let new_request_headers = new Headers(request_headers);

        new_request_headers.set('Host', upstream_domain);
        new_request_headers.set('Referer', url.href);

        let original_response = await fetch(url.href, {
            method: method,
            headers: new_request_headers
        })

        let original_response_clone = original_response.clone();
        let original_text = null;
        let response_headers = original_response.headers;
        let new_response_headers = new Headers(response_headers);
        let status = original_response.status;

        new_response_headers.set('access-control-allow-origin', '*');
        new_response_headers.set('access-control-allow-credentials', true);
        new_response_headers.delete('content-security-policy');
        new_response_headers.delete('content-security-policy-report-only');
        new_response_headers.delete('clear-site-data');

        const content_type = new_response_headers.get('content-type');
        if (content_type.includes('text/html') && content_type.includes('UTF-8')) {
            original_text = await replace_response_text(original_response_clone, upstream_domain, url_host);
        } else {
            original_text = original_response_clone.body
        }

        response = new Response(original_text, {
            status,
            headers: new_response_headers
        })
    }
    return response;
}

async function replace_response_text(response, upstream_domain, host_name) {
    let text = await response.text()

    var i, j;
    for (i in replace_dict) {
        j = replace_dict[i]
        if (i == '$upstream') {
            i = upstream_domain
        } else if (i == '$custom_domain') {
            i = host_name
        }

        if (j == '$upstream') {
            j = upstream_domain
        } else if (j == '$custom_domain') {
            j = host_name
        }

        let re = new RegExp(i, 'g')
        text = text.replace(re, j);
    }
    return text;
}

async function device_status (user_agent_info) {
    var agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"];
    var flag = true;
    for (var v = 0; v < agents.length; v++) { if (user_agent_info.indexOf(agents[v]) > 0) {
            flag = false;
            break;
        }
    }
    return flag;
}

• 镜像网站带密码访问

// 替换成你想镜像的站点
const upstream = 'google.com'

// 如果那个站点有专门的移动适配站点，否则保持和上面一致
const upstream_mobile = 'm.google.com'

// 密码访问

const openAuth = false
const username = 'username'
const password = 'password'

// 你希望禁止哪些国家访问
const blocked_region = ['RU']

// 禁止自访问
const blocked_ip_address = ['0.0.0.0', '127.0.0.1']

// 替换成你想镜像的站点
const replace_dict = {
    '$upstream': '$custom_domain',
    '//google.com': ''
}

function unauthorized() {
  return new Response('Unauthorized', {
    headers: {
      'WWW-Authenticate': 'Basic realm="goindex"',
      'Access-Control-Allow-Origin': '*'
    },
    status: 401
  });
}

function parseBasicAuth(auth) {
    try {
      return atob(auth.split(' ').pop()).split(':');
    } catch (e) {
      return [];
    }
}

function doBasicAuth(request) {
  const auth = request.headers.get('Authorization');

  if (!auth || !/^Basic [A-Za-z0-9._~+/-]+=*$/i.test(auth)) {
    return false;
  }

  const [user, pass] = parseBasicAuth(auth);
  return user === username && pass === password;
}


async function fetchAndApply(request) {
  if (request.method === 'OPTIONS') // allow preflight request
    return new Response('', {
      status: 200,
      headers: {
        'Access-Control-Allow-Origin': '*',
        'Access-Control-Allow-Headers': '*',
        'Access-Control-Allow-Methods': 'GET, POST, PUT, HEAD, OPTIONS'
      }
    });

  if (openAuth && !doBasicAuth(request)) {
    return unauthorized();
  }
    const region = request.headers.get('cf-ipcountry').toUpperCase();
    const ip_address = request.headers.get('cf-connecting-ip');
    const user_agent = request.headers.get('user-agent');

    let response = null;
    let url = new URL(request.url);
    let url_host = url.host;

    if (url.protocol == 'http:') {
        url.protocol = 'https:'
        response = Response.redirect(url.href);
        return response;
    }

    if (await device_status(user_agent)) {
        upstream_domain = upstream
    } else {
        upstream_domain = upstream_mobile
    }

    url.host = upstream_domain;

    if (blocked_region.includes(region)) {
        response = new Response('Access denied: WorkersProxy is not available in your region yet.', {
            status: 403
        });
    } else if(blocked_ip_address.includes(ip_address)){
        response = new Response('Access denied: Your IP address is blocked by WorkersProxy.', {
            status: 403
        });
    } else{
        let method = request.method;
        let request_headers = request.headers;
        let new_request_headers = new Headers(request_headers);

        new_request_headers.set('Host', upstream_domain);
        new_request_headers.set('Referer', url.href);

        let original_response = await fetch(url.href, {
            method: method,
            headers: new_request_headers
        })

        let original_response_clone = original_response.clone();
        let original_text = null;
        let response_headers = original_response.headers;
        let new_response_headers = new Headers(response_headers);
        let status = original_response.status;

        new_response_headers.set('access-control-allow-origin', '*');
        new_response_headers.set('access-control-allow-credentials', true);
        new_response_headers.delete('content-security-policy');
        new_response_headers.delete('content-security-policy-report-only');
        new_response_headers.delete('clear-site-data');

        const content_type = new_response_headers.get('content-type');
        if (content_type.includes('text/html') && content_type.includes('UTF-8')) {
            original_text = await replace_response_text(original_response_clone, upstream_domain, url_host);
        } else {
            original_text = original_response_clone.body
        }

        response = new Response(original_text, {
            status,
            headers: new_response_headers
        })
    }
    return response;
}

addEventListener('fetch', event => {
    event.respondWith(fetchAndApply(event.request).catch(err => {
      console.error(err);
      new Response(JSON.stringify(err.stack), {
        status: 500,
        headers: {
          'Content-Type': 'application/json'
        }
      });
    }));
})


async function replace_response_text(response, upstream_domain, host_name) {
    let text = await response.text()

    var i, j;
    for (i in replace_dict) {
        j = replace_dict[i]
        if (i == '$upstream') {
            i = upstream_domain
        } else if (i == '$custom_domain') {
            i = host_name
        }

        if (j == '$upstream') {
            j = upstream_domain
        } else if (j == '$custom_domain') {
            j = host_name
        }

        let re = new RegExp(i, 'g')
        text = text.replace(re, j);
    }
    return text;
}

async function device_status (user_agent_info) {
    var agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"];
    var flag = true;
    for (var v = 0; v < agents.length; v++) { if (user_agent_info.indexOf(agents[v]) > 0) {
            flag = false;
            break;
        }
    }
    return flag;
}

• 镜像网站指定目录

// 你要镜像的网站.
const upstream = 'objectstorage.ap-seoul-1.oraclecloud.com'

// 镜像网站的目录，比如你想镜像某个网站的二级目录则填写二级目录的目录名，镜像 google 用不到，默认即可.
const upstream_path = '/test/'

// 镜像站是否有手机访问专用网址，没有则填一样的.
const upstream_mobile = 'objectstorage.ap-seoul-1.oraclecloud.com'

// 屏蔽国家和地区.
const blocked_region = ['']

// 屏蔽 IP 地址.
const blocked_ip_address = ['0.0.0.0', '127.0.0.1']

// 镜像站是否开启 HTTPS.
const https = true

// 文本替换.填你要镜像的网站
const replace_dict = {
    '$upstream': '$custom_domain',
    '//objectstorage.ap-seoul-1.oraclecloud.com': ''
}

// 以下保持默认，不要动
addEventListener('fetch', event => {
    event.respondWith(fetchAndApply(event.request));
})

async function fetchAndApply(request) {

    const region = request.headers.get('cf-ipcountry').toUpperCase();
    const ip_address = request.headers.get('cf-connecting-ip');
    const user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36"

    let response = null;
    let url = new URL(request.url);
    let url_hostname = url.hostname;

    if (https == true) {
        url.protocol = 'https:';
    } else {
        url.protocol = 'http:';
    }

    if (await device_status(user_agent)) {
        var upstream_domain = upstream;
    } else {
        var upstream_domain = upstream_mobile;
    }

    url.host = upstream_domain;
    if (url.pathname == '/') {
        url.pathname = upstream_path;
    } else {
        url.pathname = upstream_path + url.pathname;
    }

    if (blocked_region.includes(region)) {
        response = new Response('Access denied: WorkersProxy is not available in your region yet.', {
            status: 403
        });
    } else if (blocked_ip_address.includes(ip_address)) {
        response = new Response('Access denied: Your IP address is blocked by WorkersProxy.', {
            status: 403
        });
    } else {
        let method = request.method;
        let request_headers = request.headers;
        let new_request_headers = new Headers(request_headers);

        new_request_headers.set('Host', url.hostname);
        new_request_headers.set('Referer', url.hostname);

        let original_response = await fetch(url.href, {
            method: method,
            headers: new_request_headers
        })

        let original_response_clone = original_response.clone();
        let original_text = null;
        let response_headers = original_response.headers;
        let new_response_headers = new Headers(response_headers);
        let status = original_response.status;

        new_response_headers.set('access-control-allow-origin', '*');
        new_response_headers.set('access-control-allow-credentials', true);
        new_response_headers.delete('content-security-policy');
        new_response_headers.delete('content-security-policy-report-only');
        new_response_headers.delete('clear-site-data');

        const content_type = new_response_headers.get('content-type');
        if (content_type.includes('text/html') && content_type.includes('UTF-8')) {
            original_text = await replace_response_text(original_response_clone, upstream_domain, url_hostname);
        } else {
            original_text = original_response_clone.body
        }

        response = new Response(original_text, {
            status,
            headers: new_response_headers
        })
    }
    return response;
}

async function replace_response_text(response, upstream_domain, host_name) {
    let text = await response.text()

    var i, j;
    for (i in replace_dict) {
        j = replace_dict[i]
        if (i == '$upstream') {
            i = upstream_domain
        } else if (i == '$custom_domain') {
            i = host_name
        }

        if (j == '$upstream') {
            j = upstream_domain
        } else if (j == '$custom_domain') {
            j = host_name
        }

        let re = new RegExp(i, 'g')
        text = text.replace(re, j);
    }
    return text;
}


async function device_status(user_agent_info) {
    var agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"];
    var flag = true;
    for (var v = 0; v < agents.length; v++) {
        if (user_agent_info.indexOf(agents[v]) > 0) {
            flag = false;
            break;
        }
    }
    return flag;
}

可替换

// 目标网站
const upstream = 'wwww.google.com'

// 目标网站路径
const upstream_path = '/'

// 打算为使用移动设备的用户检索的网站.
const upstream_mobile = 'google.com'

// 您希望暂停服务的国家和地区
const blocked_region = []

// 要阻止其使用服务的IP地址
const blocked_ip_address = ['0.0.0.0', '127.0.0.1']

// 上游地址是否使用HTTPS协议
const https = true

// 是否禁用缓存
const disable_cache = false

// 替换文本
//格式：  '被替换':'替换'
//注意js结束的的逗号
const replace_dict = {
    'google.com':'google.com'
}

let data={}
addEventListener('fetch', event => {
    event.respondWith(fetchAndApply(event.request));
})

async function fetchAndApply(request) {
    const region = request.headers.get('cf-ipcountry').toUpperCase();
    const ip_address = request.headers.get('cf-connecting-ip');
    const user_agent = request.headers.get('user-agent');

    let response = null;
    let url = new URL(request.url);
    let url_hostname = url.hostname;

    if (https == true) {
        url.protocol = 'https:';
    } else {
        url.protocol = 'http:';
    }

    if (await device_status(user_agent)) {
        var upstream_domain = upstream;
    } else {
        var upstream_domain = upstream_mobile;
    }

    url.host = upstream_domain;
    if (url.pathname == '/') {
        url.pathname = upstream_path;
    } else {
        url.pathname = upstream_path + url.pathname;
    }

    if (blocked_region.includes(region)) {
        response = new Response('拒绝访问: 您所在的地区不可用!', {
            status: 403
        });
    } else if (blocked_ip_address.includes(ip_address)) {
        response = new Response('拒绝访问: 您的IP地址在Ban列表中!', {
            status: 403
        });
    } else {
        let method = request.method;
        let request_headers = request.headers;
        let new_request_headers = new Headers(request_headers);

        new_request_headers.set('Host', upstream_domain);
        new_request_headers.set('Referer', url.protocol + '//' + upstream_domain);



        if(method == 'POST'){
            let origin_formData = await request.text()
            data = {
                method: method,
                headers: new_request_headers,
                body : origin_formData
            }
            console.log(data)
        }else if(method == 'GET'){
            data = {
                method: method,
                headers: new_request_headers
            }
        }
        let fuckKeys =  Object.fromEntries(new_request_headers)
        console.log(method)
        console.log(fuckKeys)
        let original_response = await fetch(url.href, data)

        connection_upgrade = new_request_headers.get("Upgrade");
        if (connection_upgrade && connection_upgrade.toLowerCase() == "websocket") {
            return original_response;
        }

        let original_response_clone = original_response.clone();
        let original_text = null;
        let response_headers = original_response.headers;
        let new_response_headers = new Headers(response_headers);
        let status = original_response.status;

        if (disable_cache) {
            new_response_headers.set('Cache-Control', 'no-store');
        }

        new_response_headers.set('access-control-allow-origin', '*');
        new_response_headers.set('access-control-allow-credentials', true);
        new_response_headers.delete('content-security-policy');
        new_response_headers.delete('content-security-policy-report-only');
        new_response_headers.delete('clear-site-data');

        if (new_response_headers.get("x-pjax-url")) {
            new_response_headers.set("x-pjax-url", response_headers.get("x-pjax-url").replace("//" + upstream_domain, "//" + url_hostname));
        }

        const content_type = new_response_headers.get('content-type');
        if (content_type != null && content_type.includes('text/html') && content_type.includes('UTF-8')) {
            original_text = await replace_response_text(original_response_clone, upstream_domain, url_hostname);
        } else {
            original_text = original_response_clone.body
        }

        response = new Response(original_text, {
            status,
            headers: new_response_headers
        })
    }

    return response;
}

async function replace_form_data(formData, upstream_domain, host_name) {
    let text = await response.text()

    var i, j;
    for (i in replace_dict) {
        j = replace_dict[i]
        if (i == '$upstream') {
            i = upstream_domain
        } else if (i == '$custom_domain') {
            i = host_name
        }

        if (j == '$upstream') {
            j = upstream_domain
        } else if (j == '$custom_domain') {
            j = host_name
        }

        let re = new RegExp(i, 'g')
        text = text.replace(re, j);
    }
    return text;
}

async function replace_response_text(response, upstream_domain, host_name) {
    let text = await response.text()

    var i, j;
    for (i in replace_dict) {
        j = replace_dict[i]
        if (i == '$upstream') {
            i = upstream_domain
        } else if (i == '$custom_domain') {
            i = host_name
        }

        if (j == '$upstream') {
            j = upstream_domain
        } else if (j == '$custom_domain') {
            j = host_name
        }

        let re = new RegExp(i, 'g')
        text = text.replace(re, j);
    }
    return text;
}


async function device_status(user_agent_info) {
    var agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"];
    var flag = true;
    for (var v = 0; v < agents.length; v++) {
        if (user_agent_info.indexOf(agents[v]) > 0) {
            flag = false;
            break;
        }
    }
    return flag;
}

• 在sheet1中的B2中输入=vlookup（A2， 。表示需要通过这个数值来查找想对应的资料。

• 通过VLOOKUP函数公式，在sheet1中的B2中输入=vlookup（A2，Sheet2!A1:D13 。这个是资料的查找范围。

• 在sheet1中的B2中输入=vlookup（A2，Sheet2!A1:D13,2, 。2表示在范围内的第几列。

• 在sheet1中的B2中输入=vlookup（A2，Sheet2!A1:D13,2,1）。公式完成，1表示精确查找，0表示广泛查找。

• 在sheet1A2中输入2号司机可以看到B2中会显示sheet2中2号司机在B3的资料。

• 在sheet1C2中输入的公式和B2一样.显示效果如图.

• 可以把A2或B2的公式往后拉,在D2中也能得到相应的资料,确保他们都是精确查找的对象或者列数即可.

AMH – 4.2版免费：http://amh.sh/

WDCP 老牌免费面板：http://www.wdlinux.cn/bbs/（近来爆出严重安全漏洞）

自己的路 – 支持freeBSD：http://www.zijidelu.org/

国外版 VestaCP：http://vestacp.com/ （比较推荐的面板，自带中文）

Kloxo-MR：https://github.com/mustafaramadhan/kloxo/ （7.0真的很强大，很好看，很实用，有中文包）

Webmin/Virtualmin：http://www.webmin.com/virtualmin.html （很稳定，很安全，自带中文）

Ispconfig：https://github.com/dclardy64/ISPConfig-3-Debian-Installer （官网没看懂这是一键包，有中文包）

i-MSCP：http://i-mscp.net/ （简单易用，自带中文）

EasySCP：http://www.easyscp.net/ （和i-MSCP一样来自Ispconfig，自带中文）

Ajenti：http://ajenti.org/ （轻量级，类似Webmin，自带中文）

zPanel(sentora)：http://www.zpanelcp.com/ http://www.sentora.org/（支持win，有中文包）

centos webpanel：http://centos-webpanel.com/ （据说比较有发展前途）

Froxlor：http://www.froxlor.org/ （很轻量的，适应各种环境）

AlternC：https://alternc.org/ （简单）

Easy Hosting Control Panel：http://ehcp.net/ （还不错的面板，有第三方汉化包）

CyberPanel面板：http://docs.cyberpanel.net/doku.php （目前只支持Centos 7.x）

宝塔英文版？http://www.aapanel.com

runcloud.io面板：https://runcloud.io （有免费版和付费版）

froxlor面板：https://www.froxlor.org/ (面板没有汉化)

一键安装包 国内版 http://lnmp.org/ （用的人很多，适应性很强）

https://oneinstack.com/ （用户也很多，博主一直使用这个）

http://teddysun.com/lamp （很好用的LAMP一键包） http://teddysun.com/lamp-yum （适合小内存≥64M）

http://bbs.aliyun.com/read/151729.html （阿里云论坛看到的）

http://blog.linuxeye.com/31.html （多种配置，软件较新）

http://lnmpp.net/ （支持postgresql，支持ARM）

http://www.hhvmc.com/thread-17-1-1.html （有hhvm的一键包）

http://shuang.ca/llnmp/ http://llsmp.cn/（有LiteSpeed的一键包）

https://www.lxconfig.com/thread-69-1-1.html （有openresty的一键包）

http://blog.7qy.com/html/1575.html （有cherokee的一键包）

http://lamp.phpstudy.net/ （有Lighttpd的一键包）

http://www.upupw.net/ （Windows平台环境搭建）

https://www.appnode.com （免费版不支持面板）

http://www.ltmp.cc/ （LTMP支持CentOS/RadHat）

http://bet.xrbk.top/ （BET面板 支持CentOS）

国外版 http://centminmod.com/ （据说很适合wordpress）

https://vpssim.com/ （很强大的一键包）

http://tuxlite.com/ （适用于Debian系列）

https://github.com/Xeoncross/lowendscript （lowendscript演变来的）

https://github.com/alexandreteles/monkeyServer（Monkey Web Server轻量级的web服务器）

Wordpress ： https://elements.heroku.com/buttons/philippheuer/wordpress-heroku 试过

万能镜像站（墙内随便一台电脑无需配置工具一键访问国外网站）： https://elements.heroku.com/buttons/binary-person/womginx 试过

theia（在线VSCode）： https://github.com/bpmct/deploy-code-server/blob/main/guides/heroku.md 试过

bitwarden： https://elements.heroku.com/buttons/mutouxia/bitwardenrs_heroku 试过

自建搜索引擎（Google的结果）： https://elements.heroku.com/buttons/benbusby/whoogle-search 试过

OneManager： https://github.com/qkqpttgf/OneManager-php 试过

cloudreve： https://elements.heroku.com/buttons/useblue/cloudreve-heroku

mega挂载： https://elements.heroku.com/buttons/developeranaz/mega.nz-rclone-index-heroku

minecraft： https://elements.heroku.com/buttons/jkutner/heroku-buildpack-minecraft

RSSHub： https://elements.heroku.com/buttons/diygod/rsshub

有图比-dl（下载视频）： https://elements.heroku.com/buttons/andrewstech/有图比-dl-api-server

hostloc签到Python脚本 之 Heroku 篇 https://github.com/laogui2008/heroku_hostloc_get_points2

Office 全局管理程序(PHP) Heroku 一键部署 https://github.com/testnobody/office_admin_heroku

用heroku搭建一个随机"色图" https://dashboard.heroku.com/new ... 4740/randpic-heroku

2、电子书搜索 (https://ebook.chongbuluo.com/)： 快搜电子书搜索，有多个资源站点可选择

3、苦瓜书盘 (https://link.zhihu.com/?target=https%3A//www.kgbook.com/)：可下载到符合手机尺寸的电子书；

4、OpenStaxCNXLibrary (https://cnx.org/browse)： 这是一个下载到国外教材的电子书网站；

5、好读 (http://www.haodoo.net/)：繁体字的界面，你应该知道它是哪儿的网站~一个推广中文电子书的公益网站，建站于2001年。

6、书格 (https://new.shuge.org/)： 可能是最好用的古籍资料下载网站；

7、云海电子书 (http://www.pdfbook.cn/)：站内书籍类型丰富、不管是小众、文学，还是励志成功，艺术摄影，计算机网络……你都可以在这里找到、并免费下载它的pdf版本；

8、PDF之家 (http://www.pdfzj.com/)： 拥有海量优质资源的PDF站点；

9、图灵社区 (https://www.ituring.com.cn/book?tab=free)： 国内最优质的技术书出版社之一，提供免费的技术电子书下载；

10、万千合集 (http://www.hejizhan.com/bbs/?kw=cad+)： 最专业的学术资源搜索引擎；

11、计算机书籍控 (http://bestcbooks.com/)： 最好的计算机书籍下载站点；

12、世界数字图书馆 (https://www.wdl.org/zh/)： 将在互联网上以多语种格式免费提供世界各地的重要材料,包括手稿、地图、珍本书籍、乐谱、录音、电影、印刷品、照片、建筑图等等；

13、采 书 (http://ebook.name/)： 一个免费电子书搜索引擎,为用户提供kindle电子书的搜索服务；

14、书享家 (http://shuxiangjia.cn/)： 电子书下载导航网站，提供优质的电子书搜索引擎、kindle下载站、PDF下载站、书单书评的入口导航。网站本身也会推荐一些优质的书单。

15、爱问共享资料 (http://ishare.iask.sina.com.cn/)： 资料搜索引擎。提供PPT、kindle书籍、PDF、Excel、DOC等各种格式的资料下载，内容齐全。

16、Sobooks (https://sobooks.cc/xiaoshuowenxue).：提供时间、文件格式、文件页数等维度搜索，快速定位到想要的文档

17、辣豆瓣 (http://www.ladouban.com/)： 只是这里虽然也免费，但是每天只能下载6本

18、 libgen (http://gen.lib.rus.ec/)： 这家应该是俄罗斯的ip，大部分英语书籍都可以在这里搜到，只是是pdf格式

19、電子爱好馆 (http://zlzazhi.com/)：

20、田间小站 (https://www.tjxz.cc/)：

21、EPUBEE (http://cn.epubee.com/books/): 号称最大的电子书网站。

22、E书联盟 (https://www.book118.com/)：

23、科塔学术 (https://site.sciping.com/)： 最专业、准确、及时、全面的科研与学术资源导航平台

24、若蓝格 (https://www.ifblue.net/)：杂志，各类书刊分享

25、万方数据 (http://www.wanfangdata.com.cn/index.html)： 知识服务平台，期刊、报告、论文、专利

26、上海图书馆家谱 (http://wrd2016.library.sh.cn/channel/stjp/)： 上海图书馆藏家谱古文

27、抗战文献数据平台 (http://www.modernhistory.org.cn/index.htm)： 抗日战争期间报刊文献资料

28、中国历代人物图像数据库 (http://diglweb.zjlib.cn:8081/zjtsg/mingren/index.htm)： 从夏商周开始历史人物画像资料

29、zi.1lib (https://zh.1lib.org/):全球最大的数字图书馆自2009年起的免费图书馆. 免费下载epub、pdf、mobi格式电子书支持转换为FB2、TXT、RTF等格式