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); }
終結。