概述
第1部分，JS核心技术测试
1. 如下代码输出的结果是什么
console.log(1+ "2"+"2");//1
console.log(1+ +"2"+"2");//2
console.log("A"- "B"+"2");//3
console.log("A"- "B"+2);//4
A.122 122 NaN NaN
B.122 32 NaN NaN2
C.122 32 NaN2 NaN
D.122 32 NaN2 NaN2
解析：C
字符串的拼接，+一侧出现字符串为拼接，3，4字符串隐式转数字为NaN，NaN加任何数都为 NaN
单目运算符：其他类型转成数字
双目运算符: 优先考虑字符串拼接
2. 声明一个对象，给它加上 name 属性和 show 方法显示其 name 属性值，以下代码中正确的是（）
A.var obj = [name:"zhangsan",show:function(){alert(name);}];
B.var obj = {name: ' zhangsan' ,show:' alert(this.name)'};
C.var obj = {name: ' zhangsan' ,show:function(){alert(name);}};
D.var obj = {name:' zhangsan',show:function(){alert(this.name);}};
解析：D
A：应该为花括号，B：在普通方法调用中this指向全局无法显示，C：name沿作用域往上找为全局，全局有一个name为空所以显示空而不是报错。
3. 请选择结果为真的表达式: ()
A.null instanceof Object
B.null === undefined
C.null == undefined
D.NaN === NaN
解析：D
A：查看左边对象是否是右边的构造函数实例出来的对象，B：===比较的是数据类型和数 值，D：NaN和任何数都不等包括它自身
4. var arr=[a,b,c,d];数组arr中元素都是整数，下面能得到最大整数的是?
A、Math.max(arr) //NaN
B、Math.max(arr[0], arr[1], arr[2], arr[3])
C、Math.max.call(Math, arr[0], arr[1], arr[2], arr[3])
D、Math.max.apply(Math,arr)
解析：BCD
Math方法的使用A：NaN 数组不能比要散的数据， B：基本用法
C：第一个参this指向，与B类似， D：Math.max.apply(Math,[]) 第一个参this指向
修改this指向 call直接传参 apply需打包为对象 bind需自己调用
1call----->.obj.say.call(obj2,18,”boy”)
2apply----->.obj.say.apply(obj2,[18,”boy”])
3bind----->.obj.say.bind(obj2,18,”boy”)()
5. typeof(null)打印结果是？
解析 ：object
typeof用于查看数据的数据类型 NaN属于number类型，Boolean属于function，string,undefined
6.基础数据类型有哪些？引用数据类型有哪些？区别是什么？
解析：基本数据类型：Number， string， null， undefined， boolean symbol bigint(数字有上限和下限bingint可以无限大) 表现直接加n console log (123n);
引用数据类型：数组，对象，函数，JSON
区别：1.存储上：基本数据类型在栈内存中，引用在堆内存中，2.比较上：基本是数值的比较，引用是地址的比较 3.赋值上：相同变量赋值时基本值改变不影响另一个，引用改一个都变
7.如何删除对象的指定属性
解析：delete 对象.属性
用let声明的变量不能被删除，没有let的就可以删除，即 可删除浏览器创建的对象
可以删除对象里自身的属性成功true，失败false
在严格模式删除变量会报错，
8. 写一个求和的函数sum,达到下面的效果
// Should equal 15
sum(1, 2, 3, 4, 5);
// Should equal 0
sum(5, null, -5);
// Should equal 10
sum('1.0', false, 1, true, 1, 'A',1, 'B',1,'C,1,'D',1, 'E',1,'F',1,'G', 1);
// Should equal 0.3, not 030000000000000
sum(0.1, 0.2);
function sum2() {
let result = 0;
for (let i = 0; i < arguments.length; i++) {
result += window.parseFloat(arguments[i]) || 0;
}
return result.toFixed(3) * 1000 / 1000;
}
console.log(sum2(1, 2, 3, 4, 5));
console.log(sum2(5, null, -5));
console.log(sum2('1.0', false, 1, true, 1, 'A', 1, 'B', 1, 'c', 1, 'D', 1, 'E', 1, 'F', 1, 'G', 1));
console.log(sum2(0.1, 0.2));
解析：parseFloat:其他数据类型转数字，toFixed银行家算法（四舍六入五成双），Math.round()只能取到整数，Math.floor()向下取整，Math.ceil向上取整
代码window也可不用写，toFixed后可变为（1）*10/10
9. ==运算符判断相等的流程是怎样的？
解析：如果两个值类型同正常比较，
不同时
1.null与undefined相等，
2.Boolean型与数值比较，把Boolean转为数字true为数字1，false为数字0，
3字符串与数字，将字符串转为数字.数字开头可转，其他为NaN
4.如果一个值是对象，另一个是数字或字符串，将对象转为原始值进行比较
5.NaN不与任何值相等包括他自己
6.其他情况认为不等
10. 如何实现数组和对象深度复制
解析：1.先解释什么是深度复制
2.封装函数实现
深度复制不管多少层都互不影响，
let obj = [1, [2, [3], { name: "111" }]];
function clone(obj) {
// 如果是数组
var buf;
if (obj instanceof Array) {
buf = [];
let i = obj.length;
while (i--) {
buf[i] = clone(obj[i])
}
return buf;
} else if (obj instanceof Object) {//如果是对象
buf = [];
for (let key in obj) {//对象不能随便遍历只能用for in 取出键名
buf[key] = clone(obj[key]);
}
return buf;
} else {
return obj;
}
}
console.log(obj);
let copyobj = clone(obj);
console.log(copyobj);
obj = [1, 2, 3]
console.log(obj);
copyobj = { xppll: "2222" }
console.log(copyobj);JSON.parse(JSON.stringify(ob2)); 也可实现
以下分析浅拷贝及其应用方式
数组对象都适用
1.将对象转为JSON字符串（无法实现 undefined，function，symbol 这三种类型的数据拷贝，）
2.递归，(函数内部自己调用自己易出现栈溢出)不可拷贝date对象
对象深拷贝：1.Object.assign()，2.es6扩展符（...） 只适用一层深拷贝无法嵌
object1 = [1,2,[3]]
//第一种
let object2 = {...object1} //二维改变会影响
//第二种
let object2= [];
for (let i = 0; i <object1.length; i++) {
object2.push(object1[i])
}
//第三种
let object2 = Object.assign({}, object1)数组深拷贝：concat()，2.slice() 只适用一维数组，其余为浅拷贝
// 数组的深拷贝
let arr2 = []
arr2 = arr2.concat(arr1);
// 2
let arr2 = []
arr2 = arr1.slice();基本类型采用值传递，引用类型采用地址传递。深拷贝--->对于引用类型，不再是只增加一个地址，而是在内存中重新开辟一片存储空间
11. New操作符具体干了什么？
解析：
1.创建新对象
2.将新对象的_proto_指向构造函数的prototype
3.将构造函数的this指向新对象
4.指向构造函数的代码
5.返回新对象
12. Array(2).join() 结果是()
解析：，
join()将数组转为字符串并默认以，拼接
13. x = 1; (function(){return x; var x = 2;}()) 返回值是？
解析：undefined
函数里面的x声明会提升但没赋值所以返回为undefined
14. console.log([1,2] + [3,4]) 打印什么？
解析：1，23，4
+拼接
算数运算符：除了string类型以外 的其他基本数据类型
True+false
拼接符：当数据为string或引用类型时
如果是引用数据类型，会自动调用自身的toString方法，将其转为原始值
如果调用自身的toString方法得到的不是原始值，会继续调用valueOf方法将其转为原始值，如果获取不到那么报错
15.一句话描述this的指向
解析：谁调用指向谁
在普通函数中指向window，作为对象的方法调用时谁调用指向谁，作为构造函数调用时指向实列出来的对象，箭头函数指向离他最近的
super作为对象使用时
1)在普方法中,super指向父类的原型,super的调用方法中,this指向子类的实例
2)在静态方法中,super指向父类,super的调用方法中,this指向子类
16.描述JS的三个组成部分及其含义？
解析：ECMAScript:核心，描述语言基本语法
Dom:文档对象模型操作页面
Bom:浏览器对象模型操作浏览器
17. 下面代码运行的结果是什么？
var bool = !!2;
console.log(bool);//true
var bool = !![];
console.log(bool);//true
var bool = !!{};
console.log(bool);//true
解析：true
true
true
！！将其他数据类型强转为Boolean型
18. 下面程序输出结果是？
var a = new Object ();
a.value = 1;
b = a;
b.value = 2;
console.log(a.value);//2
解析：2
对象赋值指向的是同一片地址
19. 下面程序输出结果是？
for (i=0, j=0; j<6, i<10; i++, j++) {
k = i + j;
}
console.log(k);//18
解析：18
看最后一个结尾J的判断语句
20.如何检查一个变量是String类型，请写出你知道的所有的方法 ？
解析：1.typeof操作符，
2.Object.prototype.toString.call()
Str.__proto__ ,constructor == String;
21.['1', '2', '3'].map(parseInt) 输出什么?并解释 分值3分
解析：[1,NaN,NaN]
['1', '2', '3'].map(parseInt) //parseInt(string【表示字符串】，radix【表示2-36进制】)
[‘1’, ‘2’, ‘3’].map((item,index) =>{
return parseInt(item,index)
});
//执行步骤：
parseInt(‘1’,0)//进制省略或为0，默认以10进制返回结果
parseInt(‘2’,1)//进制小于2或大于36，返回NaN
parseInt(‘3’,2)//按2进制返回但二进制无3，返回NaNmap将返回值放入新的一个数组中
22.描述in和hasOwnProperty的区别
解析：hasOwnProperty只能判断是否是属于自身的属性，无法找到原型身上的属性（hasOwnProperty()只在属性存在于实例中时才返回true）
in原型身上的属性也能找到（in操作符只要通过对象能访问到属性就返回true）
23. 描述typeof和instanceof的区别
解析：判断变量类型：Typoof 返回字符串，返回结果为五个基本数据类型加（引用数据类型）object
instanceof来检测某个对象是不是另一个对象的实例
24. 描述substr和substring的区别
解析： Substr(start,length)
Substring(start,end)
一个是下标一个是长度
都为提取字符串的方法
25. 描述Array.slice和Array.splice的区别
解析：都为对数组进行截取
Slice选取字符串的一部分返回新数组原数组不变
Splice插入，删除或替换数组元素，元素组改变
26. console.log (!!(new Boolean(false)) 输出什么？
解析：true
！！将其他类型转布尔值
27.console.log(1&&2);打印什么
解析：2
&&遇假短路
28. 请根据下面的描述，用JSON语法编写一个对象
“小明今年22岁，来自杭州。兴趣是看电影和旅游。他有两个姐姐，一个叫小芬，今年25岁，职业护士。还有一个叫小芳，今年23岁，是一名小学老师。”
<script>
var persons = {
"name": "小明",
"age": 22,
"from": "杭州",
"interesting": ["电影", "旅游"],
"sisters": [{
"name": "小芬",
"age": 25,
"work": "护士"
},
{
"name": "小芳",
"age": 23,
"work": "小学教师"
}
]
}
</script>29. 请写出如下代码的打印结果
function Foo () {
Foo.a = function () {console.log (1);}
this. a = function () {console.log (2);}
}
Foo.prototype. a = function () {console.log (3);}
Foo.a = function () {console.log (4);}
Foo.a();//4
let obj = new Foo ();
obj. a ();//2
Foo.a();//130. 填写内容让下面代码支持a.name = “name1”; b.name = “name2”
function obj(name) {
1
}
obj. 2 = "name2";
var a = obj("name1");
var b = new obj ();
function obj(name) {
if (name) {
let obj = {
name
}
}
return obj;
}
obj.prototype.name = "name2";
var a = obj("name1");
var b = new obj();
console.log(a.name);
console.log(b.name);31使用filter实现数组元素去重
function a(b) {
let arr = b.sort();
arr = arr.filter((item, index) => {
if (item == arr[index - 1]) {
return false
}
return true
})
console.log(arr);
}
let b = [1, 1, 2, 2, 8, 9, 8, 10, 5]
a(b) function unique(arr) {
var res = arr.filter(function (item, index, array) {
return array.indexOf(item) === index;
});
return res;
}
var arr = [1, 1, '1', '2', 1];
var ans = unique(arr);
console.log(ans); //[1, '1', '2',]32. 在数组的原型上实现indexOf方法
Array.prototype.addindex = function () {
var x = 0;
if (arguments[1]) { //如果有第二个参数
x = arguments[1] // 让x等于这个参数
if (arguments[1] < 0) { //如果第二个参数小于1
x = this.length + arguments[1] //从倒序开始，例如-2就是倒数第2个
}
}
for (var i = x; i < this.length; i++) { //从x开始遍历数组
if (this[i] == arguments[0]) { //如果在数组中找到了和第一个参数相等的就返回这个索引
return i;
} else
if (i == this.length - 1) { //如果找到最后一项还是没有找到，就返回-1
return -1;
}
}
}
let a = [1, 2, "a"]
const a1 = a.addindex("a")
console.log(a1); Array.prototype.indexOf = function (a, b = 0) {
for (let i = b; i < this.length; i++) {
if (a == this[i]) {
return i;
}
}
return -1;
}
33.打印1000之内的所有对称数
eg:
//new Arrar(1001) 创建一个长度为1001的空数组
let r = Array.from(new Array(1001).keys());
console.log(r);
for (let i = 0; i < r.length; i++) {
if (r[i].toString().split("").reverse().join("") == r[i]) {
console.log(r[i]);
}
}封装的函数：
function duichen(start, end) {
for (var i = start; i < end; i++) {
var strI = i.toString().split("").reverse("").join("");
if (Number(strI) == i && i >
10) {
console.log(strI);
}
}
}
duichen(1, 1000); let duiChen = function (num) {
let str = '';
for (let i = 1; i <= 9; i++) {
for (let j = 1; j <= 9; j++) {
if (i == j) {
str = str + i + j + i + ',';
}
/* str = str + i + j + j + i + ','; //10000以内 */
}
}
return str;
}
console.log(duiChen(1000));34. 实现数组合并并排序
请把数组 [A1, A2, B1, B2, C1, C2, D1, D2] 和 [A, B, C, D]，合并为 [A1, A2, A, B1, B2, B, C1
, C2, C, D1, D2, D]？
let arr6 = ["A1", "A2", "B1", "B2", "C1", "C2", "D1", "D2"];
let arr7 = ["A", "B", "C", "D"];
let arr8 = [...arr6, ...arr7].sort(
(v2, v1) => (
v2.codePointAt(0) - v1.codePointAt(0)
)
);
console.log(arr8);扩展运算符可改为concat
let a1 = ["A1", "A2", "B1", "B2", "C1", "C2", "D1", "D2"];
let a2 = ["A", "B", "C", "D"];
let a3 = a1.concat(a2)
a3.sort().sort((a, b) => {
if (a.charAt(0) == b.charAt(0) && a.length > b.length) {
return -1
}
});
console.log(a3);附加：
写一个按照下面方式调用都能正常工作的 sum 函数。
console.log (sum (2,3)); //5
console.log (sum (2)(3)); //5
然后再写一个按照下面方式调用都能正常工作的 sum 函数。
console.log (sum (2,3,4) / 1);// 9
console.log (sum (2)(3)(4) / 1); //9
console.log (sum (1,2)(3,5)(4) / 1); //15
function sum(a, b) {
if (b) {
return a + b;
} else {
return function (c) {
return a + c;
}
}
}
console.log(sum(2, 3));
document.write(sum(2)(3));改：reduce 累加运用
function sum(...arg) {
let sum2 = arg.reduce((p, i) => p + i, 0);
let sum3 = function (...arg1) {
sum2 += arg1.reduce((p, i) => p + i, 0);
return sum3
}
sum3.toString = function () {
console.log("1111");
return sum2
}
sum3.valueOf = function () {
console.log("22222");
return sum2
}
return sum3;
}
console.log(sum(2, 3, 4) / 1);// 9
console.log(sum(2)(3)(4) / 1); //9
console.log(sum(1, 2)(3, 5)(4) / 1);
此题可运行输入其他有弊端
function sum(num1, num2, num3) {
if (num2 && num3) {
return num1 + num2 + num3;
} else {
return function sum2(num4, num5) {
if (num5) {
return function sum3(num7, num8) {
if (!num8) {
return num1 + num2 + num4 + num5 + num7
}
}
} else {
return function sum3(num6) {
return num1 + num4 + num6;
}
}
}
}
}
console.log(sum(2, 3, 4) / 1);
console.log(sum(2)(3)(4) / 1);
console.log(sum(1, 2)(3, 5)(4) / 1); //15最后
以上就是阔达云朵为你收集整理的JavaScript练习题的全部内容，希望文章能够帮你解决JavaScript练习题所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
![对JS中操作符的一些理解：[]= =![] =>true,{}= =!{}=>false](/uploads/reation/bcimg7.png)
发表评论 取消回复