一无所有刷题记♥

2022-8-8
1·要求以字符串的形式返回文件名扩展名，文件名参数为"filename.text"。

const  _getExFilename = (filename) => {
    let lastIndex = filename.lastIndexOf('.')//判断最后一个.出现的索引值
    return filename.slice(0, lastIndex) && lastIndex !== -1 ? filename.slice(lastIndex) : ''
}
1
2
3
4

2·数字使用千分号隔开

 function _comma(number) {
    let str = number.toString();
    return  str.replace(/(\d)(?=(?:\d{3})+$)/g, '$1,');
}
1
2
3
4

3·要求返回一个长度为参数值并且每一项值都为参数值的数组。

      const _createArray = number => {
        return Array(number).fill(number)
  }
1
2
3

4.判断两个系统的版本号，版本相等不用更新，新版本大于旧版本要更新

const _shouldUpdate = (oldVersion, newVersion) => {
        return Number(oldVersion.split('.').join('')) == Number(newVersion.split('.').join(''))
          ? false
          : Number(oldVersion.split('.').join('')) < Number(newVersion.split('.').join(''))
          ? true
          : false
  }
1
2
3
4
5
6
7

5.根据输入的数字范围[start,end]和随机数个数"n"生成随机数, 生成的随机数存储到数组中，返回该数组, 返回的数组不能有相同元素

  const _getUniqueNums = (start, end, n) => {
        let newArray = []
        for (var i = 0; i < n; i++) {
          let temp = Math.floor(Math.random() * (start - end)) + end
            //判断数组是否含有某一个元素，含有返回他的索引值，不含有返回-1
          if (newArray.indexOf(temp) === -1) {
            newArray.push(temp)
          }
        }
        return newArray
   }
1
2
3
4
5
6
7
8
9
10
11

6.有一个数组对象请进行升序或者降序排序

  var cups = [
        { type: 1, price: 100, color: 'black', sales: 3000, name: '牛客logo马克杯' },
        { type: 2, price: 40, color: 'blue', sales: 1000, name: '无盖星空杯' },
        { type: 4, price: 60, color: 'green', sales: 200, name: '老式茶杯' },
        { type: 3, price: 50, color: 'green', sales: 600, name: '欧式印花杯' },
  ]
   let dowmArray = cups.sort(function (a, b) {
        return a.sales - b.sales
      })
   console.log(dowmArray)

   let upArray = cups.sort(function (a, b) {
        return b.sales - a.sales
      })
   console.log(upArray)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

7.在不改变原数组的情况下返回删除了索引位置项的新数组(数组方法中不改变原数组的)

const _delete = (array,index) => {
    let newarray = array.concat()//将原有的数组拷贝一份出来
    newarray.splice(index,1)
    return newarray
}
1
2
3
4
5

根据已有的person对象的注册时间求出距离当前时间的天数（天数向下取整）。
将获得的天数和person数据拼接成字符串，作为h2标签的内容。
注意：使用模板字符串进行字符串拼接

var person = {
    level: '2',
    name: '小丽',
    registTime: '2021-11-01',
  }
  let timechuo = Date.parse(new Date(person.registTime))//将时间转换为时间戳
  let now = new Date()//获取当前时间戳
  var rangeDateNum = (now.getTime() - timechuo) / (1000 * 3600 * 24)
  let htmltext = `尊贵的客网${person.level}级用户${person.name}您好，您已经注册客网${parseInt(
    rangeDateNum
  )}天啦`
1
2
3
4
5
6
7
8
9
10
11

"Chinese"类继承于"Human"类
"Human"类实现一个函数"getName"，返回该实例的"name"属性
"Chinese"类构造函数有两个参数，分别为"name"、"age"
"Chinese"类实现一个函数"getAge"，返回该实例的"age"属性   
1
2
3
4

   class Human {
        constructor(name) {
          this.name = name
          this.kingdom = 'animal'
          this.color = ['yellow', 'white', 'brown', 'black']
        }
        getName() {
          return this.name
        }
      }
      class Chinese extends Human {
        constructor(name, age) {
          super(name)
          this.age = age
        }
        getAge() {
          return this.age //
        }
      }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

10.要求将字符串参数URL中的参数解析并以对象的形式返回。

  const geturl=(url)=>{
          let keyvalue = url.split('?')[1].split('&')
          let obj = {}
          keyvalue.forEach(v => {
            let [key, value] = v.split('=') //解构赋值
            obj[key] = value
          })
         return obj
    }
    geturl(https://nowcoder.com/online?id=1&salas=1000)
1
2
3
4
5
6
7
8
9
10

11.要求将数组参数中的对象以总成绩(包括属性"chinese"、“math”、“english”)从高到低进行排序并返回

 const _array = (array) => {
       array.forEach(v => {
        v['allSource'] = v.chinese + v.math + v.english
      })
      array.sort(function(a, b) {
        return b.allSource - a.allSource
      })
    }
1
2
3
4
5
6
7
8

13· 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1]

    var twoSum = function (nums, target) {
      n = nums.length
      for (i = 0; i < n; ++i) {
        for (j = i + 1; j < n; ++j) {
          if (nums[i] + nums[j] == target) {
            return [i, j]
          }
        }
      }
      return
  }
1
2
3
4
5
6
7
8
9
10
11

14.给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false ,回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

var isPalindrome = function (nums) {
  var array = String(nums).split('')
  let temparray = array
  var arrayRever = temparray.reverse()
  if (String(nums).split('').join('') == arrayRever.join('')) {
    return true
  } else {
    return false
  }
}
1
2
3
4
5
6
7
8
9
10

16.编写一个函数来查找字符串数组中的最长公共前缀。

    var longestCommonPrefix = function(strs) {
      let res = ''
      for (let i = 0; i < strs[0].length; i++) {
        for (let j = 1; j < strs.length; j++) {
          if (strs[j][i] !== strs[0][i]) {
            return res
          }
        }
        res += strs[0][i]
        }
        return res
      }

longestCommonPrefix(['flower', 'flow', 'flight'])
1
2
3
4
5
6
7
8
9
10
11
12
13
14

17.给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。有效字符串需满足：
左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。

var isValid = function (s) {
  length = s.length / 2
    for (i = 0; i < length; i++) {
      console.log(s)
      s = s.replace('()', '').replace('{}', '').replace('[]', '')
    }

    return s.length == 0
  }
  s = '{[]}'
1
2
3
4
5
6
7
8
9
10

18. 重复数组（为啥不通过？？？）

  var removeDuplicates = function(nums) {
    let temp = [...new Set(nums)]
    console.log(temp.length, temp)
    return temp.length, temp
  }
  removeDuplicates([1, 1, 2])
1
2
3
4
5
6

19. 合并两个有序列表（为啥不通过？？？）

  var mergeTwoLists = function(list1, list2) {
    console.log(list1, list2)
    let temp = list1.concat(list2)
    temp.sort(function(a, b) {
      return a - b
    })
    console.log(temp)
 mergeTwoLists((l1 = [1, 2, 4]), (l2 = [1, 3, 4]))
1
2
3
4
5
6
7
8

20.字符串:给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。
输入：haystack = “hello”, needle = “ll”
输出：2

var strStr = function (haystack, needle) {
  return haystack.indexOf(needle)
}
1
2
3

21：给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
输入: nums = [1,3,5,6], target = 5
输出: 2

var searchInsert = function (nums, target) {
  var Ofindex = nums.indexOf(target)
  var charuIndex = 0
  if (Ofindex != -1) {
    return Ofindex
  } else {
    nums.forEach((element, i) => {
      if (element < target) {
        charuIndex = i + 1
      }
    })
    // 返回的是插入元素以后的数组
    // nums.splice(charuIndex, 0, target) 
    // return nums

    //返回的是插入元素的索引值
    return charuIndex
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

强制解析：splice(index,number,target),
参数一表示添加或者删除元素的索引值，
参数二表示添加或者删除元素的个数，
参数三表示添加或者删除的元素