function convertToF(celsius) {
let fahrenheit = (celsius * (9/5)) + 32;
if ( typeof fahrenheit !== 'undefined' ) {
return fahrenheit;
} else {
return 'fahrenheit not defined';
}
}
convertToF(30); //86
反转给出的字符串,在反转字符串前需要将其切分成字符的数组,结果必须是一个字符串。
function reverseString(str) {
return str.split("").reverse().join("");
}
reverseString("hello"); //返回 "olleh"
返回一个给定整数的阶乘。
若 n 是一个整数,n 的阶乘就是所有小于等于 n 的正整数的乘积。n 的阶乘通常用符号 n!来表示。
例如: 5! = 1 * 2 * 3 * 4 * 5 = 120
只有非负整数会被作为函数的输入参数。
function factorialize(num) {
if(num === 0){
return 1;
}
return num * factorialize(num -1);
}
factorialize(5); //120
返回给出的句子中最长的单词的长度。返回应该是一个数字。
function findLongestWordLength(str) {
var array = str.split(" ");
var len = [];
for(var i = 0; i < array.length; i++) {
len.push(array[i].length);
}
len.sort(function(a, b) {
return b - a;
});
return len[0];
}
参考方法一:
function findLongestWordLength(str) {
var words = str.split(" ");
var maxLength = 0;
for(var i = 0; i < words.length; i++) {
if(words[i].length > maxLength) {
maxLength = words[i].length;
}
}
return maxLength;
}
findLongestWordLength("The quick brown fox jumped over the lazy dog"); //6
参考方法二:
function findLongestWordLength(str) {
return str.split(' ').reduce(function(x, y) {
return Math.max(x, y.length)
}, 0);
}
findLongestWordLength("The quick brown fox jumped over the lazy dog");
参考方法三:
function findLongestWordLength(str) {
str = str.split(" ");
if(str.length == 1) {
return str[0].length;
}
if(str[0].length >= str[1].length) {
str.splice(1,1);
return findLongestWordLength(str.join(" "));
}
if(str[0].length <= str[1].length) {
return findLongestWordLength(str.slice(1, str.length).join(" "));
}
}
findLongestWordLength("The quick brown fox jumped over the lazy dog");
第一行将字符串拆分为单个单词。然后检查是否str只有1个元素,那么这是最长的元素,我们返回它。如果第一个元素的长度大于第二个元素的长度(或等于),删除第二个元素并递归调用该函数。如果第二个元素的长度大于第一个元素,那么删除第一个元素并递归调用该函数。
返回一个数组,它要由给出的所有子数组中的最大值组成。
可以在一个简单的 for 循环中遍历一个数组,并用 arr[i]这样的语法来访问数组中的元素。
function largestOfFour(arr) {
let newArray = [];
for(let i = 0; i < arr.length; i++) {
newArray.push(Math.max(...arr[i]));
}
return newArray;
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
参考方法一:
function largestOfFour(arr) {
var results = [];
for (var n = 0; n < arr.length; n++) {
var largestNumber = arr[n][0];
for (var sb = 1; sb < arr[n].length; sb++) {
if (arr[n][sb] > largestNumber) {
largestNumber = arr[n][sb];
}
}
results[n] = largestNumber;
}
return results;
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
参考方法二:
function largestOfFour(arr) {
return arr.map(function(group){
return group.reduce(function(prev, current) {
return (current > prev) ? current : prev;
});
});
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
参考方法三:
function largestOfFour(arr) {
return arr.map(Function.apply.bind(Math.max, null));
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
检查一个字符串(第一个参数, str)是否以给定的字符串(第二个参数 target)结束。
可以用 ES2015 引入的 .endsWith()方法来解决,也可以使用 JavaScript 的一个 substring 方法。
function confirmEnding(str, target) {
return str.substring(str.length - target.length) == target;
}
confirmEnding("Bastian", "n"); //true
confirmEnding("Congratulation", "on"); //true
confirmEnding("Open sesame", "game");// false
也可以用slice()方法、substr()方法
function confirmEnding(str, target) {
return str.substr(- target.length) == target;
}
将一个给定的字符串(第一个参数, str)重复 num(第二个参数)次。如果 num不是一个正数,返回一个空字符串。
function repeatStringNumTimes(str, num) {
let str2 = "";
for(let i = num; i > 0; i--){
str2 += str;
}
return str2;
}
repeatStringNumTimes("abc", 3);
参考方法一:
function repeatStringNumTimes(str, num) {
var accumulatedStr = '';
while (num > 0) {
accumulatedStr += str;
num--;
}
return accumulatedStr;
}
参考方法二:
function repeatStringNumTimes(str, num) {
if(num < 0)
return "";
if(num === 1)
return str;
else
return str + repeatStringNumTimes(str, num - 1);
}
参考方法三:
function repeatStringNumTimes(str, num) {
return num > 0 ? str.repeat(num) : '';;
}
repeatStringNumTimes("abc", 3);
如果一个字符串(第一个参数)的长度大于给出的值(第二个参数),则截断它并在其后加上 …。返回被截断的字符串。
function truncateString(str, num) {
if(str.length > num){
return str.slice(0,num) + "...";
}
return str;
}
truncateString("A-tisket a-tasket A green and yellow basket", 8);
truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)// "A-tisket a-tasket A green and yellow basket"。
增加条件:
插入到字符串尾部的三个点号也计入字符串的长度。
如果指定的参数num小于或等于3,则添加的三个点号不会计入字符串的长度。
function truncateString(str, num) {
if(num <= 3){
return str.slice(0, num) + "...";
}else if(num >= str.length) {
return str;
}else {
return str.slice(0, num - 3) + "...";
}
}
参考方法一:
function truncateString(str, num) {
if (str.length > num && num > 3) {
return str.slice(0, (num - 3)) + '...';
} else if (str.length > num && num <= 3) {
return str.slice(0, num) + '...';
} else {
return str;
}
}
参考方法二:
function truncateString(str, num) {
if (str.length <= num) {
return str;
} else {
return str.slice(0, num > 3 ? num - 3 : num) + '...';
}
}
请写一个函数来检查一个数组(第一个参数)中的元素,并返回数组中第一个通过校验测试(第二个参数,一个接受一个参数并返回一个布尔值的函数)的元素。如果没有元素通过测试,则返回 undefined。
function findElement(arr, func) {
let num = 0;
for(let i = 0; i < arr.length; i++) {
num = arr[i];
if(func(num)) {
return num;
}
}
return undefined;
}
findElement([1, 2, 3, 4], num => num % 2 === 0); //2
findElement([1, 3, 5, 9], num => num % 2 === 0); //undefined
检查一个值是否是原始的布尔值(boolean)类型。返回 true 或者 false。
布尔值原始类型为 true 或者 false。
function booWho(bool) {
return typeof bool === 'boolean';
}
booWho(null); //false
booWho(true); // true
将给出的字符串中所有单词的第一个字母变成大写,并返回得到的字符串。请确保其余的字母是小写的。
出于练习的目的,“ the ”“ of ”等虚词的首字母也要大写。
function titleCase(str) {
let arr = str.toLowerCase().split(" ").map((item) => item.slice(0,1).toUpperCase() + item.slice(1));
return arr.join(" ");
}
titleCase("I'm a little tea pot"); //I'm A Little Tea Pot
titleCase("sHoRt AnD sToUt"); // Short And Stout
参考方法一
String.prototype.replaceAt = function(index, character) {
return this.substr(0, index) + character + this.substr(index+character.length);
};
function titleCase(str) {
var newTitle = str.split(' ');
var updatedTitle = [];
for (var st in newTitle) {
updatedTitle[st] = newTitle[st].toLowerCase().replaceAt(0, newTitle[st].charAt(0).toUpperCase());
}
return updatedTitle.join(' ');
}
参考方法二
function titleCase(str) {
var convertToArray = str.toLowerCase().split(" ");
var result = convertToArray.map(function(val){
return val.replace(val.charAt(0), val.charAt(0).toUpperCase());
});
return result.join(" ");
}
titleCase("I'm a little tea pot");
参考方法三
function titleCase(str) {
return str.toLowerCase().replace(/(^|\s)\S/g, (L) => L.toUpperCase());
}
利用数组的 slice和 splice方法,将第一个数组中的所有元素依次复制到第二个数组中。
请从第二个数组中索引值为 n的地方开始插入。返回插入元素后的数组。输入的两个数组在函数执行前后要保持不变。
function frankenSplice(arr1, arr2, n) {
let arr = arr2.slice();
for (let i=0;i<arr1.length; i++) {
arr.splice(n+i,0,arr1[i]);
}
return arr;
}
frankenSplice([1, 2, 3], [4, 5, 6], 1);
从一个数组中移除所有假值(falsy values)。
JavaScript 中的假值有 false、null、0、""、undefined和 NaN。
提示:请尝试将每一个值转换为一个布尔值(boolean)。
function bouncer(arr) {
return arr.filter(Boolean);
}
bouncer([7, "ate", "", false, 9]);
返回数组(第一个参数)被排序后,将一个值(第二个参数)插入到该数组中而使数组保持有序的最小的索引。返回的值应该是一个数字。
例如,getIndexToIns([1,2,3,4], 1.5)应该返回 1因为 1.5 大于 1(索引为 0),但小于 2(索引为 1)。
同样地,getIndexToIns([20,3,5], 19)应该返回 2因为数组被排序后会变成 [3,5,20],而 19小于 20(索引为 2)且大于 5(索引为 1)。
function getIndexToIns(arr, num) {
arr.push(num);
arr.sort((a,b) => a-b);
return arr.indexOf(num);
}
getIndexToIns([40, 60], 50); //1
getIndexToIns([3, 10, 5], 3); //0
其他参考方法1
function getIndexToIns(arr, num) {
arr.sort(function(a, b) {
return a - b;
});
for (var a = 0; a < arr.length; a++) {
if (arr[a] >= num)
return a;
}
return arr.length;
}
其他参考方法2
function getIndexToIns(arr, num) {
var times = arr.length;
var count = 0;
for (var i = 0; i < times; i++){
if(num > arr[i]){ count++; } }
return count;
}
getIndexToIns([40, 60], 50);
其他参考方法3
function getIndexToIns(arr, num) {
arr.sort(function(a, b) {
return a - b;
});
var i = 0;
while (num > arr[i]) {
i++;
}
return i;
}
getIndexToIns([40, 60], 50);
其他参考方法4
function getIndexToIns(arr, num) {
var index = arr.sort((curr, next) => curr > next)
.findIndex((currNum)=> num <= currNum);
return index === -1 ? arr.length : index;
}
getIndexToIns([40, 60], 500);
其他参考方法5
function getIndexToIns(arr, num) {
return arr.concat(num).sort((a,b) => a-b).indexOf(num);
}
getIndexToIns([1,3,4],2);
输入参数是一个有两个字符串元素的数组。如果第一个字符串中包含了第二个字符串中的所有字母,则返回 true。
例如,[“hello”, “Hello”]应该返回 true 因为第一个字符串中包含了第二个字符串中出现的所有字母(忽略大小写)。
而 [“hello”, “hey”]应该返回 false 因为第一个字符串 “hello” 没有包含字母 “y”。
最后,[“Alien”, “line”], 应该返回 true,因为 “line” 中的所有字母都被包含在 “Alien” 中。
function mutation(arr) {
var arr0 = arr[0].toLowerCase();
var arr1 = arr[1].toLowerCase().split("");
for(var i = 0; i < arr1.length; i++) {
if(arr0.indexOf(arr1[i]) < 0) {
return false;
}
}
return true;
}
mutation(["hello", "hey"]); //false
其他方法
function mutation(arr) {
return arr[1].toLowerCase()
.split('')
.every(function(letter) {
return arr[0].toLowerCase()
.indexOf(letter) != -1;
});
}
将一个数组(第一个参数)分割成一组长度为 size(第二个参数)的数组,然后在一个二维数组中返回这些结果。
function chunkArrayInGroups(arr, size) {
var newArray = [];
var num = Math.ceil(arr.length/size);
for(var i = 0; i < num; i++) {
newArray.push(arr.slice(i * size, (i + 1) * size));
}
return newArray;
}
chunkArrayInGroups(["a", "b", "c", "d"], 2); //[["a", "b"], ["c", "d"]]
chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3); //[[0, 1, 2], [3, 4, 5], [6]]。
参考方法一
function chunkArrayInGroups(arr, size) {
var temp = [];
var result = [];
for (var a = 0; a < arr.length; a++) {
if (a % size !== size - 1)
temp.push(arr[a]);
else {
temp.push(arr[a]);
result.push(temp);
temp = [];
}
}
if (temp.length !== 0)
result.push(temp);
return result;
}
参考方法二
function chunkArrayInGroups(arr, size) {
var arr2 = [];
for (var i = 0; i < arr.length; i+=size) {
arr2.push(arr.slice(i , i+size));
}
return arr2;
}
参考方法三
function chunkArrayInGroups(arr, size) {
var newArr = [];
var i = 0;
while (i < arr.length) {
newArr.push(arr.slice(i, i+size));
i += size;
}
return newArr;
}
chunkArrayInGroups(["a", "b", "c", "d"], 2);
参考方法四
function chunkArrayInGroups(arr, size) {
var newArr = [];
while (arr.length) {
newArr.push(arr.splice(0,size));
}
return newArr;
}
参考方法五
function chunkArrayInGroups(arr, size) {
if (arr.length <= size){
return [arr];
}
else {
return [arr.slice(0,size)].concat(chunkArrayInGroups(arr.slice(size),size));
}
}