前端笔试题简单积累——入门

查找两个节点的最近的一个共同父节点，可以包括节点自身

输入描述：

oNode1 和 oNode2 在同一文档中，且不会为相同的节点

function commonParentNode(oNode1, oNode2) {
  for(;oNode1;oNode1=oNode1.parentNode){
  if(oNode1.contains(oNode2)){
  return oNode1
  }
  }
    
}

心得：

for循环的语法

for(语句1;语句2;语句3){
  被执行代码块
}

其中三个语句都是可以省略的 参考https://www.runoob.com/js/js-loop-for.html

parentNode:返回元素的父节点，如果没有父节点，返回Null

contains:红宝书的描述中是确定一个元素是不是另一个元素的后代，参数是待确定的目标节点。

contains不是字符串方法，是仅用于判断DOM元素的包含关系，参数是Element类型

<script>
        var a = "1234"
        var b = "12"
        alert(a.contains(b));
    </script>

斐波那契数列

输入描述：用 JavaScript 实现斐波那契数列函数,返回第n个斐波那契数。 f(1) = 1, f(2) = 1 等

 function BO(n) {
            if (n == 0) {
                return 0
            } else if (n == 1) {
                return 1
            } else {
                return BO(n - 1) + BO(n - 2)
            }
        }

字符串字符统计

描述

统计字符串中每个字符的出现频率，返回一个 Object，key 为统计字符，value 为出现频率

1. 不限制 key 的顺序

2. 输入的字符串参数不会为空

3. 忽略空白字符

示例1

输入：
'hello world'

输出：
{h: 1, e: 1, l: 3, o: 2, w: 1, r: 1, d: 1}

解1：

function count(str) {
    var obj={}
     str=str.replace(/s/g,'')
     for(let i=0; i<str.length; i++){
     if(obj.hasOwnProperty(str[i])){
     obj[str[i]]++
     }
     else  obj[str[i]]=1
 }
}

解2:

function count(str){
  var str1={}
  str=str.replace(/s/g,'')
  str=str.split('')
  str1=str.reduce((prve,cur)=>{
   prve[cur]?prve[cur]++:prve[cur]=1;
   return prve
  },{})
  console.log(str1)
}
count('sda dasdsa dasdas d')

心得：

1、replace: 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。

​ 2、这里用于去除空字符串用到了正则表达式： /s/g

​ 3、hasOwnProperty: 方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）

​ 4、split： 方法用于把一个字符串分割成字符串数组。

​ 5、reduce的语法

arr.reduce(function(prev,cur,index,arr){
...
}, init);

arr 表示原数组；
prev 表示上一次调用回调时的返回值，或者初始值 init;
cur 表示当前正在处理的数组元素；
index 表示当前正在处理的数组元素的索引，若提供 init 值，则索引为0，否则索引为1；
init 表示初始值。

reduce有很多种用法，累加、字符串统计等等，后续用到会补充。

数组求和

描述：

计算给定数组 arr 中所有元素的总和

输入描述：

数组中的元素均为 Number 类型

输入：
[ 1, 2, 3, 4 ]
复制
输出：
10

解:

function sum(arr) {
  var arr1=0
  arr1=arr.reduce((prev,cur)=>{
   return prev+cur
  },0)
  console.log(arr1)
}
sum([1,2,3,4])

还有其他方法，不举出列子

删除数组最后一个元素

描述：

删除数组 arr 最后一个元素。不要直接修改数组 arr，结果返回新的数组

输入：
[1, 2, 3, 4]
复制
输出：
[1, 2, 3]

function truncate(arr) {
   var arr1=[]
   arr1=arr.slice(0,arr.length-1)
   return arr1
}

心得：

slice： 我的理解是选择原数组的一些值，不会改变原数组，会创建新数组。

添加元素

描述：

在数组 arr 开头添加元素 item。不要直接修改数组 arr，结果返回新的数组

输入：
[1, 2, 3, 4], 10
复制
输出：
[10, 1, 2, 3, 4]

解1

function prepend(arr, item) {
   var arr1=arr.slice(0)
   arr1.unshift(item)
   return arr1
}

解2

function prepend(arr, item) {
  return [item,...arr]
}

删除数组第一个元素

描述

删除数组 arr 第一个元素。不要直接修改数组 arr，结果返回新的数组

输入：
[1, 2, 3, 4]
输出：
[2, 3, 4]

function curtail(arr) {
  var arr1=arr.slice(0)
  arr1.shift(0)
  return arr1
}

求二次方

描述:

为数组 arr 中的每个元素求二次方。不要直接修改数组 arr，结果返回新的数组

输入：
[1, 2, 3, 4]
输出：
[1, 4, 9, 16]

解1：

function square(arr) {
  var arr1=[]
  arr.forEach((a)=>{
   arr1.push(a*a)
  })
  return arr1
}

解2

function square(arr) {
   var arr1=[]
   arr1=arr.reduce((prev,cur)=>{
    prev.push(cur*cur)
    return prev
   },[])
   return arr1
}

查找元素位置

描述：

在数组 arr 中，查找值与 item 相等的元素出现的所有位置

输入：
['a','b','c','d','e','f','a','b','c'] 'a'

输出：
[0, 6]

解

function findAllOccurrences(arr, target) {
  var arr1=[]
  arr.forEach((item,index)=>{
     if(item==target){
      arr1.push(index)
       }
  })
  return arr1
}

二次封装函数

描述:

已知函数 fn 执行需要 3 个参数。请实现函数 partial，调用之后满足如下条件：
1、返回一个函数 result，该函数接受一个参数
2、执行 result(str3) ，返回的结果与 fn(str1, str2, str3) 一致

输入：
var sayIt = function(greeting, name, punctuation) {     return greeting + ', ' + name + (punctuation || '!'); };  partial(sayIt, 'Hello', 'Ellie')('!!!');
输出：
Hello, Ellie!!!

解

function partial(fn, str1, str2) {
   var f=function(str3){
   return fn(str1,str2,str3)
   }
   return f
}

使用 arguments

描述:

函数 useArguments 可以接收 1 个及以上的参数。请实现函数 useArguments，返回所有调用参数相加后的结果。本题的测试参数全部为 Number 类型，不需考虑参数转换。

输入：
1, 2, 3, 4
输出：
10

解1

function useArguments() {
 var a=Array.from(arguments)
 var sum=a.reduce((prev,cur)=>{
  return prev+cur
 },0)
 return sum
}

解2

function useArguments() {
    var sum=0
  for(let i=0; i<arguments.length; i++){
      sum=sum+arguments[i]
  }
    return sum
}

心得

arguments: 是一个对应于传递给函数的参数的类数组对象。

简单理解就是传递函数的参数都成为了类数组，类数组也可以使用for循环

这道题可以用Array.from把类数组转换为数组，也可以直接使用for循环

判断是否包含数字

描述：

给定字符串 str，检查其是否包含数字，包含返回 true，否则返回 false

输入：
'abc123'

输出：
true

function containsNumber(str) {
  var a=/d/g
  return a.test(str)
}

心得

1、/d/g: 可以匹配字符串中的数字字符

2、test ：可以检测是否包含

判断是否以元音字母结尾

描述：

给定字符串 str，检查其是否以元音字母结尾
1、元音字母包括 a，e，i，o，u，以及对应的大写
2、包含返回 true，否则返回 false

输入：
'gorilla'
输出：
true

function endsWithVowel(str) {
   var a=['a','e','i','o','u','A','E','I','O','U']
   return a.includes(str.slice(-1))
}

简单

查找数组元素位置

描述：

找出元素 item 在给定数组 arr 中的位置

输出描述：

如果数组中存在 item，则返回元素在数组中的位置，否则返回 -1

输入：
[ 1, 2, 3, 4 ], 3

输出：
2

function indexOf(arr, item) {
   return arr.indexOf(item)
}

二次封装函数

描述：

实现函数 partialUsingArguments，调用之后满足如下条件：
1、返回一个函数 result
2、调用 result 之后，返回的结果与调用函数 fn 的结果一致
3、fn 的调用参数为 partialUsingArguments 的第一个参数之后的全部参数以及 result 的调用参数

function partialUsingArguments(fn) {
  var a=Array.prototype.slice.call(arguments,1)
  var b=function(){
   var c=Array.prototype.slice.call(arguments)
   return fn.apply(this,a.concat(c))
}
return b
}

心得：

1、通过slice截取加上call的改变拿到其原函数的参数

2、同样的道理拿到第二个函数的参数

3、通过apply、concat进行整合

二进制转换

描述：

获取数字 num 二进制形式第 bit 位的值。注意：
1、bit 从 1 开始
2、返回 0 或 1
3、举例：2 的二进制为 10，第 1 位为 0，第 2 位为 1

输入：
128, 8
输出：
1

function valueAtBit(num, bit) {
     var a=num.toString(2)
     return a[a.length-bit]
}

心得:

1、js中十进制转二进制： 数.toString(2)

检查重复字符串

描述：

给定字符串 str，检查其是否包含连续重复的字母（a-zA-Z），包含返回 true，否则返回 false

示例：

输入：

'rattler'

输出：

true

function containsRepeatingLetter(str) {
    return /([a-zA-Z])1/.test(str)
}

查找重复元素

描述:

找出数组 arr 中重复出现过的元素（不用考虑返回顺序）

输入：
[1, 2, 4, 4, 3, 3, 1, 5, 3]
输出：
[1, 3, 4]

function duplicates(arr) {
  var b=[]
  arr.forEach((value)=>{
   if(arr.indexOf(value)!==arr.lastIndexOf(value)&&b.indexOf(value)==-1){
    b.push(value)
}
})
return b
}