常用Javascript函数与原型功能收藏(必看篇)


Posted in Javascript onOctober 09, 2016

如下所示:

// 重复字符串
String.prototype.repeat = function(n) {
  return new Array(n+1).join(this);
}
 
// 替换全部
String.prototype.replaceAll = function(str1, str2) {
  return this.replace(new RegExp(str1, "gm"), str2);
}
 
// 清除空格
String.prototype.trim = function() {
  return this.replace(/^\s*(.*?)\s+$/, "$1");
}
 
// 计算数组中的最大值
Array.prototype.max = function() {
  return Math.max.apply({}, this);
}
 
// 计算数组中的最小值
Array.prototype.min = function() {
  return Math.min.apply({}, this);
}
 
// 复制数组
Array.prototype.copy = function() {
  return [].concat(this);
};
 
// 去除数组中指定元素,只能去除一个,如果想多个,之前先用unique处理
Array.prototype.remove = function(value){
  for (var i = 0, len = this.length; i < len; i++) {
    if (this[i] == value) {
      this.splice(i, 1);
      break;
    }
  }
  return this;
}
 
// 判断数组中是否存在指定元素,返回索引值
Array.prototype.inArray = function(value) {
  var index = -1, key;
  for (key in this) {
    if (this[key] == value) {
      index = key;
      break;
    }
  }
  return index;
}
 
// 去除数组中的重复元素
Array.prototype.unique = function() {
  var key, ret = [];
  for (key in this) {
    if (ret.inArray(this[key]) < 0) {
      ret.push(this[key]);
    }
  }
  return ret;
}
 
// 检测是否已经安装flash,检测flash的版本
var flashVersion = (function() {
  var version;
  try {
    version = navigator.plugins['Shockwave Flash'];
    version = version.description;
  } catch (ex) {
    try {
      version = new ActiveXObject('ShockwaveFlash.ShockwaveFlash')
        .GetVariable('$version');
    } catch (ex2) {
      version = '0.0';
    }
  }
  version = version.match(/\d+/g);
  return parseFloat(version[0] + '.' + version[1], 10);
})();
 
// 检测是否支持transition
var supportTransition = (function() {
  var s = document.createElement('p').style,
    r = 'transition' in s ||
    'WebkitTransition' in s ||
    'MozTransition' in s ||
    'msTransition' in s ||
    'OTransition' in s;
  s = null;
  return r;
})();
 
// 判断浏览器是否支持图片的base64
var isSupportBase64 = (function() {
  var data = new Image();
  var support = true;
  data.onload = data.onerror = function() {
    if (this.width != 1 || this.height != 1) {
      support = false;
    }
    return support;
  };
  data.src = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==";
})();
 
// 首字母大写
function ucfirst(str) {
  return str.charAt(0).toUpperCase() + str.slice(1);
}
 
// 清除左空格
function ltrim(str) {
  return str.replace(/^(\s*| *)/, "");
}
 
// 清除右空格
function rtrim(str) {
  return str.replace(/(\s*| *)$/, "");
}
 
// 设置Cookie值
function setCookie(name, value, hours, path, domain) {
  var d = new Date();
  var offset = 8;
  var utc = d.getTime() + (d.getTimezoneOffset() * 60000);
  var nd = utc + (3600000 * offset);
  var expire = new Date(nd);
  expire.setTime(expire.getTime() + hours * 60 * 60 * 1000);
  var path = path || "";
  var domain = domain || "";
  document.cookie = name + "=" + escape(value) + ";path="+ path +";expires=" + expire.toGMTString() + ";domain="+ domain +";"
}
 
// 获取Cookie值
function getCookie(name) {
  var arr = document.cookie.match(new RegExp("(^| )" + name + "=([^;]*)(;|$)"));
  if (arr != null) {
    return unescape(arr[2]);
  }
  return null;
}
 
// 删除Cookie值
function removeCookie(name) {
  setCookie(name, "", -1);
}
 
// 生成范围随机数
function rand(n, m) {
  return Math.random() * (m - n) + n;
}
 
// 加入收藏夹
function addFavorite(url, title) {
  try {
    window.external.addFavorite(url, title);
  } catch(e) {
    try {
      window.sidebar.addPanel(title, url, "");
    } catch(e) {
      alert("加入收藏失败,请使用Ctrl+D进行添加");
    }
  }
}
 
// 设为首页
function setHomepage(url) {
  if (document.all) {
    document.body.style.behavior = 'url(#default#homepage)';
    document.body.setHomePage(url);
  } else if (window.sidebar) {
    if (window.netscape) {
      try {
        netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
      } catch(e) {
        alert("该操作被浏览器拒绝,如果想启用该功能,请在地址栏内输入 about:config,然后将项 signed.applets.codebase_principal_support 值该为true");
      }
    }
    var prefs = Components.classes['@mozilla.org/preferences-service;1'].getService(Components.interfaces.nsIPrefBranch);
    prefs.setCharPref('browser.startup.homepage', url);
  }
}
 
// 加载样式文件
function loadStyle(url) {
  try {
    document.createStyleSheet(url);
  } catch(e) {
    var cssLink = document.createElement('link');
    cssLink.rel = 'stylesheet';
    cssLink.type = 'text/css';
    cssLink.href = url;
    var head = document.getElementsByTagName('head')[0];
    head.appendChild(cssLink)
  }
}
 
// 清除脚本内容
function stripscript(str) {
  return str.replace(/<script.*?>.*?<\/script>/ig, '');
}
 
// 检验URL链接是否有效
function getUrlState(url) {
  var xmlhttp = new ActiveXObject("microsoft.xmlhttp");
  xmlhttp.open("GET", url, false);
  try {
    xmlhttp.send();
  } catch(e) {
     
  } finally {
    var result = xmlhttp.responseText;
    if (result) {
      if (xmlhttp.status == 200) {
        return true;
      } else {
        return false;
      }
    } else {
      return false;
    }
  }
}
 
// 格式化CSS代码
function formatCss(str){
  str = str.replace(/\s*([\{\}\:\;\,])\s*/g, "$1");
  str = str.replace(/;\s*;/g, ";"); //清除连续分号
  str = str.replace(/\,[\s\.\#\d]*{/g, "{");
  str = str.replace(/([^\s])\{([^\s])/g, "$1 {\n\t$2");
  str = str.replace(/([^\s])\}([^\n]*)/g, "$1\n}\n$2");
  str = str.replace(/([^\s]);([^\s\}])/g, "$1;\n\t$2");
  return str;
}
 
// 压缩CSS代码
function compressCss (str) {
  str = str.replace(/\/\*(.|\n)*?\*\//g, "");    //删除注释
  str = str.replace(/\s*([\{\}\:\;\,])\s*/g, "$1");
  str = str.replace(/\,[\s\.\#\d]*\{/g, "{");    //容错处理
  str = str.replace(/;\s*;/g, ";");         //清除连续分号
  str = str.match(/^\s*(\S+(\s+\S+)*)\s*$/);    //去掉首尾空白
  return (str == null) ? "" : s[1];
}
 
// getElementsByClassName
function getElementsByClassName(name, context) {
  var context = context || document;
  if (context.getElementsByClassName) {
    return context.getElementsByClassName(name);
  }
   
  var nodes = context.getElementsByTagName("*"), nodesLength = nodes.length, ret = [];
  for (var i = 0; i < nodesLength; i++) {
    var className = nodes[i].className;
    if (nodes[i].nodeType == 1 && className) {
      var classes = className.split(' ');
      for (var j = 0; j < classes.length; j++) {
        if (name == classes[j]) {
          ret.push(nodes[i]);
          break
        }
      }
    }
  }
  return ret;
}
 
// 获取页面高度
function getPageHeight() {
  var doc = document;
  var rot = doc.compatMode == "BackCompat" ? doc.body : doc.documentElement;
  return Math.max(doc.documentElement.scrollHeight, doc.body.scrollHeight, rot.clientHeight);
}
 
// 获取页面scrollLeft
function getPageScrollLeft() {
  var doc = document;
  return doc.documentElement.scrollLeft || doc.body.scrollLeft;
}
 
// 获取页面可视宽度
function getPageViewWidth() {
  var doc = document;
  var rot = doc.compatMode == "BackCompat" ? doc.body : doc.documentElement;
  return rot.clientWidth;
}
 
// 获取页面宽度
function getPageWidth(){
  var doc = document;
  var rot = doc.compatMode == "BackCompat" ? doc.body : doc.documentElement;
  return Math.max(doc.documentElement.scrollWidth, doc.body.scrollWidth, rot.clientWidth);
}
 
// 获取页面scrollTop
function getPageScrollTop(){
  var doc = document;
  return doc.documentElement.scrollTop || doc.body.scrollTop;
}
 
// 获取页面可视高度
function getPageViewHeight() {
  var doc = document;
  var rot = doc.compatMode == "BackCompat" ? doc.body : doc.documentElement;
  return rot.clientHeight;
}
 
// 获取网页被卷去的位置
function getScrollXY() {
  return document.body.scrollTop ? {
    x : document.body.scrollLeft,
    y : document.body.scrollTop
  } : {
    x : document.documentElement.scrollLeft,
    y : document.documentElement.scrollTop
  }
}
// 获取元素的样式值
function getStyle(elem, name) {
  if (elem.style[name]) {
    return elem.style[name];
  } else if (elem.currentStyle) {
    return elem.currentStyle[name];
  } else if (document.defaultView && document.defaultView.getComputedStyle) {
    var s = document.defaultView.getComputedStyle(elem, "");
    return s && s.getPropertyValue(name);
  } else {
    return null;
  }
}
 
// 获取元素相对于这个页面的X坐标
function pageX(elem) {
  return elem.offsetParent ? (elem.offsetLeft + pageX(elem.offsetParent)) : elem.offsetLeft;
}
 
// 获取元素相对于这个页面的Y坐标
function pageY(elem) {
  return elem.offsetParent ? (elem.offsetTop + pageY(elem.offsetParent)) : elem.offsetTop;
}
 
// 获取元素相对于父元素的X坐标
function parentX(elem) {
  return elem.parentNode == elem.offsetParent ? elem.offsetLeft : pageX(elem) - pageX(elem.parentNode);
}
 
// 获取元素相对于父元素的Y坐标
function parentY(elem) {
  return elem.parentNode == elem.offsetParent ? elem.offsetTop : pageY(elem)-pageY(elem.parentNode);
}
 
// 获取使用CSS定位的元素的X坐标
function posX(elem) {
  return parseInt(getStyle(elem, "left"));
}
 
// 获取使用CSS定位的元素的Y坐标
function posY(elem) {
  return parseInt(getStyle(elem, "top"));
}
 
// 设置元素X位置
function setX(elem, pos) {
  elem.style.left = pos + "px";
}
 
// 设置元素Y位置
function setY(elem, pos) {
  elem.style.top = pos + "px";
}
 
// 增加元素X坐标
function addX(elem, pos) {
  set(elem, (posX(elem) + pos));
}
 
// 增加元素Y坐标
function addY(elem, pos) {
  set(elem, (posY(elem) + pos));
}
 
// 获取元素使用CSS控制大小的高度
function getHeight(elem) {
  return parseInt(getStyle(elem, "height"));
}
 
// 获取元素使用CSS控制大小的宽度
function getWidth(elem) {
  return parseInt(getStyle(elem, "width"));
}
 
// 设置透明度
function setOpacity(elem, num) {
  if (elem.filters) {
    elem.style.filter="alpha(opacity="+ num +")";
  } else {
    elem.style.opacity = num/100;
  }
}
 
// 获取鼠标光标相对于整个页面的X位置
function getX(e) {
  e = e || window.event;
  return e.pageX || e.clientX + document.body.scrollLeft;
}
 
// 获取鼠标光标相对于整个页面的Y位置
function getY(e) {
  e = e || window.event;
  return e.pageY || e.clientY + document.body.scrollTop;
}
 
// 获取鼠标光标相对于当前元素的X位置
function getElementX(e) {
  return (e && e.layerX) || window.event.offsetX;
}
 
// 获取鼠标光标相对于当前元素的Y位置
function getElementY(e) {
  return (e && e.layerY) || window.event.offsetY;
}
 
// 获取滚动条的X位置
function scrollX() {
  var de = document.documentElement;
  return self.pageXOffset || (de && de.scrollLeft) || document.body.scrollLeft;
}
 
// 获取滚动条的Y位置
function scrollY() {
  var de = document.documentElement;
  return self.pageYOffset || (de && de.scrollTop) || document.body.scrollTop;
}
 
// 确认是否键盘有效输入值
function checkKey(iKey) {
  if (iKey == 32 || iKey == 229) {return true;} /*空格和异常*/
  if (iKey>47 && iKey < 58)   {return true;} /*数字*/
  if (iKey>64 && iKey < 91)   {return true;} /*字母*/
  if (iKey>95 && iKey < 108)  {return true;} /*数字键盘1*/
  if (iKey>108 && iKey < 112)  {return true;} /*数字键盘2*/
  if (iKey>185 && iKey < 193)  {return true;} /*符号1*/
  if (iKey>218 && iKey < 223)  {return true;} /*符号2*/
  return false;
}
 
// 获得URL中GET参数值
function getParams() {
  var queryStr = window.location.href.split("?");
  var params = [];
  if (queryStr[1]) {
    var gets = queryStr[1].split("&");
    for (var i = 0; i < gets.length; i++) {
      temp = gets.split("=");
      params[temp[0]] = temp[1];
    }
  }
  return params;
}
 
// 字符串反序
function strReverse(text) {
  return text.split('').reverse().join('');
}
 
// HTML实体
function htmlEncode(str) {
  var s = "";
  if (str.length == 0) return "";
  s = str.replace(/\&/g, "&");
  s = s.replace(/</g, "<");
  s = s.replace(/>/g, ">");
  s = s.replace(/\'/g, "'");
  s = s.replace(/\"/g, "&qout;");
  return s;
}
 
// HTML还原
function htmlDecode(str) {
  var s = "";
  if (str.length == 0) return "";
  s = str.replace(/&/g, "&");
  s = s.replace(/</g, "<");
  s = s.replace(/>/g, ">");
  s = s.replace(/'/g, "\'");
  s = s.replace(/&qout;/g, "\"");
  return s;
}
 
// 克隆
function clone(obj) {
  var ret;
  switch (typeof obj) {
    case 'undefined':
      break;
    case 'string':
      ret = obj + '';
      break;
    case 'number':
      ret = obj - 0;
      break;
    case 'boolean':
      ret = obj;
      break;
    case 'object':
      if (obj === null) {
        ret = null;
      } else {
        if (obj instanceof Array) {
          ret = [];
          for (var i = 0, len = obj.length; i < len; i++) {
            ret.push(clone(obj[i]));
          }
        } else {
          ret = {};
          for (var k in obj) {
            ret[k] = clone(obj[k]);
          }
        }
      }
      break;
    default:
      ret = obj;
      break;
  }
  return ret;
}
 
// 检测变量是否为email格式
function isEmail(mail) {
  if (/^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(mail)) {
    return true;
  }
  return false;
}
 
// 验证身份证号码
function isIdenCode(code){
  var city={11:"北京",12:"天津",13:"河北",14:"山西",15:"内蒙古",21:"辽宁",22:"吉林",23:"黑龙江 ",31:"上海",32:"江苏",33:"浙江",34:"安徽",35:"福建",36:"江西",37:"山东",41:"河南",42:"湖北 ",43:"湖南",44:"广东",45:"广西",46:"海南",50:"重庆",51:"四川",52:"贵州",53:"云南",54:"西藏 ",61:"陕西",62:"甘肃",63:"青海",64:"宁夏",65:"新疆",71:"台湾",81:"香港",82:"澳门",91:"国外"};
  var tip = "";
  var pass = true;
  if (!code || !/^\d{6}(18|19|20)?\d{2}(0[1-9]|1[012])(0[1-9]|[12]\d|3[01])\d{3}(\d|X)$/i.test(code)) {
    tip = "身份证号格式错误";
    pass = false;
  } else if (!city[code.substr(0,2)]) {
    tip = "地址编码错误";
    pass = false;
  } else {
    //18位身份证需要验证最后一位校验位
    if(code.length == 18){
      code = code.split('');
      //∑(ai×Wi)(mod 11)
      //加权因子
      var factor = [ 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 ];
      //校验位
      var parity = [ 1, 0, 'X', 9, 8, 7, 6, 5, 4, 3, 2 ];
      var sum = 0;
      var ai = 0;
      var wi = 0;
      for (var i = 0; i < 17; i++) {
        ai = code[i];
        wi = factor[i];
        sum += ai * wi;
      }
       
      var last = parity[sum % 11];
      if (parity[sum % 11] != code[17]) {
        tip = "校验位错误";
        pass = false;
      }
    }
  }
  return pass;
}
 
// 检测变量是否为小数
function isDecimal(dec){
  if (dec.match(/^-?\d+(\.\d+)?$/g) == null) {
    return false;
  }
  return true;
}
 
// 检测变量是否为整型
function isInteger(num){
  if (num.match(/^[-+]?\d*$/) == null) {
    return false;
  }
  return true;
}
 
// 检测变量是否为时间格式
function checkTime(str) {
  var time = str.match(/^(\d{1,2})(:)?(\d{1,2})\2(\d{1,2})$/);
  if (time == null) {
    return false;
  }
   
  if (time[1] > 24 || time[3] > 60 || time[4] > 60) {
    return false
  }
  return true;
}
 
// 检测变量类型是否为日期格式
function checkDate(str) {
  var date = str.match(/^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2})$/);
  if (date == null) {
    return false;
  }
   
  var d = new Date(r[1], r[3]-1, r[4]);
  return (d.getFullYear() == r[1] && (d.getMonth()+1) == r[3] && d.getDate() == r[4]);
}
 
// 检测变量是否为长日期格式
function checkDateTime(str) {
  var reg = /^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})$/;
  var dt = str.match(reg);
  if (dt == null) {
    return false;
  }
   
  var d = new Date(dt[1], dt[3]-1, dt[4], dt[5], dt[6], dt[7]);
  return (d.getFullYear() == dt[1] && (d.getMonth()+1) == dt[3] && d.getDate() == dt[4] && d.getHours() == dt[5] && d.getMinutes() == dt[6] && d.getSeconds() == dt[7]);
}
 
// 检测变量是否为未定义
function isUndefined(val) {
  return typeof val === 'undefined';
}
 
// 检测变量是否为定义
function isDefined(val) {
  return typeof val !== 'undefined';
}
 
// 检测变量类型是否为对象
function isObject(val) {
 return val !== null && typeof val === 'object';
}
 
// 检测变量类型是否为空对象
function isBlankObject(val) {
 return val !== null && typeof val === 'object' && !Object.getPrototypeOf(val);
}
 
// 检测变量类型是否为字符串
function isString(val) {
  return typeof val === 'string';
}
 
// 检测变量类型是否为数字
function isNumber(val) {
  return typeof val === 'number';
}
 
// 检测变量类型是否为日期
function isDate(val) {
  return toString.call(val) === '[object Date]';
}
 
// 检测变量类型是否为函数
function isFunction(val) {
  return typeof val === 'function';
}
 
// 检测变量类型是否为正则表达式
function isRegExp(val) {
  return toString.call(val) === '[object RegExp]';
}
 
// 检测变量是否window窗体对象
function isWindow(obj) {
  return obj && obj.window === obj;
}
 
// 检测变量类型是否为布尔
function isBoolean(val) {
  return typeof val === 'boolean';
}
 
// 检测变量类型是否为文件对象
function isFile(obj) {
  return toString.call(obj) === '[object File]';
}
 
// 检测变量类型是否为表单对象
function isFormData(obj) {
  return toString.call(obj) === '[object FormData]';
}
 
// 检测变量类型是否为二进制对象
function isBlob(obj) {
  return toString.call(obj) === '[object Blob]';
}
 
// 转全角字符
function toDBC(str) {
  var result = "";
  var len = str.length;
  for (var i = 0; i < len; i++) {
    var code = str.charCodeAt(i);
    //全角与半角相差(除空格外):65248(十进制)
    code = (code >= 0x0021 && code <= 0x007E) ? (code + 65248) : code;
    //处理空格
    code = (code == 0x0020) ? 0x03000 : code;
    result += String.fromCharCode(code);
  }
  return result;
}
 
// 转半角字符
function toSBC(str) {
  var result = "";
  var len = str.length;
  for (var i = 0; i < len; i++) {
    var code = str.charCodeAt(i);
    //全角与半角相差(除空格外):65248(十进制)
    code = (code >= 0xFF01 && code <= 0xFF5E) ? (code - 65248) : code;
    //处理空格
    code = (code == 0x03000) ? 0x0020 : code;
    result += String.fromCharCode(code);
  }
  return result;
}
 
// 全角半角转换
// angle: 0全到半,1半到全,其他不转化
function chgAngle(str, angle) {
  if (typeof str != "string" || str.length <= 0 || !(angle === 0 || angle == 1)) {
    return str;
  }
   
  var i, len, ret = [], code;
  if (angle) {
    /*半->全*/
    for (i = 0, len = str.length; i < len; i++) {
      code = str.charCodeAt(i);
      if (code == 32) {
        code = 12288;
      } else if (code < 127) {
        code += 65248;
      }
      ret.push(String.fromCharCode(code));
    }
  } else {
    /*全->半*/
    for (i = 0, len = str.length; i < len; i++) {
      code = str.charCodeAt(i);
      if (code == 12288) {
        code = 32;
      } else if (code > 65280 && code < 65375) {
        code -= 65248;
      }
      ret.push(String.fromCharCode(code));
    }
  }
  return ret.join("");
}
 
// 数据的本地化存储
function makeWebStorage() {
  //IE用userdata实现,w3c浏览器本身支持
  if (("localStorage" in window)) {
    var store = {
      set  : function(key, value) {localStorage.setItem(key, value)},
      get  : function(key)    {return localStorage.getItem(key)},
      remove : function(key)    {return localStorage.removeItem(key)}
    }
  } else {
    var store = {
      userData : null,
      name   : location.hostname,
      init   : function () {
        if (!store.userData) {
          try {
            store.userData = document.createElement('INPUT');
            store.userData.type = "hidden";
            store.userData.style.display = "none";
            store.userData.addBehavior("#default#userData");
            document.body.appendChild(store.userData);
            var expires = new Date();
            expires.setDate(expires.getDate() + 365);
            store.userData.expires = expires.toUTCString();
          } catch (e) {
            return false;
          }
        }
        return true;
      },
      setItem : function(key, value) {
        if (store.init()) {
          store.userData.load(store.name);
          store.userData.setAttribute(key, value);
          store.userData.save(store.name);
        }
      },
      getItem : function(key) {
        if (store.init()) {
          store.userData.load(store.name);
          return store.userData.getAttribute(key);
        }
      },
      remove : function(key) {
        if (store.init()) {
          store.userData.load(store.name);
          store.userData.removeAttribute(key);
          store.userData.save(store.name);
        }
      }
    };
  }
  window.webStorage = store;
}
 
function makeSessionStorage() {
  if (("sessionStorage" in window)) {
    var store = {
      set  : function(key, value) {window.sessionStorage.setItem(key, value)},
      get  : function(key)    {return window.sessionStorage.getItem(key)},
      remove : function(key)    {return window.sessionStorage.removeItem(key)}
    }
  } else {
    var store = {
      set  : function(key, value) {},
      get  : function(key)    {},
      remove : function(key)    {}
    }
  }
  window.sessStorage = store;
}

以上就是小编为大家带来的常用Javascript函数与原型功能收藏(必看篇)全部内容了,希望大家多多支持三水点靠木~

Javascript 相关文章推荐
将input file的选择的文件清空的两种解决方案
Oct 21 Javascript
详解Node.js如何开发命令行工具
Aug 14 Javascript
JQuery实现动态操作表格
Jan 11 Javascript
jQuery实现的简单排序功能示例【冒泡排序】
Jan 13 Javascript
BootStrap框架中的data-[ ]自定义属性理解(推荐)
Feb 14 Javascript
Bootstrap 模态对话框只加载一次 remote 数据的完美解决办法
Jul 09 Javascript
Express使用html模板的详细代码
Sep 18 Javascript
vue 文件目录结构详解
Nov 24 Javascript
详解微信小程序开发聊天室—实时聊天,支持图片预览
May 20 Javascript
深入学习Vue nextTick的用法及原理
Oct 08 Javascript
实现vuex与组件data之间的数据同步更新方式
Nov 12 Javascript
解决vue路由name同名,路由重复的问题
Aug 05 Javascript
javascript汉字拼音互转的简单实例
Oct 09 #Javascript
Javascript农历与公历相互转换的简单实例
Oct 09 #Javascript
Angularjs 创建可复用组件实例代码
Oct 09 #Javascript
Boostrap实现的登录界面实例代码
Oct 09 #Javascript
深入理解bootstrap框架之第二章整体架构
Oct 09 #Javascript
javascript 判断是否是微信浏览器的方法
Oct 09 #Javascript
深入理解bootstrap框架之入门准备
Oct 09 #Javascript
You might like
php 判断网页是否是utf8编码的方法
2014/06/06 PHP
浅谈json_encode用法
2015/03/05 PHP
Laravel 5.3 学习笔记之 错误&amp;日志
2016/08/28 PHP
浅析PHP 中move_uploaded_file 上传中文文件名失败
2019/04/17 PHP
php 多继承的几种常见实现方法示例
2019/11/18 PHP
JavaScript 判断判断某个对象是Object还是一个Array
2010/01/28 Javascript
将string解析为json的几种方式小结
2010/11/11 Javascript
jsTree 基于JQuery的排序节点 Bug
2011/07/26 Javascript
Extjs4.0 ComboBox如何实现三级联动
2016/05/11 Javascript
JavaScript必知必会(六) delete in instanceof
2016/06/08 Javascript
JQuery form表单提交前验证单选框是否选中、删除记录时验证经验总结(整理)
2017/06/09 jQuery
详解vue中computed 和 watch的异同
2017/06/30 Javascript
基于JS实现移动端左滑删除功能
2017/07/28 Javascript
Vue中this.$router.push参数获取方法
2018/02/27 Javascript
使用Vue 实现滑动验证码功能
2019/06/27 Javascript
微信小程序实现录音功能
2019/11/22 Javascript
js实现小球在页面规定的区域运动
2020/06/16 Javascript
用Javascript实现发送短信验证码间隔功能
2021/02/08 Javascript
JS获取一个字符串中指定字符串第n次出现的位置
2021/02/10 Javascript
[43:18]NB vs Infamous 2019国际邀请赛淘汰赛 败者组 BO3 第一场 8.22
2019/09/05 DOTA
python使用tensorflow保存、加载和使用模型的方法
2018/01/31 Python
Opencv-Python图像透视变换cv2.warpPerspective的示例
2019/04/11 Python
高考考python编程是真的吗
2020/07/20 Python
python时间time模块处理大全
2020/10/25 Python
如何用python写个模板引擎
2021/01/14 Python
String s = new String(“xyz”);创建了几个String Object?
2015/08/05 面试题
怎样有效的进行自我评价
2013/10/06 职场文书
护士个人简历自荐信
2013/10/18 职场文书
简历的个人自我评价范文
2014/01/03 职场文书
计算机应用专业毕业生求职信
2014/06/03 职场文书
亲子阅读的活动方案
2014/08/15 职场文书
交通事故被告答辩状
2015/05/22 职场文书
人代会简报
2015/07/21 职场文书
最美劳动诗,致敬所有的劳动者!
2019/07/12 职场文书
vue项目两种方式实现竖向表格的思路分析
2021/04/28 Vue.js
java代码实现空间切割
2022/01/18 Java/Android