方法集的特性与最佳实践,javascript基础知识【10bet手机官网】
分类:微服架构

JavaScript底子知识之方法汇计算,javascript基本功知识

数组的诀要:

array.concat 叁个数组去老是另三个数组,重返一个合成数组。var arrC=arrA.concat(arrB,'asd','sad',true,1.5卡塔尔国;
array.join 将数组用钦赐符号连接为二个字符串,并重临那个字符串。比用+快相当多。var strA=arrA.join(","State of Qatar;//默感到逗号
array.pop 移除数组最终八个成分,并回到这么些成分.var A=arrA.pop(卡塔尔国;
array.push 将叁个或三个参数附加到数组的尾巴部分,并赶回一个新长度值。arrA.push("asd"卡塔尔(قطر‎;
array.shift 移除数组的首先个因素,并再次回到这几个因素。它比pop慢得多,原因作者想应该正是那仅仅只是三个伪数组,删除第叁个要将兼具的因素往前推生龙活虎格。var A=arrA.shift(卡塔尔(قطر‎;
array.unshift 讲三个或多少个参数附加到数组的尾部。arrA.unshift("asd"卡塔尔国;
array.reverse 反转数组里成分的逐大器晚成。var arrB=arrA.reverse(卡塔尔;
array.slice 对数组做生机勃勃段浅复制。然后赋值多个下标之间的数组,再次回到叁个新的数组。var arrB=arrA.slice(0,3卡塔尔;//将第0,1,2个因素抽取,前面的3也得以不填
array.sort 对数组中的内容展开排序。arrA.sort(State of Qatar;//暗许会吧成分都转载为字符串并开展比较。当然也得以将三个相比较函数作为参数字传送进去
arrA.sort(function(a,b){
return a-b;
});
array.splice 从数组中移除一个只怕七个因素,并用新的要素代替他们。var arrB=arrA.splice(0,3,'asd','ads'卡塔尔国;//移除从下标0之前的3个成分,并用前边七个因素进行改换

函数的格局:

function.apply 调用函数,传递一个被绑定到this之上的目的,和贰个可选的数组作为参数数组。

数字的章程:

number.toExponential 将那几个数字调换为贰个指数方式的字符串。Math.PI.toExponential(2卡塔尔(قطر‎;//3.14e+0
number.toFixed 将以此数字转变为二个十进制数格局的字符串。Math.PI.toFixed(2卡塔尔国;//3.14,保留两位小数
number.toPrecision 将这一个数字转变为二个十进制数情势的字符串。Math.PI.toPrecision(2卡塔尔(قطر‎;//3.1,保留三个有效数字
number.toString 将以此数字转换为叁个字符串。Math.PI.toString(2卡塔尔(قطر‎;//这里的2代表进制,并不是精度

对象的章程:

object.hasOwnProperty 判别指标是还是不是带有三个以内定字符串命名的质量

正则表明式的方法:

regexp.exec
要是成功相称,会回到叁个数组。下标0会回到相称的原字符串,1~后边重返的是分组1~捕获的文件。
假诺含有g标志(全局标志),那么查找不是从字符串开首之处上马,而是从regexp.lastIndex起初。借使相称成功,那么会安装regexp.lastIndex为相称成功的字符串第多个字符的任务,不然重新復苏设置为0。
regexp.test 如若成功相配,再次来到true,不然false

字符串的法子:

string.charAt 重回在字符串中钦赐地点处的字符
string.charCodeAt 重回在字符串中内定地点处的字符的ASCII码值
string.concat 将其余字符串连接到协作,再次来到二个新的合成字符串。实际上用+更方便,且越来越直观。
string.indexOf 在这里字符串中检索钦定的其余二个字符串,假如找到了,就重临第三个找到的字符串的职责,不然重临-1."asdasd".indexOf("sd",2卡塔尔(قطر‎;//值为4,2象征从第四个字符初阶查找
string.lastIndexOf 那一个与地方的相似,只可是是从字符串尾巴部分开头查找
string.localeCompare 相比五个字符串。strA.localeCompare(strB卡塔尔国;//结果也是回来正数,负数,零,你懂的
string.replace 对两个字符串实行搜寻并替换的操作,并回到新的字符串(以下名字标红的法子,都以足以采用正则表达式的卡塔尔(قطر‎

平常方法:

'asdasd'.replace('as','d'State of Qatar;//结果为ddasd,replace只会更替第三遍的产出岗位。

正则表明式方法:

加g标志相配数14次,不加相称贰回

var regExp=/ee(asdd{0,3}卡塔尔/g;//加g标志相称多次,不加相称贰遍
var p='eeasd1323'.replace(regExp,'$1end');//结果为eeasd1323end
//'$1end'的岗位也得以放一个函数,每便相称到会运营这些函数,然后用函数的重临值替换,这里就不举栗子了
'$1end'以此东西的阐述是那般的:
$$:表示$那些符号
$&: 表示$&整个相配到的文件
$number:表示分组捕获到的公文,比方上边的$1就是捕获分组1捕捉到的文件
$`:相配在此以前的公文
$':相称之后的文书
string.match 让三个字符串和二个正则表达式相配。它依照g标志来调控怎样实行相称。
万风华正茂未有g标志,相配结果与regexp.exec效果一样
倘若有,那么会转移二个带有全体相配(除捕获分组之外这几个括号里的搞不懂什么意思,明明就协作了富有的)的数组
string.search 与indexof相通,只是选择贰个正则表明式相配而已。此方式忽略g标志。
string.split 将字符串分割来创立一个字符串数组。此方式忽略g标志。
貌似的耍法
var digits='0123456789';
var arr=digits.split('',5State of Qatar;//5表示收获的数组顶多八个元素,多余的消释
//结果为['0','1','2','3','4']
正则表明式的耍法
var text='troy ,123 , good ';
var d=text.split(/s*,s*/State of Qatar;//前边讲过s表示unicode各类空字符,然后据此相称的相间符正是带有空字符的逗号,那样就活动去掉空字符了,好强大
//不过有特例哦,来自分组捕获的文本会被含有在细分后的字符,所以自身个人提出那就别用分组捕获好了,在那处没要求
string.slice 复制字符串的意气风发有的来布局贰个新的字符串
string.substring 与slice效果雷同,只是无法采用负数下标。未有任何理由使用substring实际不是slice(作者说的)。其实是一些,比方字面意思上自身就精晓怎么意思了。
string.toLowerCase 再次来到三个总体小写化的新字符串。
string.toLocaleLowerCase 同上,Turkey语专项使用,所以您就当看不见好了
string.toUpperCase 重临三个全体大写化的新字符串。
string.toLocaleUpperCase 同上,Türkiye Cumhuriyeti语专项使用,所以你就当看不见好了
String.fromCharCode 看好哦,string是大写啊。所以不是在字符串前边调用,而是用String调用。依照豆蔻梢头串数字编码再次来到三个字符串。(笔者信赖您大致用不到的)

10bet手机官网 1

你恐怕感兴趣的篇章:

  • js幼功知识(公有方法、私有方法、特权方法)
  • JavaScript底子知识及常用方法总计

数组的章程: array.concat 二个数组去老是另一个数组,重回八个合成数组。var arrC=arrA.co...

JavaScript 包涵了风度翩翩套迷你的、可用在专门的学问项目上的法子集。上边大家对那一个艺术风流倜傥生机勃勃举办解析。

1 Array

1.1 array.concat(item...)

concat 方法会发生八个新数组,它是数组的浅复制,并把叁个或三个 item 附加在其后。假设 item 是八个数组,那么它的每一个成分都会被增加:

var a = ['a', 'b', 'c'];
var b = ['x', 'y', 'z'];
var c = a.concat(b, true);
console.log(c);//[ "a", "b", "c", "x", "y", "z", true ]

1.2 array.join(separator)

join 方法会把三个 array 布局成八个字符串。它先把 array 中的每个因素都社团成五个字符串,然后再用 separator 分隔符把它们连接起来。暗许的 separator 是逗号 ','。倘若想要达成无间距连接,能够把 separator 设置为空字符串。

var a = ['a', 'b', 'c'];
a.push('d');
console.log(a.join(''));//abcd

也可以接收 + 运算符连接这一个字符串。最近主流的浏览器(蕴含 IE8 之后的版本)都对 + 运算符做了特意的优化,所以它的习性已经引人瞩目大于 Array.join(卡塔尔 咯,在大部情景下,假若急需一而再一而再字符串,提议首荐 + 运算符哦O(∩_∩)O~

1.3 array.pop()

pop 与 push 方法能够使得数组像宾馆一样工作。pop 方法会移除 array 中的最后一个成分并再次回到那几个元素。要是 array 是空数组,那么会重返undefined:

var a = ['a', 'b', 'c'];
console.log(a.pop());//c

pop 能够像这么完结:

Array.method('pop2', function () {
    return this.splice(this.length - 1, 1)[0];
});
console.log(a.pop2());//b

1.4 array.push()

push 方法把一个或多少个参数 item 附加到二个数组的尾巴。它会修改array。就算 item 是一个数组,它会把这几个数组作为单个成分增多到数组中,并回到那么些 array 的新长度值:

var a = ['a', 'b', 'c'];
var b = ['x', 'y', 'z'];
console.log(a.push(b, true));//5
console.log(a);//[ "a", "b", "c", Array[3], true ]

push 能够像这样实现:

Array.method('push2', function () {
    //[this.length,0] 中的 length 指定 slice 的初始索引;0 表示执行不删除
    this.splice.apply(this, [this.length, 0].concat(Array.prototype.slice.apply(arguments)));
    return this.length;
});
console.log(a.push2(b, true));//7
console.log(a);//[ "a", "b", "c", Array[3], true, Array[3], true ]

1.5 array.reverse()

其一方法会反转 array 里成分的次第,并赶回 array 自己:

var a = ['a', 'b', 'c'];
var b = a.reverse();
console.log(a);//[ "c", "b", "a" ]
console.log(b);//[ "c", "b", "a" ]

1.6 array.shift()

shift 会移除数组 array 中的第 1 个成分并回到该因素。假如 array 是空数组,那么会回到 undefined。shift 常常比 pop 慢的多:

var a = ['a', 'b', 'c'];
console.log(a.shift());//a
console.log(a);//[ "b", "c" ]

shift 能够像那样完结:

Array.method('shift2', function () {
    return this.splice(0, 1)[0];
});
console.log(a.shift2());//b
console.log(a);//[ "c" ]

1.7 array.slice(start, end)

slice 方法会对 array 中的生机勃勃段进行浅复制。从 array[start] 一向复制到 array[end]。end 参数是可选的,默以为数据的长度 array.length。

以下是出格景况:

  • 假定三个参数中随性所欲二个是负数,这些负值的参数会与 array.length 相加,试图让它成为非负数。
  • 比方 start 大等于 array.length ,将会获取叁个空数组。
var a = ['a', 'b', 'c'];
console.log(a.slice(0, 1));// [ "a" ]
console.log(a.slice(1));//[ "b", "c" ]
console.log(a.slice(1, 2));

1.8 array.sort(comparefn)

sort 方法会对 array 的源委展开排序,暗中同意的可比函数是把要排序的因素就是字符串,所以它不可能科学地给意气风发组数字排序:

var n = [4, 8, 29, 33, 48, 50, 98];
n.sort();//默认要排序的元素都为字符串
console.log(n);//[ 29, 33, 4, 48, 50, 8, 98 ]

咱俩得以选用自定义的可比函数来消除数字排序的主题素材。相比较函数选拔多个参数:

  • 假如那五个参数相等,则赶回 0。
  • 万黄金年代第一个参数排在前面,则赶回负数。
  • 若果第三个参数排在前面,则赶回正数。
n.sort(function (a, b) {
    return a - b;
});
console.log(n);//[ 4, 8, 29, 33, 48, 50, 98 ]

地方的这几个相比较函数能够给数字排序,但不能够为字符串排序。大家得以定义二个方可给自由轻便值的数组实行排序的相比较函数:

var m = ['a', 'cc', 'aa', 4, 8, 29, 33, 48, 50, 98];
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, 29, 33, 48, 50, 98, "a", "aa", "cc" ]

若是大小写不首要,应该在相比较前,先把待相比的值都转载为小写。

至今编辑贰个更智能的可比函数,它亦可对指标数组排序:

/**
 * 为对象数组排序
 * @param name 以对象中的哪一个成员名排序
 * @return 可进行排序的比较函数
 */
var by = 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: 'Besser'},
    {first: 'Hoe', last: 'Howard'},
    {first: 'Joe', last: 'Derita'},
    {first: 'Shemp', last: 'Howard'},
    {first: 'Larry', last: 'Fine'},
    {first: 'Curly', last: 'Howard'}
];
s.sort(by('first'));
console.log(s);

sort 方法是不稳定的,即排序后会校订相等值的相对地方。所以假如想借助八个键值进行排序,供给改进那些相比较函数,让它能够肩负第 2 个参数,当主要的键值产生了一个配适这个时候,另叁个 compare 方法能够被调用,以调控最后的逐条:

/**
 *
 * @param name 以对象中的哪一个成员名排序
 * @param minor 次要比较函数(可选)
 * @returns {Function} 可进行排序的比较函数
 */
var by = function (name, minor) {
    return function (o, p) {
        var a, b;
        if (o && p && typeof o === 'object' && typeof p === 'object') {
            a = o[name];
            b = p[name];
            if (a === b) {
                return typeof minor === 'function' ? minor(o, p) : 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
            }
        }
    };
};
s.sort(by('last', by('first')));
console.log(s);

1.9 array.splice(start, deleteCount, item...)

小心:splice 与 slice 方法名十分轻巧指鹿为马,请稳重区分。固然不记得 slice 方法了,能够把页面拉上去再看看哦O(∩_∩)O~

splice 方法从 array 中移除一个或几个要素,并用新的 item 来替换这么些成分。参数 start 是要求移除成分的苗子地点。deleteCount 是要移除成分的个数。要是有额外的参数,那么 item 会被插入到被移除成分的职位上。那几个方法会重返贰个包蕴被移除成分的数组。

splice 首要用场是从数组中除去元素:

var a = ['a', 'b', 'c'];
var r = a.splice(1, 1, 'deniro', 'li');
console.log(a);// [ "a", "deniro", "li", "c" ]
console.log(r);// [ "b" ]

splice 能够像这么完结:

//start:需要移除元素的索引位置
//deleteCount:要移除元素的个数
Array.method('splice2', function (start, deleteCount) {
    var max = Math.max,//最大值函数
        min = Math.min,//最小值函数
        delta,//增量
        element,
        insertCount = max(arguments.length - 2, 0),//需要插入的元素个数
        k = 0,
        len = this.length,//数组长度
        new_len,//新数组长度
        result = [],//返回结果集
        shift_count;

    start = start || 0;//设置需要移除元素的索引位置的默认值为 0
    if (start < 0) {
        start += len;//纠正起始索引为负值的情况
    }
    start = max(min(start, len), 0);//纠正起始索引为非正常值的情况

    deleteCount = max(min(typeof deleteCount === 'number' ? deleteCount : len, len - start), 0);//纠正要移除元素的个数为非正常值的情况

    delta = insertCount - deleteCount;
    new_len = len + delta;

    //把需要删除的元素放入返回结果集
    while (k < deleteCount) {
        element = this[start + k];
        if (element !== undefined) {
            result[k] = element;
        }
        k += 1;
    }

    shift_count = len - start - deleteCount;//原数组元素被替换的个数
    if (delta < 0) {//数组变短
        k = start + insertCount;
        while (shift_count) {//从要删除的最后一个元素的下一个元素开始,都向前移动
            this[k] = this[k - delta];
            k += 1;
            shift_count -= 1;
        }
        this.length = new_len;
    } else if (delta > 0) {//数组变长
        k = 1;
        while (shift_count) {//从起始位置的下一元素开始到数组结尾,从后往前,把这些元素都向后移动
            this[new_len - k] = this[len - k];
            k += 1;
            shift_count -= 1;
        }
        this.length = new_len;
    }

    //插入新元素
    for (k = 0; k < insertCount; k += 1) {
        this[start + k] = arguments[k + 2];
    }
    return result;
});

var a = ['a', 'b', 'c'];
var r = a.splice2(1, 1, 'deniro', 'li');
console.log(a);// [ "a", "deniro", "li", "c" ]
console.log(r);// [ "b" ]

1.10 array.unshift(item...)

unshift 方法会把成分加多到数组的首部,并赶回 array 新的 length:

var a = ['a', 'b', 'c'];
var r = a.unshift('?', '@');
console.log(a);//[ "?", "@", "a", "b", "c" ]
console.log(r);//5

unshift 能够像这么完成:

Array.method('unshift2', function () {
    this.splice.apply(this, [0, 0].concat(Array.prototype.slice.apply(arguments)));
    return this.length;
});
var a = ['a', 'b', 'c'];
var r = a.unshift2('?', '@');
console.log(a);//[ "?", "@", "a", "b", "c" ]
console.log(r);//5

2 function.apply(thisArg, argArray)

使用 array 方法调用 function,会传送三个绑定到 this 上的目的和八个可选的数组作为参数:

Function.method('bind2', function (that) {
    var method = this;

    return function () {
        return method.apply(that, arguments);
    };
});

var x = function () {
    return this.value;
}.bind2({value: 666});
console.log(x());

3 Number

3.1 number.toExponential(fractionDigits)

toExponential 方法会把 number 转变为叁个指数方式的字符串。可选参数 fractionDigits 调控小数点后的数字位数,它的值范围是 0 ~ 20:

console.log(Math.PI.toExponential(0));//3e+0
console.log(Math.PI.toExponential(2));//3.14e+0
console.log(Math.PI.toExponential(7));//3.1415927e+0
console.log(Math.PI.toExponential(16));//3.1415926535897931e+0
console.log(Math.PI.toExponential());//3.141592653589793e+0

3.2 number.toFixed(fractionDigits)

toFixed 方法会把 number 转变为叁个十进制数情势的字符串。可选参数 fractionDigits 调节小数点后的数字位数,它的值范围是 0 ~ 20,默认为 0:

console.log(Math.PI.toFixed(0));//3
console.log(Math.PI.toFixed(2));//3.14
console.log(Math.PI.toFixed(7));//3.1415927
console.log(Math.PI.toFixed(16));//3.1415926535897931
console.log(Math.PI.toFixed());//3

3.3 number.toPrecision(precision)

toPrecision 方法会把 number 转变为一个十进制数方式的字符串。可选参数 precision 调整数字的精度,它的值的界定是 0 ~ 21:

console.log(Math.PI.toPrecision(2));//3.1
console.log(Math.PI.toPrecision(7));//3.141593
console.log(Math.PI.toPrecision(16));//3.141592653589793
console.log(Math.PI.toPrecision());//3.141592653589793

3.4 number.toString(radix)

toString 方法会把 number 转变为一个字符串。可选参数 radix 调节基数,它的值的范围是 2 ~ 36。暗许的 radix 是 10。radix 平时是整数,但也足以是随机数字。能够把 number.toString(卡塔尔 简写为 String(number卡塔尔(قطر‎。

console.log(Math.PI.toString(2));//11.001001000011111101101010100010001000010110100011
console.log(Math.PI.toString(8));//3.1103755242102643
console.log(Math.PI.toString(16));//3.243f6a8885a3
console.log(Math.PI.toString());//3.141592653589793

4 object.hasOwnProperty(name)

倘若 object 中含盛名称叫 name 的属性(不反省原型链中的同名属性),那个主意就重回 true。

 Object.create = function (o) {
        var F = function () {
        };
        F.prototype = o;
        return new F();
    }

var a = {member: true};
var b = Object.create(a);
console.log(a.hasOwnProperty('member'));//true
console.log(a.hasOwnProperty('false'));//false
console.log(b.hasOwnProperty('member'));//false
console.log(b.member);//true

5 RegExp

5.1 regexp.exec(string)

exec 方法是正则表明式中最强盛、也是运转最慢的不二诀要。假设它成功匹配了 regexp 和 string,它就能回去三个数组 array。array[0] 包涵 regexp 相配的子字符串。array[1] 是分组 1 捕获的文件,array[2] 是分组 2 捕获的公文,就那样推算。假若合营退步,会再次回到 null。

只要 regexp 带有 g 标志(全局标志),那么查找会从 regexp.lastIndex(最早值为 0)地点上马。假设合营成功,那么 regexp.lastIndex 会被安装为这几个相配后的率先个字符位置。相称不成事,会重新恢复生机设置regexp.lastIndex 为 0。利用那样的计划,就足以循环调用 exec 来询问二个神工鬼斧形式在一个字符串中发生了两遍。但要注意两点:

  • 举例提前退出了巡回,再一次进入那么些轮回此前,必需把 regexp.lastIndex 重新设置为 0。
  • ^ 仅匹配 regexp.lastIndex 为 0 的情况。
/**
 * regexp.text(string)
 */
var b = /&.+;/.test('frank & beans');
console.log(b);//true

/**
 * 把 HTML 文本分解为标签和文本
 * 产生这样一个数组:
 * [0] 匹配的标签和文本
 * [1] /(斜杠);如果有
 * [2] 标签名
 * [3] 属性;如果有
 */
var text = '<html><body bgcolor="linen"><p>This is <b>bold</b>!</p></body></html>';
var tags = /[^<>]+|<(/?)([A-Za-z]+)([^<>]*)>/g;
var a, i;
while ((a = tags.exec(text))) {
    for (i = 0; i < a.length; i += 1) {
        console.log((('// [' + i + '] ' + a[i])));
    }
}

10bet手机官网 2

解说为标签和文书的结果

5.2 regexp.test(string)

test 方法是利用正则表达式最简便也是最快的法子。借使 regexp 相配string,它会回去 true;不然重返 false。

var b = /&.+;/.test('frank &amp; beans');
console.log(b);//true

test 能够像这么完毕:

RegExp.method('test2', function (string) {
    return this.exec(string) !== null;
});
console.log(/&.+;/.test2('frank &amp; beans'));//true

6 String

6.1 string.charAt(pos)

charAt 方法会重返 string 中 pos 地点处的字符。若是 pos 小于 0 或大等于 string 的长短,这些方法会再次来到空字符串。JavaScript 未有字符类型,所以那一个格局再次来到的结果是字符串:

var name = "Deniro";
console.log(name.charAt(0));//D

charAt 能够像这么实现:

String.method('charAt2', function (pos) {
    return this.slice(pos, pos + 1);
});
console.log(name.charAt2(0));//D

6.2 string.charCodeAt(pos)

charCodeAt 方法会重返 string 中 pos 地方处的字符所对应的字符码位(整数格局)。要是 pos 小于 0 或大等于 string 的长度,这些方法会重回 NaN。

var name = "Deniro";
console.log(name.charCodeAt(0));//68

6.3 string.concat(string...)

concat 方法会把别的字符串连接起来,布局三个新的字符串。它超级少使用,因为使用 + 运算符更便于。

console.log('C'.concat('a', 't'));//Cat

6.4 string.indexOf(searchString,position)

indexOf 方法在 string 中寻找字符串 searchString。如若被找到,就回去第三个匹配字符的职位,不然再次回到-1。可选参数 position 可设置从 string 的某部内定地方开首查找:

var text = 'Denironi';
console.log(text.indexOf('ni'));//2
console.log(text.indexOf('ni', 4));//6
console.log(text.indexOf('ni', 8));//-1

6.5 string.lastIndexOf(searchString,position)

lastIndexOf 方法和 indexOf 方法相似,只是它是从字符串的结尾最早查找的:

var text = 'Denironi';
console.log(text.lastIndexOf('ni'));//6
console.log(text.lastIndexOf('ni', 4));//2
console.log(text.lastIndexOf('ni', 8));//6

6.6 string.localeCompare(that)

localeCompare 方法相比很多少个字符串。相同 array.sort 相比较函数的约定:

var m = ['AAA', 'A', 'aa', 'a', 'Aa', 'aaa'];
m.sort(function (a, b) {
    return a.localeCompare(b);
});
console.log(m);//[ "a", "A", "aa", "Aa", "aaa", "AAA" ]

6.7 string.match(regexp)

那几个方法根据 g 标识来支配哪些合营:

  • 风度翩翩经未有 g 标记 - 那么调用 string.match(regexp卡塔尔 的结果与调用 regexp.exec(stringState of Qatar 的结果同样。
  • 设若含有 g 标记 - 那么那一个方法会重回三个带有全数匹配(除了捕获分组之外)的数组。
var text = '<html><body bgcolor="#faf0e6"><p>This is <b>bold</b>!</p></body></html> ';
var tags = /[^<>]+|<(/?)([A-Za-z]+)([^<>]*)>/g;
var a, i;
a = text.match(tags);
for (i = 0; i < a.length; i += 1) {
    console.log('[' + i + '] ' + a[i]);
}

6.8 string.replace(searchValue, replaceValue)

replace 方法会对 string 进行检索与替换,并赶回一个新的字符串。参数 searchValue 能够是一个字符串或一个正则表明式的靶子。要是它是二个字符串,那么 searchValue 只会在第 1 次现身的地点被替换:

console.log("mother_in_law".replace('_', '-'));//mother-in_law

那或然不是你想要的结果哦o( ̄︶ ̄)o

replaceValue 能够是字符串或函数。假如是字符串,那么字符 $ 有着非常的意思:

美元符号序列 替换对象
$$ $
$^ 整个匹配的文本
$number 分组捕获的文本
$' 匹配后的文本
$`:匹配之前的文本

因为符号太新鲜咯,所以只可以写在那O(∩_∩)O~

var oldareacode = /((d{3}))/g;
console.log('(555)666-1212'.replace(oldareacode, '$1-'));//555-666-1212

大器晚成旦 replaceValue 是贰个函数,那么每遭逢贰遍相配,就能调用三回函数,该函数的再次来到值将会被用作替换文本。传递给这么些函数的首先个参数是整套被相配的文件,第二个参数是分组 1 捕获的文书,第多少个参数是分组 2 捕获的文本,就那样推算。

String.method('entityify', function () {
    var character = {
        '<': '&lt;',
        '>': '&gt;',
        '&': '&amp;',
        '"': '&quot;'
    };

    return function () {
        return this.replace(/[<>&"]/g, function (c) {
            return character[c];
        });
    };
}());

console.log("entityify:"+("<&>".entityify()));//&lt;&amp;&gt;

6.9 string.search(regexp)

search 方法与 indexOf 方法相符,但它只选取二个正则表达式对象作为参数。若是找到,会回来第二个门户相当的首字符地方;若无找到,就回到 -1。该方法会忽视 g 标志,它也未曾 position 参数哦O(∩_∩)O~

var text = 'and in it he says "Any damn fool could';
console.log(text.search(/["']/));//18

6.10 string.slice(start, end)

slice 方法会复制 string 的大器晚成有的来组织新的字符串。倘若 start 是负数,那么它会与 string.length 相加,试图让它成为正数。end 参数是可选的,默许值是 string.length。假如 end 是负数,那么它也会与 string.length 相加。end 参数是你要拿走的终极二个字符的任务值加 1。如果想要取从地点 p 最初的 n 个字符,那么能够这么做:string.slice(p, p+n卡塔尔(قطر‎。

console.log(text.slice(18));//"Any damn fool could
console.log(text.slice(0, 3));//and
console.log(text.slice(-5));//could
console.log(text.slice(19, 32));//Any damn fool

6.11 string.split(separator, limit)

split 方法会把 string 分割成片段,然后回来那个片段组成的数组。可选参数 limit 会限定被分开的部分数量。separator 参数能够是字符串,也得以是正则表明式。

假设 separator 参数是八个空字符,那么这几个方法会重回二个单字符的数组:

var digits = '0123456789';
console.log(digits.split('', 5));//[ "0", "1", "2", "3", "4" ]

那一个方法会忽略 g 标志,并把分隔符两侧的文书都复制到要重回的数组中:

console.log('192.168.0.1'.split('.'));//[ "192", "168", "0", "1" ]

console.log('|a|b|c|'.split('|')); //[ "", "a", "b", "c", "" ]

var text = 'last, first, middle';
console.log(text.split(/s*,s*/));//[ "last", "first", "middle" ]

细心:来自分组捕获的文书也会被含有在被分开后的数组中:

console.log(text.split(/s*(,)s*/));//[ "last", ",", "first", ",", "middle" ]

当 separator 是叁个正则表达式时,老的浏览器(举例IE8)会在输出数组中解除掉空字符串。新的浏览器就能保留:

console.log('|a|b|c|'.split(/|/));//[ "", "a", "b", "c", "" ]

6.12 String.fromCharCode(char...)

以此方法会依据数字编码再次回到一个字符串:

console.log(String.fromCharCode(67,97,116));//Cat

6.13 string.substring(start, end)

substring 方法与 slice 相近,但它不能够管理负数的参数,所以请使用 slice 方法哦O(∩_∩)O~

本文由10bet手机官网发布于微服架构,转载请注明出处:方法集的特性与最佳实践,javascript基础知识【10bet手机官网】

上一篇:python查找目录下指定扩展名的文件实例,Python实现替换文件中指定内容的方法 下一篇:没有了
猜你喜欢
热门排行
精彩图文