javascript 经常使用函数(一)

部分也是本身经常使用的，可是部分还须要实际验证 一、Array类型函数:
array.concat(item…) 函数功能：关联数组，实现数组相加功能，但并不影响原先数组，concat返回新数组。 JS经常使用的标准函数 array.join(separator) 函数功能：将array中的每一个元素用separator为分隔符构形成字符串，默认的separator是逗号，固然你能够本身指定separator 事实上join方法最经常使用的地方在字符串相加，用过js的人都知道js的字符串相加是特别慢且性能特别差的，把大量片断字符串放在一个数组中并用join方法链接比用+链接要快得多。 JS经常使用的标准函数 array.pop() pop和push方法使数组array像堆栈同样工做。 函数功能：pop方法移除array中的最后一个元素并返回该元素。 若是array是空的，则返回undefined; JS经常使用的标准函数 array.push(item…) 函数功能：push方法将一个或多个item参数附加到array尾部。可是它不像concat方法那样，push方法不会修改item参数，若是参数item是一个数组，它会将参数数组做为单个元素整个添加到数组中，它返回array的新长度 JS经常使用的标准函数 array.reverse() 函数功能：反转array中元素的顺序，返回当前array array.shift() 函数功能：移除array中的第一个元素并返回该元素，若是array是空的，它会返回undefined。 shift比pop要慢不少 array.slice(start,end) 函数功能：对array中的一段作浅复制。end参数是可选的，默认值为数组的长度array.length。 若是两个参数中任何一个是负数，array.length将和它们相加来试图将它们成为非负数。 若是start大于等于array.length，获得的结果将是一个新的空数组 JS经常使用的标准函数 array.sort(compareFn) 函数功能：对array中的内容进行排序。 var n = [4, 8, 15, 16, 23, 43]; n.sort(function (a, b) { return a - b; }); console.log(n); //[4, 8, 15, 16, 23, 43]
 

var m = ['aa', 'bb', 'a', 4, 8, 15, 16, 23, 43]; m.sort(function (a, b) { if (a === b) { return 0; } if (typeof a === typeof b) { return a < b ? -1 : 1; } return typeof a < typeof b ? -1 : 1; }); console.log(m); //[4, 8, 15, 16, 23, 43, "a", "aa", "bb"]
var compare = function(name) { return function(o, p) { var a, b; if (typeof o === 'object' && typeof p === 'object' && o && p) { a = o[name]; b = p[name]; if (a === b) { return 0; } if (typeof a === typeof b) { return a < b ? -1 : 1; } return typeof a < typeof b ? -1 : 1; } else { throw { name : "Error", message : 'Expected an object when sorting by ' + name }; } }; }; var s = [ { first : 'Joe', last : 'Felix' }, { first : 'Moe', last : 'Besser' }, { first : 'Joe', last : 'Howard' }, { first : 'Shemp', last : 'DeRita' }, { first : 'Larry', last : 'Howard' }, { first : 'Curly', last : 'Fine' }, { first : 'Shirly', last : 'Angela' } ]; s.sort(compare('first')); /* * s = [ { first: 'Curly', last: 'Fine' }, { first: 'Joe', last: 'Felix' }, { * first: 'Joe', last: 'Howard' }, { first: 'Larry', last: 'Howard' }, { first: * 'Moe', last: 'Besser' }, { first: 'Shemp', last: 'DeRita' }, { first: * 'Shirly', last: 'Angela' } ]; */
array.splice(start,deleteCount,item…) 函数功能：从array中移除1个或多个元素，并用新的item替换它们。返回一个包含移除元素的数组。 array.unshift(item…) 函数功能：将item插入到array的开始部位。返回array的新长度值。 2、Function类型函数 function.apply(thisArg,argArray) Function.prototype.bind = function(that) { // 返回一个函数，调用这个函数就像它是那个对象的方法同样
    var method = this, slice = Array.prototype.slice, args = slice.apply( arguments, [ 1 ]); return function() { return method.apply(that, args.concat(slice.apply(arguments, [ 0 ]))); }; }; var x = function() { return this.value; }.bind({ value : 666 }); console.log(x());// 666
3、Number类型函数 number.toExponential(fractionDigits) 函数功能：把number转换成一个指数形式的字符串。可选参数fractionDigits控制其小数点后的数字位数，它的值必须在0到20之间。 JS经常使用的标准函数 number.toFixed(fractionDigits) 函数功能：把number转换成一个十进制形式的字符串。可选参数fractionDigits控制其小数点后的数字位数，它的值必须在0到20之间。默认为0。 JS经常使用的标准函数 number.toPrecision(precision) 函数功能：把number转换成一个十进制形式的字符串。可选参数fractionDigits控制其小数点后的数字位数，它的值必须在1到21之间。 JS经常使用的标准函数 number.toString(radix) 函数功能：把number转换成一个字符串。可靠参数radix控制基数，它的值必须在2和36之间，默认为10 JS经常使用的标准函数 4、Object类型函数 object.hasOwnProperty(name) 函数功能：若是object包含名为name的属性，hasOwnProperty方法将返回true，原型链中的同名属性是不会被检查的。 for (name in obj) { if (obj.hasOwnProperty(name)) { console.log(obj[name]); } } 5、Regexp类型函数 regexp.exec(string) 函数功能：成功匹配regexp和字符串，返回一个数组。 数组中下标为0的元素包含正则表达式regexp匹配的子字符串 下标为1的元素是分组1捕获的文本，下标为2的元素是分组2捕获的文本，依此类推。若是匹配失败，就返回null。 若是regexp带有一个g(全局)标志，查找不是从这个字符串起始位置开始，而是从regexp.lastIndex（它的初始值为0）位置开始，若是匹配成功，那么regexp.lastIndex将被设置为该匹配后第一个字符的位置。 不成功的匹配会重置regexp.lastIndex为0 regexp.test(string) 函数功能：若是regexp匹配string，返回true 不然返回false 6、String类型函数 string.charAt(pos) 函数功能：返回在string中pos位置处的字符。 若是pos小于0或者大于string.length，将返回空字符串 string.charCodeAt(pos) 函数功能：返回在string中pos位置处的字符的字符编码。 string.concat(string…) 函数功能：链接字符串（不过不多被使用，由于用运算符+也能实现这个功能） string.indexOf(searchString,position) 函数功能：在string内查找另外一个字符串searchString，若是找到则返回第一个匹配字符的位置，不然返回-1。 可选参数position可设置从string的某个位置开始查找。 string.lastIndexOf(searchString,position) 函数功能：跟indexOf方法相似，区别是从字符串的末尾开始查找而不是从开头。 string.localCompare(that) 函数功能：比较两个字符串 string.match(regexp) 函数功能：匹配一个字符串和一个正则表达式。 若是没有g标识，string.match(regexp)和regexp.exec(string)结果相同。 若是有g标识，返回一个包含除捕获分组之处的全部匹配的数组。 string.replace(searchValue,replaceValue) 函数功能：对string进行查找和替换操做，并返回一个新的字符串。 var oldAreaCode = /\((\d{3})\)/g; var p = '(555)(666)-1212'.replace(oldAreaCode, '$1-'); console.log(p);//555-666--1212
string.search(regexp) 函数功能：和indexOf方法相似，只是它接受一个正则表达式做为参数而不是一个字符串，若是找到匹配返回第一个匹配的首字符位置，若是没有找到匹配，则返回-1。 string.slice(start,end) 函数功能：复制string的一部分来构造一个新的字符串。 若是start参数是负数，它将与string.length相加。end参数是可选的，而且它的默认值是string.length。若是end参数是负数，它将与string.length相加。end参数是一个比最末一个字符的位置值还大的数。 string.split(separator,limit) 函数功能：把string分割成片断来建立一个字符串数组。可选参数limit能够限制被分割的片断数量。 var digits = '0123456789'; var a = digits.split('', 5); //["0", "1", "2", "3", "4"]
string.substring(start,end) 函数功能：substring的用法和slice方法同样，只是它不能处理负数参数，通常性的用slice替代它。 string.toLocalLowerCase() 函数功能：用本地化的规则把string中的全部字母转换为小写格式。 string.toLocalUpperCase() 函数功能：用本地化的规则把string中的全部字母转换为大写格式。 string.toLowerCase() 函数功能： 把string中的全部字母都转化为小写格式。 string.toUpperCase() 函数功能： 把string中的全部字母都转化为大格式。 string.fromCharCode(char…) 函数功能：从一串数字中返回一个字符串。 var a = String.fromCharCode(67, 97, 116); console.log(a);//Cat;

/** *javascript按字节进行截取 * * param str 要截取的字符串 * param L 要截取的字节长度，注意是字节不是字符，一个汉字两个字节 * return 截取后的字符串 */
function cutStr(str,L){ var result = '',
        strlen = str.length, // 字符串长度
        chrlen = str.replace(/[^\x00-\xff]/g,'**').length; // 字节长度

    if(chrlen<=L){return str;} for(var i=0,j=0;i<strlen;i++){ var chr = str.charAt(i); if(/[\x00-\xff]/.test(chr)){ j++; // ascii码为0-255，一个字符就是一个字节的长度
        }else{ j+=2; // ascii码为0-255之外，一个字符就是两个字节的长度
 } if(j<=L /* || j==L+1 */){ // 当加上当前字符之后，若是总字节长度小于等于L，则将当前字符真实的+在result后
            result += chr; }else{ // 反之则说明result已是不拆分字符的状况下最接近L的值了，直接返回
            return result; } } } // 用例
alert(cutStr("abc中英文混合",10)); //获取firstchild
function firstChild(elem) { var node = elem.firstChild ? elem.firstChild : null; while(node && node.nodeType != 1) { node = node.nextSibling; } return node; } //获取下一个同辈元素（ie下回忽略空白文节点）
function next(elem) { var node = elem.nextSibling ? elem.nextSibling : null; while(node && node.nodeType != 1 ) { node = node.nextSibling; } return node; } //获取上一个同辈元素（ie下回忽略空白文节点）
function prev(elem) { var node = elem.previousSibling ? elem.previousSibling : null; while(node && node.nodeType != 1 ) { node = node.previousSibling; } return node; } /** * 获取指定类名的父元素 * @param elem * @param className * @returns */
function parents(elem, className) { //检测自身是否知足条件
    if(elem.className.indexOf(className) != -1) { return elem; } var parent = null; while((parent = elem.parentNode) &&  parent.nodeType == 1 && !!className) { if(parent.className.indexOf(className) != -1) { break; } elem = parent; } return parent; } //输入html代码，输出转换后的代码
function htmlEncode( html ) { //使用div来模拟
    var div = document.createElement("div"); if(typeof div.innerText != 'undefined') { div.innerText  = html; }else{ div.textContent = html; } var html_encode = div.innerHTML; div = null; return html_encode; } function htmlDecode( html ) { //使用div来模拟
    var text, div = document.createElement("div"); div.innerHTML = html; if(typeof div.innerText != 'undefined') { text = div.innerText; }else{ text = div.textContent; } return text; } 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, """); return s; } 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(/"/g, "\""); return s; } function htmlEncode(html) { var div = document.createElement("div"); var text = document.createTextNode(""); div.appendChild(text); text.nodeValue=html; return div.innerHTML; } function htmlDecode(str) { var div = document.createElement("div"); div.innerHTML = str; return div.firstChild.nodeValue; } /** ****/ //获取scrolltop function getScrollTop() { var scrollTop = document.documentElement.scrollTop || document.body.scrollTop; return scrollTop; } //设置scrolltop function setScrollTop(top) { document.documentElement.scrollTop = document.body.scrollTop = top; } /** 获取浏览器可视区域的尺寸 */ function getBrowserSize() { //在标准模式下用 documentElement， 在怪癖模式下用 body return { width:document.documentElement.clientWidth ? document.documentElement.clientWidth : document.body.clientWidth, height:document.documentElement.clientHeight ? document.documentElement.clientHeight : document.body.clientHeight, } } /** 获取页面大小 */ function getPageSize() { //ie下优先取 body return { width:document.body.scrollWidth ? document.body.scrollWidth : document.documentElement.scrollWidth, height: document.body.scrollHeight ? document.body.scrollHeight : document.documentElement.scrollHeight } } /** 获取元素到页面顶端的距离(出自jquery源码) */ function getCoords(el) { if (typeof el == 'string') { el = Fid(el); } var box = el.getBoundingClientRect(), doc = el.ownerDocument, body = doc.body, html = doc.documentElement, clientTop = html.clientTop || body.clientTop || 0, clientLeft = html.clientLeft || body.clientLeft || 0, top = box.top + (self.pageYOffset || html.scrollTop || body.scrollTop) - clientTop, left = box.left + (self.pageXOffset || html.scrollLeft || body.scrollLeft) - clientLeft return { 'top' : top, 'left' : left }; }; /* 获取元素到页面顶端的 document.documentElement.clientLeft ie6/7 下2px的bodrer */ function getAbsPoint(e) { if (typeof e == 'string') { e = Fid(e); } var x = e.offsetLeft; var y = e.offsetTop; var de = document.documentElement; while (e = e.offsetParent) { //在IE下offset对象是对当前元素到上一级元素的距离,FF则是正常的 x += e.offsetLeft; y += e.offsetTop; //须要加上元素自身的border, offsetTop 自己就包含margin if (e && e != de && !Browser.isOpera) { x += e.clientLeft; y += e.clientTop; //ie6下设置元素宽度后才能到获取他的边框大小,若是不设置则下级取上级的时候会把上级的边框算进去(整体计算仍是没有错) } } return { "left" : x, "top" : y }; } //浏览器类型检测 var FBrowser=(function(){ var ua = navigator.userAgent; var isOpera = Object.prototype.toString.call(window.opera) == '[object Opera]'; return { isIE: !!window.attachEvent && window.ActiveXObject && !isOpera, isOpera: isOpera, isSafari: ua.indexOf('AppleWebKit/') > -1, isFirefox: ua.indexOf('Gecko') > -1 && ua.indexOf('KHTML') === -1, MobileSafari: /Apple.*Mobile.*Safari/.test(ua), isChrome: !!window.chrome, }; })(); FBrowser.isIE6=FBrowser.isIE&&!window.XMLHttpRequest; FBrowser.isIE7=FBrowser.isIE&&!!window.XMLHttpRequest; //document.documentMode ie8+以上显示浏览器版本 var IE = (function(){ var ie = !!window.ActiveXObject; e = { isIE: !!window.ActiveXObject, isIE6: ie && !window.XMLHttpRequest, isIE7: ie && window.XMLHttpRequest && document.documentMode == 7, isIE8: ie && window.XMLHttpRequest && document.documentMode == 8, isIE9: ie && window.XMLHttpRequest && document.documentMode == 9 } return e; })(); /** 获取元素样式 处理透明度、元素浮动样式的获取 ，结果带有单位 */ function getStyle(elem, name) { var nameValue = null; if (document.defaultView) { var style = document.defaultView.getComputedStyle(elem, null); nameValue = name in style ? style[name] : style.getPropertyValue(name); } else { var style = elem.style, curStyle = elem.currentStyle; //透明度 from youa if (name == "opacity") { if (/alpha\(opacity=(.*)\)/i.test(curStyle.filter)) { var opacity = parseFloat(RegExp.$1); return opacity ? opacity / 100 : 0; } return 1; } if (name == "float") { name = "styleFloat"; } var ret = curStyle[name] || curStyle[camelize(name)]; //单位转换 from jqury if (!/^-?\d+(?:px)?$/i.test(ret) && /^\-?\d/.test(ret)) { var left = style.left, rtStyle = elem.runtimeStyle, rsLeft = rtStyle.left; rtStyle.left = curStyle.left; style.left = ret || 0; ret = style.pixelLeft + "px"; style.left = left; rtStyle.left = rsLeft; } nameValue = ret; } return nameValue === 'auto' ? '0px' : nameValue; } function uncamelize(s) {//将CSS属性名由驼峰式转为普通式 return s.replace(/[A-Z]/g,function (c) { return '-'+c.charAt(0).toLowerCase(); }); } function camelize(s) {//将CSS属性名转换成驼峰式 return s.replace(/-[a-z]/gi,function (c) { return c.charAt(1).toUpperCase(); }); }