1.計算給定陣列 arr 中所有元素的總和 （陣列中的元素均為 Number 型別）
1 function sum(arr) { 2 var sum=0; 3 for (var i=arr.length-1; i>=0; i--) { 4 sum += arr[i]; 5 } 6 return sum; 7 } 8 sum([1,2,3,4]);
function sum(arr) { return eval(arr.join('+')); }; sum([1,2,3,4]);//10
2.移除陣列 arr 中的所有值與 item 相等的元素。不要直接修改陣列 arr，結果返回新的陣列
1 function remove(arr, item) { 2 var newArr = [];//返回的陣列 3 for(var i=0;i<arr.length;i++){ 4 if(arr[i]!=item){ 5 newArr.push(arr[i]); 6 } 7 } 8 return newArr; 9 } 10 remove([1,2,3,4,2],2);//[1,3,4]
3. 移除陣列 arr 中的所有值與 item 相等的元素，直接在給定的 arr 陣列上進行操作，並將結果返回
1 function removeWithoutCopy(arr, item) { 2 //可以先去重，再進行操作 3 //arr =Array.from(new Set(arr)); 4 for(var i=0;i<arr.length;i++){ 5 if(arr[i]==item){ 6 arr.splice(i,1); 7 i--; 8 } 9 } 10 return arr; 11 } 12 removeWithoutCopy([1, 2, 2, 3, 4, 2, 2], 2);//[1,3,4]
4.在陣列 arr 末尾新增元素 item。不要直接修改陣列 arr，結果返回新的陣列
function append(arr, item) { var newArr =[]; newArr=arr.concat([item]); return newArr; } append([1, 2, 3, 4], 10);//[1, 2, 3, 4, 10]
5.刪除陣列 arr 最後一個元素。不要直接修改陣列 arr，結果返回新的陣列
function truncate(arr) { var a = arr.slice(0); a.pop(); return a; } truncate([1,2,3]);//[1,2]
6.刪除陣列 arr 第一個元素。不要直接修改陣列 arr，結果返回新的陣列
function curtail(arr) { var a = arr.slice(0); a.shift(); return a; } curtail([1, 2, 3, 4]);//[2,3,4]
7.合併陣列 arr1 和陣列 arr2。不要直接修改陣列 arr，結果返回新的陣列
function concat(arr1, arr2) { return newArr = arr1.concat(arr2); } concat([1, 2, 3, 4], ['a', 'b', 'c', 1]);//[1, 2, 3, 4, "a", "b", "c", 1]
8.在陣列 arr 的 index 處新增元素 item。不要直接修改陣列 arr，結果返回新的陣列
function insert(arr, item, index) { var newArr = arr.slice(0); newArr.splice(index,0,item) return newArr; } insert([1, 2, 3, 4], 'z', 2);// [1, 2, "z", 3, 4]
9.統計陣列 arr 中值等於 item 的元素出現的次數
function count(arr, item) { var num=0; for(var i=0;i<arr.length;i++){ if(arr[i]==item){ ++num; } } return num; } count([1, 2, 4, 4, 3, 4, 3], 4);//3
10.找出陣列 arr 中重複出現過的元素
function duplicates(arr) { //宣告兩個陣列，a陣列用來存放結果，b陣列用來存放arr中每個元素的個數 var a = [],b = []; //遍歷arr，如果以arr中元素為下標的的b元素已存在，則該b元素加1，否則設定為1 for(var i = 0; i < arr.length; i++){ if(!b[arr[i]]){ b[arr[i]] = 1; continue; } b[arr[i]]++; } //遍歷b陣列，將其中元素值大於1的元素下標存入a陣列中 for(var i = 0; i < b.length; i++){ if(b[i] > 1){ a.push(i); } } return a; } duplicates([1, 2, 4, 4, 3, 3, 1, 5, 3]);
11.為陣列 arr 中的每個元素求二次方。不要直接修改陣列 arr，結果返回新的陣列
function square(arr) { var newArr=[]; arr.forEach(function(value, index, arr){ newArr.push(value*value); }); return newArr; } square([1, 2, 3, 4]);// [1, 4, 9, 16]
function square(arr) { var newArr = []; for(var i=0;i<arr.length;i++){ newArr.push(arr[i]*arr[i]); } return newArr; } square([1, 2, 3, 4]);
12.在陣列 arr 中，查詢值與 item 相等的元素出現的所有位置
function findAllOccurrences(arr, target) { var temp = []; arr.forEach(function(val,index){ val !== target || temp.push(index); }); return temp; } findAllOccurrences(['abcdefabc'],'a');
13.js 程式碼中 parseInt 的呼叫方式，使之通過全部測試用例
"12" 12
"12px" 12
//parseInt(string, radix) //parseInt() 函式可解析一個字串，並返回一個整數。 //string:必需。要被解析的字串。 //radix:可選。表示要解析的數字的基數。該值介於 2 ~ 36 之間。 //如果省略該引數或其值為 0，則數字將以 10 為基礎來解析。如果它以 “0x” 或 “0X” 開頭，將以 16 為基數。 //如果該引數小於 2 或者大於 36，則 parseInt() 將返回 NaN。 function parse2Int(num) { return parseInt(num,10); }
14.判斷 val1 和 val2 是否完全等同
function identity(val1, val2) { if(val1===val2){ return true; } return false; } //一般使用雙等來判斷（==），如果還需要型別相同那麼就用三等（===）。 //說一下這兩個的區別： //== equality 等同，=== identity 恆等。 //==， 兩邊值型別不同的時候，要先進行型別轉換，再比較。 //==，不做型別轉換，型別不同的一定不等。 //下面分別說明： //先說 ===，這個比較簡單。下面的規則用來判斷兩個值是否===相等： //1、如果型別不同，就[不相等] //2、如果兩個都是數值，並且是同一個值，那麼[相等]。 //3、如果兩個都是字串，每個位置的字元都一樣，那麼[相等]；否則[不相等]。 //4、如果兩個值都是true，或者都是false，那麼[相等]。 //5、如果兩個值都引用同一個物件或函式，那麼[相等]；否則[不相等]。 //6、如果兩個值都是null，或者都是undefined，那麼[相等]。 再說 ==，根據以下規則： //1、如果兩個值型別相同，進行 === 比較。 //2、如果兩個值型別不同，他們可能相等。根據下面規則進行型別轉換再比較： //a、如果一個是null、一個是undefined，那麼[相等]。 //b、如果一個是字串，一個是數值，把字串轉換成數值再進行比較。 //c、如果任一值是 true，把它轉換成 1 再比較；如果任一值是 false，把它轉換成 0 再比較。 //d、任何其他組合，都[不相等]。
15.解釋型語言的特性？
計算機不能直接理解高階語言，只能直接理解機器語言，所以必須要把高階語言翻譯成機器語言，計算機才能執行高階語言編寫的程式。
翻譯的方式有兩種，一個是編譯，一個是解釋。兩種方式只是翻譯的時間不同。
解釋性語言的定義：
解釋性語言的程式不需要編譯，在執行程式的時候才翻譯，每個語句都是執行的時候才翻譯。這樣解釋性語言每執行一次就需要逐行翻譯一次，效率比較低。
現代解釋性語言通常把源程式編譯成中間程式碼，然後用直譯器把中間程式碼一條條翻譯成目標機器程式碼，一條條執行。
編譯性語言的定義：
編譯性語言寫的程式在被執行之前，需要一個專門的編譯過程，把程式編譯成為機器語言的檔案，比如exe檔案，以後要執行的話就不用重新翻譯了，直接使用編譯的結果就行了（exe檔案），因為翻譯只做了一次，執行時不需要翻譯，所以編譯型語言的程式執行效率高。
JSONP的缺點則是：它只支援GET請求而不支援POST等其它型別的HTTP請求；它只支援跨域
HTTP請求這種情況，不能解決不同域的兩個頁面之間如何進行JavaScript呼叫的問題。
18.js的原型繼承
var F=function(){}; Object.prototype.a=function(){}; Function.prototype .b=function(){}; var f=new F(); //1. f.__proto__ === f[的建構函式].prototype === F.prototype //2. F.prototype.__proto__ === (F.prototype)[的建構函式].prototype === Object.prototype (所以a能夠 通過f.a訪問) //3. f.constructor === F //4. F.__proto__ === F[的建構函式].prototype === Function.prototype (所以b可以通過, f.constructor.b訪問到) //注意: //(F.prototype)[的建構函式] === Object //F[的建構函式] === Function
19.運算子
Boolean([]); //true Number([]); //0 Number({}); // NaN Number(false); //0
“==”運算子（兩個運算元的型別不相同時）
- 如果一個值是null，另一個值是undefined，則它們相等
- 如果一個值是數字，另一個值是字串，先將字串轉換為數學，然後使用轉換後的值進行比較。
- 如果其中一個值是true，則將其轉換為1再進行比較。如果其中的一個值是false，則將其轉換為0再進行比較。
- 如果一個值是物件，另一個值是數字或字串，則將物件轉換為原始值，再進行比較。
物件到數字的轉換
- 如果物件具有valueOf()方法，後者返回一個原始值，則JavaScript將這個原始值轉換為數字（如果需要的話）並返回一個數字。
- 否則，如果物件具有toString()方法，後者返回一個原始值，則JavaScript將其轉換並返回。（物件的toString()方法返回一個字串直接量（作者所說的原始值），JavaScript將這個字串轉換為數字型別，並返回這個數字）。
- 否則，JavaScript丟擲一個型別錯誤異常。
空陣列轉換為數字0
- 陣列繼承了預設的valueOf()方法，這個方法返回一個物件而不是一個原始值，因此，陣列到數學的轉換則呼叫toString()方法。空陣列轉換為空字串，空字串轉換為數字0.
20.
21.實現一個打點計時器，要求
- 1、從 start 到 end（包含 start 和 end），每隔 100 毫秒 console.log 一個數字，每次數字增幅為 1
- 2、返回的物件中需要包含一個 cancel 方法，用於停止定時操作
- 3、第一個數需要立即輸出
function count(start, end) { console.log(start++); var timer= setInterval(function(){ if(start <= end){ console.log(start++); }else{ clearInterval(id); } },100); return { cancel:function(){ clearInterval(timer);
}
}
}
count(10,12);
setInterval() 方法會按照指定週期不停地呼叫函式，直到 clearInterval() 被呼叫或視窗被關閉。由 setInterval() 返回的 ID 值可用作 clearInterval() 方法的引數。
22.實現 fizzBuzz 函式，引數 num 與返回值的關係如下：
- 1、如果 num 能同時被 3 和 5 整除，返回字串 fizzbuzz
- 2、如果 num 能被 3 整除，返回字串 fizz
- 3、如果 num 能被 5 整除，返回字串 buzz
- 4、如果引數為空或者不是 Number 型別，返回 false
- 5、其餘情況，返回引數 num
function fizzBuzz(num) { if(num % 3==0 && num %5==0 ){ return 'fizzbuzz'; }else if(num % 3==0){ return 'fizz'; }else if(num % 5==0){ return 'buzz'; }else if(num=="" || isNaN(num)){//不是Number型別，也可以用typeof num != "number" return false; }else{ return num; } } fizzBuzz(15);
23.將陣列 arr 中的元素作為呼叫函式 fn 的引數
function argsAsArray(fn, arr) { return fn.apply(this,arr); } argsAsArray(function (greeting, name, punctuation) {return greeting + ', ' + name + (punctuation || '!');}, ['Hello', 'Ellie', '!']); //呼叫函式可以使用call或者apply這兩個方法，區別在於call需要將傳遞給函式的引數明確寫出來，是多少引數就需要寫多少引數。而apply則將傳遞給函式的引數放入一個陣列中，傳入引數陣列即可。
24.將函式 fn 的執行上下文改為 obj 物件
function speak(fn, obj) { return fn.apply(obj,[]); } //在JavaScript中，函式是一種物件，其上下文是可以變化的，對應的，函式內的this也是可以變化的，
//函式可以作為一個物件的方法，也可以同時作為另一個物件的方法，可以通過Function物件中的call或者apply方法來修改函式的上下文，
//函式中的this指標將被替換為call或者apply的第一個引數。將函式 fn 的執行上下文改為 obj 物件，只需要將obj作為call或者apply的第一個引數傳入即可
25.實現函式 functionFunction，呼叫之後滿足如下條件：
- 1、返回值為一個函式 f
- 2、呼叫返回的函式 f，返回值為按照呼叫順序的引數拼接，拼接字元為英文逗號加一個空格，即 ', '
- 3、所有函式的引數數量為 1，且均為 String 型別
function functionFunction (arg1) { return function(arg2){ return arg1 + ', ' + arg2; }; }
26.實現函式 makeClosures，呼叫之後滿足如下條件：
- 1、返回一個函式陣列 result，長度與 arr 相同
- 2、執行 result 中第 i 個函式，即 result[i]()，結果與 fn(arr[i]) 相同
function makeClosures(arr, fn) { return arr.map(function(item){ return fn.bind(this,item); }); }
簡單的描述閉包：如果在函式func內部宣告函式inner，然後在函式外部呼叫inner，這個過程即產生了一個閉包。
27.已知函式 fn 執行需要 3 個引數。請實現函式 partial，呼叫之後滿足如下條件：
- 1、返回一個函式 result，該函式接受一個引數
- 2、執行 result(str3) ，返回的結果與 fn(str1, str2, str3) 一致
function partial(fn, str1, str2) { function result(str3){ return fn.apply(this,[str1,str2,str3])；//或者用call return fn.call(this,str1,str2,str3); } return result; }
28.函式 useArguments 可以接收 1 個及以上的引數。請實現函式 useArguments，返回所有呼叫引數相加後的結果。本題的測試引數全部為 Number 型別，不需考慮引數轉換。
function useArguments() { var num=0; for(var i=0;i<arguments.length;i++){ num+=arguments[i]; } return num; }
arguments能獲得函式物件傳入的引數組，類似與一個陣列，能夠通過length獲取引數個數，能通過下標獲取該位置的引數，但是它不能使用forEach等方法。
29.實現函式 callIt，呼叫之後滿足如下條件:
- 1、返回的結果為呼叫 fn 之後的結果
- 2、fn 的呼叫引數為 callIt 的第一個引數之後的全部引數
function callIt(fn) { //將arguments轉化為陣列後，擷取第一個元素之後的所有元素 var args = Array.prototype.slice.call(arguments,1); //呼叫fn var result = fn.apply(this,args);//給apply傳遞null，“”空字串，預設都是this; //將arguments轉換為真正的陣列:var args = Array . prototype . slice . call ( arguments ); return result; }
30.下面三個事件都是事件物件的方法：
-
stopPropagation()阻止事件冒泡。 這個事件不會阻止定義在元素上的其他事件。 -
stopImmediatePropagation()會徹底的阻止事件， 在其之後的繫結在元素上的其他監聽事件都不會觸發 -
preventDefault()阻止事件的預設動作
31.下面這個JS程式的輸出是什麼：
function Foo() { var i = 0; return function() { console.log(i++); } } var f1 = Foo(), f2 = Foo(); f1(); f1(); f2();
0 1 0
閉包；首先返回的function函式賦值給全域性變數f1，因此function函式就被儲存在了記憶體中，因為foo函式是function函式的父函式，於是foo函式和區域性變數i也被存在了記憶體。之後f1（）被呼叫了兩次，第一次呼叫時i=0，因為是i++，先輸出i的值0，然後再++；
第二次呼叫是i=1，所以先輸出1；而f2是一個新的變數，因此i的值初始化為0。
32.下面哪種方式不能改變作用域鏈？while（with、try catch、eval都可以改變作用域鏈）
1.while的話只是在函式區域性環境或者全域性環境執行，並不會改變作用域鏈。 2.try catch紅皮書第四章講的清清楚楚：雖然執行環境的型別總共只有兩種--全域性和區域性（函式），但還是有其他辦法來延長作用域鏈。這麼說是因為有些語句可以在作用域鏈的前端臨時增加一個變數物件，該變數物件會在程式碼執行後被移除。在兩種情況下回發生這種現象。具體來說，就是當執行流進入下列任何一個語句時，作用域鏈就會得到加強： try catch語句的catch塊； with語句； 這兩個語句都會在作用域鏈的前端新增一個變數物件。對WITH語句來說，將會指定的物件新增到作用域鏈中。對catch語句來說，會建立一個新的變數物件，其中包含的是被丟擲的錯誤物件的宣告。 Example： function builderUrl(){ var qs="?debug=true"; with(location){ var url = href + qs; } return url; } 在此，with語句接受的是location物件，因此其變數物件中就包含了Location物件的所有屬性和方法，而這個變數物件被新增到了作用域鏈的前端。builderUrl()函式中定義了一個變數qs。當在with語句中引用變數href時（實際引用的是location.href），可以在當前執行環境的變數物件中找到。當引用變數qs時，引用的則是在buildUrl()中定義的那個變數，而該變數位於函式環境的變數物件中。至於with語句內部，則定義了一個名為url的變數，因而url就成了函式執行環節的一個部分，所以可以作為函式的值被返回。
33.寫出下面程式碼的執行結果:var a=b=3 相當於 var a = 3；b = 3；b是全域性的;從右向左進行
var a,b; (function(){ alert(a); alert(b); var a=b=3; alert(a); alert(b); })(); alert(a); alert(b); //這段程式碼相當於： var a,b; //執行自調函式中的 var a,b; a=b;b=3; alert(a);//3;區域性變數 alert(b)://3全域性變數 //外面 alert(a);undefined; alert(b);//3
34.執行以下程式：
<script>
var m= 1, j = k = 0;
function add(n) {
return n = n+1;
}
y = add(m);
function add(n) {
return n = n + 3;
}
z = add(m);
</script>
js裡面沒有函式過載的概念，在其他語言中（如java）java中，可以存在同名函式，只要傳入的引數數量或者型別不同即可。在js中，定義了兩個同名函式後，後面的函式會覆蓋前面定義的函式。因為都是+，從“2”開始加的時候，先處理"2"+3，再處理"23"+4，結果"234" ，如果是 "2"+3/4 ，結果就不一樣了，先執行3/4 再和“2”加，結果是2036.
37.顯示結果為：
var x = new Boolean(false); if (x) { alert('hi'); } var y = Boolean(0); if (y) { alert('hello'); }
if(x){} //由於x是boolean的物件，故意思為:是否存在布林物件X，很顯然，X是存在的，所以判斷值為true;
38.實現函式 partialUsingArguments，呼叫之後滿足如下條件：
1、返回一個函式 result
2、呼叫 result 之後，返回的結果與呼叫函式 fn 的結果一致
3、fn 的呼叫引數為 partialUsingArguments 的第一個引數之後的全部引數以及 result 的呼叫引數
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; }
39.已知 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
function curryIt(fn) { //獲取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; }
40.完成函式 createModule，呼叫之後滿足如下要求：
- 1、返回一個物件
- 2、物件的 greeting 屬性值等於 str1， name 屬性值等於 str2
- 3、物件存在一個 sayIt 方法，該方法返回的字串為 greeting屬性值 + ', ' + name屬性值
function createModule(str1, str2) { var obj = { greeting : str1, name : str2, sayIt : function(){ return this.greeting+", "+this.name; } }; return obj; }
41.獲取數字 num 二進位制形式第 bit 位的值。注意：
- 1、bit 從 1 開始
- 2、返回 0 或 1
- 3、舉例：2 的二進位制為 10，第 1 位為 0，第 2 位為 1
輸入：
128,8
輸出：
1
function valueAtBit(num, bit) { return (num >> (bit -1)) & 1; }
42.給定二進位制字串，將其換算成對應的十進位制數字
輸入：
'11000000'
輸出：
192
//parseInt方法可以將其它進位制轉換為十進位制，只需要給該方法傳入需要轉換的字串和該字串的進製表示兩個引數即可。 function base10(str) { return parseInt(str,2); }
43.將給定數字轉換成二進位制字串。如果字串長度不足 8 位，則在前面補 0 到滿8位。
輸入：
65
輸出：
01000001
function convertToBinary(num) { var s=num.toString(2);//toString方法將num轉為2進位制數形式 var len=s.length; if(len<8){ //宣告一個字串用於補滿0 var s1="0000000"; var s2=s1.slice(0,8-len); s=s2+s; } return s; }
44.求 a 和 b 相乘的值，a 和 b 可能是小數，需要注意結果的精度問題；
function multiply(a, b) { //var reg = /(\d+\.)|(\d+)/; var reg = /\d*[\.\d]/; var la = a.toString().replace(reg,"").length, lb = b.toString().replace(reg,"").length; return (a*b).toFixed(la+lb); } console.log(multiply(0, 0.001));//0.000 console.log(multiply(0.001, 0.001));//0.000001 console.log(multiply(3, 0.000001));//0.000003 console.log(multiply(1000, 0.001));//1.000
或者：
function multiply(a, b) { aLen = a.toString().substring(a.toString().indexOf(".")+1).length; bLen = b.toString().substring(b.toString().indexOf(".")+1).length;
return (a*b).toFixed(Math.max(aLen,bLen)); } console.log(multiply(0, 0.001)); console.log(multiply(0.001, 0.001)); console.log(multiply(3, 0.000001)); console.log(multiply(1000, 0.001));
或者：
function multiply(a, b) { return parseFloat((a*b).toFixed(10)); } //都變為浮點數就可以保留精度
45.將函式 fn 的執行上下文改為 obj，返回 fn 執行後的值
//在JavaScript中，函式是一種物件，其上下文是可以變化的，對應的，函式內的this也是可以變化的，
//函式可以作為一個物件的方法，也可以同時作為另一個物件的方法，可以通過Function物件中的call或者apply方法來修改函式的上下文，
//函式中的this指標將被替換為call或者apply的第一個引數。將函式 fn 的執行上下文改為 obj 物件，只需要將obj作為call或者apply的第一個引數傳入即可。 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); }
46.給定一個建構函式 constructor，請完成 alterObjects 方法，將 constructor 的所有例項的 greeting 屬性指向給定的 greeting 變數。
//每個建構函式都有一個原型物件，原型物件都包含一個指向建構函式的指標，而例項都包含一個指向原型物件的內部指標。 //訪問一個物件的方法或者是屬性，首先會在該物件中尋找，如果找到則返回，如果沒找到，則在其原型鏈上面向上尋找，直至其原型，
//如還未找到，則返回undefined。將 constructor 的所有例項的 greeting 屬性指向給定的 greeting 變數，
//只需要在constructor的原型上面新增greeting屬性，並指定值。 function alterObjects(constructor, greeting) { constructor.prototype.greeting=greeting; }
47.找出物件 obj 不在原型鏈上的屬性(注意這題測試例子的冒號後面也有一個空格~)
- 1、返回陣列，格式為 key: value
- 2、結果陣列不要求順序
function iterate(obj) { var arr=[];//存放返回陣列 for(var key in obj){ if(obj.hasOwnProperty(key)){ arr.push(key+": "+obj[key]); } } return arr; } //---------------第二種---------------------- function iterate(obj) { return Object.getOwnPropertyNames(obj).map(function(key){ return key+": "+obj[key]; }); }
48.給定字串 str，檢查其是否包含數字，包含返回 true，否則返回 false
function containsNumber(str) { var reg=/\d/; return reg.test(str); }
49.給定字串 str，檢查其是否包含連續重複的字母（a-zA-Z），包含返回 true，否則返回 false
//在正規表示式中，利用()進行分組，使用斜槓加數字表示引用，\1就是引用第一個分組，\2就是引用第二個分組。
//將[a-zA-Z]做為一個分組，然後引用，就可以判斷是否有連續重複的字母。 function containsRepeatingLetter(str) { return /([a-zA-Z])\1/.test(str); }
50.給定字串 str，檢查其是否以母音字母結尾
- 1、母音字母包括 a，e，i，o，u，以及對應的大寫
- 2、包含返回 true，否則返回 false
//$表示匹配結尾，/i表示忽略大小寫 function endsWithVowel(str) { return /(a|e|i|o|u)$/i.test(str); } //----------------第二種------------------------------- function endsWithVowel(str) { return str && ("aeiouAEIOU".indexOf(str[str.length-1]) > -1); }
51.給定字串 str，檢查其是否包含連續的任意3個數字
- 1、如果包含，返回最新出現的 3 個數字的字串
- 2、如果不包含，返回 false
function captureThreeNumbers(str) { //宣告一個陣列儲存匹配的字串結果 var arr = str.match(/\d{3}/); //如果arr存在目標結果，則返回第一個元素，即最早出現的目標結果 if(arr){ return arr[0]; }else { return false; } }
52.給定字串 str，檢查其是否符合如下格式
- 1、XXX-XXX-XXXX
- 2、其中 X 為 Number 型別
//正規表示式的開頭和結尾一定要加上^,$,
//3個數的正則寫成\d{3},4個數的正則要寫成\d{4},所以按照要求寫應該為/^\d{3}-\d{3}-\d{4}/，
//這種形式進行合併之後為/^(\d{3}-){2}\d{4}/;其中中間的2表示的是兩遍的意思。 function matchesPattern(str){ return /^(\d{3}-){2}\d{4}/g.test(str); } function matchesPattern(str) { return /^\d{3}-\d{3}-\d{4}$/.test(str); }
53.給定字串 str，檢查其是否符合美元書寫格式
- 1、以 $ 開始
- 2、整數部分，從個位起，滿 3 個數字用 , 分隔
- 3、如果為小數，則小數部分長度為 2
- 4、正確的格式如：$1,023,032.03 或者 $2.03，錯誤的格式如：$3,432,12.12 或者 $34,344.3
//正規表示式分為四部分 $符:開頭必是$，而正規表示式中$表示結尾，需要進行轉義，因此開頭為^\$ 匹配緊跟$符的數字:(0|[1-9]|[1-9]\d{0,2}) 匹配逗號和跟在逗號後面的數字(,\d{3})* 匹配點號和小數位(\.\d{2})? function isUSD(str) { return /^\$(0|[1-9]\d{0,2})(,\d{3})*(\.\d{2})?$/.test(str); }
終結。