一.数组扁平化
(将一个多维数组变为一个一维数组。例如,将数组[1, 2, [3, [4, 5]], [6, 7]]扁平化处理后输出[1, 2, 3, 4, 5, 6, 7];)
function getArray(arr) {
let res = [];
for (let i = 0; i < arr.length; i++) {
if (Array.isArray(arr[i])) {
res = res.concat(getArray(arr[i]));
} else {
res.push(arr[i]);
}
}
return res;
}
console.log(getArray([1, 2, [3, [4, 5]], [6, 7]]));//[1, 2, 3, 4, 5, 6, 7]
二.合并有序数组
给定两个从小到大排好序的数组,亲,请你把它两个合并成新的数组,合并后的结果依然有序。如:给定数组:[1,3,7,15,20]和数组:[-5,0,2,8,9,12]。那么结果是:[-5,0,1,2,3,7,8,9,12,15,20]
function mergeSortedArrays(arr1, arr2) {
var mergedArray = arr1.concat(arr2);
return mergedArray.sort(function (a, b) {
return a - b;
});
}
var arr1 = [1, 3, 7, 11111,312323,313215, 20, 232132331];
var arr2 = [-5, 0, 2, 8, 9, 12,111];
var mergedArray = mergeSortedArrays(arr1, arr2);
console.log(mergedArray); // [-5, 0, 1, 2, 3, 7, 8, 9, 12, 15, 20]
let arr = [1, 2, 3]
let arr1 = [3, 7, 5]
let arr2 = [...arr, ...arr1]
arr.sort((a, b) => a - b)
console.log(arr2);
三.求两个数的交集
如:给定数组 [12,23,34,45]和数组 [21,23,45,100],那么交集是[23,34];
function intersection(arr1, arr2) {
var set1 = new Set(arr1);
var set2 = new Set(arr2);
var result = new Set();
for (var value of set1) {
if (set2.has(value)) {
result.add(value);
}
}
return Array.from(result);
}
var arr1 = [12, 23, 34, 45,21];
var arr2 = [21, 23, 45, 100];
var result = intersection(arr1, arr2);
console.log(result); // [23, 45]
四.最接近三个数之和
给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数,使它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在恰好一个解。
function threeSumClosest(nums, target) {
let closestSum = nums[0] + nums[1] + nums[2]; // 初始化最接近的三数之和
for (let i = 0; i < nums.length - 2; i++) {
for (let j = i + 1; j < nums.length - 1; j++) {
for (let k = j + 1; k < nums.length; k++) {
const sum = nums[i] + nums[j] + nums[k];
if (Math.abs(sum - target) < Math.abs(closestSum - target)) { // 如果当前的三数之和更接近目标值,则更新最接近的三数之和
closestSum = sum;
}
}
}
}
return closestSum;
}
console.log(threeSumClosest([1, 2, 3, 4, 5], 7))
五.实现事件处理器EventEmitter,有如下功能
const event = new EventEmitter();
绑定事件
event.on(name, callback);
取消绑定
event.off(name);
触发事件
event.emit(name, data);
// 自己实现一个事件处理机制:(事件绑定,事件触发,事件解绑);
class EventEmitter {
constructor() {
this.events = {};
}
// 绑定事件:
// 参数:
// name:事件名
// callback:事件处理函数
on(name, callback) {
this.events[name] = callback;
}
// 触发事件
// name:事件名
// data:传给事件处理函数的参数
emit(name, data) {
this.events[name](data);
}
// 解绑事件:
// 参数:
// name:事件名
off(name) {
delete this.events[name];
}
}
const event = new EventEmitter();
// 绑定事件
event.on("myclick", function (params) {
console.log("myclick", params);
});
event.on("yourclick", function (params) {
console.log("yourclick", params);
});
function fn01() {
// 触发事件
event.emit("myclick", "hi");
}
function fn02() {
event.emit("yourclick", "hello");
}
function fn03() {
// 取消绑定
event.off("myclick");
}
六.请阅读如下代码(非严格模式下),写出结果,并写出为什么?
var a = 2;
const foo = {
bar: function () {
console.log(this.a,"20");
},
bar1: function () {
return function () {
console.log(this.a,"24");
}
},
a: 1
};
foo.bar();//1
var bar1 = foo.bar1();
console.log(bar1,"31")
bar1();//2
// foo.bar() 方法是直接通过 foo 对象调用的,所以其中的 this 指向的是 foo 对象本身,而 foo 对象中的 a 属性的值为 1,所以输出结果为 1。
// 而执行 bar1() 方法时,实际上是通过 return 返回的函数执行的,因此其执行上下文中的 this 指向的是全局对象 window(或者在某些环境中是 global 对象),而全局对象中定义的 a 变量的值为 2,所以输出结果为 2。
七.请编写函数,将data数组中所有对象按照value从小到大排列,不能使用sort函数。
var data = [{
name: "uc",
value: 5
}, {
name: "amap",
value: 2
}, {
name: "ali",
value: 3
}
]
function bubbleSort(arr, compareFn) {
for (var i = 0; i < arr.length; i++) {
for (var j = 0; j < arr.length - 1 - i; j++) {
if (compareFn(arr[j], arr[j + 1]) > 0) {
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
}
}
}
return arr;
}
function compareByValue(a, b) {
return a.value - b.value;
}
console.log(bubbleSort(data, compareByValue))
七.封装一个queryString函数,支持输入 URL来获取 query 等参数)
例如,输入https://www.antgroup.com?
name=ant&from=alibaba&job-frontend&extraInfo %7B%22a%22%3A%226%22%2C%22C%22%3A%22d%22%7D
可得到一个这样的对象
(name:"ant",from: "alibaba' ,job: "frontend" ,extraInfo: (a:"b', c:'d]}本平台可运行代码,建议在平台跑通后再提交
function getURLParams(url) {
const [fullURL, queryString] = url.split('?'); // 将 URL 分割成 URL 本身和查询字符串两部分
const query = new URLSearchParams(queryString); // 使用 URLSearchParams 解析查询字符串
const result = {}; // 初始化结果对象
for (const [key, value] of query) { // 遍历解析后的查询字符串
if (/\[\]$/.test(key)) { // 如果键以 [] 结尾,说明这是一个数组
const name = key.slice(0, -2); // 去掉 [] 后缀,得到数组名
if (result[name]) { // 如果结果对象已经有了这个数组
result[name].push(parseParamValue(value)); // 在数组中添加新的值
} else {
result[name] = [parseParamValue(value)]; // 否则创建一个新的数组
}
} else { // 否则这是一个普通的键值对
result[key] = parseParamValue(value); // 直接将值添加到结果对象中
}
}
// return { url: fullURL, query: result }; // 返回 URL 和解析后的查询参数对象
return result
}
function parseParamValue(value) { // 解析参数的值
try { // 尝试解析 JSON
return JSON.parse(value);
} catch { // 如果失败则返回原始字符串
return value;
}
}
const url =
"https://example.com/path?param1=value1¶m2=[1,2,3]¶m3=%7B%22key%22%3A%22value%22%7D¶m4=not%20a%20JSON";
const params = getURLParams(url); // 获取解析后的查询参数对象
console.log(params); // 输出查询参数对象
八. 用递归实现:求两个数的最大公约数(思路:使用欧几里得算法)。要求封装成函数。
// 首先确定如何求最大公约数,我们采用欧几里得算法(辗转相除法),算法描述如下:
// 例:48, 57
// 57 % 48=9 大数对小数求余
// 48 % 9=3 小数对上次的余数求余,重复这个过程直到余数为0
// 9 % 3=0 余数为0时,此次求余的小数就是最大公约数
// 第一次运算n1 = 57, n2 = 48, n3 = 9,第二次运算n1 = 48, n2 = 9, n3 = 3, 第三次运
// 算n1 = 9, n2 = 3, n3 = 0
// 规律是:求余的大数是前次运算的小数,小数是前次运算的余数,余数是0就结束。
function gongYS(n1, n2) {
let n3 = n1 % n2;
n1 = n2;
n2 = n3;
if (n3 == 0) {
return n1;
}
return gongYS(n1, n2);
}
console.log(gongYS(48, 57));
九.利用递归求两个数的最大公约数
function gongYS(m, n) {//最大公约数函数
var r = 0;//声明变量r;
r = m % n;//把m%n的值赋值给r;
m = n;//把n的值给m;
n = r;//把r的值给n;
if (r == 0) {//如果r等于0,说明最大公约数是那个值小的数,比如:16/8;
return m;//n的值赋值给m后,返回值为m;
}
return gongYS(m, n);//否则继续运行函数
}
var result = gongYS(16, 24);
console.log(result);
十.把下面的对象数组变成对象嵌套。
规则:每个对象的parentId就是父级对象的id。
// let arr = [
// {
// id: 1,
// name: "张一",
// parentId: null
// },
// {
// id: 2,
// name: "张二",
// parentId: 1
// },
// {
// id: 3,
// name: "张三",
// parentId: 1
// },
// {
// id: 4,
// name: "张四",
// parentId: 2
// },
// {
// id: 5,
// name: "张五",
// parentId: 2
// },
// {
// id: 6,
// name: "张六",
// parentId: 3
// },
// {
// id: 7,
// name: "张七",
// parentId: 4
// },
// {
// id: 8,
// name: "张八",
// parentId: 6
// }
// ]
//方法一:======================================================================
function arrToJson(root) {
// 2、循环数组,找子元素
let children = arr.filter(item => item.parentId == root.id);
if (children.length > 0) {
root.children = children;
children.forEach(item => {
arrToJson(item);
})
};
}
// 1、先找的根元素;
let root = arr.filter(item => item.parentId == null)[0]
arrToJson(root);
console.log(root);
//方法二:======================================================================
function arrToJSON(arr) {
let root;
arr.forEach(item => {
if(item.parentId!=null){
// 如果有父级
// 找到父级
let parentObj = arr.filter(parentItem=>parentItem.id===item.parentId)[0];
// 给父级增加children属性(数组)
!parentObj.children && (parentObj.children=[]);
// 把自己添加到父级的children属性(数组)
parentObj.children.push(item);
}else{
root = item;
}
});
return root;
}
console.log(arrToJSON(arr));
console.log(arr.length);
十一.封装一个函数,完成功能:add(2).multi(9).div(3) 的结果是6。
function add(x) {
return {
multi(y) {
return {
div(z) {
return x*y/z;
}
}
}
};
}
console.log(add(2).multi(9).div(3)); // 输出6
console.log(['1', '2', '3'].map(parseInt))
十二. ['1', '2', '3'].map(parseInt)的结果是什么 ? 为什么 ?
console.log(['1', '2', '3'].map(parseInt));//[1, NaN, NaN];
// 这是因为 map 函数会将数组中的每一个元素都调用一遍指定的函数,
// 并将函数的返回值组成一个新的数组返回。parseInt 函数的第二个参数表示进制,
// map 函数会将当前元素的值和索引分别作为 parseInt 函数的第一个和第二个参数传入。
parseInt('1', 0); // 1
parseInt('2', 1); // NaN,因为 '2' 不是一进制的数
parseInt('3', 2); // NaN,因为 '3' 不是二进制的数
十三..请用两种方式完成数组去重
方式一
function norepeat(arr){
var newarr = [];
for(var i = 0;i<arr.length;i++){
if(newarr.indexof(arr[i]) == -1){
newarr.push(arr[i])
}
}
return newarr;
}
方式二
function norepeat(arr){
var newarr = arr;
var obj = {};
for(var i = 0;i<arr.length;i++){
obj[arr[i]] = 1;
}
return Object.keys(obj).map(item=>Number(item));
}
方式三
function norepeat(arr){
var newarr = arr;
newarr.sort();
for(var i = 0;i<newarr.length;i++){
if(arr[i] == arr[i+1]){
arr.splice(i,1)
i--;
}
}
return newarr;
}
方式四
function norepeat(arr){
return Array.from(new Set(arr));
}
十四. 请写出常见的http状态码与含义(4中以上)
200:(成功)服务器已成功处理了请求。通常,这表示服务器提供了请求的网页。
400:(错误请求)服务器不理解请求的语法
401:(未授权)请求要求身份验证。对于需要登录的网页,服务器可能返回此响应
403:(禁止)服务器拒绝请求
404:(未找到)服务器找不到请求的网页
408:(请求超时)服务器等候请求时发生超时
500:(服务器内部错误)服务器遇到错误,无法完成请求
502:(错误网关)服务器作为网关或代理,从上游服务器收到无效响应
503:(服务不可用)服务器目前无法使用(由于超载或停机维护)。通常,这只是暂时状态
504:(网关超时)服务器作为网关或代理,但是没有及时从上游服务器收到请求
505:(HTTP 版本不受支持)服务器不支持请求中所用的 HTTP 协议版本
十五 . 如何解决跨域 并说出ajax与解决跨域方式的区别
①解决跨域三种方案:jsonp、cors、proxy
② AJAX 是一种在无需重新加载整个网页的情况下,能够更新部分网页的技术。(注意!ajax不是跨域方式!它是一种技术)
请问jsonp是不是ajax中实现跨域访问的技术
jsonp不是AJAX中实现跨域访问的技术 1、jsonp没有使用XMLHttpRequest对象。 2、jsonp只是在一种跨域的技巧。 3、jsonp只支持Get方式;由于按照jsonp的这种方式跨域访问时,就是可以利用javascript和服务器端交互,能达到AJAX中XMLHttpRequest对象同样的效果