• JavaScript——笔试题、面试题

    目录

    1、JavaScript的组成 （校招笔试题）：

    2、typeof数据类型返回值是什么？

    3、前置与后置++ --

    4、&&符号

    5、兼容、优化、项目中的难点如何解决 是面试官最喜欢问的问题

    6、这中间发生了什么

    7、for循环输出结果

    8、this关键字

    9、函数调用  arguments

    10、对象调方法

    11、this

    12、数组遍历

    13、类型检测，连等

    14、回调函数

    15、函数作用域

    16、对象的创建，空间的引用

    17、形参、实参、函数调用

    18、引用

    19、类型检测、加减法、优先级

    20、函数运行时的作用域

    21、数组遍历

    22、声明变量以及作用域

    23、this 作用域 隐式声明提升 原型 符号优先级

    24、把当前网页的url的参数解析为一个对象

    25、类型

    26、map、parseInt

    27、>>>

    28、find  findOne   get  filter

    30、 优雅降级，渐进增强

    1、JavaScript的组成 （校招笔试题）：

    1、ECMAScript （简称ES），js语言核心部分，描述了该语言的语法和基本对象；

    2、文档对象模型（DOM）,网页文档操作标准；

    3、浏览器对象模型（BOM），客户端和浏览器窗口操作基础。

    2、typeof数据类型返回值是什么？

    1.         var a=100
    2.         a=a+21
    3.         var b=a%19
    4.         var re=typeof(b)
    5.         // re变量的数据类型是什么
    6.         console.log(typeof(re))

    答案：string

    3、前置与后置++ --

    1.         var obj={age:20}
    2.         var a=100
    3.         var c=(-a+++obj.age++)
    4.         console.log(c)

    答案： -80

    4、&&符号

    1.  
    2.         var a=(b=0) && (c=30)
    3.         console.log(a) 
    4.         console.log(b) 
    5.         console.log(c)

    0 0 报错

    5、兼容、优化、项目中的难点如何解决 是面试官最喜欢问的问题



    6、这中间发生了什么

    7、for循环输出结果

    此代码不是由i++决定的，逗号操作符，最后一个表达式作为结果，所以i<5才是判定条件

    flase根本不会执行，因为从B语句开始

    1.         var i=0;
    2.         for(;i++,i<5;) {
    3.             console.log(i)
    4.         }   //1 2 3 4 
    5.  
    6.  
    7.         var i=0;
    8.         for(false;i++,i<5;) {
    9.             console.log(i)
    10.         }   //1 2 3 4 
    11.  
    12.         for(var i=0,j=6;i<4,j>0;i++,j--) {
    13.             console.log(i)
    14.         }  //06 15  24  33 42 51  
    15.         //所以打印 0 1 2 3 4 5
    16.  
    17.         var arr=[]
    18.         for(var i=0;i<4;i++) {
    19.             arr[i]=function(){console.log(i)}
    20.         }
    21.         arr[0]()   //4
    22.         arr[2]()   //4
    23.

    8、this关键字

    基本数据取一个成员是可以的，但是是undefined

    1.         function a(xx) {
    2.             this.x=xx
    3.             return this
    4.         }
    5.         var x=a(5)   //a=6
    6.         var y=a(6)   //y=window
    7.         console.log(x.x)   //undefined        6.x==>基本数据取一个成员是可以的，但是是undefined
    8.         console.log(y.x)   //6                window.x=6

    9、函数调用  arguments

    1. 			function sum() {			
    2. 				if (arguments.length == 2) {
    3. 					return arguments[0] + arguments[1];  
    4. 				} else if (arguments.length == 1) {
    5. 					var first = arguments[0];
    6. 					return function(second) {
    7. 						return first + second;
    8. 					};
    9. 				}
    10. 			}
    11. 			console.log(sum(2,3));	  
    12. 			console.log(sum(2)(3));

    5    5

    10、对象调方法

    1. 			var fn = 90;
    2. 			var o = {
    3. 				fn: function() {					
    4. 					console.log(fn);  //90   上一排的fn只有对象o才可以使用
    5. 				}
    6. 			}
    7. 			console.log(o.fn());
    1. 			var fn = 90;
    2. 			var o = {
    3. 				fn: function fm() {					
    4. 					console.log(fm);   //fm函数，这样写就可以访问
    5. 				}
    6. 			}
    7. 			console.log(o.fn());

    11、this

    1. 			var User = {
    2. 			      count: 1,
    3. 			      getCount: function() {
    4. 			          return this.count
    5. 			      }
    6. 			  }
    7. 			  var fn = User.getCount
    8. 			  console.log(fn());

     undefined

    12、数组遍历

    1. 			    var buttons = [{name:'b1'},{name:'b2'},{name:'b3'}];
    2. 			    function bind(){
    3. 			        for (var i = 0; i < buttons.length; i++) {
    4. 			        	buttons[i].onclick = function() {
    5. 			   				console.log(i);
    6. 							}
    7. 			        }
    8. 			    };
    9. 			    bind();
    10. 			    buttons[0].onclick();  
    11. 			    buttons[1].onclick();  
    12. 			    buttons[2].onclick();

    答案： 3  3  3

    console.log(i);是在最后调用的时候才取i，foe循环已经完了，就是3了
    如果想最后的值不一样，有两种方法：

    1、将var改成let

    2、使用闭包
    但是这样写有两个问题：1内存泄露 2程序不太好阅读

    1.  
    2. 				var buttons = [{name:'b1'},{name:'b2'},{name:'b3'}];
    3. 			    function bind(){
    4. 			        for (var i = 0; i < buttons.length; i++) {
    5. 						(function(index){
    6. 							buttons[i].onclick = function() {
    7. 				   				console.log(index);
    8. 							}
    9. 						})(i)
    10. 					}
    11. 				};
    12. 			    bind();
    13. 			    buttons[0].onclick();  //0
    14. 			    buttons[1].onclick();  //1
    15. 			    buttons[2].onclick();  //2

    13、类型检测，连等

    1. 			var a=b=3
    2. 			console.log("a defined? " + (typeof a !== 'undefined'));//false
    3. 			console.log("b defined? " + (typeof b !== 'undefined'));//true
    4. 			console.log(b);//3
    5. 			console.log(typeof a);//'undef'
    6.  
    7. 			var re1=typeof(a)
    8. 			var re2=typeof(b)
    9. 			// 变量a的值 
    10. 			console.log(a)       //没有值,会报错 因为它是局部变量
    11. 			//变量b的值   //3
    12. 			//变量re1的值    //"undf"
    13. 			//变量re1的数据类型			  //string
    14. 			//变量re2的值    //"number"
    15. 			//变量re2的数据类型   //string
    16. 			console.log(typeof re2)
    17. 			//变量a的数据类型      //unf
    18. 			//变量b的数据类型     //number

    var a=b=3     ==>  b=3;var a=3

    14、回调函数

    1. 			var fn1 = 'ivan';
    2. 			var name = 'good';
    3. 			var fn1 = function(y) {
    4. 				y();
    5. 			}
    6. 			function fn1(x) {
    7. 				x(name);
    8. 			}
    9. 			function fn2(x) {
    10. 				console.log(x);   
    11. 				console.log(name);
    12. 				var name = 'hello';
    13. 				console.log(name);
    14. 			}
    15. 			fn1(fn2);

    答案：undefined  undefined  hello

    15、函数作用域

    1. 			var num = 5;
    2. 			function func1() {
    3. 				var num = 3;
    4. 				var age = 4;  //6
    5. 				function func2() {
    6. 					console.log(num);  //und
    7. 					var num = 'ivan';
    8. 					function func3() {
    9. 						age = 6;
    10. 					}
    11. 					func3();
    12. 					console.log(num);  //ivan
    13. 					console.log(age);   //6
    14. 				}
    15. 				func2();
    16. 			}
    17. 			func1();

    16、对象的创建，空间的引用

    1. 	       function changeObjectProperty(o) {
    2. 				o.siteUrl = "http://www.csser.com/";
    3. 				o = new Object();
    4. 				o.siteUrl = "http://www.popcg.com/";
    5. 				return o
    6. 			}
    7. 			var CSSer = new Object();			
    8. 			var re=changeObjectProperty(CSSer);			
    9. 			console.log(CSSer.siteUrl);
    10. 			console.log(re.siteUrl)
    11. 			// re=null;    //因为return了o，并且还使用了，所以要释放

    答案：

    http://www.csser.com/
    index.html:169 http://www.popcg.com/

    17、形参、实参、函数调用

    1. 			var x = 8;
    2. 			var objA = {
    3. 				x: 'good',
    4. 				y: 32//5
    5. 			}
    6. 			function add(x, y) {
    7. 				console.log(x.y + y);  
    8. 			}
    9. 			function fn(x, y) {
    10. 				x.y = 5;
    11. 				y(x, 3);
    12. 			}
    13. 			fn(objA, add);
    14. 			console.log(objA);

    18、引用

    1. 			var obj1 = new Object();
    2. 			obj1.name = 'zjzhome';
    3. 			var obj2 = obj1;
    4. 			console.log(obj2.name);//'zjzhome'
    5. 			obj1.name = 'zjz';
    6. 			console.log(obj2.name);//'zjz'

    19、类型检测、加减法、优先级

    1. 			var a = '' + 3;
    2. 			var b = 4;
    3. 			console.log(typeof a); //"string"
    4. 			console.log(a + b); //"34"
    5. 			console.log(a - b); //-1  数值类型的字符串可以跟数字减法运算
    6. 			console.log({} - b) //NaN  
    7. 			//number: NAN 200 100 10.2 Infinity
    8.  
    9. 			var foo = "11" + 2 + "1";
    10. 			console.log(foo); //"1121"
    11. 			console.log(typeof foo); //"string"
    12.  
    13. 			var foo1 = "11" + 2 + 1;
    14. 			console.log(foo1)  //1121   加号是从左到右
    15.  
    16. 			var foo2 = "11" + 2 * 2;
    17. 			console.log(foo2)   //114   //乘号优先级高

    20、函数运行时的作用域

    1. 			var name = 'laruence';
    2. 			function echo() {
    3. 				console.log(name);
    4. 			}
    5. 			function env() {
    6. 				var name = 'eve';
    7. 				echo();//'laruence';
    8. 			}
    9. 			env();

    21、数组遍历

    1. 			a = new Array(2, 3, 4, 5, 6);
    2. 			sum = 0;
    3. 			for (i = 1; i < a.length; i++)
    4. 				sum += a[i];
    5. 			console.log(sum);//18

    可以不用写var i

    22、声明变量以及作用域

    1. 	    	var f = true;
    2. 		 	if (f === true) {
    3. 				var a = 10;
    4. 			}
    5. 			function fn() {
    6. 				var b = 20;
    7. 				c = 30;
    8. 			}
    9. 			fn();
    10. 			console.log(a); //10
    11. 			console.log(b); //代码报错，以至于后面的代码也不会运行了
    12. 			console.log(c); //30

    23、this 作用域 隐式声明提升 原型 符号优先级

    1. 	       function Foo() {
    2. 				getName = function() {
    3. 					console.log(1);
    4. 				}
    5. 				return this;
    6. 			}
    7. 			Foo.getName = function() {console.log(2)}   
    8. 			Foo.prototype.getName = function() {console.log(3)}
    9. 			var getName = function() {console.log(4)}
    10. 			function getName() {console.log(5)}
    11. 			
    12. 			Foo.getName();  
    13. 			getName();  
    14. 			Foo().getName();   
    15. 			getName();   
    16. 			new Foo.getName();   
    17. 			new Foo().getName();  
    18. 			new new Foo().getName();

    函数点语法，是给函数添加一个方法，不会改变函数里面得代码

    new Foo()==>  this不是window，是创建的那个对象，就是构造函数的那三步

    1. 			/*
    2. 			var getName
    3. 			function Foo() {
    4. 				getName = function() {
    5. 					console.log(1);
    6. 				}
    7. 				return this;
    8. 			}
    9. 			Foo.getName = function() {console.log(2)}
    10. 			Foo.prototype.getName = function() {console.log(3)}
    11. 			getName = function() {console.log(4)}
    13. 			Foo.getName();    //2
    14. 			getName();   //4
    15. 				getName = function() {
    16. 					console.log(1);
    17. 				}
    18. 			Foo().getName();    //1
    19. 			getName();   //1
    22. 			new Foo.getName();   //2
    24. 			new Foo().getName();  //3
    25. 			//(new Foo()).getName()
    26. 			getName = function() {
    27. 					console.log(1);
    28. 				}
    29. 			//new Foo()==>   {__prroto__:Foo.prototype:Foo.prototype.getName = function() {console.log(3)}}
    30. 			//new Foo()==>  this不是window，是创建的那个对象，就是构造函数的那三步
    32. 			new new Foo().getName();  //3
    33. 			//new ((new Foo()).getName)();
    34. 				getName = function() {
    35. 					console.log(1);
    36. 				}
    38. 			new Foo()==>   {__prroto__:Foo.prototype:Foo.prototype.getName = function() {console.log(3)}} 
    39. 			*/

    24、把当前网页的url的参数解析为一个对象

       window.location.href    //获取当前地址的网址

    1.          window.location.href    //获取当前地址的网址
    2.             var url='http://www.baidu.com/?user=karen&page=10&count=100'
    3.             function parseurl (str) {
    4.                 var arr=str.split("?")[1]
    5.                 var arr2=arr.split("&")
    6.                 var obj={}
    7.                 for(var i=0;i<arr2.length;i++) {
    8.                     var arr3=arr2[i].split("=")
    9.                     obj[arr3[0]]=arr3[1]
    10.                 }
    11.                 return obj
    12.             }
    13.             var re=parseurl(url)
    14.             console.log(re)

    25、类型

    1.         console.log(typeof''.prototype)  
    2.         console.log(typeof''.__proto__)   
    3.         console.log(typeof''.__proto__===typeof''.prototype)

    1、'undefined'

    2、'object'     //new String() 是一个对象

    3、false

    26、map、parseInt

    1.         var re =['1','2','3'].map(parseInt)
    2.         console.log(re)

    结果：(3) [1, NaN, NaN]

    解析：

    map函数是将数组的每个元素传递给指定的函数处理，并返回处理后的数组，所以["1", "2", "3"].map(parseInt)就是将字符串1，2，3作为元素，0，1，2作为下标分别调用parseInt函数，即分别求出parseInt('1', 0)，parseInt('2', 1)，parseInt('3', 2)的结果

    ==> 
      //  parseInt('1', 0) -> 1   radix 为 0，parseInt() 会根据十进制来解析，所以结果为 1；
      //  parseInt('2', 1) -> radix 为 1，超出区间范围，所以结果为 NaN；
      //  parseInt('3', 2) -> NaN radix 为 2，用2进制来解析，应以 0 和 1 开头，所以结果为 NaN。
     
    因为parseInt接收两个参数，所以结果为 [1, NaN, NaN]
     

    知识：

    1、map方法会传递3个参数

    arr.map(function(item, index, arr){     .....    });

    2、parseInt  有两个参数

    第一个是string==>必须，要被解析的字符串

    第二个是radix==>可选，表示要解析的数字的基数，该值介于2-36 

    (默认值： 0x开头解析为16进制，0开头，解析为8或者16进制，1-9的数字开头，解析为10进制)

    如果省略该参数或其值为 0，则数字将以 10 为基础来解析。如果它以 “0x” 或 “0X” 开头，将以 16 为基数。如果该参数小于 2 或者大于 36，则 parseInt() 将返回 NaN。

    27、>>>

            console.log(-1 >>> 32)   //4294967295    2的32次方 -1

    28、find  findOne   get  filter

     答案：选 D

    29、不改变原来数组，拷贝出数组b，且满足b!=a

            请问下面哪种方式可以在不改变原来数组的情况下，拷贝出数组b，且满足b!=a

            例如数组a为[1,2,3]

            A.let b=a.slice()

            B.let b=a

            C.let b=a.splice(0,0)

            D.let b=a.concat()

    解析：此题类似于深拷贝，深拷贝是不改变原来的，而且让新的与原来的不相等，里面所有层都不相等==》此题是只要第一层不相等就可以了

    1.         var a=[1,2,3]
    2.         let b=a.slice()
    3.         console.log(a,b)   //(3) [1, 2, 3]  (3) [1, 2, 3]
    4.  
    5.         let c=a  //是同一个数组
    6.  
    7.         var a=[1,2,3]
    8.         let d=a.splice(0,0)  //下标为0的位置，删除0个元素，不插入元素。返回删除的元素装在数组中
    9.         console.log(a,d)  //(3) [1, 2, 3] []
    10.        
    11.         var a=[1,2,3]
    12.         let e=a.concat()  //数组的拼接，将a中的拼接到b中，所以成立
    13.         console.log(a,e)  //(3) [1, 2, 3] (3) [1, 2, 3]

    30、 优雅降级，渐进增强

    渐进增强：在网页开发中，渐进增强认为应该专注于内容本身，一开始针对低版本的浏览器构建页面，满足最基础功能后，再针对高级浏览器进行效果交互，追加各种功能以达到更好的用户体验；即以最低的要求实现最基本的功能，向上兼容

    优雅降级：指一开始针对高版本/高级浏览器进行页面构建，先完善所有功能后，再针对各个不同的浏览器进行测试，修复，保证低版本浏览器也有进本功能；即以高要求，高版本浏览器为准，向下兼容

    两者的区别：

    a. 优雅降级是从复杂的现状开始，并试图减少用户体验的供给

    b. 渐进增强则是从一个非常基础的，能够起作用的版本开始，并不断扩充，以适应未来环境的需要

    c. 降级（功能衰减）意味着往回看；而渐进增强则意味着朝前看，同时保证其根基处于安全地带。

  • 相关阅读:
    一个简单高效低内存的.NET操作Excel开源框架 - MiniExcel
    FPGA系统性学习笔记连载_Day1数字电路基础篇
    git merge rebase 分别什么时候用？
    Linux知识
    C++ —— string类的实用接口
    支持向量机：原理与python案例
    P1208 [USACO1.3] 混合牛奶 Mixing Milk
    安全关键软件开发与审定——DO-178C标准实践指南阅读笔记七——软件设计
    百度SEO不稳定的原因及解决方法（百度SEO不稳定因素的5大包括）
    MySql中分割字符串
  • 原文地址：https://blog.csdn.net/qq_52301431/article/details/125271301