隔壁老王都知道的JavaScript+mysql+HTML+CSS的客户管理系统设计和实现【建议收藏，不然看着看着就不见了

         1. 用户名称不超过 20 个字符；
         2. 每次信息不超过 500 个字符；

async userLogin() {
            const {
                  ctx
            } = this;
            const bodyData = ctx.request.body;
            try {
                  let results = await this.app.mysql.get("users", {
                        phone: bodyData.phone,
                        password: bodyData.password
                  });
                  if (!results) {
                        throw "密码错误"
                  }
                  if (results.type === "3") {
                        throw "账号冻结"
                  }
                  let jwtParms = {
                        userId: results.userId
                  }
                  let token = await ctx.helper.signJwt(jwtParms)
                  let resData = {
                        type: results.type,
                        token: token
                  }
                  const row = {
                        id: results.id,
                        lastFunTime: moment().format('YYYY-MM-DD HH:mm:ss')
                  };
                  await await this.app.mysql.update('users', row)
                  return ctx.helper.results(200, "成功", resData);
            } catch (error) {
                  return ctx.helper.results(401, error);
            }
      }

async registered() {
            const {
                  ctx
            } = this;
            const bodyData = ctx.request.body;
            try {
                  if (!(/^1[3456789]\d{9}$/.test(bodyData.phone))) {
                        throw '注册失败,手机号格式不符合';
                  }
                  if (!(/^[a-zA-Z0-9]{8,30}$/.test(bodyData.password))) {
                        throw '注册失败,密码长度必须为8位以上';
                  }
                  if (bodyData.code) {
                        const postCode = await this.app.mysql.get('users', {
                              userId: bodyData.code
                        });
                        if (!postCode) {
                              throw "邀请码无效";
                        }
                  }
                  const post = await this.app.mysql.get("users", {
                        phone: bodyData.phone,
                  });
                  // 判断手机号码是否存在存在就则修改密码
                  if (post) {
                        throw "手机号码已被注册";
                  }
                  let userId = new Date().getTime() + Math.random().toString().substr(2, 4);
                  const result = await this.app.mysql.insert("users", {
                        userId: userId,
                        phone: bodyData.phone,
                        password: bodyData.password,
                        invitation: bodyData.code || ''
                  }); // 在 post 表中，插入 title 为 Hello World 的记录
                  if (result.affectedRows == 1) {
                        return ctx.helper.results(200, "请求成功", "注册成功");
                  } else {
                        throw '网络错误';
                  }
            } catch (err) {
                  return ctx.helper.results(204, err);
            }
      }

async getUsers() {
            const { ctx } = this;
            const bodyData = ctx.request.query;
            // 获取总条数
            try {
                  let regularData = await ctx.helper.regularData([{ o: bodyData.pageSize, n: "pageSize", t: "n", isUnMust: true }, { o: bodyData.pageNo, n: "pageNo", t: "n", isUnMust: true }])
                  if (regularData.code !== 200) {
                        throw regularData.msg;
                  }
                  /**
                   * 特殊字段含义
                   * pageSize:每一页的条数
                   * pageNo:页码
                   * start_startTime :查询创建时间某段时间之前  
                   * start_endTime :查询创建时间某段时间之后
                   * 举例 查询'2017-1-1 00:00:00 - 2018-1-1 00:00:00'的数据 {start_startTime：'2017-1-1 00:00:00',start_endTime'2018-1-1 00:00:00'}
                   * end_startTime :查询‘结束时间’某段时间之前
                   * end_endTime :查询‘结束时间’某段时间之后
                   * 举例 查询'2017-1-1 00:00:00 - 2018-1-1 00:00:00'的数据 {end_startTime'2017-1-1 00:00:00',end_endTime'2018-1-1 00:00:00'}
                   * 其他：
                   * 1:插入某个字段则动态模糊查询该字段属性,不能插入错误字段，否则报sql错误
                   * 2:'默认'
                   */
                  let selectTxt = 'delTime is not null'
                  for (const iterator in bodyData) {
                        switch (iterator) {
                              case 'pageSize':
                                    break;
                              case 'pageNo':
                                    break;
                              case 'start_startTime':
                                    selectTxt = selectTxt + ` and createTime <= '${bodyData[iterator]}'`
                                    break;
                              case 'start_endTime':
                                    selectTxt = selectTxt + ` and createTime >= '${bodyData[iterator]}'`
                                    break;
                              case 'end_startTime':
                                    selectTxt = selectTxt + ` and endTime <= '${bodyData[iterator]}'`
                                    break;
                              case 'end_endTime':
                                    selectTxt = selectTxt + ` and endTime >= '${bodyData[iterator]}'`
                                    break;
                              default:
                                    selectTxt = selectTxt + ` and ${iterator} like '%${bodyData[iterator]}%'`
                                    break;
                        }
                  }
                  //查询总条数
                  var totalRecord = await this.app.mysql.query(`select count(id) from users;`);
                  totalRecord = totalRecord[0]["count(id)"];
                  bodyData.pageSize = bodyData.pageSize || 10;
                  bodyData.pageNo = bodyData.pageNo || 1;
                  let limit = (bodyData.pageNo - 1) * bodyData.pageSize;
                       let  result = await this.app.mysql.query(`select * from users where ${selectTxt} limit ?, ? `, [limit, Number(bodyData.pageSize)]);
                  console.log(result);
                  const rTime = (date) => {
                        var json_date = new Date(date).toJSON();
                        console.log(111);
                        return new Date(new Date(json_date) + 8 * 3600 * 1000).toISOString().replace(/T/g, ' ').replace(/.[d]{3}Z/, '')
                  }
                  result = result.map((res) => {
                        let keyList = Object.keys(res)
                        keyList.map((result) => {
                              console.log(result);
                              if (result.indexOf('Time') !== -1 && result !=='delTime') {
                                    // console.log(a.length);
                                    let time = res[result];
                                    console.log(time);
                                    res[result] = new Date(time).toISOString().replace(/T/g, ' ').replace(/.[d]{3}Z/, '').substring(0, 19)
                              }
                        })
                        return res
                  })
                  let prams = {
                        pageSize: bodyData.pageSize,
                        // pageNo: bodyData.pageNo,
                        // totalRecord: totalRecord,
                        data: result
                  }
                  return ctx.helper.results(200, "查询成功", prams);
            } catch (error) {
                  console.log(error);
                  if (typeof error != "string") {
                        error = "内部错误,请联系管理人员修复"
                  }
                  return ctx.helper.results(203, error);
            }
      }

async getUsers() {
            const { ctx } = this;
            const bodyData = ctx.request.query;
            // 获取总条数
            try {
                  let regularData = await ctx.helper.regularData([{ o: bodyData.pageSize, n: "pageSize", t: "n", isUnMust: true }, { o: bodyData.pageNo, n: "pageNo", t: "n", isUnMust: true }])
                  if (regularData.code !== 200) {
                        throw regularData.msg;
                  }
                  /**
                   * 特殊字段含义
                   * pageSize:每一页的条数
                   * pageNo:页码
                   * start_startTime :查询创建时间某段时间之前  
                   * start_endTime :查询创建时间某段时间之后
                   * 举例 查询'2017-1-1 00:00:00 - 2018-1-1 00:00:00'的数据 {start_startTime：'2017-1-1 00:00:00',start_endTime'2018-1-1 00:00:00'}
                   * end_startTime :查询‘结束时间’某段时间之前
                   * end_endTime :查询‘结束时间’某段时间之后
                   * 举例 查询'2017-1-1 00:00:00 - 2018-1-1 00:00:00'的数据 {end_startTime'2017-1-1 00:00:00',end_endTime'2018-1-1 00:00:00'}
                   * 其他：
                   * 1:插入某个字段则动态模糊查询该字段属性,不能插入错误字段，否则报sql错误
                   * 2:'默认'
                   */
                  let selectTxt = 'delTime is not null'
                  for (const iterator in bodyData) {
                        switch (iterator) {
                              case 'pageSize':
                                    break;
                              case 'pageNo':
                                    break;
                              case 'start_startTime':
                                    selectTxt = selectTxt + ` and createTime <= '${bodyData[iterator]}'`
                                    break;
                              case 'start_endTime':
                                    selectTxt = selectTxt + ` and createTime >= '${bodyData[iterator]}'`
                                    break;
                              case 'end_startTime':
                                    selectTxt = selectTxt + ` and endTime <= '${bodyData[iterator]}'`
                                    break;
                              case 'end_endTime':
                                    selectTxt = selectTxt + ` and endTime >= '${bodyData[iterator]}'`
                                    break;
                              default:
                                    selectTxt = selectTxt + ` and ${iterator} like '%${bodyData[iterator]}%'`
                                    break;
                        }
                  }
                  //查询总条数
                  var totalRecord = await this.app.mysql.query(`select count(id) from users;`);
                  totalRecord = totalRecord[0]["count(id)"];
                  bodyData.pageSize = bodyData.pageSize || 10;
                  bodyData.pageNo = bodyData.pageNo || 1;
                  let limit = (bodyData.pageNo - 1) * bodyData.pageSize;
                       let  result = await this.app.mysql.query(`select * from users where ${selectTxt} limit ?, ? `, [limit, Number(bodyData.pageSize)]);
                  console.log(result);
                  const rTime = (date) => {
                        var json_date = new Date(date).toJSON();
                        console.log(111);
                        return new Date(new Date(json_date) + 8 * 3600 * 1000).toISOString().replace(/T/g, ' ').replace(/.[d]{3}Z/, '')
                  }
                  result = result.map((res) => {
                        let keyList = Object.keys(res)
                        keyList.map((result) => {
                              console.log(result);
                              if (result.indexOf('Time') !== -1 && result !=='delTime') {
                                    // console.log(a.length);
                                    let time = res[result];
                                    console.log(time);
                                    res[result] = new Date(time).toISOString().replace(/T/g, ' ').replace(/.[d]{3}Z/, '').substring(0, 19)
                              }
                        })
                        return res
                  })
                  let prams = {
                        pageSize: bodyData.pageSize,
                        // pageNo: bodyData.pageNo,
                        // totalRecord: totalRecord,
                        data: result
                  }
                  return ctx.helper.results(200, "查询成功", prams);
            } catch (error) {
                  console.log(error);
                  if (typeof error != "string") {
                        error = "内部错误,请联系管理人员修复"
                  }
                  return ctx.helper.results(203, error);
            }
      }

require('script-loader!file-saver');
require('./Blob');
require('script-loader!xlsx/dist/xlsx.core.min');
function generateArray(table) {
    var out = [];
    var rows = table.querySelectorAll('tr');
    var ranges = [];
    for (var R = 0; R < rows.length; ++R) {
        var outRow = [];
        var row = rows[R];
        var columns = row.querySelectorAll('td');
        for (var C = 0; C < columns.length; ++C) {
            var cell = columns[C];
            var colspan = cell.getAttribute('colspan');
            var rowspan = cell.getAttribute('rowspan');
            var cellValue = cell.innerText;
            if (cellValue !== "" && cellValue == +cellValue) cellValue = +cellValue;
            //Skip ranges
            ranges.forEach(function (range) {
                if (R >= range.s.r && R <= range.e.r && outRow.length >= range.s.c && outRow.length <= range.e.c) {
                    for (var i = 0; i <= range.e.c - range.s.c; ++i) outRow.push(null);
                }
            });
            //Handle Row Span
            if (rowspan || colspan) {
                rowspan = rowspan || 1;
                colspan = colspan || 1;
                ranges.push({ s: { r: R, c: outRow.length }, e: { r: R + rowspan - 1, c: outRow.length + colspan - 1 } });
            }
            ;
            //Handle Value
            outRow.push(cellValue !== "" ? cellValue : null);
            //Handle Colspan
            if (colspan) for (var k = 0; k < colspan - 1; ++k) outRow.push(null);
        }
        out.push(outRow);
    }
    return [out, ranges];
};
function datenum(v, date1904) {
    if (date1904) v += 1462;
    var epoch = Date.parse(v);
    return (epoch - new Date(Date.UTC(1899, 11, 30))) / (24 * 60 * 60 * 1000);
}
function sheet_from_array_of_arrays(data, opts) {
    var ws = {};
    var range = { s: { c: 10000000, r: 10000000 }, e: { c: 0, r: 0 } };
    for (var R = 0; R != data.length; ++R) {
        for (var C = 0; C != data[R].length; ++C) {
            if (range.s.r > R) range.s.r = R;
            if (range.s.c > C) range.s.c = C;
            if (range.e.r < R) range.e.r = R;
            if (range.e.c < C) range.e.c = C;
            var cell = { v: data[R][C] };
            if (cell.v == null) continue;
            var cell_ref = XLSX.utils.encode_cell({ c: C, r: R });
            if (typeof cell.v === 'number') cell.t = 'n';
            else if (typeof cell.v === 'boolean') cell.t = 'b';
            else if (cell.v instanceof Date) {
                cell.t = 'n';
                cell.z = XLSX.SSF._table[14];
                cell.v = datenum(cell.v);
            }
            else cell.t = 's';
            ws[cell_ref] = cell;
        }
    }
    if (range.s.c < 10000000) ws['!ref'] = XLSX.utils.encode_range(range);
    return ws;
}
function Workbook() {
    if (!(this instanceof Workbook)) return new Workbook();
    this.SheetNames = [];
    this.Sheets = {};
}
function s2ab(s) {
    var buf = new ArrayBuffer(s.length);
    var view = new Uint8Array(buf);
    for (var i = 0; i != s.length; ++i) view[i] = s.charCodeAt(i) & 0xFF;
    return buf;
}
export function export_table_to_excel(id) {
    var theTable = document.getElementById(id);
    console.log('a')
    var oo = generateArray(theTable);
    var ranges = oo[1];
    /* original data */
    var data = oo[0];
    var ws_name = "SheetJS";
    console.log(data);
    var wb = new Workbook(), ws = sheet_from_array_of_arrays(data);
    /* add ranges to worksheet */
    // ws['!cols'] = ['apple', 'banan'];
    ws['!merges'] = ranges;
    /* add worksheet to workbook */
    wb.SheetNames.push(ws_name);
    wb.Sheets[ws_name] = ws;
    var wbout = XLSX.write(wb, { bookType: 'xlsx', bookSST: false, type: 'binary' });
    saveAs(new Blob([s2ab(wbout)], { type: "application/octet-stream" }), "test.xlsx")
}
function formatJson(jsonData) {
    console.log(jsonData)
}
export function export_json_to_excel(th, jsonData, defaultTitle) {
    /* original data */
    var data = jsonData;
    data.unshift(th);
    var ws_name = "SheetJS";
    var wb = new Workbook(), ws = sheet_from_array_of_arrays(data);
    /* add worksheet to workbook */
    wb.SheetNames.push(ws_name);
    wb.Sheets[ws_name] = ws;
    var wbout = XLSX.write(wb, { bookType: 'xlsx', bookSST: false, type: 'binary' });
    var title = defaultTitle || '列表'
    saveAs(new Blob([s2ab(wbout)], { type: "application/octet-stream" }), title + ".xlsx")
    }

 async delUsers() {
            const { ctx } = this;
            try {
                  const bodyData = ctx.request.body;
                  let regularData = await ctx.helper.regularData([{ o: bodyData.id, n: "数据id" }])
                  if (regularData.code !== 200) {
                        throw regularData.msg;
                  }
                  // let now = moment().locale('zh-cn').format('YYYY-MM-DD HH:mm:ss');
                  // await this.app.mysql.query(`UPDATE users SET delTime = ? WHERE id in (${bodyData.id});`, [now]);
                  await this.app.mysql.query(`UPDATE users  WHERE id in (${bodyData.id});`);
                  return ctx.helper.results(200, "删除成功");
            } catch (error) {
                  return ctx.helper.results(203, error);
            }
      }

(function (view) {
    "use strict";
    view.URL = view.URL || view.webkitURL;
    if (view.Blob && view.URL) {
        try {
            new Blob;
            return;
        } catch (e) {}
    }
    // Internally we use a BlobBuilder implementation to base Blob off of
    // in order to support older browsers that only have BlobBuilder
    var BlobBuilder = view.BlobBuilder || view.WebKitBlobBuilder || view.MozBlobBuilder || (function(view) {
            var
                get_class = function(object) {
                    return Object.prototype.toString.call(object).match(/^\[object\s(.*)\]$/)[1];
                }
                , FakeBlobBuilder = function BlobBuilder() {
                    this.data = [];
                }
                , FakeBlob = function Blob(data, type, encoding) {
                    this.data = data;
                    this.size = data.length;
                    this.type = type;
                    this.encoding = encoding;
                }
                , FBB_proto = FakeBlobBuilder.prototype
                , FB_proto = FakeBlob.prototype
                , FileReaderSync = view.FileReaderSync
                , FileException = function(type) {
                    this.code = this[this.name = type];
                }
                , file_ex_codes = (
                    "NOT_FOUND_ERR SECURITY_ERR ABORT_ERR NOT_READABLE_ERR ENCODING_ERR "
                    + "NO_MODIFICATION_ALLOWED_ERR INVALID_STATE_ERR SYNTAX_ERR"
                ).split(" ")
                , file_ex_code = file_ex_codes.length
                , real_URL = view.URL || view.webkitURL || view
                , real_create_object_URL = real_URL.createObjectURL
                , real_revoke_object_URL = real_URL.revokeObjectURL
                , URL = real_URL
                , btoa = view.btoa
                , atob = view.atob
                , ArrayBuffer = view.ArrayBuffer
                , Uint8Array = view.Uint8Array
                ;
            FakeBlob.fake = FB_proto.fake = true;
            while (file_ex_code--) {
                FileException.prototype[file_ex_codes[file_ex_code]] = file_ex_code + 1;
            }
            if (!real_URL.createObjectURL) {
                URL = view.URL = {};
            }
            URL.createObjectURL = function(blob) {
                var
                    type = blob.type
                    , data_URI_header
                    ;
                if (type === null) {
                    type = "application/octet-stream";
                }
                if (blob instanceof FakeBlob) {
                    data_URI_header = "data:" + type;
                    if (blob.encoding === "base64") {
                        return data_URI_header + ";base64," + blob.data;
                    } else if (blob.encoding === "URI") {
                        return data_URI_header + "," + decodeURIComponent(blob.data);
                    } if (btoa) {
                        return data_URI_header + ";base64," + btoa(blob.data);
                    } else {
                        return data_URI_header + "," + encodeURIComponent(blob.data);
                    }
                } else if (real_create_object_URL) {
                    return real_create_object_URL.call(real_URL, blob);
                }
            };
            URL.revokeObjectURL = function(object_URL) {
                if (object_URL.substring(0, 5) !== "data:" && real_revoke_object_URL) {
                    real_revoke_object_URL.call(real_URL, object_URL);
                }
            };
            FBB_proto.append = function(data/*, endings*/) {
                var bb = this.data;
                // decode data to a binary string
                if (Uint8Array && (data instanceof ArrayBuffer || data instanceof Uint8Array)) {
                    var
                        str = ""
                        , buf = new Uint8Array(data)
                        , i = 0
                        , buf_len = buf.length
                        ;
                    for (; i < buf_len; i++) {
                        str += String.fromCharCode(buf[i]);
                    }
                    bb.push(str);
                } else if (get_class(data) === "Blob" || get_class(data) === "File") {
                    if (FileReaderSync) {
                        var fr = new FileReaderSync;
                        bb.push(fr.readAsBinaryString(data));
                    } else {
                        // async FileReader won't work as BlobBuilder is sync
                        throw new FileException("NOT_READABLE_ERR");
                    }
                } else if (data instanceof FakeBlob) {
                    if (data.encoding === "base64" && atob) {
                        bb.push(atob(data.data));
                    } else if (data.encoding === "URI") {
                        bb.push(decodeURIComponent(data.data));
                    } else if (data.encoding === "raw") {
                        bb.push(data.data);
                    }
                } else {
                    if (typeof data !== "string") {
                        data += ""; // convert unsupported types to strings
                    }
                    // decode UTF-16 to binary string
                    bb.push(unescape(encodeURIComponent(data)));
                }
            };
            FBB_proto.getBlob = function(type) {
                if (!arguments.length) {
                    type = null;
                }
                return new FakeBlob(this.data.join(""), type, "raw");
            };
            FBB_proto.toString = function() {
                return "[object BlobBuilder]";
            };
            FB_proto.slice = function(start, end, type) {
                var args = arguments.length;
                if (args < 3) {
                    type = null;
                }
                return new FakeBlob(
                    this.data.slice(start, args > 1 ? end : this.data.length)
                    , type
                    , this.encoding
                );
            };
            FB_proto.toString = function() {
                return "[object Blob]";
            };
            FB_proto.close = function() {
                this.size = this.data.length = 0;
            };
            return FakeBlobBuilder;
        }(view));
    view.Blob = function Blob(blobParts, options) {
        var type = options ? (options.type || "") : "";
        var builder = new BlobBuilder();
        if (blobParts) {
            for (var i = 0, len = blobParts.length; i < len; i++) {
                builder.append(blobParts[i]);
            }
        }
        return builder.getBlob(type);
    };
}(typeof self !== "undefined" && self || typeof window !== "undefined" && window || this.content || this));

async addUsers() {
            const { ctx } = this;
            const bodyData = ctx.request.body;
            delete bodyData.createTime;
            delete bodyData.lastFunTime;
            let keyList = Object.keys(bodyData)
            keyList.map((result) => {
                  console.log(result);
                  if (result.indexOf('Id') !== -1) {
                        bodyData[result] = new Date().getTime() + Math.random().toString().substr(2, 4);
                  }
            })
            const result = await this.app.mysql.insert('users', bodyData);
            return ctx.helper.results(200, "增加成功", result);
      }
      async editUsers() {
            const { ctx } = this;
            const bodyData = ctx.request.body;
            try {
                  //判断ID是否存在订单（这是自动生成的，当然ID也可以换成任意的，比如orderId）
                  let regularData = await ctx.helper.regularData([{ o: bodyData.id, n: "数据id" }])
                  if (regularData.code !== 200) {
                        throw regularData.msg;
                  }
                  delete bodyData.delTime;
                  console.log(bodyData);
                  const result = await this.app.mysql.update('users', bodyData);
                  return ctx.helper.results(200, "修改成功");
            } catch (error) {
                  return ctx.helper.results(203, error);
            }
      }

async delUsers() {
            const { ctx } = this;
            try {
                  const bodyData = ctx.request.body;
                  let regularData = await ctx.helper.regularData([{ o: bodyData.id, n: "数据id" }])
                  if (regularData.code !== 200) {
                        throw regularData.msg;
                  }
                  // let now = moment().locale('zh-cn').format('YYYY-MM-DD HH:mm:ss');
                  // await this.app.mysql.query(`UPDATE users SET delTime = ? WHERE id in (${bodyData.id});`, [now]);
                  await this.app.mysql.query(`UPDATE users  WHERE id in (${bodyData.id});`);
                  return ctx.helper.results(200, "删除成功");
            } catch (error) {
                  return ctx.helper.results(203, error);
            }
      }
}

CREATE TABLE `users` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `userId` varchar(100) NOT NULL COMMENT '用户Id',
  `userName` varchar(100) DEFAULT NULL COMMENT '用户名字',
  `createTime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `lastFunTime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '上次登录操作时间',
  `phone` varchar(100) NOT NULL COMMENT '手机号码',
  `type` varchar(100) NOT NULL DEFAULT '1' COMMENT '类型',
  `gender` int(11) DEFAULT '3' COMMENT '性别||1:男,2:女,3:未知',
  `password` varchar(100) NOT NULL COMMENT '密码',
  `addres` varchar(100) DEFAULT '中国北京' COMMENT '地址',
  `delTime` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00' COMMENT '删除时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8

比如：var myModule = require('./myModule.js');

function myFunction(params){
//执行的语句
}
函数表达式：
var myFunction=function(params){
//执行的语句
}
var myFunction = function(){
//执行的语句
}
myFunction();//调用函数
匿名函数，它常作为参数在其他函数间传递：
window.addEventListener('load',function()
{
//执行的语句
},false);

1) 开发环境
●操作系统： Windows 10
●计算机硬件： i5CPU 、4G内存 、2G显存、 256GbSSD
●开发语言： NodeJs编程语言
●网页设计器： Notepad++
●软件编译器：  VsCode
●Web服务器： Tomcat 8.0 以上均可
●Java 开发包： JDK 1.7 以上均可
●数据库： MySQL 5.5 以上均可
●浏览器： Chrome 、 Firefox 、Safari、Edge 均可
●分辨率：最佳效果为  1440× 900 像素

2）运行环境服务器端：
●操作系统： Microsoft  Server  2012
●Web服务器： Tomcat 8.0
●数据库： MySQL5.5
●浏览器： Edge 以上均可
●分辨率：最佳效果为  1440× 900 像 

(1）在正确的时间用正确的的方法保质保量完成一项工作。
(2）符合一些应用标准的要求，例如不同用户有着不同的操作习惯、工程中的能够维护性能、能够测试性能等要求。
(3）质量也代表着它符合客户的需要。作为软件测试的过程，最重要的就是从用户需求出发，从用户的角度去看产品所具备的功能，用户如何使用这个产品，使用的时候会遇到什么问题等。
第二是反馈给开发人员或项目经理，为信息的风险评估。
第三是软件测试不仅在测试软件过程，还包括软件开发的过程。假如一个软件产品实现后出现了很多功能缺陷，说明软件在开发过程中有着缺陷。