JS有哪些数据类型，基本类型有哪些，引用类型有哪些

• JS有7种数据类型：

  三种基本类型——数字(number)、字符串(Sring)、布尔(Boolean)；

  两种引用数据类型——对象(Object)、数组(Array)；

  两种特殊数据类型——undefined、null

• JS有5种原始类型：数字、字符串、布尔、undefined、null

• typeOf运算符是检测变量或值的数据类型。

JS有哪些内置对象

• Object是JavaScript中所有对象的父对象
• 数据封装类对象：对象、数组、布尔、数字、字符串
• 其他对象：Function、Argument、Math、Date、RegExp、Error

列举JavaScript的基本代码规范

• 不要在同一行声明多个变量
• 如果不知道数组的长度，使用push
• 请使用===/!===来比较true/false或者数值
• 对字符串使用单引号‘’（因为大多数字符串，特别是html会出现“ ”)
• 使用对象字面量代替new Array这种形式

JavaScript中如何检测一个变量是String类型？请写出函数实现

1

type (obj) === "string"

2

type obj === "string"

3

obj.constructor ===String

请用js去除字符串空格

• 方法一：使用replace正则匹配的方法

  去除所有空格：str = str.replace(/\s*/g,“”);

  去除两头空格：str = str.replace(/^\s*|\s*$/g,"");

  去除左空格：str = str.replace(/(\s*$)/g,"");

  str为要去除空格的字符串，实例如下：

  javascript

  1	var str = " 23 23 ";
  2	var str2 = str.replace(/\s*/g,"");
  3	console.log(str2); //2323

• 方法二：使用str.trim()方法

  str.strm()的局限性：无法去除中间的空格，实例如下：

  javascript

  1	var str = " xiao ming ";
  2	var str2 = str.trim();
  3	console.log(str2); //xiao ming

  同理，str.trimLeft()，str.trimRight()分别用于去除字符串左右空格

• 方法三：使用jQuery，$.trim(str)方法

  $.trim(str)局限性：无法去除中间的空格，实例如下：

  javascript

  1	var str = " xiao ming ";
  2	var str2 = $.trim(str);
  3	console.log(str2); //xiao ming

JS字符串操作函数

列举了常用的字符串函数，具体使用方法，请参考网址

添加、移除、移动、复制、创建和查找节点

• 创建新节点

  javascript

  1	createDocumentFragment() //创建一个DOM片段
  2	createElement() //创建一个具体的元素
  3	createTextNode() //创建一个文本节点

• 添加、移除、替换、插入

  javascript

  1	appendChild() //添加
  2	removeChild() //移除
  3	replaceChild() //替换
  4	insertBefore() //插入

• 查找

  javascript

  1	getElementsByTagName() //通过标签名称
  2	getElementsByName() //通过元素的Name属性的值
  3	getElementById() //通过元素id，具有唯一性

比较typeOf与instanceOf

相同点

JavaScript中typeOf和instanceOf常用来判断一个变量是否为空，或者是什么类型的

typeOf的定义与用法：返回值是一个字符串，用来说明变量的数据类型。

细节

1. typeof一般只返回如下几个结果： number、boolean、string、function、object、undefined

2. typeof来获取一个变量是否存在，如if(typeOf a!="undefined"){alert("ok")}而不是去使用if(a)因为如果a不存在（未声明）则会出错

3. 对于Array，Null等特殊对象使用typeOf一律返回object，这正是typeOf的局限性。

   instanceof定义与用法：instanceof用于判断一个变量是否属于某个对象的实例

   实例演示：

   a instanceOf b?alert("true"):alert("false"); //a是b的实例？真:假

   javascript

   1	var a = new Array();
   2	alert(a instanceOf Array); //true
   3	alert(a instanceOf Object); //false

   如上，会返回true，同时alert(a instanceOf Object)也会返回true；这是因为Array是object的子类。

   javascript

   1	function test() {};
   2	var a = new test();
   3	alert(a instanceOf test); //true

   细节

   如下，得到的结果为’N‘，这里的instanceof测试的object是指js语法中的object，不是指dom模型对象。

   javascript

   1	if (window instanceOf Object) {
   2	alert('Y')
   3	}else {
   4	alert('N'); //'N'
   5	}

call和apply的作用是什么？区别是什么？

• call和apply的功能基本相同，都是实现继承或者转换对象指针的作用；

• 唯一不通的是前者参数是罗列出来的，后者是存到数组中的；

• call和apply的功能就是实现继承的；与面向对象的继承extends功能相似；但是写法不同；

• 语法：

  javascript

  1	.call(obj,“参数1”,“参数2”);

  javascript

  1	.apply(obj,new Array(“参数1”,“参数2”));

push()、pop()、shift()、unshift()分别是什么功能

• push 方法

  将新元素添加到一个数组中，并返回数组的新长度值

  javascript

  1	var a=[1,2,3,4];
  2	a.push(5);

• pop 方法

  移除数组中的最后一个元素并返回该元素

  javascript

  1	var a=[1,2,3,4];
  2	a.pop();

• shift 方法

  移除数组中的第一个元素并返回该元素

  javascript

  1	var a=[1,2];
  2	alert(a.shift());

• unshift 方法

  将指定元素插入数组开始位置并返回该数组

说说对JavaScript this工作原理的理解

在函数中：this通常是一个隐含的参数

在函数外（顶级作用域中）：在浏览器中this指的是全局对象；在Node.js中指的是模块（module）的导出（exports）

传递到eval()中的字符串：如果eval()是被直接调用的，this指的是全局对象；如果eval()是被间接调用的，this就是指的是全局对象。

写出3个使用this的典型应用

• 在html元素属性中使用，如：

  html

  1	<input type="button" onclick="showInfo(this);" value="点击一下"/>

• 构造函数

  javascript

  1	function Animal(name, color) {
  2	this.name = name;
  3	this.color = color;
  4	}

• input点击、获取值

  html

  1	<input type="button" id="text" value="点击一下" />
  2	<script>
  3	var btn = document.getElementById("text");
  4	btn.onclick = function () {
  5	alert(this.value); //此处的this是按钮元素
  6	}
  7	</script>

• apply()和call()求数组最值

  javascript

  1	var numbers = [5,458,120,-215];
  2	var maxInNumber = Math.max.apply(this, numbers);
  3	console.log(maxInNumber); //458
  4	var maxInNumber = Math.max.call(this, 5,458,120,-215);
  5	console.log(maxInNumber); //458

介绍一下JavaScript原型，原型链，他们有什么特点

每个对象都会在其内部初始化一个属性，就是prototype(原型)，当我们访问一个对象的属性时，如果这个对象内部不存在这个属性，那么他就会去prototype里找这个属性，这个prototype又会有自己的prototype，于是这样一直找下去，也就是我们平时所说的原型链的概念。

• 关系：

  instance.constructor.prototype = instance._proto_

• 特点：

  JavaScript对象是通过引用来传递的，我们创建的每个新对象实体中并没有一份属于自己的原型副本，当我们修改原型时，与之相关的对象也会继承这一改变。

  当我们需要一个属性时，JavaScript引擎会先看当前对象中是否有这个属性，如果没有的话，就会查找它的prototype对象是否有这个属性，如此递推下去，一致检索到Object内建对象。

  javascript

  1	function Func(){
  2	Func.prototype.name = "Xiao Ming";
  3	Func.prototype.getInfo = function(){
  4	return this.name;
  5	}
  6	var person = new Func();
  7	console.log(person.getInfo()); //"Xiao Ming"
  8	consloe.log(Func.prototype); //Func {name = "Xiao Ming",getInfo = function()}
  9	}

对闭包的理解

• 定义与用法：当一个函数的返回值是另外一个函数，而返回的那个函数如果调用了其父函数内部的其他变量，如果返回的这个函数在外部被执行，就产生了闭包

• 表现形式： 使函数外部能够调用函数内部定义的变量

• 实例如下：

  根据作用域链的规则，底层作用域没有声明的变量，会向上一级找，找到就返回，没找到的就会一直找，直到windows的变量，没有就返回undefined。这里明显count是函数内部的flag2的那个count。

  javascript

  1	var count = 10; //全局作用域 标记为flag1
  2	function add() {
  3	var count=0; //函数全局作用域 标记为flag2
  4	return function() {
  5	count+=1; //函数的内部作用域
  6	alert(count);
  7	}
  8	}
  9	var s = add ()
  10	s(); //输出1
  11	s(); //输出2

• 变量的作用域

  要理解闭包，首先必须理解JavaScript特殊的变量作用域

  变量的作用域分类：全局变量和局部变量

  特点：

  1. 函数内部可以读取函数外部的全局变量；在函数外部无法读取函数内的局部变量
  2. 函数内部声明变量的时候，一定要使用var命令。如果不用的话，实际上声明一个全局变量！

• 使用闭包的注意点

  1. 滥用闭包，会造成内存泄漏：由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不要滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄漏

     解决办法，在退出函数之前，将不使用的局部变量全部删除。

  2. 会改变父函数内部变量的值。所以，如果把父函数当作对象（object）使用，把闭包当作它的公用方法（Public Method），把内部变量当作它的私有属性（private value），这时一定要小心，不要随便改变父函数内部变量的值。

什么是跨域？跨域请求资源的方法有哪些？

什么是跨域

由于浏览器同源策略，凡是发送请求url的协议、域名、端口三者之间任意一与当前页面地址不同即为跨域。存在跨域的情况：

• 网络协议不同，如http协议访问https协议
• 端口不同，如80端口访问8080端口
• 域名不同，如song77.top访问baidu.com
• 子域名不同，如abc.song77.top访问def.song77.top
• 域名和域名对应ip，如www.rjyfzx.com访问59.72.194.42

跨域请求资源的方法

1. proxy代理

   定义与用法：proxy代理用于将请求发送给后台服务器，通过服务器来发送请求，然后将请求的结果传递给前端。

   实现方法：通过nginx代理；

   注意点：如果代理的是https协议的请求，那么proxy首先需要信任该证书（尤其是自定义证书）或者忽略证书检查，否则请求无法成功

2. CORS 【Corss-Origin Resource Sharing】

   定义与用法：是现代浏览器支持跨域资源请求的一种常用的方式

   使用方法：一般需要后端人员在处理请求数据的时候，添加允许跨域的相关操作。

   ada

   1	res.writeHead(200, {
   2	"Content-Type": "text/html; charset=UTF-8",
   3	"Access-Control-Allow-Origin":'http://localhost',
   4	'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
   5	'Access-Control-Allow-Headers': 'X-Requested-With, Content-Type'
   6	})

3. jsonp

   定义与用法：通过动态插入一个script标签。浏览器对script的资源引用没有同源限制，同时资源加载到页面会立即执行（没有阻塞的情况下）

   特点：通常情况下，通过动态创建script来读取它域的动态资源，获取的数据一般为json格式

   实例：

   javascript

   1	<script>
   2	function testjsonp(data){
   3	console.log(data.name);
   4	}
   5	</script>
   6	<script>
   7	var _script = document.createElement('script');
   8	_script.type = "text/javascript";
   9	_script.src = "http://localhost:8888/jsonp?callback=testjsonp";
   10	document.head.appendChild(_script);
   11	</script>

   缺点：

   1. 这种方法无法发送post请求
   2. 另外要确定jsonp的请求是否失败并不容易，大多数框架的实现都是结合超时时间来判定。

垃圾回收机制方式及内存管理

回收机制方式

1. 定义与用法：垃圾回收机制（GC：Garbage Collection），执行环境负责管理代码执行过程中使用的内存。

2. 原理：垃圾收集器会定期（周期性）找出那些不存在继续使用的变量，然后释放其内存。但是这个过程不是实时的，因为其开销比较大，所以垃圾回收器会按照固定的时间间隔周期性的执行。

3. 实例：

   javascript

   1	function fn1() {
   2	var obj = {name: 'hanzichi', age: 10};
   3	}
   4	function fn2() {
   5	var obj = {name: 'hanzichi',age: 10};
   6	return obj;
   7	}
   8	var a = fn1();
   9	var b = fn2();

   fn1中定义的obj为局部变量，而当调用结束后，出了fn1的环境，那么该块内存会被js引擎中的垃圾回收器自动释放；在fn2被调用的过程中，返回的对象被全局变量b所指向，所以该块内存并不会被释放。

4. 垃圾回收策略：标记清除（较为常用）和引用计数

   标记清除

   定义与用法：当变量进入环境时，将变量标记“进入环境”，当变量离开环境时，标记为： “离开环境”。某一时刻，垃圾回收器会过滤掉环境中的变量，以及被环境变量引用的变量，剩下的就是被视为回收的变量。

   到目前为止，IE，Firefox，Opera，Chrome，Safari的js实现使用的都是标记清除的垃圾回收策略或类似的策略，只不过垃圾收集时间间隔互不相同。

   引用计数

   定义与用法：引用计数是跟踪记录每个值被引用的次数

   基本原理：就是变量的引用次数，被引用一次则加1，当这个引用计数为0时，被视为准备回收的对象。

内存管理

1. 什么时候触发垃圾回收？

   垃圾回收周期性运行，如果分配的内存非常多，那么回收工作也会很艰巨，确定垃圾回收时间间隔就变成一个值得思考的问题。

   IE6的垃圾回收是根据内存分配量运行的，当环境中的变量，对象，字符串达到一定数量时触发垃圾回收。垃圾回收器一直处于工作状态，严重影响浏览器性能。

   IE7中，垃圾回收器会根据内存分配量与程序占用内存的比例进行状态调整，开始回收工作。

2. 合理的GC方案：（1）遍历所有可访问的对象 、（2）回收已不可访问的对象

3. GC缺陷：停止响应其他操作；

4. GC优化策略：（1）分代回收（Generation GC），（2）增量GC

开发过程中遇到内存泄露情况，该如何解决

定义与用法

内存泄露是指一块被分配的内存既不能使用，又不能回收，直到浏览器进程结束。C#和Java等语言采用了自动垃圾回收方法管理内存，几乎不会发生内存泄露。我们知道，浏览器中也是采用自动垃圾回收方法管理内存，但是由于浏览器垃圾回收方法有bug，会产生内存泄露

内存泄露的几种情况

1. 当页面中元素被移除或者替换时，若元素绑定的事件仍没被移除，在IE中不会做出恰当处理，此时要先手工移除事件，不会存在内存泄露

   实例如下：

   html

   1	<div id="myDiv">
   2	<input type="button" value="Click me" id="myBtn">
   3	<div>
   4	<script>
   5	var btn = document.getElementById("myBtn");
   6	btn.onclick = function() {
   7	document.getElementById("myDiv").innerHTML="Processing...";
   8	}
   9	</script>

   解决方法如下：

   html

   1	<div id="myDiv">
   2	<input type="button" value="Click me" id="myBtn">
   3	</div>
   4	<script>
   5	var btn = document.getElementById("myBtn");
   6	btn.onclick = function() {
   7	btn.onclick = null;
   8	document.getElementById("myDiv").innerHTML="Processing...";
   9	}
   10	</script>

2. 由于是函数内定义函数，并且内部函数——事件回调的引用外暴了，形成了闭包。闭包可以维持函数内局部变量，使其得不到释放

   实例如下：

   javascript

   1	function bindEvent(){
   2	var obj=document.createElement("xxx");
   3	obj.onclick=function() {
   4	//Even if it's empty function
   5	}
   6	}

   解决方法如下：

   javascript

   1	function bindEvent() {
   2	var obj=documnet.createElement("xxx");
   3	obj.onclick=function(){
   4	//Even if it's a empty function
   5	}
   6	obj=null;
   7	}

JavaScript面向对象中继承实现？

面向对象的基本特征有：封闭、继承、多态

在JavaScript中实现继承的方法：

1. 原型链（prototype chaining）
2. call() /apply()
3. 混合模式（prototype和call()/apply()结合）
4. 对象冒充

继承的方法如下：

1. prototype原型链方式

   javascript

   1	function teacher(name){
   2	this.name = name;
   3	}
   4	teacher.prototype.sayName = function() {
   5	console.log("name is "+this.name);
   6	}
   7	var teacher1 = new teacher("xiao ming");
   8	teacher1.sayName();
   9
   10	function student(name) {
   11	this.name = name;
   12	}
   13	student.prototype = new teacher()
   14	var student1 = new student("xiaolan");
   15	student1.sayName();
   16	// name is xiaoming
   17	// name is xiaolan

2. call() /apply()方法

   javascript

   1	function teacher(name,age){
   2	this.name = name;
   3	this.age = age;
   4	this.sayhi = function(){
   5	alert('name:'+name+", age:"+age);
   6	}
   7	}
   8	function student(){
   9	var args = arguments;
   10	teacher.call(this,args[0],args[1]);
   11	// teacher.apply(this,arguments);
   12	}
   13	var teacher1 = new teacher('xiaoming',23);
   14	teacher1.sayhi();
   15
   16	var student1 = new student('xiaolan',12);
   17	student1.sayhi();
   18
   19	// alert: name:xiaoming, age:23
   20	// alert: name:xiaolan, age:12

3. 混合方法（prototype，call()/apply())

   javascript

   1	function teacher(name,age){
   2	this.name = name;
   3	this.age = age;
   4	}
   5	teacher.prototype.sayName = function(){
   6	console.log('name:'+this.name);
   7	}
   8	teacher.prototype.sayAge = function(){
   9	console.log('age:'+this.age);
   10	}
   11
   12	function student(){
   13	var args = arguments;
   14	teacher.call(this,args[0],args[1]);
   15	}
   16	student.prototype = new teacher();
   17
   18	var student1 = new student('xiaolin',23);
   19	student1.sayName();
   20	student1.sayAge();
   21	// name:xiaolin
   22	// age:23

4. 对象冒充

   javascript

   1	function Person(name,age){
   2	this.name = name;
   3	this.age = age;
   4	this.show = function(){
   5	console.log(this.name+", "+this.age);
   6	}
   7	}
   8
   9	function Student(name,age){
   10	this.student = Person; //将Person类的构造函数赋值给this.student
   11	this.student(name,age); //js中实际上是通过对象冒充来实现继承的
   12	delete this.student; //移除对Person的引用
   13	}
   14
   15	var s = new Student("小明",17);
   16	s.show();
   17
   18	var p = new Person("小花",18);
   19	p.show();
   20	// 小明, 17
   21	// 小花, 18

JavaScript数组（Array）对象

Array相关的属性和方法

只做相关的列举，具体的使用方法，参考网址

• Array对象属性

  constructor 返回对创建此对象的数组函数的引用。

  length 设置或返回数组中元素的数目。

  prototype 使您有能力向对象添加属性和方法。

• Array对象方法

  concat() 连接两个或更多的数组，并返回结果。

  join() 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。

  pop() 删除并返回数组的最后一个元素。

  shift() 删除并返回数组的第一个元素

  push() 向数组的末尾添加一个或更多元素，并返回新的长度。

  unshift() 向数组的开头添加一个或更多元素，并返回新的长度。

  reverse() 颠倒数组中元素的顺序。

  slice() 从某个已有的数组返回选定的元素

  sort() 对数组的元素进行排序

  splice() 删除元素，并向数组添加新元素。

  toSource() 返回该对象的源代码。

  toString() 把数组转换为字符串，并返回结果。

  toLocaleString() 把数组转换为本地数组，并返回结果。

  valueOf() 返回数组对象的原始值

编写一个方法，去掉一个数组的重复元素

方法1：

1

var arr = [0,2,3,4,4,0,2];

2

var obj = {};

3

var tmp = {};

4

for(var i = 0;i< arr.length;i++) {

5

    if( !obj[arr[i]]){

6

        abj[arr[i]] = 1;

7

        tmp.push(arr[i]);

8

    }

9

}

10

console.log(tmp);

11

// [0,2,3,4]

方法2：

1

var arr = [2,3,4,4,5,2,3,6],

2

   arr2 = [];

3

for(var i = 0;i< arr.length;i++){

4

    if(arr2.indexOf(arr[i]) < 0){

5

        arr2.push(arr[i]);

6

    }

7

}

8

console.log(arr2);

9

// [2,3,4,5,6]

方法3:

1

var arr = [2,3,4,4,5,2,3,6];

2

var arr2 = arr.filter(function(element,index,self){

3

return self.indexOf(element) === index;

4

});

5

console.log(arr2);

6

// [2,3,4,5,6]

JavaScript相关程序计算题

判断一个字符串中出现次数最多的字符，统计这个次数

1

var str = 'asdfssaaasasasasaa';

2

var json = {};

3

for (var i = 0; i < str.length; i++) {

4

    if(!json[str.charAt(i)]){

5

       json[str.charAt(i)] = 1;

6

    }else{

7

       json[str.charAt(i)]++;

8

    }

9

};

10

var iMax = 0;

11

var iIndex = '';

12

for(var i in json){

13

    if(json[i]>iMax){

14

         iMax = json[i];

15

         iIndex = i;

16

    }

17

}        

18

console.log('出现次数最多的是:'+iIndex+'出现'+iMax+'次');

19

//出现次数最多的是：a 出现9次