JavaScript —— JSchallenger Basics 基础练习（测试一下你的 JS 基础）【专题一】

一、JavaScript 基础

1. 将两个数字相加：

myFunction(1,2) —> 预期的 3

  function myFunction(a, b){
    return a + b
  }

2. 比较运算符，严格相等：

myFunction(2, 3) —> 预期的 false

myFunction(3, 3) —> 预期的 true

  function myFunction(a, b){
    return a === b
  }

3. 获取值类型：

myFunction(1) —>预期的 ‘number’

myFunction(false) —>预期的 ‘boolean’

myFunction({}) —> 预期的 ‘object’。

  function myFunction(a){
    return typeof a
  }

4. 获取字符串的第 n 个字符：

myFunction(‘abcd’,1) —> 预期的 ‘a’

myFunction(‘zyxbwpl’,5) —> 预期的 ‘w’

  function myFunction (a, n) {
        return a[n-1]
    }

5. 删除字符串的前 n 个字符：

myFunction(‘abcdefg’) —> 预期的 ‘defg’

myFunction(‘1234’) —> 预期的 ‘4’

myFunction(‘fgedcba’) —> 预期的 ‘dcba’

方法一：slice()

  function myFunction (a) {
        return a.slice(3)
    }

方法二：substring()

  function myFunction (a) {
        return a.substring(3)
    }

扩展：

slice提取字符串的一部分并在不修改原始字符串的情况下返回它。要定义要提取的部分，可以使用两个参数调用它。第一个参数定义要提取的字符串中第一个字符的索引。第二个参数定义您不想提取的第一个字符的索引。

console.log(‘abcd’.slice(1,3)) // bc

第二个参数是可选的。如果未定义，slice将仅返回从您定义的 start-index 开始的所有字符。

console.log(‘abcd’.slice(1)) // bcd

6. 获取字符串的最后 n 个字符：

myFunction(‘abcdefg’) —> 预期的 ‘efg’

myFunction(‘1234’) —> 预期的 ‘234’

  function myFunction (a) {
        return a.slice(-3)
    }

扩展：slice 使用负的 startIndex 调用。在这种情况下，startIndex不是索引，而是通过从字符串末尾向后计数来标识起始位置。

7. 获取字符串的前 n 个字符：

myFunction(‘abcdefg’) —> 预期的 ‘abc’

myFunction(‘1234’) —> 预期的 ‘123’

myFunction(‘fgedcba’) —> 预期的 ‘fge’

  function myFunction (a) {
        return a.slice(0, 3)
    }

8. 提取字符串的前半部分：

myFunction(‘1234’) —>预期的 ‘12’

myFunction(‘gedcba’) —> 预期的 ‘ged’

  function myFunction (a) {
        return a.slice(0, a.length/2)
    }

9. 删除字符串的最后 n 个字符：

myFunction(‘abcdefg’) —> 预期的 ‘abcd’

myFunction(‘1234’) —> 预期的 ‘1’

myFunction(‘fgedcba’) —> 预期的 ‘fged’

  function myFunction (a) {
        return a.slice(0, -3) // a.slice(0, a.length-3)
    }

10. 返回数字的百分比：

myFunction(100,50) —> 预期的 50

myFunction(10,1) —> 预期的 0.1

myFunction(500,25) —> 预期的 125

  function myFunction(a, b){
    return a * b * 0.01
  }

11. 基本的 JavaScript 数学运算符：

编写一个以6个值（a、b、c、d、e、f）为参数的函数

a和b之和

然后减去c

然后乘以d，除以e

最后提升到f的幂并返回结果

myFunction(6,5,4,3,2,1) —> 预期的 10.5

myFunction(6,2,1,4,2,3) —> 预期的 2744

  function myFunction(a, b, c, d, e, f){
    return (((a+b)-c)*d/e)**f
  }

12. 检查一个数是否是偶数

myFunction(10) —> 预期的 true

myFunction(-4) —> 预期的 true

myFunction(5) —> 预期的 false

myFunction(-111) —> 预期的 false

  function myFunction(a){
    return a % 2 === 0
  }

13. 一个字符出现多少次：

myFunction(‘m’, ‘how many times’) —> 预期的 2

myFunction(‘h’, ‘how many times’) —> 预期的 1

  function myFunction (a,b) {
        return b.split(a).length - 1
    }

split() 方法用于把一个字符串分割成字符串数组。

14. 检查一个数字是否为整数：

myFunction(4) —> 预期的 true

myFunction(1.123) —> 预期的 false

  function myFunction(a) {
      return a - Math.floor(a) === 0 // a % 1 === 0
  }

15. 比较运算符：

a 比 b 小，返回 a / b
a 比 b 大，返回 a * b 

myFunction(8, 20) —> 预期的 0.4

myFunction(2, 0.5) —> 预期的 1

  function myFunction(a, b) {
    return a < b ? a / b : a * b
  }

16. 检查一个字符串是否包含另一个字符串并连接：

如果 a 包含 b，则将 b 附加到 a 的开头

如果没有，将其附加到末尾

myFunction(‘Java’, ‘Script’) —> 预期的 ‘JavaScript’

myFunction(’ think, therefore I am’, ‘I’) —> 预期的 ‘I think, therefore I am’

方法一：indexOf()

  function myFunction(a, b) {
      return a.indexOf(b) === -1 ? a + b : b + a
  }

在字符串中查找字符串

字符串使用 indexOf() 来定位字符串中某一个指定的字符首次出现的位置

方法二: match()

  function myFunction(a, b) { 
      return a.match(b) ? b + a : a + b
  }

match()函数用来查找字符串中特定的字符，并且如果找到的话，则返回这个字符。

17. 将数字四舍五入到小数点后 2 位：

myFunction(2.12397) —> 预期的 2.12

myFunction(3.136) —> 预期的 3.14

  function myFunction(a, b) {
      return a.toFixed(2)
  }

18. 拆分数字并以数组的方式返回：

myFunction(10) —> 预期的 [1,0]

myFunction(931) —> 预期的 [9,3,1]

方法一：

  function myFunction( a ) {
      const string = a + '';
    const strings = string.split('');
    return strings.map(digit => Number(digit))
  }

方法二：

  function myFunction(a) {
      return a.toString().split("").map(num => parseInt(num))
  }

split() 方法用于把一个字符串分割成字符串数组。

map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

19. 拼接两个字符串（前面的字符串首字母大写）（后面的字符串翻转）

myFunction(‘java’, ‘tpi%rcs’) => 预期的 ‘Javascript’

myFunction(‘c%ountry’, ‘edis’) => 预期的 ‘Countryside’

myFunction(‘down’, ‘nw%ot’) => 预期的 ‘Downtown’

方法一 (菜鸟式写法)：

  function myFunction(a, b) {
     let arr = b.split('') //将 b 从字符串转为数组
     let reverse = arr.reverse() //翻转数组 arr
     let string = reverse.join('') //将翻转的数组从数组转为字符串
     let aUpper = a[0].toUpperCase() + a.slice(1) //将a 的首字母大写再拼接剩余的字母
     let str = aUpper + string //拼接两个改造好的字符串
     let rep = str.replace(/%/g,'') //全局替换 % 为 ''
     return rep
  }

方法二 (大神式写法)：

  function myFunction(a, b) {
    const func = x => x.replace('%','') //定义去除 % 的函数
    const first = func(a) //第一个字符串去符号
    const second = func(b).split('').reverse().join('') //第二个字符串去符号 转为数组 翻转 再转为字符串
    return first.charAt(0).toUpperCase() + first.slice(1) + second //返回改造后的字符串 并使第一个字符串首字母大写
  }

不积跬步无以至千里 不积小流无以成江海