这里写目录标题
选择题
-
for…in 循环可以遍历对象自身及其原型链上的可枚举属性
-
obeject.keys()只是遍历自身的可枚举属性,不可以遍历原型链上的可枚举属性,
-
object.assign()对象的拷贝,用于将所有可枚举属性的值从一个或多个源对象复制到目标对象,将他返回到目标对象
-
null == undefined、null === null （true）
-
null === undefined、NaN == null、NaN === NaN、Infinity + 1 !== Infinity（false）
-
X当前域的 cookie 都可以通过 js 在当前域下获取,错误，http-only，对于一些保密性较高的 cookie 后端可以通过设置 HttpOnly 标记 cookie 只能通过 http 传递，前端 js 无法读取，这样可以防范xss攻击。
-
JSONP 不是 XMLHttpRequest 中的一种，JSONP 用的是 html 的 script 标签，xmlhttprequest 是浏览器内置的 HTTP 相关对象，两者不同。
-
localStorage API 不支持设置过期时间
-
css加载不会阻塞DOM树的解析、会阻塞DOM树的渲染、会阻塞后面js语句的执行
-
iframe会阻塞主页面的onload事件；
-
会阻塞dom解析的资源有：
1.内联css
2.内联js
3.普通外联js
4.外联defer js
5.js之前的外联css
简答题
给出的打印的值
Tom
Tom（使用new操作时，构造函数内部的this指向相应的实例化对象；未使用new操作符时，为普通函数调用，全局函数内的this指向window，所以var a = Person就将全局范围内的name改成了Tom）
undefined？（person('Tom)相当于只是执行person函数，没有返回值，输出undefined）
Michael
Person{name：‘Michael’}
let num = 6364643.22
function paddingNum(num){
let flag = num > 0 ? true : false;
let numArr = Math.abs(num).toString().split('.');
let right = numArr[1] ? '.'+numArr[1] : '';
let left = numArr[0];
let temp = '';
while(left.length){
temp = ',' + left.slice(-3) + temp;
left = left.slice(0,left.length - 3);
}
return flag ? left + temp + right:'-'+left+temp+right
}
console.log(paddingNum(num).slice(1));
function duplicates(arr){
let obj = {};
arr.forEach((str) => {
obj[str] = typeof obj[str] === 'undefined' ? false:true
});
return obj
}
js严格模式下
1.严格模式对 JavaScript 的语法和行为，都做了一些改变。
严格模式下，变量必须先声明再使用，严禁删除已经声明变量。
严格模式下，预编译时 this 为 undefined。
严格模式下，不支持arguments、caller、callee、with。
严格模式下，在函数内部对修改参数不会反映到 arguments 中，淘汰了 arguments.callee 和 arguments.caller， 抛弃 with 语句。
严格模式下，不可在 if 内部声明函数
严格模式下，拒绝重复的属性和参数。
严格模式下，局部的this必须被赋值、赋值什么就是什么。
- 严格模式下 this 指向问题
① 以前在全局作用域函数中的 this 指向 window 对象。
② 严格模式下全局作用域中函数中的 this 是 undefined。
③ 以前构造函数不加 new 也可以调用，当普通函数，this 指向全局对象。
④ 严格模式下，如果构造函数不加 new 调用， this 指向的是 undefined ，如果给他赋值则会报错 。
console.log(null == undefined); // true
console.log(typeof NaN); // ‘number’
console.log(typeof Function); // ‘function’
console.log(typeof Object); // ‘function’
console.log(typeof {}); // ‘object’
console.log(‘a’ + 1); // ‘a1’
console.log(‘a’ - 1); // NaN
console.log(Function instanceof Object); // true
console.log(Object instanceof Function); // true
'use strict'
var name = 'Jay'
var person = {
name: 'Wang',
pro: {
name: 'Micheal',
getName: function() {
return this.name
}
}
}
console.log(person.pro.getName());
var people = person.pro.getName
console.log(people);
"use strict"声明以严格模式执行
输出：“Michael”
解释：这里是person.pro调用了getName(),getName()里面的this指向了person.pro,所以这里的this.name == “Michael”
输出：error报错
解释：将person.pro.getName方法赋给了pepole,然后在全局执行上下文中调用了pepole(),因为是在严格模式下执行，所以pepole()里面的this是指向undefined,undefined又获取name属性，最后导致报错
关键词屏蔽 **
这个题比较经典，有一次面试也考来着
用正则处理非常简单，别的方法比较麻烦
function fn(str, arr) {
for (let item of arr) {
let len = item.length;
let ret = new RegExp(`${item}`, 'g')
str = str.replace(ret, '*'.repeat(len));
}
return str;
}
console.log(fn('想要轻生，have sex,sexy,babe', ['轻生', 'sex']))
编程题
1、括号删除，<<<回退
薯队长写了一篇笔记草稿，请你帮忙输出最后内容。
1.输入字符包括，“(” , “)” 和 "<“和其他字符。
2.其他字符表示笔记内容。
3.()之间表示注释内容，任何字符都无效。 括号保证成对出现。
4.”<“表示退格, 删去前面一个笔记内容字符。括号不受”<"影响 。
2、薯队长写了n篇笔记，编号从1~n,每篇笔记都获得了不少点赞数。
薯队长想从中选出一些笔记，作一个精选集合。挑选的时候有两个规则：
1.不能出现连续编号的笔记。
2.总点赞总数最多
如果满足1，2条件有多种方案，挑选笔记总数最少的那种
动态规划，打家劫舍
let len = parseInt(readline());
let arr = readline().split(' ').map((item) => parseInt(item));
let dp = new Array(len+1).fill(0);
let count = new Array(len + 1).fill(0);
dp[0] = arr[0];
count[0] = 1;
dp[1] = Math.max(arr[0],arr[1]);
count[1] = 1;
for(let i = 2; i < len; i++){
if(dp[i-1] < dp[i-2] + arr[i]){
dp[i] = dp[i-2] + arr[i];
count[i] = count[i-2]+1;
}else{
dp[i] = dp[i-1];
count[i] = count[i-1];
}
}
console.log(dp[len-1] + ' ' + count[len-1]);
3、二维排序，然后最长上升子序列
在游戏中，击败魔物后，薯队长获得了N件宝物，接下来得把这些宝物卖给宝物回收员来赚点小钱。这个回收员有个坏毛病，每次卖给他一件宝 物后，之后他就看不上比这件宝物差的宝物了。在这个世界中，衡量宝物的好坏有两个维度，稀有度X和实用度H，回收员在回收一个宝物A 后，下一个宝物的稀有度和实用度都不能低于宝物A。那么薯队长如何制定售卖顺序，才能卖给回收员宝物总个数最多。
let num = [
[3, 2],
[1, 1],
[1, 3],
[1, 5],
[2, 3],
[2, 3],
];
num.sort((a, b) => {
if (a[0] != b[0]) {
return a[0] - b[0]
} else {
return a[1] - b[1]
}
})
console.log(num);
let dp = new Array(num.length).fill(1);
let max = 1;
for (let i = 1; i < num.length; i++) {
for (let j = 0; j < i; j++) {
if (num[j][1] <= num[i][1]) {
dp[i] = Math.max(dp[i], dp[j] + 1);
max = Math.max(dp[i], max);
}
}
}
console.log(max);
这个输入要多注意
长城数组，最少改变几次
这个题很简单啊！！！，就是去比较奇数位置和偶数位置的第一多第二多的数字！！！！！！！
【长城数组】要求数组内每个数两边的数都相等，且和它本身不相等。输入 n ，和一个长度为 n 的任意数组。你需要修改其中的数，使得它变为“长城数组”。输出最少需要修改几个数？？？
思路：“长城数组”其实就是 奇数位置（第1,3,5,…个）均相等、偶数位置均相等，且不全相等的数组。因此需要分别记下来原数组中奇数位、偶数位上每个数字出现的次数，最终我们留下出现最多的数，其他都替换成这个数。但是，有一种特殊情况，那就是这两个数相同，此时只能让奇数位或者偶数位“退而求其次”，即替换成出现第二多的数。所以需要对比一下，奇数位和偶数位换哪个需要的额外次数更小。
//长城数组
//[1,2,1,3,2,1] ————》 [1,2,1,2,1,2];
//奇数、偶数分别相同，记录出现最多次数的，如果相同则有一个要去找第二多的数字
function getTimes(arr) {
let oddMap = new Map();
evenMap = new Map();
for (let i = 0; i < arr.length; i++) {
if (i % 2 === 0) {
oddMap.set(arr[i], (oddMap.get(arr[i]) || 0) + 1);
} else {
evenMap.set(arr[i], (evenMap.get(arr[i]) || 0) + 1);
}
}
//找出奇数、偶数中第一和第二多的
let [oddFirstNum, oddFirstCount, oddSecondNum, oddSecondCount] = getValue(oddMap);
let [evenFirstNum, evenFirstCount, evenSecondNum, evenSecondCount] = getValue(evenMap);
function getValue(map) {
let firstNum = 0,
firstCount = 0;
secondNum = 0, secondCount = 0;
for (let [item, value] of map) {
if (value >= firstCount) {
secondCount = firstCount;
secondNum = firstNum;
firstNum = item;
firstCount = value;
} else if (value < firstCount && value > secondCount) {
secondCount = value;
secondNum = item;
}
}
return [firstNum, firstCount, secondNum, secondCount];
}
//最终要判断一下奇数偶数中最多的数字是否相同
if (evenFirstNum !== oddFirstNum) {
return arr.length - oddFirstCount - evenFirstCount;
} else if (evenFirstNum === oddFirstNum) {
if (oddFirstCount - oddSecondCount >= evenFirstCount - evenSecondCount) {
return arr.length - oddFirstCount - evenSecondCount;
} else {
return arr.length - oddSecondCount - evenFirstCount;
}
}
}
console.log(getTimes([1, 1, 4, 5, 1, 4]))
走迷宫系列
薯队长最近在玩一个迷宫探索类游戏，迷宫是一个N*N的矩阵形状，其中会有一些障碍物禁止通过。这个迷宫还有一个特殊的设计，它的左右 边界以及上下边界是连通的，比如在(2,n)的位置继续往右走一格可以到(2,1)， 在(1,2)的位置继续往上走一格可以到(n,2)。请问薯队长从起点位置S，最少走多少格才能到达迷宫的出口位置E。
//左右边界连通、上下连通
function node(x, y, layer) {
this.x = x;
this.y = y;
this.layer = layer;
}
/**
* 找出起点和终点
* @param {*} a
* @param {*} arr
*/
function fn(a, arr) {
var xStart = -1,
yStart = -1;
var xEnd = -1,
yEnd = -1;
var count = 0;
for (var i = 0; i < arr.length; i++) {
for (var k = 0; k < arr[0].length; k++) {
if (arr[i][k] == 'S') {
xStart = i;
yStart = k;
}
if (arr[i][k] == 'E') {
xEnd = i;
yEnd = k;
}
}
}
//
var stack = [];
stack.push(new node(xStart, yStart, 0));
var newArr = arr.slice();
var x = -1,
y = -1;
/**
* dfs进行遍历？？找出最小的？？？
*
*/
while (stack.length > 0) {
var temp = stack.shift();
if (temp.x == xEnd && temp.y == yEnd) {
return temp.layer
}
x = temp.x + 1;
y = temp.y;
if (x == a) x = 0;
if (newArr[x][y] != '#') {
stack.push(new node(x, y, temp.layer + 1));
newArr[x][y] = '#'
};
//---------------
x = temp.x - 1;
y = temp.y;
if (x == -1) x = a - 1;
if (newArr[x][y] != '#') {
stack.push(new node(x, y, temp.layer + 1));
newArr[x][y] = '#'
};
//-------------
x = temp.x;
y = temp.y + 1;
if (y == a) y = 0;
if (newArr[x][y] != '#') {
stack.push(new node(x, y, temp.layer + 1));
newArr[x][y] = '#'
};
//-----------------
x = temp.x;
y = temp.y - 1;
if (y == -1) y = a - 1;
if (newArr[x][y] != '#') {
stack.push(new node(x, y, temp.layer + 1));
newArr[x][y] = '#'
};
}
return "-1"
}
var a = 5,
arr = [
[1, '#', 1, 1, 1],
[1, 1, '#', 's', 1],
[1, 'e', '#', '#', '#'],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1]
]
console.log(fn(a, arr))
扫一扫
1194
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
