1、js 正则表达式题

var s1 = "get-element-by-id"; 给定这样一个连字符串，写一个function转换为驼峰命名法形式的字符串: "getElementById"

用正则api把 -e -b -i 分别转换成大写就可以了。

var f = function (s) {
        return s.replace(/-\w/g, function (x) { return x.slice(1).toUpperCase(); });
    }

2、 回文

回文是一个单词或短语，它的读法是前后一致的（如“Cigar? Toss it in a can. It is so tragic”）。写一个函数来检查。
var string = 'Cigar? Toss it in a can. It is so tragic';

方法一：

var funcA = (str) => {
    var regExp = /[a-zA-Z]/g; //创建一个正则表达式，过滤非字母的字符
    // String.prototype.match()一次性返回所有匹配成功的结果 
    var arr = str.match(regExp);
   //reverse方法用于颠倒排列数组元素，返回改变后的数组。注意，该方法将改变原数组。
  //join()方法以指定参数作为分隔符，将所有数组成员连接为一个字符串返回。如果不提供参数，默认用逗号分隔。
    return arr.reverse().join('').toLowerCase() === arr.join('').toLowerCase()
}

if (funcA(string)) {
    console.log('这是回文!')
};

方法二：

const isPalindrome = string => {
//split方法按照给定规则分割字符串，返回一个由分割出来的子字符串组成的数组。
    const validCharacters = "abcdefghijklmnopqrstuvwxyz".split("")
//toLowerCase方法用于将一个字符串全部转为小写，toUpperCase则是全部转为大写。它们都返回一个新字符串，不改变原字符串。
//reduce方法和reduceRight方法依次处理数组的每个成员，最终累计为一个值。它们的差别是，reduce是从左到右处理（从第一个成员到最后一个成员），reduceRight则是从右到左（从最后一个成员到第一个成员），其他完全一样。reduce方法第一个参数都是一个函数，第二个参数为累积变量指定初值。
    const stringCharacters = string // 过滤掉特殊符号
        .toLowerCase()
        .split("")
        .reduce(
            (characters, character) =>
                validCharacters.indexOf(character) > -1
                    ? characters.concat(character)
                    : characters,
            []
        ); //[]为reduce第二个参数，即characters的初始值。
    return stringCharacters.join("") === stringCharacters.reverse().join("")
}

if (isPalindrome(string)) {
    console.log('这是回文2!')
};

3、 整数反转

给定一个整数，反转数字的顺序。
比如：

assert.equal(reverse(1234), 4321);
assert.equal(reverse(-1200), -21);

const revserInteger = integer => parseInt(number
      .toString()
      .split('')
      .reverse()
      .join('')) * Math.sign(integer)
//Math.sign(integer)获取数值符号

4. 出现次数最多的字符

给定一个字符串，返回出现次数最多的字符

var string = 'Hello World!';

var func = (string) => {
    var arr = string.split('');
    var maxTime = 1;
    var characterL = '';
    var obj = {};
    arr.forEach((ele, index) => {
        if (obj[ele]) {
            // 如果之前出现过，次数+1
            obj[ele] += 1;
            if (obj[ele] > maxTime) {
                maxTime = obj[ele];
                characterL = ele;
            }
        } else {
            // 每个字符出现次数为1
            obj[ele] = 1;
        }
    });
    return characterL;
}

5、数组分隔

给定数组和大小，将数组项拆分为具有给定大小的数组列表。

chunk([1, 2, 3, 4], 2), [[1, 2], [3, 4]]);
chunk([1, 2, 3, 4], 3), [[1, 2, 3], [4]]);
chunk([1, 2, 3, 4], 5), [[1, 2, 3, 4]]);

var array = [1,2,3,4];
var size = 3;

var func = (arr, size) => {
    var chunks = [];
    var index = 0;
    if (size >= arr.length) return chunks.push(arr);
    while (index < arr.length) {
        chunks.push(arr.slice(index, index + size));
        index += size;
    }
    return chunks;
}
console.log('chunks=', func(array, size));
// [[1, 2, 3], [4]]

本题主要考察slice方法，slice方法用于提取目标数组的一部分，返回一个新数组，原数组不变。arr.slice(start, end);end参数可以大于数组长度，如下：

var a = ['a', 'b', 'c'];
var aaa = a.slice(1,4);
console.log('aaa', aaa); // ["b","c"]

6、words反转

给定一个短语，按照顺序反转每一个单词。

assert.equal(reverseWords("I love JavaScript!"), "I evol !tpircSavaJ");

var string = 'I love JavaScript!';
var func = string => {
    var reverseWorlds = string.split(' ').map(ele => {
        return ele.split('').reverse().join('');
    }).join(' ');
    console.log('reverseWorlds', string, reverseWorlds);
}
func(string);

map方法将数组的所有成员依次传入参数函数，然后把每一次的执行结果组成一个新数组返回。

7、首字母大写

给定一个短语，每个首字母变为大写。
assert.equal(capitalize("hello world"), "Hello World");

var str = 'hello world';
var upperStr = str.split(' ').map(ele => {
    var words = ele.split('');
    return words.join('').replace(words[0], words[0].toUpperCase())
}).join(' ');
console.log('upp', upperStr);

String.prototype.replace() 方法用于替换匹配的子字符串，一般情况下只替换第一个匹配（除非使用带有g修饰符的正则表达式,如'aaa'.replace(/a/g, 'b') // "bbb"）。

9、凯撒密码

给定一个短语，通过在字母表中上下移动一个给定的整数来替换每个字符。如果有必要，这种转换应该回到字母表的开头或结尾。

assert.equal(caesarCipher("I love JavaScript!", 100), "E hkra FwrwOynelp!")
assert.equal(caesarCipher("I love JavaScript!", -100), "M pszi NezeWgvmtx!");

var string = 'I love JavaScript!';

var func = (string, size) => {
    var zm = "abcdefghijklmnopqrstuvwxyz";
    var zmArr = zm.split('');
    var upperZm = zm.toUpperCase();
    var upperZmArr = upperZm.split('');
    var recordIndex = size % 26;
    if (recordIndex === 0) return string;
    if (recordIndex < 0) {
        zmArr = zm.split('').reverse();
        upperZmArr = upperZm.split('').reverse();
        recordIndex = Math.abs(recordIndex);
    }
    console.log('recordIndex=', recordIndex);
    return string.split('').map(ele => {
        if (zm.match(ele) !== null) {
            var index = recordIndex - (26 - zmArr.indexOf(ele));
            return zmArr[index];
        } else if (upperZm.match(ele) !== null) {
            var index = recordIndex - (26 - upperZmArr.indexOf(ele));
            return upperZmArr[index];
        }
        return ele;
    }).join('');
}