-
对常用函数的封装，有助于综合运用和认时接口和代码层次，加快项目进度。
一部分功能基于jQ，但是如果html中没有引入jQ的话，该公共js会自动检测并自动引入。
-
代码思路和用法再代码注释和注释调用中已经说明。
你可以试着调用alert_txt("hello", 2000);来查看效果。
-
/*
* create: 2018-06-00 update: 2018-09-18 unicode: UTF-8
* [email protected]
* author: fyonecon
*
* js兼容性：Android 5.0+，iOS 10.3+，IE 10+，主要面向移动设备
* ES6(逻辑) + jQ(dom)，但是可以不引入jQ，因为jQ会自动检测并自动引入CDN
*
* 推荐CND：
*
* VUE.js CDN：
*
* js、css在线压缩：
* https://tool.css-js.com
* js加密
* https://www.sojson.com/jsobfuscator.html
*
* */
/*
* 使用方法：
1. 直接引用方法函数即可，无Block函数那种繁琐引用；
2. 注意一些自带的全局变量，避免一些坑；
3. 场景值可以解决多个或者多次调用同一函数的冲突，注意区分。
*
* common.js函数调用表（主要已列出，次要的未列出）：
common.css自动引入，初始化了一些必要样式
animated.css自动引入，预增加页面动画
无刷新更改页面地址，请参照
http://cdnaliyun.oss-cn-hangzhou.aliyuncs.com/js/js_extent_push.js
批量写入css CDN链接
var cdn_css = ["", ""];
add_css(cdn_css)
字典转数组，return
dictionary_to_array(input_data)
扩展js数据类型的判断，return
js_typeof(input_data)
图片展示插件
show_img(img_url, txt, refresh, display_btn)
获取url的参数的值，return
getThisUrlParam(url, key)
单个替换参数url里面的老参数，输出新url，return
changeUrlParam(url, key, new_value)
批量替换参数url里面的老参数，输出新url，return
changeAllUrlParam(str, arr)
过滤字符串特殊符号，return
getPureStr(str)
用于显示[多文字Toast]提示
alert_txt(txt, time, call_func)
用于显示[多文字确定]提示
alert_msg(title, content, btn_txt, this_func)
设置和更新cookie，return
setCookie(key, value, expiredays)
读取cookie，return
getCookie(key)
时间戳转日期，return
timestampToTime(timestamp)
生成二维码，回调函数返回二维码地址
make_qr(content, width, call_func)
求范围内的值[min, max]，return
js_rand(min, max)
获取当前时间的 日期、星期、时间戳(秒)、时间戳(毫秒)，return
getNowDate()
时间戳(毫秒)转日期，输入时间统一用秒，然后将毫秒转换成秒，return
formatDateTime(inputTime)
浏览器设备运动事件（摇一摇、加速运动等）
device_motion(call_func, during)
处理触摸手势
调用swipe_touch(document.getElementById("test"));开启该区域触摸事件
使用function touch_data(data){console.log(data);}取出该区域触摸参数
base64编码解密加密，return
js_base64_decode(result)
js_base64_encode(string)
处理图片
在img标签中加入class="img-select-cell"即可完成
md5加密，return
js_md5(string, toUpperCase, call_func)
判断是否是微信浏览器的函数
user_weixin(status, jump_url, call_func, data)
判断设备类型，Android、iOS、PC
user_device(device_func, data)
获取用户的地址和IP，回调函数返回信息数组，return
user_address(call_func)
页面刷新次数安全校验，利用cookie
refresh_check(max_num, common_cookie_pre, jump_url)
基于jQ的get方法请求
get_func(get_api_url, call_func)
基于jQ的post方法请求
post_func(post_api_url, obj, call_func)
原生get请求
get_api(get_api_url, call_func)
原生Fetch的post方法请求
post_api(post_api_url, obj, call_func)
//页面加载的百分比 [0~1]，直接调用loading_percent(show_load)将使用默认加载效果
//loading_percent(show_load)
遮蔽层的开启和删除
show_layer(tag, bg_color, z_index)
delete_layer(tag);
实现自定义的多次点击
many_click(_click_num, call_func)
或者直接调用
双击 two_click(call_func)
三击 three_click(call_func)
*
* */
/*
*
* es6+php+oc
*
* */
// 'use strict'; // 暂不开启这个功能
/*
* 处理调试模式
* */
//var common_debug = true; // bool： true时打开调试
if(typeof common_debug === "undefined"){
console.info("%c"+"'common_debug=false'，console默认关闭", "color:blue;font-size:13px;");
common_debug = false;
}else {
if (common_debug === true){
console.info("%c"+"'common_debug=true'，console默认打开，unicode: UTF-8，2018-09-04", "color:green;font-size:13px;");
}else {
console.info("%c"+"'common_debug=false'，console已经关闭", "color:blue;font-size:13px;");
}
}
var common_debug_num = 1; // 参照
function console_info_func(txt) { // 日志分流
if(common_debug_num === 1){
console.info("%c"+txt, "color:grey;font-size:12px;");
common_debug_num++;
}else {
//console.info(common_debug_num);
common_debug_num++;
}
}
/*
* 重写日志输出格式
* */
function common_log(txt) { // 日志函数，注意，已经将其他数据类型强制转化成了string
common_debug === true ? console.info("%c" + txt, "color:#A0A0A0;font-size:12px;") : console_info_func("The common.js is running");
}
/*
* 扩展js框架
* */
const kd_jq = "http://cdnaliyun.oss-cn-hangzhou.aliyuncs.com/js/jquery-1.11.3.min.js" +'?'+time_milli(); // jq框架
const md5_url = "http://cdnaliyun.oss-cn-hangzhou.aliyuncs.com/js/md5.js" +'?'+time_milli(); // 引用md5.js
const common_css = "http://cdnaliyun.oss-cn-hangzhou.aliyuncs.com/css/common.css" ; // 公共样式
const qr_js= "http://cdnaliyun.oss-cn-hangzhou.aliyuncs.com/js/qrcode.js" +'?'+time_milli(); // js生成二维码库
const js_push = "http://cdnaliyun.oss-cn-hangzhou.aliyuncs.com/js/js_extent_push.js" +'?'+time_milli(); // 无刷新更改页面地址
const souhu_address = "http://pv.sohu.com/cityjson?ie=utf-8"; // 搜狐获取用户IP、城市统计
const animated_css = "http://cdnaliyun.oss-cn-hangzhou.aliyuncs.com/css/animate.min.css" ; // 动画css3
(function (e) {
var jq_check_num = 0;
function run_jq_check(jq_check_num){
try {
document.write(' ');
common_log("遮蔽层tag="+_tag+"已经创建，请及时删除（请调用delete_layer(tag)）");
}
/*
* 清除遮蔽层
* tag 标识（指的是要删除哪个或者全部的遮蔽层）
* */
function delete_layer(tag) {
if (tag === "all"){
_tag = "all";
$(".bg-layer").remove();
}else {
!tag ? _tag = 0 : _tag = tag;
$(".bg-layer-"+_tag).remove();
}
common_log("已经执行删除tag="+_tag+"的删除");
}
/*
* 404
* */
function jump_404(url) {
if (url){
window.location.replace(url);
}else {
window.location.replace("https://m.sogou.com/404");
}
}
/*
* 基础函数
* 毫秒时间戳
* */
function time_milli() {
var timestamp = Date.parse(new Date()); // 000毫秒时间戳
var milli = (new Date()).getMilliseconds(); // 纯毫秒毫秒
var time_milli_res = timestamp + milli;
//common_log(time_milli_res);
return time_milli_res;
}
/*
* 基础函数
* 字典转数组
* */
function dictionary_to_array(input_data) {
// 字典转数组
var new_arr = [];
for (let i in input_data) {
new_arr.push(input_data[i]); // 取value，不能取到key
}
//new_arr = Array.from(input_data); // es6
//console.log(new_arr);
common_log("字典转数组："+new_arr); // 已经强制array转string
return new_arr;
}
/*
* 基础函数
* js 具体的数据类型判断，输出准确的数据类型
* array dictionary null number string boolean undefined function
* */
function js_typeof(input_data) {
var this_type = typeof input_data;
if (this_type === "object"){ // null {} []
if (input_data === null){
input_data = "null";
that_type = "null";
}else {
if(input_data.constructor === Array){ // 数组
that_type = "array for object";
}else if (input_data.constructor === Object){ // 字典类型，或者叫json
input_data = dictionary_to_array(input_data); // 字典转数组
that_type = "dictionary(json) for object";
}else if(input_data.constructor === Date){
that_type = "date";
}else {
that_type = this_type;
}
}
}else{ // number string boolean undefined function
that_type = this_type;
}
//console.log(input_data);
common_log("数据类型："+that_type+""+"；值："+input_data);
return that_type;
}
/*
* 预览单个大图功能：直接引用：show_img(img_url, "", "", "hide")
* 可以判断图片地址是空或者404。
*
* img_url：图片地址或者图片base64编码
* txt：提示语
* refresh："refresh" 关闭图片预览时刷新，
* display_btn： "hide" 关闭按钮和图层背景不显示
* */
function show_img(img_url, txt, refresh, display_btn){
$("body").append('
');
$(".kd-picture").attr("src", img_url);
if(!img_url){
alert_txt("图片地址为空！
无法预览大图", 3000);
return;
}
$(".kd-layer-bg").show(300);
$(".kd-picture").show(300).attr("src", img_url);
if(!txt){ // 提示语
//alert_txt("长按可以保存图片哦~", 3000);
}else{
alert_txt(txt, 3000);
}
if (display_btn === "hide"){ // 是否展示关闭按钮
$(".kd-close-show_img").remove();
common_log("隐藏了-关闭-按钮");
}else if(display_btn === "show"){
common_log("关闭-按钮默认显示1");
}else {
common_log("关闭-按钮默认显示2");
}
// 图片高度超过一定范围，操作背景按钮不方便，即显示一个另外的关闭图片按钮
var _img_url = img_url + "?" + Date.parse(new Date());
var img = new Image();
var patt = new RegExp("data:image/");
var res_base = patt.test(_img_url);
if(res_base){ // 是base64
common_log("base64："+res_base);
$("body").append('
关闭
');
}else{ // 不是base64
img.src = _img_url;
img.onload = function(){
//alert('width:'+img.width+',height:'+img.height);
var img_height = (img.height/img.width)*window.innerWidth; // 计算图片的动态高度
common_log(img_height);
if(Math.abs(img_height-window.innerHeight) < 60 || img_height-window.innerHeight>=60){
common_log("为特别高度图提供关闭按钮");
$("body").append('
关闭
');
}
};
}
}
// 图片地址无效时
function kd_img_error(){
alert_txt("图片地址无效！图片404", 5000);
setTimeout(function(){
kd_layer_bg();
}, 2000);
// 抛出图片地址
common_log("图片404地址："+$(".kd-picture").attr("src"));
}
// 删除图片预览节点
function kd_layer_bg(refresh){
$(".kd-layer-bg").remove();
$(".kd-picture").remove();
$(".kd-close-show_img").remove();
if(refresh === "refresh"){
window.location.reload();
}else if(!refresh){
//common_log("关闭图层不刷新页面");
return;
}else{
//common_log("关闭图层不刷新页面");
return;
}
common_log("处理了图片浏览图层节点");
}
/*
* return
* js获取 url后的参数值，如果存在键，则返回键的值，如果不存在则返回null
* string key: 键名，调用getUrlParam("sex")则返回0
* */
function getThisUrlParam(url, key) { // 返回值
// 兼容模式url地址，例如：poop.html?page=3&ok=222#p=2#name=kd
var url_str = "";
if(!url){
url_str = window.location.href;
}else {
url_str = url;
}
// 正则匹配url中的参数，如果存在键，则返回键的值，如果不存在则返回null
var regExp = new RegExp("([?]|&|#)" + key + "=([^&|^#]*)(&|$|#)");
var result = url_str.match(regExp);
if (result) {
return decodeURIComponent(result[2]); // 转义还原参数
} else {
return null; // 没有匹配的键即返回null
}
}
/*
* return
* 单个替换参数url里面的老参数，输出新url
* string url：网址或取他
* string key：键
* string new_value：新值
* */
function changeUrlParam(url, key, new_value) { // 返回新url
var url_str = url;
var regExp = new RegExp("([?]|&|#)" + key + "=([^&|^#]*)(&|$|#)");
var result = url_str.match(regExp);
if (result) {
var old_value = decodeURIComponent(result[2]);
var old_str = key+"="+old_value;
url_str = url_str.replace(new RegExp(old_str, "g"), key+"="+new_value); // 全局替换
common_log("单个替换结果="+url_str);
return url_str;
} else {
common_log("'"+url_str+"'中没有匹配到key="+key+"，new_value="+new_value);
return url; // 没有匹配的键即返回原始url
}
}
/*
* return
* 批量替换参数url里面的老参数，输出新url
* string str：网址或取他
* array arr： [[键, 新值], [key, new_value], [key, new_value]];
*
* */
function changeAllUrlParam(str, arr) { // 返回新被替换过的url
common_log("批量替换url中的键的值");
var url_str = str;
var old_str = str;
var array = arr;
common_log(array);
if(arr.length<=0 && typeof arr !== "object"){
common_log("arr参数错误："+typeof arr+"=="+arr);
return "arr is null";
}
for(let kd= 0; kd
');
if (!time){
time = 4000;
}
if(time === "long"){ // 超长时间提示
time = 1000*60*30;
long_time = setTimeout(function () { // 定时执行，但是微信环境中，链接可能会被封杀，所以暂时没有回调
common_log("alert_txt()时间设置超时>'long 1000*60*30'，但是并没有设置超时时的回调函数");
}, time);
}
if(time >= 1000*60*25){
var time_self = 1000*60*30;
long_time_self = setTimeout(function () { // 定时执行，但是微信环境中，链接可能会被封杀，所以暂时没有回调
common_log("alert_txt()时间设置超时>1000*60*30，但是并没有设置超时时的回调函数");
}, time_self);
}
if ( txt.trim() === ""){ // 扔出错误
clearTimeout(kd_ST);
alert_txt("系统报错：txt文字为空
txt is null", 5000);
return;
}
setTimeout(function () {
$(".kd-toast-txt").html(txt);
//document.getElementById("kd-toast-txt").innerHTML = txt;
},80);
kd_ST = setTimeout(function () {
$(".kd-alert-txt").fadeOut(700).remove();
$(".kd-alert-bg").remove();
//_div.remove();
}, time);
if(call_func){
call_func(); // 直接异步调用
}else {
common_log("alert_txt()没有设置回调函数");
}
}
// cookie前缀 var cookie_pre = "le_";
// 示例：expiredays = 30 * 24 * 60 * 60 * 1000，30天
// 设置和更新cookie
// function setCookie(key, value, expiredays){
// common_log("设置或更新cookie="+key+"="+value);
// var exdate=new Date();
// exdate.setDate(exdate.getDate()+expiredays);
// document.cookie=key+ "=" +escape(value) + ((expiredays==null) ? "" : ";expires="+exdate.toGMTString());
// }
// // 读取cookie
// function getCookie(key){
// common_log("读取cookie="+key);
// if (document.cookie.length>0) {
// c_start=document.cookie.indexOf(key + "=");
// if (c_start!==-1){
// c_start=c_start + key.length+1;
// c_end=document.cookie.indexOf(";",c_start);
// if (c_end===-1) c_end=document.cookie.length;
// return unescape(document.cookie.substring(c_start,c_end));
// }
// }
// return "";
// }
//写入cookies
// time = 1*24*60*60*1000;
function setCookie(name, value, time) {
if (!time){
time = 1*24*60*60*1000; // 默认1天
}
var exp = new Date();
exp.setTime(exp.getTime() + time);
document.cookie = name + "="+ escape (value) + ";expires=" + exp.toGMTString();
}
//读取cookies
function getCookie(name) {
var arr,reg=new RegExp("(^| )"+name+"=([^;]*)(;|$)");
if(arr=document.cookie.match(reg)){
return unescape(arr[2]);
} else{
return null;
}
}
//删除cookies
function delCookie(name) {
var exp = new Date();
exp.setTime(exp.getTime() - 1);
var cval=getCookie(name);
if(cval!=null) {
document.cookie = name + "=" + cval + ";expires=" + exp.toGMTString();
}
}
// 时间戳转日期
function timestampToTime(timestamp) {
var date = new Date(timestamp * 1000);//时间戳为10位需*1000，时间戳为13位的话不需乘1000
Y = date.getFullYear() + '-';
M = (date.getMonth()+1 < 10 ? '0'+(date.getMonth()+1) : date.getMonth()+1) + '-';
D = date.getDate() + ' ';
h = date.getHours() + ':';
m = date.getMinutes() + ':';
s = date.getSeconds();
return Y+M+D+h+m+s;
}
// 生成二维码，回调函数返回二维码地址，必要文件qrcode.js
function make_qr(content, width, call_func) {
var _width = 200;
if (!width){
common_log("make_qr()没有设置宽，将默认200px");
}else {
_width = width;
}
if (!content){
alert_txt("没有设置二维码内容");
}
var _height = _width;
$.getScript(qr_js, function (e) {
common_log("生成二维码");
// 生成二维码
// 二维码图位置
$("body").append('
');
var qrcode = new QRCode("qrcode", {
text: content,
width: _width,
height: _height,
colorDark : "#000000",
colorLight : '#ffffff',
correctLevel : QRCode.CorrectLevel.L
});
var qr_img_url = $(".qr-img").attr("src");
if (!call_func){
common_log("make_qr()无回调函数");
}else {
call_func(qr_img_url);
}
});
}
/*
* 求范围内的值，
*/
function js_rand(min, max) { // [min, max]
var this_rand = Math.floor(Math.random()*(max-min+1)+min);
common_log("范围内的随机值="+this_rand);
return this_rand;
}
/*
* 将各个位数数字单独取出，范围[百亿--百分位]
*/
function select_number(number) {
var _number = [];
if (typeof number === "number"){
// 正则方法
// var num = 123456;
// var numArr = num.split('');
// //个位
// var a = numArr[numArr.length-1];
// //十位
// var b = numArr[numArr.length-2];
// //百位
// var c = numArr[numArr.length-3];
// //...以此类推
var _eleven = Math.floor(number/10000000000 % 10); // 百亿
var _ten = Math.floor(number/1000000000 % 10); // 十亿
var _nine = Math.floor(number/100000000 % 10); // 亿
var _eight = Math.floor(number/10000000 % 10); // 千万
var _seven = Math.floor(number/1000000 % 10); // 百万
var _six = Math.floor(number/100000 % 10); // 十万
var _five = Math.floor(number/10000 % 10); // 万
var _four = Math.floor(number/1000 % 10); // 千
var _three = Math.floor(number/100 % 10); // 百
var _two = Math.floor(number/10 % 10); // 十
var _one = Math.floor(number % 10); // 个
var __one = Math.floor(number/0.1 % 10); // 十分位
var __two = Math.floor(number/0.01 % 10); // 百分位
_number = [number,_eleven,_ten,_nine,_eight,_seven,_six,_five,_four,_three,_two,_one,__one,__two];
common_log("范围[原数0-百亿1-个位11-百分位13]=="+_number+"=="+typeof _number+"==示例：个位[11]="+_number[11]);
return _number;
}else {
common_log(typeof number);
_number = [number,0,0,0,0,0,0,0,0,0,0,0,0,0];
common_log("数据类型错误，不可解析，各个位默认返回=="+_number);
return _number;
}
}
/*
*
* num 要匹配的数
* dot 是否循环出小数点后dot位，dot=2取到个位，dot=1取到十分位，dot=0取到百分位
*
* */
function select_num(num, dot) {
var num_array = select_number(num);
if ( dot>2 || dot<0){ // dot取值异常时
common_log("取小数点位数异常，dot范围：[0,2]");
return;
}else if(typeof dot !== "number"){
common_log("将默认低位取到个位，dot=2");
dot = 2;
}
var j_num_max = 0;
for (let j=0;j
= 1 && month <= 9) {
month = "0" + month;
}
if (day >= 0 && day <= 9) {
day = "0" + day;
}
if (hour >= 0 && hour <= 9) {
hour = "0" + hour;
}
if (minutes >= 0 && minutes <= 9) {
minutes = "0" + minutes;
}
if (seconds >= 0 && seconds <= 9) {
seconds = "0" + seconds;
}
var currentdate = [year + sign1 + month + sign1 + day, hour + sign2 + minutes + sign2 + seconds, week, timestamp, time_milli()];
common_log("当前时间[日期、星期、时间戳(秒)]数组："+currentdate);
return currentdate;
}
/*
* 时间戳(毫秒)转日期，输入时间统一用秒，然后将毫秒转换成秒
* */
function formatDateTime(inputTime) {
var s_time = inputTime*1000;
var number = new Number(s_time); // 数字转字符串，以便计算长度
if (number.toString().length < 10 || number.toString().length > 14){
common_log("输入时间戳单位为秒，特此提醒。当前数字长度："+number.toString().length);
}
var date = new Date(s_time);
var y = date.getFullYear();
var m = date.getMonth() + 1;
m = m < 10 ? ('0' + m) : m;
var d = date.getDate();
d = d < 10 ? ('0' + d) : d;
var h = date.getHours();
h = h < 10 ? ('0' + h) : h;
var minute = date.getMinutes();
var second = date.getSeconds();
minute = minute < 10 ? ('0' + minute) : minute;
second = second < 10 ? ('0' + second) : second;
var currentdate = [y+'-'+m+'-'+d, h+':'+minute+':'+second];
common_log("时间戳 转 日期数组："+currentdate);
return currentdate;
}
/*
*
* 浏览器设备运动事件（摇一摇、加速运动等）
* 浏览器兼容性：Android（全）、iOS（全）运行正常
* 文档：https://developer.mozilla.org/zh-CN/docs/Web/API/DeviceMotionEvent
*
* call_func 回调函数，此回调函数不能携带参数，提前写带参数会造成device函数不能运行
* during 范围[20ms, 3000ms] 。设置默认时间段内回调一次，单位xx ms/次，默认500ms。
*
* 例：function kd_func() { // 回调函数
common_log("123");
alert_txt("123");
}
device_motion(kd_func, 500); // 调用主函数
*
* */
var SHAKE_THRESHOLD = 1000; // 默认动作时间差
var last_update = 0;
var last_time = 0;
var x;
var y;
var z;
var last_x;
var last_y;
var last_z;
var curTime;
var isShakeble = true; // 调试
function device_motion(call_func, during) {
if(!during){
during = 500;
}else if(during<20){
during = 20;
}else if(during>3000){
during = 3000;
}
var first_time = new Date().getTime();
if (window.DeviceMotionEvent) {
window.addEventListener('devicemotion', function (ev) {
curTime = new Date().getTime();
var diffTime = curTime - last_update;
if (diffTime > 100) {
var acceleration = ev.accelerationIncludingGravity;
last_update = curTime;
x = acceleration.x;
y = acceleration.y;
z = acceleration.z;
var speed = Math.abs(x + y + z - last_x - last_y - last_z) / diffTime * 10000;
if (speed > SHAKE_THRESHOLD && curTime - last_time > 1100 && isShakeble) {
common_log("该设备有加速事件，开始执行回调函数");
// 处理回调函数
if(call_func){
var cur_time = new Date().getTime();
if(Math.abs(first_time-cur_time) >= during){
common_log("调用了回调函数");
first_time = new Date().getTime(); // 初始化
call_func(); // 调用函数。此回调函数不能携带参数，提前写带参数会造成device函数不能运行
}else {
common_log("由于时间段限制，跳过了回调函数");
}
}else {
common_log("该设备加速有效，但是没有指定回调函数。");
}
}
last_x = x;
last_y = y;
last_z = z;
}
}, false);
common_log("该设备支持位置和方向改变的速度，下一步，请让设备（浏览器）加速运动（摇一下设备）起来。");
} else {
common_log("该设备（浏览器）不支持运动属性");
alert_txt("该设备（浏览器）不支持加速运动属性");
}
}
/*
* msg_func_ok(函数操作标识)，需要coder使用时拿出来
* msg_func_close(函数操作标识)，不需要自定义
* alert_msg(标题，内容描述或其它标签内容，按钮文字，函数操作标识[多个msg时区分各自操作])，不需要自定义
* 注意：this_func参数指的是标识数字或者标识字符串，并不是函数
* */
/*
function msg_func_ok(this_func) { // msg确定按钮 ，示例
common_log("msg_ok标识="+this_func);
switch(this_func){
case 1:
run_test1();
break;
case 8:
run_test8();
break;
default:
common_log("发现未知操作标识="+this_func);
}
}
function msg_func_close_call(this_func){
common_log("关闭msg的回调函数，如果没有，报错可以忽略。");
}
*/
function msg_func_close(this_func) { // 关闭msg提示
common_log("msg_close标识="+this_func);
$(".kd-alert-msg-div-"+this_func).remove();
$(".kd-alert-msg-bg-"+this_func).remove();
msg_func_close_call(this_func);
}
function alert_msg(title, content, btn_txt, this_func) { // 渲染msg
// 校验msg_func_ok()函数方法是否存在，因为这个是自定义函数
try {
if(typeof msg_func_ok === "function") { //是函数 ，其中 msg_func_ok 为函数名称
common_log("msg_func_ok(this_func)函数方法存在");
} else { //不是函数
common_log("msg_func_ok(this_func)函数方法不存在，将无法完成msg_func_ok按钮的调用");
//alert_txt("msg_func_ok(this_func)函数方法不存在，将无法完成msg_func_ok按钮的调用");
}
if(typeof msg_func_close_call === "function") { //是函数 ，其中 msg_func_ok 为函数名称
common_log("msg_func_close_call(this_func)函数方法存在");
} else { //不是函数
common_log("msg_func_close_call(this_func)函数方法不存在，不过这只是一个回调函数，可以忽略报错");
//alert_txt("msg_func_ok(this_func)函数方法不存在，将无法完成msg_func_ok按钮的调用");
}
} catch(e) {
common_log("alert_msg(title, content, btn_txt, this_func)未知异常="+e);
}
// 校验出现多个alert_msg()函数调用时，实现各自控制各自
if(!this_func){
var timestamp = Date.parse(new Date())/1000; // 精确到秒的时间戳
this_func = timestamp;
common_log("没有设置this_func的区别标识，将默认为="+this_func);
}
// 校验必要参数
if(!title || !content || !btn_txt){
common_log("alert_msg参数不完整，this_func="+this_func);
//alert_txt("alert_msg参数不完整，this_func="+this_func);
return;
}
$("body").append('
');
$(".alert-msg-title-text-"+this_func).html(title);
$(".alert-msg-content-"+this_func).html(content);
$(".alert-msg-btn-ok-"+this_func).html(btn_txt)
}
var alert_msg_border = 1;
try{
//kd-alert-msg-div
$(document).on("click", ".kd-alert-msg-bg", function (e) {
common_log("on");
if(alert_msg_border === 1){
$(".kd-alert-msg").css("border", "2px solid #7B68EE");
alert_msg_border = 2;
}else {
$(".kd-alert-msg").css("border", "2px solid #3CB371");
alert_msg_border = 1;
}
});
$(document).on("click", ".kd-alert-msg-div", function (e) {
common_log("on");
if(alert_msg_border === 1){
$(".kd-alert-msg").css("border", "2px solid #CDCD00");
alert_msg_border = 2;
}else {
$(".kd-alert-msg").css("border", "2px solid #CD3700");
alert_msg_border = 1;
}
});
//alert_msg("提示", "这是内容1", "确定", 1);
//alert_msg("提示", "这是内容2","确定", 8);
//alert_msg("提示", "这是内容3","确定");
//alert_msg("提示", "这是内容4","确定");
}catch (err){
common_log(err);
}
/*
* 基于jQ
* get请求封装
* void
* get_api_url get接口
* call_func 回调函数
*
* */
function get_func(get_api_url, call_func) {
$.getJSON(get_api_url, function(data, status){
common_log("get返回数据：" + data+"；status："+status+"；返回数据的类型："+typeof data);
if(status === "success"){
if(!call_func){
common_log("回调函数为必填！否则无法异步返回结果");
}else {
call_func(data); // 异步得到结果
}
}else{
common_log("请求错误，检查后台get方法");
alert_txt("请求错误或者网络不通");
}
});
}
/*
* 基于jQ
* post请求封装
* void
* post_url_api 接口
* dataObj 数据
* call_func 回调函数
* */
function post_func(post_url_api, dataObj, call_func) {
var post_url = post_url_api;
var obj = dataObj;
// 请求数据
$.ajax({
url: post_url,
type: "POST",
dataType: "json", // 已经默认json
async: true, // 已经默认true
data: obj, // dataObj为Object类型: {nickname: "name",}
success: function(data, status){
common_log("post返回数据：" + data+"；status："+status+"；返回数据的类型："+typeof data);
// 确保返回数据是object类型
if(typeof data === "string"){
datas = JSON.parse(data); // json字符串转换成json对象
}else {
datas = data;
}
if(!call_func){
common_log("回调函数为必填！否则无法异步返回结果");
}else {
call_func(datas); // 异步得到结果
}
},
error: function (xhr) {
console.log(xhr);
alert_txt("接口请求错误或者网络不通");
}
});
}
/*
*
* 基于ES，或者原生js
* get请求封装
*
* */
function get_api(get_api_url, call_func) {
//请求数据库存在的用户信息
var url = get_api_url;
var ajax_get = function(url) {
return new Promise(function(resolve2, reject) {
var r = new XMLHttpRequest();
r.open("GET", url, true);
r.onreadystatechange = function () {
if (r.readyState !== 4 || r.status !== 200) return;
var data = r.responseText;
resolve2(data);
// 确保返回数据是object类型
if(typeof data === "string"){
datas = JSON.parse(data); // json字符串转换成json对象
}else{
datas = data;
}
if(!call_func){
common_log("回调函数为必填！否则无法异步返回结果");
}else {
call_func(datas); // 异步得到结果
}
};
r.send();
})
};
ajax_get(url);
}
/*
*
* 基于ES，或者原生js
* post请求封装
* 貌似不能上传大于2M的base64，原因未知
*
* */
function post_api(post_api_url, dataObj, call_func) {
var url = post_api_url;
var obj = dataObj; // object类型: {nickname: "name",}
fetch(url,{
method:"POST",
mode: "cros",
headers:{
"Content-type":"application/x-www-form-urlencoded; charset=UTF-8"
},
body: JSON.stringify(obj)
})
.then(function (response){
common_log(response);
})
.then(function(data){
common_log("fetch请求成功，响应数据为:", data);
// 确保返回数据是object类型
if(typeof data === "string"){
datas = JSON.parse(data); // json字符串转换成json对象
}else{
datas = data;
}
if(!call_func){
common_log("回调函数为必填！否则无法异步返回结果");
}else {
call_func(datas); // 异步得到结果
}
})
.catch(function(err){
common_log("Fetch错误:"+err);
alert_txt("接口请求错误或者网络不通");
});
}
/*
*
* base64编码语解码
* Base64 encode / decode
* 文档：https://blog.csdn.net/u011127019/article/details/51673230
*
*/
function Base64() {
// private property
_keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
// public method for encoding
this.encode = function (input) {
var output = "";
var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
var i = 0;
input = _utf8_encode(input);
while (i < input.length) {
chr1 = input.charCodeAt(i++);
chr2 = input.charCodeAt(i++);
chr3 = input.charCodeAt(i++);
enc1 = chr1 >> 2;
enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
enc4 = chr3 & 63;
if (isNaN(chr2)) {
enc3 = enc4 = 64;
} else if (isNaN(chr3)) {
enc4 = 64;
}
output = output +
_keyStr.charAt(enc1) + _keyStr.charAt(enc2) +
_keyStr.charAt(enc3) + _keyStr.charAt(enc4);
}
return output;
}
// public method for decoding
this.decode = function (input) {
var output = "";
var chr1, chr2, chr3;
var enc1, enc2, enc3, enc4;
var i = 0;
input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
while (i < input.length) {
enc1 = _keyStr.indexOf(input.charAt(i++));
enc2 = _keyStr.indexOf(input.charAt(i++));
enc3 = _keyStr.indexOf(input.charAt(i++));
enc4 = _keyStr.indexOf(input.charAt(i++));
chr1 = (enc1 << 2) | (enc2 >> 4);
chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
chr3 = ((enc3 & 3) << 6) | enc4;
output = output + String.fromCharCode(chr1);
if (enc3 != 64) {
output = output + String.fromCharCode(chr2);
}
if (enc4 != 64) {
output = output + String.fromCharCode(chr3);
}
}
output = _utf8_decode(output);
return output;
}
// private method for UTF-8 encoding
_utf8_encode = function (string) {
string = string.replace(/\r\n/g,"\n");
var utftext = "";
for (let n = 0; n < string.length; n++) {
var c = string.charCodeAt(n);
if (c < 128) {
utftext += String.fromCharCode(c);
} else if((c > 127) && (c < 2048)) {
utftext += String.fromCharCode((c >> 6) | 192);
utftext += String.fromCharCode((c & 63) | 128);
} else {
utftext += String.fromCharCode((c >> 12) | 224);
utftext += String.fromCharCode(((c >> 6) & 63) | 128);
utftext += String.fromCharCode((c & 63) | 128);
}
}
return utftext;
}
// private method for UTF-8 decoding
_utf8_decode = function (utftext) {
var string = "";
var i = 0;
var c = c1 = c2 = 0;
while ( i < utftext.length ) {
c = utftext.charCodeAt(i);
if (c < 128) {
string += String.fromCharCode(c);
i++;
} else if((c > 191) && (c < 224)) {
c2 = utftext.charCodeAt(i+1);
string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
i += 2;
} else {
c2 = utftext.charCodeAt(i+1);
c3 = utftext.charCodeAt(i+2);
string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
i += 3;
}
}
return string;
}
}
var base = new Base64();
//1.加密
// var str = '124内容';
// var result = base.encode(str);
// //2.解密
// var result2 = base.decode(result);
// base64加密
function js_base64_encode(string) {
var result = base.encode(string);
common_log("js_base64加密结果="+result);
return result;
}
// base64解密，默认1次解密
var js_base64_j = 1;
function js_base64_decode(result){
var string = base.decode(result);
common_log("js_base64解密（第"+js_base64_j+"次解密）="+string);
js_base64_j++;
return string;
}
/*
*
* 处理图片
* 在img标签中加入class="img-select-cell"即可完成
*
* */
var img_src = ""; // 当前图片地址
try {
$(document).on("click", ".img-select-cell", function (e) { // 消除append()带来的不可点击
var that = $(this);
img_src = that.attr("src");
var timestamp = Date.parse(new Date())/1000; // 精确到秒的时间戳
$("body").append('
' +
'' +
'
查看大图
' +
'
截取图片
' +
'
保存图片
' +
'
取消
-
-
