1.
下面哪几个和
[http://store.company.com/dir/page.html]
符合同源策略？
( )
A. http://store.company.com/dir2/other.htm
B. https://store.company.com/dir/secure.html
C. http://store.company.com:81/dir/etc.html
D. http://news.company.com/dir/other.html
答案：A
同源表明，同协议，同域名，同端口号
端口号：http默认为80/8080/3128/8081/9080,https默认443
2.
关于DOMContentLoaded和load事件说法正确的是？
A. DOMContentLoaded事件比load事件更早执行
B. load事件比DOMContentLoaded事件更早执行
C. 按监听代码从上到下先后执行
D. dom文档完全加载完后执行load事件
答案：A
在任何情况下，DOMContentLoaded的触发不需要等待图片等其他资源加载完成。当HTML部分被完全加载以及解析时，DOMContentLoaded事件会被触发，而不必等待样式表，图片或者子框架完成加载。
页面上所有资源（图片，音频，视频等）被加载以后才会触发load时间。
3.
如何在 div 容器里展示
这几个字符？
A.
B.
”
C. document.querySelector(‘div’).innerText = “
”
D. document.querySelector(‘div’).innerHTML = “
”
答案：C
innerHTML:设置或获取标签所包含的HTML与文本信息。（不含标签本身）；
innerText:设置或获取标签所包含的文本信息。（不含标签本身）
outerHTML:设置或获取标签本身以及所包含的HTML与文本信息。（包含标签本身）
outText:设置或获取标签本身以及所包含的文本信息。（包含标签本身）
4.
以下是哪一组全是块级元素？
A. div i h2 li
B. div p h1 ul
C. li ul h3 span
D. p h4 canvas em
答案: B
5.
<div class="box box1 box2" style="color:#222">hello</div>
,
这个div里面最终的字体颜色是什么？
.box{
color:#999;
}
.box{
color:#333 !important;
}
.box2{
color:#666
}
A. #999
B. #222
C. #333
D. #666
6.
以下不是box-sizing的属性是？
A. border-box
B. auto
C. content-box
D. inherit
答案: B
7.
以下不是CSS伪类选择器的是？
A. :first-child()
B. :before
C. :center
D. :after
正确答案: C
8.
‘-1 >>> 32 的值为( )’
A. -1
B. 1
C. 0
D. 2^32-1
正确答案: D
这个是带符号右移
这个是无符号右移
无符号右移运算符（>>>）
按二进制形式把所有的数字向右移动对应位数，低位移出(舍弃)，高位的空位补零。对于正数来说和带符号右移（>>） 相同，但是对于负数来说不同。
正数
例：20 >> 2
1、首先转化为二进制，20的二进制为0001 0100
2、将二进制数向右移两位，高位补符号位（0），得到0000 0101
3、最后将二进制数转化成十进制数，0000 0101转化为十进制为5
所以，20 >> 2 = 5
负数
例：-20 >> 2
1、首先转化为二进制，20的二进制为1110 1100 //取反加1 20的二进制为0001 0100 取反得到1110 1011 加1后得到1110 1100
2、将二进制数向右移两位，高位补符号位（1），得到1111 1011
3、最后将二进制数转化成十进制数，1111 1011转化为十进制为-5 //取反 0000 0100 加1 0000 0101 因为是负数，也就是1000 0101也就是2的2次方加2的零次方 等于-5
所以，-20 >> 2 = -5
9.
[1 < 2 < 3, 3 < 2 < 1] ( )
A. [true, true]
B. [true, false]
C. [false, true]
D. [false, false]
正确答案: A
[1 < 2 < 3, 3 < 2 < 1]
1<2 => true
true < 3 => true // true自动转换为1
3<2 => false
false < 1 => true //false 自动转换为0
answer: [true, true]
10.
[‘1’, ‘2’, ‘3’].map(parseInt) ( )
A. [1, 2, 3]
B. [0, 1, 2]
C. [NaN, NaN, NaN]
D. [1, NaN, NaN]
正确答案: D
[‘1’, ‘2’, ‘3’].map((item, index) => {
return parseInt(item, index)
})
parseInt(‘1’, 0) // 1 默认十进制的1
parseInt(‘2’, 1) // NaN 1进制没有2
parseInt(‘3’, 2) // NaN,2进制逢2进1
ps 啥是parseInt
parseInt(‘11’,2) //二进制的11 转换成十进制应该是 3
ppppps
[‘10’,‘10’,‘10’,‘10’,‘10’].map(parseInt); // [10, NaN, 2, 3, 4]
意思是0(默认0是十进制)进制的十转换成十进制是多少 1进制的十转换成十进制是多少 二进制的10转换成十进制是多少
11.
let a = { c:1 }
let b = a
a = 1
b.c = 2
a.c = (?)
A. 1
B. 2
C. undefined
D. NaN
正确答案: C
let a = { c:1 } //a的作用域指向 {c:1} 这个地址
let b = a //b的作用域指向 {c:1} 这个地址
a = 1 // a指向的作用域发生改变，指向1，但是{c:1} 这个地址还存在
b.c = 2 //改变{c:1} 这个地址中c的值为2
a.c = (?) //a指向的地址已经发生改变，没有c这个变量，所以返回undefined
12.
console.log(1);
setTimeout(() => {console.log(2)}, 0);
console.log(3);
Promise.resolve(4).then(b => {
console.log(b);
});
console.log(5);
A. 1 2 3 4 5
B. 1 3 5 4 2
C. 1 4 2 3 5
D. 1 3 5 2 4
正确答案: B
console.log() -> 同步
promise -> 异步，微任务
setTimeout -> 异步，宏任务
执行顺序: 同步 > 异步,微任务 > 异步，宏任务
13.
Math.abs(-6.666) 的结果是多少?
A. -6.666
B. 6
C. -6
D. 6.666
正确答案: D
Math.abs(x) 返回x的绝对值
Math.pow(x, power) 返回x的power次幂
Math.pow(…nums) 返回nums中每个数平方和的平方根
Math.sign(x) 返回表示x符号的1、0、-0或-1
Math.trunc(x) 返回x的整数部分，删除所有小数
Math.sqrt(x) 返回x的平方根
Math.cbrt(x) 返回x的立方根
Math.acos(x) 返回x的反余弦
Math.asin(x) 返回x的反正弦
Math.atan(x) 返回x的反正切
Math.cos(x) 返回x的余弦
Math.sin(x) 返回x的正弦
Math.tan(x) 返回x的正切
1.丢弃小数部分,保留整数部分
js:parseInt(7/2)
2.向上取整,有小数就整数部分加1
js: Math.ceil(7/2)
3,四舍五入.
js: Math.round(7/2)
4,向下取整
js: Math.floor(7/2)
14.
替换字符串 bilibili 替换字符串中所有的b变成大写B
A. ‘bilibili’.delete(‘b’, ‘B’)
B. ‘bilibili’.replace(/b/g, ‘B’)
C. ‘bilibili’.replace(‘b’, ‘B’)
D. ‘bilibili’.toUpperCase()
正确答案: B
replace()第一个参数可以是正则表达式
/b/g的意思是：匹配所有的b字符
字符串 stringObject 的 replace() 方法执行的是查找并替换的操作。它将在 stringObject 中查找与 regexp 相匹配的子字符串，然后用 replacement 来替换这些子串。如果 regexp 具有全局标志 g，那么 replace() 方法将替换所有匹配的子串。否则，它只替换第一个匹配子串。
replacement 可以是字符串，也可以是函数。如果它是字符串，那么每个匹配都将由字符串替换。但是 replacement 中的 $ 字符具有特定的含义。如下表所示，它说明从模式匹配得到的字符串将用于替换。
15.
[1,2,3,4,5] 的数组的基础上 删除第一个 和 最后一位
A. [1,2,3,4,5].replace(1, -1)
B. [1,2,3,4,5].reverse(1，-1)
C. [1,2,3,4,5].toString(-1，1)
D. [1,2,3,4,5].slice(1, -1)
正确答案: D
slice(1,-1) slice不会操作原数组，会返回一个新数组 。 表示从索引为0开始截取，-1表示截取到倒数第二个，并将这个新数组返回。
16.
function setname(name){
this.name = name
}
setname.prototype.printName = function(){ console.log(this.name) }
let a = new setname(“cc”)
a.name = “dd”
a.
proto
.name = “ee”
a.
proto
.printName() // ?
a.printName() // ?
A. ee dd
B. cc dd
C. ee cc
D. ee Error
正确答案: A
首先定义了一个函数 setname（）接下来定义了一个方法printname
调用new 方法生成对象传参 “cc” 此时a对象上面的name属性为cc
接下来通过a.name修改属性 此时a对象的name属性为 dd
最后修改通过a修改构造函数中的属性 –proto–
17.
const players = [ {name: ‘UZI’, team: ‘RNG’, position: ‘ADC’},
{name: ‘theshy’, team: ‘IG’, position: ‘TOP’},
{name: ‘Metoer’, team: ‘BLG’, position: ‘Jungle’},
{name: ‘ADD’, team: ‘BLG’, position: ‘TOP’},
{name: ‘Scout’, team: ‘EDG’, position: ‘Middle’},
{name: ‘iBoy’, team: ‘EDG’, position: ‘ADC’},
{name: ‘Baolan’, team: ‘IG’, position: ‘Support’},
{name: ‘Xiaohu’, team: ‘RNG’, position: ‘Middle’}]
获取列表中战队名是BLG 位置上路的 选手对象？
A. players.filter(x=> x.position === ‘TOP’ && x.team === ‘BLG’)
B. players.get(position=‘TOP’, team=‘BLG’)
C. players.find(position=‘TOP’, team=‘BLG’)
D. players.findOne(position=‘TOP’, team=‘BLG’)
正确答案: A
players.filter(item=>item.position === ‘TOP’ && item.team === ‘BLG’)
[{name: “ADD”, team: “BLG”, position: “TOP”}]
players.find(item=> item.position===‘TOP’ && item.team === ‘BLG’)
{name: “ADD”, team: “BLG”, position: “TOP”}
18.
找出有序数组（从小到大排列）中和为sum的两个数，要求复杂度为O(n)，找到一组即可
答案：
function solve (arr, target) {
let i = 0；
let j = arr.length - 1；
let first, last；
while (i < j) {
first = arr[i]；
last = arr[j]；
const sum = first + last；
if (sum === target) return [first, last]；
else if (sum > target) j--；
else i++；
}
return null；
}
19.**判断由”()[]{}”6种括号组成的字符串是否合法
- 所有括号必须闭合
- 左括号必须在正确的位置闭合**
1.利用 map 实现一一对应
2.利用栈
function IsValue(str) {
let map = new Map([
['(',')'],
['{','}'],
['[',']']
])
let stack = [];
for(let i = 0 ; i < str.length ; i ++) {
if(map.has(str[i])) { // 在左边
stack.push(str[i])
} else { // 在右边
if(stack.length == 0) return false;
let top = stack[stack.length - 1]; // 栈顶元素
if(map.get(top) == str[i]) {
stack.pop()
} else {
return false;
}
}
}
return true;
}
while(line = readline()) {
var str = line;
print(IsValue(str))
}
不利用其他函数，直接判断，简单容易理解
var str = readline();
var n = str.length;
var arr = [];
var j=0;
for(var i=0;i<n;i++){
switch(str[i]){
case '(':
arr[j++] = '(';
break;
case '[':
arr[j++] = '[';
break;
case '{':
arr[j++] = '{';
break;
case ')':
if(arr[j-1]=='('){
j--;
}else{
i=n;//跳出
}
break;
case ']':
if(arr[j-1]=='['){
j--;
}else{
i=n;//跳出
}
break;
case '}':
if(arr[j-1]=='{'){
j--;
}else{
i=n;//跳出
}
break;
}
}
if(j==0){
console.log("true");
}else{
console.log("false");
}
20.
有n级台阶，每一步可以走1级或2级，问一共有多少种走法
使用数组保存变量。比使用递归节省时间。。。
function NumberOf1(number) {
// write code here
var arr = [1, 2]
for (var i = 2; i < number; i++) {
arr[i] = arr[i - 1] + arr[i - 2]
}
return arr[number - 1]
}
就是一道斐波那契数列的经典问题，学习算法基础递归的时候老师都有讲。
while (line = readline()) {
var n = parseInt(line);
var res = fibonacci(n);
print(res);
}
function fibonacci(n) {
// 递归基
if (n <= 1) {
return 1;
}
// 递归计算实例
return fibonacci(n - 1) + fibonacci(n - 2);
}
共n个楼梯，第一次跳1阶，后面还有n-1，有n-1种跳法；第一次跳两个台阶，后面还有n-2，有n-2种跳法。所以递归方式是f(n-1)+f(n-2)
function getStairs(stair) {
if(stair <= 0) {
return0
}
if(stair === 1) {
return1
}
if(stair === 2) {
return2
}
return getStairs(stair - 1) + getStairs(stair - 2)
}
conststair = parseInt(readline())
console.log(getStairs(stair))