前端笔试中可能会遇到的编程题

最近做了几份笔试题，发现这些题目也比较实在，实际意义比较强一些，可能会在工作中碰到，自己最近也写了写，标记一下

1，将变量命名转换为小驼峰命名，这个题目实际意义还是相对来说比较大的

let str = 'soSj_ss_iiI_'
let str1 = str.split('_')
if (!str1[0]) str1.shift()
if (!str1[str1.length]) str1.pop()
let newstr = ""

str1.forEach((item, index) => {
  let temp1
  index === 0 ? temp1 = item[0].toLowerCase() : temp1 = item[0].toUpperCase();
  let temp2 = item.slice(1, item.length).toLowerCase()
  let temp3 = temp1 + temp2
  newstr = newstr + temp3
})
console.log(newstr);  //sosjSsIii

2，数组去重，自己简单写了4种，这个不用说了，基础必考题

//数组去重


const a = [1, 2, 2, 2, 2, 3, 33, 3, 3, 3, 4, 5, 6, 7, 7, 7, 7]

//方法一
const b = Array.from(new Set(a))
console.log(b)

//方法二
const b = a.filter((item,index)=> {
   return a.indexOf(item) === index
})
console.log(b)

//方法三
let map = {}
a.forEach(item => {
  return map[item]=""
})
const b = Object.keys(map)
console.log(b)

//方法四


for (var i = 0; i < a.length; i++) {
  console.log(i, "外层")
  for (var j = i + 1; j < a.length; j++) {
    if (a[j] === a[i]) {
      a.splice(j, 1)
      console.log(j, "内层")
      j--
      i--
    }
  }
}

     
   //  [ 1, 2, 3, 33,
   //  4, 5, 6,  7 ]      

3，去重升级版，指定条件去重，比如说只针对a-Z的字母去重，这个意义有点，但不大

var str = "rifffdqwe1555"
function norepeat(str) {
  var x = Array.from(str)
  var h = x.every((item, index) => {
    if ((item >= 'a' && item <= 'z') || (item >= 'A' && item <= 'Z'))
      return x.indexOf(item) === index
    else
      return true
  })
  return h
}
console.log(norepeat(str))   //只返回true或者false 代表是否重复

4，将url解析为对象，这个实际意义还是比较大的

const url = "https://liyucc.com/demo?name=liyucc&from=home&job=frontend&extraInfo=%7B%22a%22%3A%22b%22%2C%22c%22%3A%22d%22%7D";
function urlToObj(url){
let obj = {}
let strArry1 = url.split("?")[1]
let strArry2 = strArry1.split("&")
strArry2.forEach((item, index) => {
  let temp = item.split("=")
  temp[1].indexOf("%") === -1 ? obj[temp[0]] = temp[1] : obj[temp[0]] = JSON.parse(decodeURIComponent(temp[1]))
});
return obj
}
console.log(urlToObj(url));


// {
//   name: 'liyucc',
//   from: 'home',
//   job: 'frontend',
//   extraInfo: { a: 'b', c: 'd' }
// }

5，按type将如下结构数据归类到一个对象结构中，并给每个type内的数据，按 value 值大小，正序排序，如上面的数组将输出如下结果：  注意： type值的数量不固定，实现方法请考虑通用性（这些活都要前端干？，后端人呢？）

const origin = [
  { type: 'b', value: "A" },
  { type: 'a', value: "B" },
  { type: 'c', value: "C" },
  { type: 'b', value: "A" },
  { type: 'b', value: "B" },
  { type: 'b', value: "C" },
  { type: 'c', value: "A" },
  { type: 'c', value: "B" },
  { type: 'a', value: "A" },
  { type: 'c', value: "C" },
  { type: 'a', value: "A" },
]

function change(origin) {
  const obj = {}
  const num = origin.map(function (item) {
    return item.type
  })

  const sett = Array.from(new Set(num))
  sett.forEach(function (item1) {
    let temp = origin.filter(function (item2) {
      return item2.type === item1
    })

    obj[item1] = temp.sort(function (a, b) {
      if (a.value > b.value)
        return 1
      if (a.value < b.value)
        return -1
      if (a.value === b.value)
        return 0
    })

  })

  return obj
  
}
const obj1 = change(origin)
console.log(obj1)



// {
//   b: [
//     { type: 'b', value: 'A' },
//     { type: 'b', value: 'A' },
//     { type: 'b', value: 'B' },
//     { type: 'b', value: 'C' }
//   ],
//   a: [
//     { type: 'a', value: 'A' },
//     { type: 'a', value: 'A' },
//     { type: 'a', value: 'B' }
//   ],
//   c: [
//     { type: 'c', value: 'A' },
//     { type: 'c', value: 'B' },
//     { type: 'c', value: 'C' },
//     { type: 'c', value: 'C' }
//   ]
// }