搬运整理牛客网中的题，不知道算不算抄袭……如果有冒犯到任何人的话请联系我 ^^
获取 url 参数
描述
- 指定参数名称，返回该参数的值 或者 空字符串
- 不指定参数名称，返回全部的参数对象 或者 {}
- 如果存在多个同名参数，则返回数组
- 不支持URLSearchParams方法
示例
输入：http://www.nowcoder.com?key=1&key=2&key=3&test=4#hehe key
输出：[1, 2, 3]
题解中的答案
function getUrlParam(sUrl, sKey) {
let arr = sUrl.split("?")[1].split("#")[0].split("&"), obj={};
arr.forEach(item=>{
let [key, value] = item.split("=");
if(key in obj){//已存在同名参数
obj[key] = [].concat(obj[key], value);//通过数组存起来
}else{//第一次遍历这个元素
obj[key] = value//直接添加到对象上面
}
})
return sKey ? obj[sKey] || "" : obj;
}
dom 节点查找
描述
查找两个节点的最近的一个共同父节点，可以包括节点自身
oNode1 和 oNode2 在同一文档中，且不会为相同的节点
题解的答案
判断一个节点以及它的父节点是否包含另一个节点
//从一个结点出发
function commonParentNode(oNode1, oNode2) {
while(true){
oNode1 = oNode1.parentNode;
if(oNode1.contains(oNode2)){
return oNode1;
}
}
}
//从两个结点一起出发
function commonParentNode(oNode1, oNode2) {
while(true){
oNode1=oNode1.parentNode;
if(oNode1.contains(oNode2)){
return oNode1;
}
oNode2=oNode2.parentNode;
if(oNode2.contains(oNode1)){
return oNode2;
}
}
}
递归
function commonParentNode(oNode1, oNode2) {
oNode1=oNode1.parentNode;
oNode2=oNode2.parentNode;
if(oNode1==oNode2){
return oNode1;
}
commonParentNode(oNode1,oNode2);
}
根据包名，在指定空间中创建对象
描述
根据包名，在指定空间中创建对象
示例
输入namespace({a: {test: 1, b: 2}}, 'a.b.c.d')
输出{a: {test: 1, b: {c: {d: {}}}}}
题解的答案
当空间中包含对象时（如a：{test：1}）则保留此对象；
当包含内容不是对象时（如b：2），则将其设置为一个空对象。
function namespace(oNamespace, sPackage) {
let namespace=oNamespace;
let arr=sPackage.split('.');
for(let i=0 ; i<arr.length ; i++){
namespace[arr[i]]=typeof(namespace[arr[i]])=='object'?namespace[arr[i]]:{};
namespace=namespace[arr[i]];
}
return namespace;
}
数组去重
描述
为 Array 对象添加一个去除重复项的方法
示例
输入：[false, true, undefined, null, NaN, 0, 1, {}, {}, 'a', 'a', NaN]
输出：[false, true, undefined, null, NaN, 0, 1, {}, {}, 'a']
题解答案
===： NaN != NaN
set： NaN = NaN
{} != {}，+0=-0
Array.prototype.uniq = function () {
return Array.from(new Set(this))//Set只是类似数组，要用Array.from返回一个真正的数组
}
时间格式化输出
示例
输入：formatDate(new Date(1409894060000), 'yyyy-MM-dd HH:mm:ss 星期w')
输出：2014-09-05 13:14:20 星期五
题解答案
function formatDate(t,str){
var obj = {
yyyy:t.getFullYear(),
yy:(""+ t.getFullYear()).slice(-2),
M:t.getMonth()+1,
MM:("0"+ (t.getMonth()+1)).slice(-2),
d:t.getDate(),
dd:("0" + t.getDate()).slice(-2),
H:t.getHours(),
HH:("0" + t.getHours()).slice(-2),
h:t.getHours() % 12,
hh:("0"+t.getHours() % 12).slice(-2),
m:t.getMinutes(),
mm:("0" + t.getMinutes()).slice(-2),
s:t.getSeconds(),
ss:("0" + t.getSeconds()).slice(-2),
w:['日', '一', '二', '三', '四', '五', '六'][t.getDay()]
};
return str.replace(/([a-z]+)/ig,function($1){return obj[$1]});
// $1, $2, ... $99 与regexp中的第1到第99个子表达式相匹配的文本
// +表示匹配前面的子表达式一次或多次(大于等于1次）。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”
// /ig(全文查找、忽略大小写)
}
获取字符串的长度
描述
如果第二个参数 bUnicode255For1 === true，则所有字符长度为 1
否则如果字符 Unicode 编码 > 255 则长度为 2
示例
输入：'hello world, 牛客', false
输出：17
题解答案
function strLength(s, bUnicode255For1) {
var length=s.length;
if(!bUnicode255For1){
for( var i in s){
if(s.charCodeAt(i)>255) {//获得字符的Unicode 编码
length++;
}
}
}
return length;
}
判断输入是否是正确的邮箱格式
function isAvailableEmail(sEmail) {
var reg = /^(\w)+(\.\w+)*@(\w)+((\.\w+)+)$/;
// \W：匹配包括下划线的任何单词字符，等价于 [A-Z a-z 0-9_]
return reg.test(sEmail);
}
颜色字符串转换
描述
将 rgb 颜色字符串转换为十六进制的形式，如 rgb(255, 255, 255) 转为 #ffffff
- rgb 中每个 , 后面的空格数量不固定
- 十六进制表达式使用六位小写字母
- 如果输入不符合 rgb 格式，返回原始输入
示例
输入：'rgb(255, 255, 255)'
输出：#ffffff
题解答案
将字符串转换为驼峰格式
描述
css 中经常有类似 background-image 这种通过 - 连接的字符，通过 javascript 设置样式的时候需要将这种样式转换成 backgroundImage 驼峰格式，请完成此转换功能
- 以 - 为分隔符，将第二个起的非空单词首字母转为大写
- -webkit-border-image 转换后的结果为 webkitBorderImage
示例
输入：'font-size'
输出：fontSize
题解答案（绝了）
function cssStyle2DomStyle(sName)
{
return sName.replace(/^-/,'').replace(/-([a-z])/g,(a,b)=>b.toUpperCase());
// g：全局查找，找到所有的后才停止
//a：替换前，b：替换后
}
字符串字符统计
描述
统计字符串中每个字符的出现频率，返回一个 Object，key 为统计字符，value 为出现频率
- 不限制 key 的顺序
- 输入的字符串参数不会为空
- 忽略空白字符
示例
输入：'hello world'
输出：{h: 1, e: 1, l: 3, o: 2, w: 1, r: 1, d: 1}
题解答案 （绝绝子）
function count(str) {
let obj={};
str.replace(/\S/g,function(s){
!obj[s]?obj[s]=1:obj[s]++;
})
//别忘了全局替换 /g
return obj;
}
加粗文字
描述
使用一个标签将“牛客网”三个字加粗显示
let p = document.querySelector("p")
p.innerHTML = p.innerText.replace("牛客网","<strong>牛客网</strong>")
移除数组中的元素
描述
移除数组 arr 中的所有值与 item 相等的元素
不直接修改数组 arr，结果返回新的数组
示例
输入：[1, 2, 3, 4, 2], 2
输出：[1, 3, 4]
题解答案
function remove(arr, item) {
let arr1=arr.filter(value=>{
return value!=item;
})
return arr1;
}
移除数组中的元素
描述
移除数组 arr 中的所有值与 item 相等的元素
直接在给定的 arr 数组上进行操作，并将结果返回
示例
输入：[1, 2, 3, 4, 2], 2
输出：[1, 3, 4]
题解答案
正确
function removeWithoutCopy(arr, item) {
while(arr.indexOf(item)!=-1){
arr.splice(arr.indexOf(item),1);//开始位置，修改数量，（要修改为的值）
}
return arr;
}
错误
删除后会从下一个开始
function removeWithoutCopy(arr, item) {
arr.forEach((value,index)=>{
if(value==item){
arr.splice(index,1);
}
})
return arr;
}
添加元素
描述
在数组 arr 末尾添加元素 item。不要直接修改数组 arr，结果返回新的数组
题解代码
function append(arr, item) {
return arr.concat([item]);//concat进行数组合并，不会影响原来的数组
}
function append(arr, item) {
return [...arr,item];//扩展运算符进行数组合并，浅拷贝
}
添加元素
描述
在数组 arr 开头添加元素 item。不要直接修改数组 arr，结果返回新的数组
题解代码
function prepend(arr, item) {
let arr1 = [...arr];
arr1.unshift(item)//在开头添加元素
return arr1;//返回
}
而不是
function prepend(arr, item) {
let arr1 = [...arr];
return arr1.unshift(item);//返回添加后的元素个数
}
添加元素
描述
在数组 arr 的 index 处添加元素 item。不要直接修改数组 arr，结果返回新的数组
题解答案
function insert(arr, item, index) {
let arr1=[...arr];
arr1.splice(index,0,item)//arr1数组 index处 添加元素item
return arr1;
}
而不是
function insert(arr, item, index) {
let arr1=[...arr];
arr1.splice(index,1,item)//arr1数组 index处 修改为item元素
return arr1;
}
计数
描述
统计数组 arr 中值等于 item 的元素出现的次数
题解答案(好简洁啊）
function count(arr, item) {
return arr.filter(value=>value==item).length;
}
查找重复元素
描述
找出数组 arr 中重复出现过的元素（不用考虑返回顺序）
示例
输入：[1, 2, 4, 4, 3, 3, 1, 5, 3]
输出：[1, 3, 4]
题解答案
function duplicates(arr) {
let arr1=[];
arr.forEach(value=>{
if(arr.indexOf(value)!=arr.lastIndexOf(value)&&arr1.indexOf(value)==-1){
arr1.push(value);
}
})
return arr1;
}
正确的函数定义
描述
请修复给定的 js 代码中，函数定义存在的问题
题目
function functions(flag) {
if (flag) {
function getValue() { return 'a'; }
} else {
function getValue() { return 'b'; }
}
return getValue();
}
题解答案
函数声明 function 函数名(){} ：在执行之前就会被解析
函数表达式 var 函数名 = function(){} ：在执行过程中被解析
function functions(flag) {
if (flag) {
var getValue = function () { return 'a'; }
} else {
var getValue = function () { return 'b'; }
}
return getValue();
}
正确的使用 parseInt
描述
修改 js 代码中 parseInt 的调用方式，使之通过全部测试用例
示例
输入：'12'
输出：12
输入：'12px'
输出：12
输入：'0x12'
输出：0
题解答案
parseInt(string, radix)
radix 的值为 0 或 没有设置该参数时，parseInt() 会根据 string 来判断数字的基数
如果 string 以 “0x” 开头 —> 十六进制的整数。
如果 string 以 0 开头 —> 八进制或十六进制的数字。
如果 string 以 1 ~ 9 的数字开头 —> 十进制的整数。
function parse2Int(num)
{
return parseInt(num,10);//按10进制去处理字符串，碰到非数字字符，会将后面的全部无视
}
计时器
描述
实现一个打点计时器，要求
1、从 start 到 end（包含 start 和 end），每隔 100 毫秒 console.log 一个数字，每次数字增幅为 1
2、返回的对象中需要包含一个 cancel 方法，用于停止定时操作
3、第一个数需要立即输出
题解答案
function count(start, end) {
console.log(start);
let timer=setInterval(()=>{
if(start<end)
console.log(++start);
else
clearInterval(timer);
},100)
return {
cancel(){
clearInterval(timer);
}
}
}
函数传参
描述
将数组 arr 中的元素作为调用函数 fn 的参数
示例
输入：function (greeting, name, punctuation) {return greeting + ', ' + name + (punctuation || '!');}, ['Hello', 'Ellie', '!']
输出：Hello, Ellie!
题解答案
function argsAsArray(fn, arr) {
return fn.apply(this,arr)//将参数放入一个数组中
}
function argsAsArray(fn, arr) {
return fn.call(this,arr[0],arr[1],arr[2])//将传递给函数的参数明确写出来
}
function argsAsArray(fn, arr) {
return fn(...arr)//（扩展运算符）数组--->用逗号分隔的参数序列
}
返回函数
描述
实现函数 functionFunction，调用之后满足如下条件：
1、返回值为一个函数 f
2、调用返回的函数 f，返回值为按照调用顺序的参数拼接，拼接字符为英文逗号加一个空格，即 ', ’
3、所有函数的参数数量为 1，且均为 String 类型
示例
输入：functionFunction('Hello')('world')
输出：Hello, world
题解答案
// 一个闭包完美解决
function functionFunction(str) {
return function(str1){
return str+", "+str1;
}
}
使用闭包
描述
实现函数 makeClosures，调用之后满足如下条件：
1、返回一个函数数组 result，长度与 arr 相同
2、运行 result 中第 i 个函数，即 result[i]，结果与 fn(arr[i]) 相同
示例
输入：[1, 2, 3], function (x) {
return x * x;
}
输出：4
题解答案
简单的描述闭包：如果在函数func内部声明函数inner，然后在函数外部调用inner，这个过程即产生了一个闭包。
function makeClosures(arr, fn) {
return arr.map(el=>{
return function(){
return fn(el);
}
})
}
function makeClosures(arr, fn) {
let result=[];
for(let i=0;i<arr.length;i++){
result[i]=fn.bind(this,arr[i]);
}
return result;
}
function makeClosures(arr, fn) {
let result=[];
for(let i=0;i<arr.length;i++){
result[i]=function(){
return fn(arr[i]);
}
}
return result;
}
错误
function makeClosures(arr, fn) {
var result = new Array();
for(var i=0;i<arr.length;i++){
result[i] = function(){//i为最终迭代停止的值，在函数被调用时，i依旧为最终迭代停止的值
return fn(arr[i]);
};
}
return result;
}
为了解决这个问题，需要声明一个匿名函数，并立即执行它。
函数执行后，i立即传入并被内部函数访问到，因此就能得到正确的结果。
function makeClosures(arr, fn) {
var result = new Array();
for(var i=0;i<arr.length;i++){
result[i] = (function(i){
return function(){
return fn(arr[i]);
}
}(i));
}
return result;
}
二次封装函数
描述
已知函数 fn 执行需要 3 个参数。请实现函数 partial，调用之后满足如下条件：
1、返回一个函数 result，该函数接受一个参数
2、执行 result(str3) ，返回的结果与 fn(str1, str2, str3) 一致
示例
输入：var sayIt = function(greeting, name, punctuation) { return greeting + ', ' + name + (punctuation || '!'); }; partial(sayIt, 'Hello', 'Ellie')('!!!');
输出：Hello, Ellie!!!
题解答案
function partial(fn, str1, str2) {
return function result(str3){
return fn(str1,str2,str3);
}
}
bind不加后面的括号返回的是函数，加上后面的括号返回的是函数值
这也是bind和call，apply的主要区别
bind需要二次调用，而call和apply返回的是函数值，是直接调用
function partial(fn, str1, str2) {
function result(str3) {
return fn.call(this, str1, str2, str3);//必须显式地调用str3，立即执行
}
return result;
}
function partial(fn, str1, str2) {
function result(str3) {
return fn.apply(this, [str1, str2, str3]);//必须显式地调用str3，立即执行
}
return result;
}
function partial(fn, str1, str2) {
return fn.bind(this, str1, str2);
// 或 return fn.bind(null, str1, str2);
//会生成一个新函数（对象）, 它的str1, str2参数都定死了, str3未传入, 一旦传入就会执行
//bind不是立即执行，未传入str3时，并未执行，只是返回一个函数，等待参数传入
}
function partial(fn, str1, str2) {
return function(str3) {
return fn(str1, str2, str3); 匿名函数，默认this绑定global，与bind的第一个参数为this时效果一样。
}
}
使用 arguments
描述
函数 useArguments 可以接收 1 个及以上的参数。请实现函数 useArguments，返回所有调用参数相加后的结果。本题的测试参数全部为 Number 类型，不需考虑参数转换。
示例
输入：1, 2, 3, 4
输出：10
题解答案
arguments对象是一个类数组：
拥有length属性；可以通过数组下标访问数据；但是不能使用数组的方法
可以先将arguments对象转换成数组对象，进而就是一个数组求和的问题
function useArguments() {
let result=0;
for(let i=0;i<arguments.length;i++){
result+=arguments[i];
}
return result;
}
function useArguments() {
let arr=[...arguments];
return arr.reduce((total,value)=>total+value)
//总和，当前遍历值
}
function useArguments() {
return Array.from(arguments).reduce((total,value)=>total+value)
}
使用 apply 调用函数
描述
实现函数 callIt，调用之后满足如下条件
1、返回的结果为调用 fn 之后的结果
2、fn 的调用参数为 callIt 的第一个参数之后的全部参数
题解答案
function callIt(fn) {
return fn.apply(this,[].slice.call(arguments,1));
//fn.apply(this,Array.prototype.slice.call(arguments,1));
//把传入进来的具有length属性的第一个参数转换为数组，再调用slice（截取）方法
}
二次封装函数
描述
实现函数 partialUsingArguments，调用之后满足如下条件：
1、返回一个函数 result
2、调用 result 之后，返回的结果与调用函数 fn 的结果一致
3、fn 的调用参数为 partialUsingArguments 的第一个参数之后的全部参数以及 result 的调用参数
题解答案
function partialUsingArguments(fn) {
let args1 = Array.prototype.slice.call(arguments, 1)
return function() {
let args2 = Array.prototype.slice.call(arguments, 0)
return fn.apply(this, args1.concat(args2))
}
}
function partialUsingArguments(fn) {
var arr = Array.prototype.slice.call(arguments,1);
arr.unshift(null);
return fn.bind.apply(fn,arr);
}
function partialUsingArguments(fn) {
//先获取p函数第一个参数之后的全部参数
var args = Array.prototype.slice.call(arguments,1);
//声明result函数
var result = function(){
//使用concat合并两个或多个数组中的元素
return fn.apply(null, args.concat([].slice.call(arguments)));
}
return result;
}
柯里化
描述
已知 fn 为一个预定义函数，实现函数 curryIt，调用之后满足如下条件：
1、返回一个函数 a，a 的 length 属性值为 1（即显式声明 a 接收一个参数）
2、调用 a 之后，返回一个函数 b, b 的 length 属性值为 1
3、调用 b 之后，返回一个函数 c, c 的 length 属性值为 1
4、调用 c 之后，返回的结果与调用 fn 的返回值一致
5、fn 的参数依次为函数 a, b, c 的调用参数
示例
输入：var fn = function (a, b, c) {return a + b + c}; curryIt(fn)(1)(2)(3);
输出：6
题解答案
柯里化是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。简单理解题目意思，就是指，我们将预定义的函数的参数逐一传入到curryIt中，当参数全部传入之后，就执行预定义函数。于是，我们首先要获得预定义函数的参数个数fn.length，然后声明一个空数组去存放这些参数。返回一个匿名函数接收参数并执行，当参数个数小于fn.length，则再次返回该匿名函数，继续接收参数并执行，直至参数个数等于fn.length。最后，调用apply执行预定义函数。
function curryIt(fn) {
let args = []
return function curried(arg) {
args.push(arg)
if (args.length >= fn.length) {
return fn.apply(this, args)
} else {
return function(arg2) {
return curried.call(this, arg2)
}
}
}
}
function curryIt(fn) {
var length = fn.length,
args = [];
var result = function (arg){
args.push(arg);
length --;
if(length <= 0 ){
return fn.apply(this, args);
} else {
return result;
}
}
return result;
}
function curryIt(fn) {
//获取fn参数的数量
var n = fn.length;
//声明一个数组args
var args = [];
//返回一个匿名函数
return function(arg){
//将curryIt后面括号中的参数放入数组
args.push(arg);
//如果args中的参数个数小于fn函数的参数个数，
//则执行arguments.callee（其作用是引用当前正在执行的函数，这里是返回的当前匿名函数）。
//否则，返回fn的调用结果
if(args.length < n){
return arguments.callee;
}else return fn.apply("",args);
}
}
模块
描述
完成函数 createModule，调用之后满足如下要求：
1、返回一个对象
2、对象的 greeting 属性值等于 str1， name 属性值等于 str2
3、对象存在一个 sayIt 方法，该方法返回的字符串为 greeting属性值 + ', ’ + name属性值
题解答案
声明对象有两种常见的方式：
var obj = {}; 在括号中以key:value的方式定义属性
function createModule(str1, str2) {
return obj={
greeting :str1,//逗号啊，兄弟
name :str2,//逗号啊，兄弟
sayIt :function(){
return this.greeting +', ' +this.name;//两个属性前面都需要加上this
}
};
}
var obj = new Object(); 采用点运算符给对象添加属性
function createModule(str1, str2) {
function Obj(){
this.greeting =str1;
this.name=str2;
}
Obj.prototype.sayIt =function(){
return this.greeting+', '+this.name;
}
return new Obj();
}
二进制转换
描述
获取数字 num 二进制形式第 bit 位的值。注意：
1、bit 从 1 开始
2、返回 0 或 1
3、举例：2 的二进制为 10，第 1 位为 0，第 2 位为 1
示例
输入：128, 8
输出：1
题解答案
Number.toString([radix]):
返回指定 Number 对象的字符串表示形式；
radix指定要用于数字到字符串的转换的基数(从2到36)，默认为 10
function valueAtBit(num, bit) {
let value=num.toString(2);
return value[value.length-bit];
}
二进制转换
描述
给定二进制字符串，将其换算成对应的十进制数字
示例
输入：'11000000'
输出：192
题解答案
数字 ——> 字符：toString()
字符 ——> 数字：parseInt()
function base10(str) {
return parseInt(str,2);
}
二进制转换
描述
将给定数字转换成二进制字符串。如果字符串长度不足 8 位，则在前面补 0 到满8位。
示例
输入：65
输出：01000001
function convertToBinary(num) {
return ('00000000'+num.toString(2)).slice(-8);//负数：从字符串的尾部开始算起
}
乘法
描述
求 a 和 b 相乘的值，a 和 b 可能是小数，需要注意结果的精度问题
示例
输入：3, 0.0001
输出：0.0003
改变上下文
题解答案
function alterContext(fn, obj) {
return fn.bind(obj)();//bind()返回的是一个函数，所以需要立即执行
function alterContext(fn, obj) {
return fn.call(obj);
}
function alterContext(fn, obj) {
return fn.apply(obj);
}
批量改变对象的属性
描述
将 constructor 的所有实例的 greeting 属性指向给定的 greeting 变量。
示例
输入：var C = function(name) {this.name = name; return this;};
var obj1 = new C('Rebecca');
alterObjects(C, 'What\'s up'); obj1.greeting;
输出：What's up
题解答案
所有实例的某个属性都改变只需要改变这个构造函数的原型即可
在constructor的原型上添加greeting属性，并指定值。
function alterObjects(constructor, greeting) {
constructor.prototype.greeting = greeting
}
属性遍历
描述
找出对象 obj 不在原型链上的属性(注意这题测试例子的冒号后面也有一个空格
1、返回数组，格式为 key: value
2、结果数组不要求顺序
示例
输入：var C = function() {this.foo = 'bar'; this.baz = 'bim';};
C.prototype.bop = 'bip';
iterate(new C());
输出：["foo: bar", "baz: bim"]
题解答案
Object.keys(obj)
只会遍历实例属性key值，不会遍历原型上的属性。返回可枚举的实例属性的数组。
function iterate(obj) {
const keyArr = Object.keys(obj)
const temp = []
for(let i in keyArr){
temp[i] = keyArr[i].concat(': ',obj[keyArr[i]])
}
return temp
}
function iterate(obj) {
return Object.keys(obj).map(function(key) {
return key + ": " + obj[key];
});
}
for…in 可以遍历到obj的原型属性和方法
obj.hasOwnProperty()用于判断是否为实例属性。
function iterate(obj) {
const temp = []
for(let key in obj){
if(obj.hasOwnProperty(key)){
temp.push(key.concat(': ',obj[key]))
}
}
return temp
}
Object.getOwnPropertyNames 方法
用法跟Object.keys一样，区别在于返回的是所有实例属性（包括不可枚举的）。
function iterate(obj) {
return Object.getOwnPropertyNames(obj).map(function(key) {
return key + ": " + obj[key];
});
}
判断是否包含数字
题解答案
完成比完美更重要。用笨方法做出来也行啊
function containsNumber(str) {
for(let i=0;i<10;i++){
if(str.indexOf(i)!=-1)
return true;
}
return false;
}
function containsNumber(str) {
let reg=/\d/;
return reg.test(str);//正则表达式.test(字符串)
}
检查重复字符串 反向引用？？？？？
描述
检查str是否包含连续重复的字母（a-zA-Z），包含返回 true，否则返回 false
题解答案
function containsRepeatingLetter(str) {
return /([a-zA-Z])\1/.test(str);
}
获取指定字符串
描述
给定字符串 str，检查其是否包含连续3个数字
1、如果包含，返回最先出现的 3 个数字的字符串
2、如果不包含，返回 false
示例
输入：'9876543'
输出：987
题解答案
function captureThreeNumbers(str) {
let arr=str.match(/\d{3}/);//字符串.match(正则表达式)
return (arr && arr[0]) || false;
}
判断是否符合指定格式
描述
给定字符串 str，检查其是否符合如下格式
1、XXX-XXX-XXXX
2、其中 X 为 Number 类型
题解答案
开头^和结尾$必须加上来限定字符串
function matchesPattern(str) {
return /^\d{3}-\d{3}-\d{4}$/.test(str);
}
判断是否符合 USD 格式
描述
给定字符串 str，检查其是否符合美元书写格式
1、以 $ 开始
2、整数部分，从个位起，满 3 个数字用 , 分隔
3、如果为小数，则小数部分长度为 2
4、正确的格式如：$1,023,032.03 或者 $2.03，错误的格式如：$3,432,12.12 或者 $34,344.3
题解答案
function isUSD(str) {
return /^\$\d{1,3}(,\d{3})*(\.\d{2})*$/.test(str);
// \ 是转义的意思，把 $ 转义为普通字符
// * 匹配零次或多次
}