后续 机试通过
--
前言
最近北漂漂累了，想找一个城市定居，发现了武汉这个城市，薪水给的跟我目前差不多，但房价比北京便宜个2-3倍，属于干5年就能全款买房的地方，而且查资料以后的发展还是挺有潜力的，遂抱着试试的心态投了投，这家给发了笔试题，一打开就是下面这四道，全列这了，有没有好心人教教我第四道该怎么写。
题目
- 将对象{'a_b_cd_e':1}的键的下划线转化为小驼峰{'aBCdE': 1}
- 正则表达式法
function toCamelCase(obj) {
const newObj = {};
for (let key in obj) {
const newKey = key.replace(/_([a-z])/g, function (match, p1) {
return p1.toUpperCase();
});
newObj[newKey] = obj[key];
}
return newObj;
}
- 逻辑
function translate(obj) {
const newObj = {};
Object.keys(obj).forEach((key) => {
// 控制是否匹配到了下划线
let isUnderline = false;
let i = 0;
let newKey = "";
while (i < key.length) {
if (key[i] === "_") {
isUnderline = true;
i++;
} else if (isUnderline) {
// 上一个是下划线
newKey += key[i].toUpperCase();
i++;
isUnderline = false;
} else {
newKey += key[i];
i++;
}
}
newObj[newKey] = obj[key];
});
return newObj;
}
- 手写Flat 拍平
function flattenArrayWithDepth(arr, depth) {
return depth > 0
? arr.reduce(
(acc, val) =>
acc.concat(
Array.isArray(val) ? flattenArrayWithDepth(val, depth - 1) : val
),
[]
)
: arr;
}
- 给定一维对象数组转成两层的树结构数组
父级项目的定义为parentId === 0，要求子节点不能有children属性
interface Item {
id: number;
parentId: number;
children?: Item[];tian
}
function buildTree(arr: Item[]) {
const parentMap = new Map();
const result = [];
arr.forEach((cur) => {
if (cur.parentId !== 0) {
if (parentMap.has(cur.parentId)) {
const index = parentMap.get(cur.parentId);
if (!result[index].children) {
result[index].children = [];
}
result[index].children.push(cur);
} else {
const parentIndex = result.push({ children: [cur] }) - 1;
parentMap.set(cur.parentId, parentIndex);
}
} else {
result.push({ ...cur, children: [] });
parentMap.set(cur.id, result.length - 1);
}
});
return result;
}
- 给定
package.json的dependencies,判断有没有循环依赖，忽略版本号
由于还不会数据结构图的章节，所以乱写了一堆用map实现的，以下为chatGPT4的实现
function hasCycle(dependencies, packageName, visited = new Set(), stack = new Set()) {
if (stack.has(packageName)) {
// 当前包已在调用堆栈中，意味着我们发现了一个循环依赖
return true;
}
if (visited.has(packageName)) {
// 当前包已被访问且没有发现循环依赖
return false;
}
visited.add(packageName);
stack.add(packageName);
const packageDependencies = dependencies[packageName] || [];
for (const dep of packageDependencies) {
if (hasCycle(dependencies, dep, visited, stack)) {
return true;
}
}
stack.delete(packageName); // 移除当前包，因为所有依赖已检查完毕
return false;
}
function findCircularDependencies(packageJson) {
const dependencies = {};
for (const [packageName, version] of Object.entries(packageJson.dependencies)) {
// 此处省略了解析版本号和获取依赖列表的实现
// 假设我们直接获得了依赖包名称的列表
dependencies[packageName] = parseDependencies(packageName, version); // 需要实现
}
for (const packageName in dependencies) {
if (hasCycle(dependencies, packageName)) {
return true; // 发现循环依赖
}
}
return false; // 未发现循环依赖
}
// 假设这是从package.json文件中读取的dependencies部分
const packageJson = {
dependencies: {
"packageA": "^1.0.0",
"packageB": "^2.0.0",
"packageC": "^3.0.0",
// ...其他依赖
}
};
// 请注意，此函数中的parseDependencies函数是一个占位符，
// 它应该解析给定包的版本号并返回其依赖列表。
// 这通常需要查询一个包管理器的API，如npm或yarn。
console.log(findCircularDependencies(packageJson)); // 输出：true 或 false
