js基础面试题

最新推荐文章于 2024-05-15 19:04:55 发布

不会敲代码的小王ꦿ

最新推荐文章于 2024-05-15 19:04:55 发布

阅读量240

点赞数 2

文章标签： javascript 开发语言 ecmascript

本文链接：https://blog.csdn.net/qq_68086484/article/details/127972463

版权

一、值类型与引用类型

1、 js如何判断数据类型

值类型：javascript存储数据两个区域，栈，堆

栈，通常空间是固定，堆通常空间是动态的分配

js值类型名称与值都存储在栈中

		var  a = 15;  // 值类型
			var   b = a; //把a的值赋值给 b
			b = 50;
			// console.log(a);//a //15
			
			var d = {age:18};  //d是引用类型 栈key与内存地址  真正的值存储在堆中
			
			var e =d;  // 把d的引用地址赋值给e （e与d都指向同一块内存储地址）
			e.age = 35;
			console.log(d.age);// 35

ES5 值类型

Boolen布尔 String字符串 Number数字 undefine未定义 null 空（特殊）

ES5 引用类型

Object对象 Array 数组 Function 函数

ES6 值类型

Symbol 符号

ES6

map图 set集合 Promise承诺

值类型与引用类型的区别

答:值类型key与value都存储在js内存栈中，

引用类型key存储在栈中，真正的值存储在堆中

把引用类型赋值给一个变量其实是不引用类型的地址指向变量

值类型与引用类型的有哪些？

值（简单）：String，Number，Boolean ，Symbol

引用（复杂）：Array Object Function，Set,Map

二、判断数据类型

01 typeof 02 instanceOf 03 constructor 04 prototype.toString isArray

typeof只能判断是否为值类型或者引用类型，引用类型除函数都返回的是 object

String "abc" typeof "abc" string

Number 123 typeof 123 number

Boolean true typeof true boolean

undefined typeof undefine undefined

null typeof null object(null 空指针)

function typof function(){} function

Object tyoeof {} object

array typeof [] obejct

// instanceof 是不是某个对象的实例 （是数组还是对象）
		var a = [1,2,3];
		a instanceof Array // true  a 是数组的实例
		a instanceof Object // true  a是数组的实例  数组也是对象object
		
		var b = {age:18};
		b instanceof Array //false  b不是数组的实例
		b instanceof Object //true  b 是对象的实例
		
		// constructor 构造函数
		// a.constructor == Array  true
		// a.constructor === Object false
		
		// b.constructor == Array false;
		// b.constructor == Object true
		
		
		// 数组专用 Array.isArray()

三、浅拷贝

//js 拷贝一个对象
    //浅拷贝 只拷贝值类型，引用类型数据还是指向地址
    var obj1={name:'wang',age:18,friend:["小红","小绿",{name:'小蓝',job:"teacher"}]}
    // 01 ES6 扩展 02 for循环 03 object.assgin
    var obj2={...obj1};//浅拷贝（如果属性值是引用类型，两个变量的属性都指向同一内存地址）
    // 02 循环
    var obj3={};
    for(var k in obj1){
        obj3[k]=obj1[k];
    }
    // 03 Object.assgin 把参数的两个对象进行合并，属性相同后面覆盖前面
    var obj4=Object.assign(obj1,{})

四、深拷贝

    //js 拷贝一个对象
    //深拷贝 目标对象与源对象相互之间切断联系
    var obj1={name:"wang",age:18,friend:["小红","小绿",{name:'小蓝',job:'teacher'}],
    say(){
        alert("你好我是"+this.name)
    }
    }
    //01 JSON转字符串  字符串转对象
    var obj2=JSON.parse(JSON.stringify(obj1))
    //l / json字符串的值只会保留数组，对象，字符串，数字, nuLl , undefdine
    //对家中的函数会被过滤掉(一般数据也是不带函数的
    // 02通过递归拷贝

五、递归

<script>
    //js递归  
    //递归就是函数自己调用自己      要有结束条件
    //需求  从1+2+..5;1+2+3+4+5=15
    function add(n) {
        //如果n是1直接返回（递归函数的结束条件）
        if (n == 1) {
            return 1

        }
        return n + add(n - 1)
    }
    alert(add(5))  //15

    //01  5+add(4)
    //02  5+4+add(3)
    //03  5+4+3+add(2)
    //04  5+4+3+2+add(1)
    //05  5+4+3+2+1

    //1*2*3*....*10


    //斐波拉契数列
//求斐波拉契第n为数的数列
//下一个数等于前面两个数之和，第0位和第1位返回的是1
// 1，1，2，3，5，8，13，21，34，55，89
function fib(n){
    //如果是第0位返回1 如果是第1位返回1
    if(n==0||n==1){
        return 1
    }else{
        //如果其他位 返回 前面两个数的和
        return fib(n-1)+fib(n-2);
    }
}
alert(fib(10))



function getFib(n){
    //如果小于1返回1
    if(n<=1){
        return 1
    }else{
        //做数组arr
        var arr =[1,1];
        //从第二位开始算
        for(var i=2;i<=n;i++){
            //第n位数是前面两个数的和
            arr.push(arr[1-1]+arr[i-2])
        }
        //返回最后一个（删除并返回最后一个）
        return arr.pop()
    }
}
alert(getFib(45))
</script>

六、深拷贝-递归

<script>
    //js 拷贝一个对象
    //深拷贝，目标对象与源对象相互之间切断联系
    var obj1 = { name: "mumu", age: 18, friend: ["小红", "小绿", { name: '小蓝', job: 'teacher' }],
        say() {
            alert("你好我是" + this.name)
        }
    }
    //如果数组需要递归，如果是对象需要递归，如果是值类型递归结束
    function deepCopy(obj){
        // typeof是object不是null
        if(typeof obj=="object"&&obj!=null){
            //引用类型
            var temp=null;
            if(obj instanceof Array){
                //需要返回的结果应该是个数组
                temp=[];
                //递归拷贝数组
                for(vari=0;i<obj.length;i++){
                    //temp[i]=obj[i] //x 这样就是普通浅拷贝
                    temp[i]=deepCopy(obj[i]);//递归拷贝
                    //函数自己调用自己 返回的 拷贝obj[i] 的结果
                }
            }else{
                //返回的结果就是对象
                temp={};
                //递归拷贝对象
                for(var k in obj){
                    temp[k]=deepCopy(obj[k])
                }
            }
            //返回结果
             return temp;
    }else{
        //引用类型或者其他
            return obj;
    }
}
var obj2=deepCopy(obj1)
       // var obj1 = fname : "mumu " age :18,friend:["小红" , "小绿" [(name :" 小蓝" , job: "teacher")], say(){(aLert("你好我是" +this . name)}
            // 01进入deepCopy 函数
            // l typeof obj1结果是object并且不是nuLl
             // 02 obj1 instanceof Array结果为falsel 
             // temp = {}
    
            //for(var k in obj1){
           // temp[k] = deepcopy(obj1[k]); 
          // }
                // 03 return temp;//返回temp对象(拷贝好的对象)
                //============================2.1
            // temp[name] = deepcopy(obj1["name"])deepcopy("mumu")
            // typeof "mumu”不是object也不是mull return "mumu""
                // temp[name] = "name" ;
                //==========================2.2
            // temp[age] = deepcopy(obj1["age"])  deepcopy(18) 
            // typeof 18不是object也不是null return 18
                // temp[age] =18;
                //======================2.2
            // temp["friend"] = deepcopy(obj1["friend"])
            //===================== 2.2.1
                // typeof["小红" , "小绿" , {name:"小蓝" , job : "teacher"}]结果是object也是nuLll/[”小红", "小绿" , {name: "小蓝" , job : "teacher" }] instance of结果为true
                // temp["friend"]=
          // for (var i = 0; i < ["小红", "小绿", { name: "小蓝", job: "teacher" }].Length; i++){}
        // ------------------- 只要是引用类型就递归拷贝下去直到拷贝typeof不会object
 
</script>

七、隐式转换

数据类型转换强制转换，隐式转换

强制转换 Number()转换为数字 String() 转换为字符串 Boolean() 转换为布尔值

隐转换符号

+ 字符串连接符号（隐式转换为字符串）

八、严格等于与等于判断

		<script>
			// == 判断隐是转换后值是否相等
			// === 判断类型与值是否相对
			// ==
			// alert(100 == "100"); //true（如果两边类似数字会优先隐式转换为数字）
			// alert(""==false);//true
			// alert(1 == true);//true
			// alert(null == undefined); //true 隐式转换后都为false
			// alert(null == null);//true 空指针都指向一个地方（空）
			alert(undefined == undefined);
						
			// alert(null == NaN);// false（特殊） 数字不等于空
			// alert([] == []);//false  //两块不同的内存地址
			// alert({} == {});//false //两块不同的内存地址



	      // === 严格等于 判断类型与值是否相对
			// alert(0 === ""); // false
			// alert([] === []);//false
			// alert({} === {}); //false
			// alert(null === undefined) //false
			alert(null === null) // true
			
			// 什么时候用=== 什么用 ===
			// 答：应该都用=== 严格等于
			// 判断是为null还是undefined 可以用===


		</script>

九、if

		<script>		 
		 /* var a = 10;
		 if(a){
			 alert("条件通过")
		 } */
		 
		/* var b = "";
		 if(b){
			 alert("通过")
		 }else{
			 alert("不通过")
		 }
			 */
		// 01 if判断只要求（）内表达式结果是否为truly变量
		// 02 falely变量 对变量取两次反 !! 得到结果为false的变量 称为falely变量
		// 03 false "" 0 NaN  false  undefined null
		// 04 除了这结果falsely变量外其他都是truly变量	
		</script>

十、逻辑且或

或

	// || 或 如果前面的变量为truely 最终的结果为第一个，如果为falely结果为第二个;
		var a  = 15 ||0; //15 转换结果为true  a的值就是15
		var b = false || 50; //false转换的结果为false b的值是50；
		var c = false ||undefined;
		var d = 0 || false;
		// alert(a);
		// alert(b);
		// alert(c);
		alert(d);
			
		</script>

且

<script>		 
		// 逻辑&&  如果前面的位false直接返回false ，如果前面位true，看后面的是否为true
		
		// // 报错Uncaught ReferenceError: b is not defined
		
		// &&前面是truely变量则返回后面的值,前面是falsely变量直接使用前面的值
		// var c = 15&&20; // 20;
		// alert(c);
		// var c = false&&18; //false;
		// alert(c);
		
		// 在逻辑判断中 &&前面的值为falsely后面的不执行，前面位truly则看&&后面的值
		var obj = {age:15,leg:{len:70,width:30}};
		// if(obj.abc.len){
		// if(obj&&obj.abc&&obj.abc.len){
		if(obj?.abc?.len){ //es6的语法
			alert("通过")
		}else{
			alert("不通过");
		}
		// 在 Uncaught TypeError: Cannot read properties of undefined (reading 'len') 
		// 在undefined上面读取len读取不到
		</script>

十一、原型与原型链

<script>
			// 原型与原型链有什么作用？
			// 01 在js中实现继承
			// 02 实现类的实例方法扩展
			
			// 怎么样让所有的数组求最大最小值通用方法
			// 数组数组Array的实例都拥有最大最小值方法
			// 把自定义方法挂载到类的原型上
			Array.prototype.max = function(){
				// this就是当前数组 ，展开求最大值
				return Math.max(...this);
			}
			// 可以在所有的数组实例上访问max方法
			// 准则，不要修改js默认对象原型上的方法
			// 准则，进行不要在js默认对象的原型上添加方法
			// vue2 数组的的双向绑定劫持就是重写了数组的原型上的方法实现的
			
			// 怎么样让字符串有通用翻转方法
			String.prototype.reverse = function(){
				return this.split("").reverse().join("");
			}
			
			// 什么是类，什么事实例
			// 类是:构造对象的一个模板  Array  Object String
			// 实例:就是有类创建的对象  [1,2,3] {name:"mumu"},"abc"
			// 本质上讲 类是个函数，实例是一个有函数创建对象
			
			// 什么是原型，什么是原型链
			// 每一个类（构造函数）都有一个显示原型prototype
			// 每一个实例 都有个一隐式原型 __proto__
			// 类的prototype等于其实例的__proto__
			
			// var arr = [1,2,3];
			// Array.prototype === arr.__proto__
			//  var obj = {}''
			// obj.__proto__ === Object.prototype
			
			// 什么是原型链（实现js的继承）
			// 当查找对象一个属性是先在自身找，找不到则沿着__proto__的__proto__向上查找
			// 我们__proto__形成的链条关系我们称为原型链
			// var arr = [1,2,3]
			// arr.toString() 在 arr.__proto___有这个方法
			// arr.hasOwnProperty()在arr.__proto__.__proto__上面有这个方法
			// arr.__proto__ === Array.prototype  arr继承了Array的prototype上所有方法
			// Array.prototype.__proto__ === Object.prototype //Array 继承Object的protype所有方法
			// arr.__proto__.__proto__ === Object.prototype arr继承了 Object 的prototype上的所有方法
			
			// 创建3个类解释原型与原型链 People  Student 
			// People  eat方法  age属性  name属性
			// Student 继承People类  study方法  age属性 name属性 no学号
			// 01 创建People类
			function People(name,age){
				this.name = name;
				this.age = age;
			}
			// 02 给pepole显示原型添加 eat方法
			People.prototype.eat = function(){
				console.log(this.name+"正在吃饭")
			}
			
			// 03  创建学生类继承 People类
			function Student(name,age,no){
				// 执行People构造按函数（执行people函数并把当前的this传入函数，当前peoplethis）
				People.call(this,name,age);
				// 定义学号
				this.no =no;
			}
			// 04 让Student原型链继承People的原型链
			Student.prototype = Object.create(People.prototype);
			// 05  修正 Student 显示原型上的构造函数
			Student.prototype.constructor = Student;
			// 06 在Student显示原型链添加方法
			Student.prototype.study = function(){
				console.log(this.name+"正在好好学习，dayday up");
			}
			// 07 构建Student的实例 s1
			var s1 = new Student("小曾",18,9527);
			
			
			
		</script>

不会敲代码的小王ꦿ

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
js基础面试题

强制转换 Number()转换为数字 String() 转换为字符串 Boolean() 转换为布尔值。typeof只能判断是否为值类型或者引用类型，引用类型除函数都返回的是 object。引用（复杂）：Array Object Function，Set,Map。值（简单）：String，Number，Boolean ，Symbol。值类型：javascript存储数据两个区域，栈，堆。答:值类型key与value都存储在js内存栈中，引用类型key存储在栈中，真正的值存储在堆中。
复制链接

扫一扫