JavaScript基础知识点归纳,JS常见面试题

应用原型+构造函数方式来定义对象

JavaScript基础知识点总结(推荐),javascript基础知识

概念在函数外的变量一定是全局变量;定义在函数内的变量,固然证明了var,那该变量正是一对变量,要是不证明var,那么该变量就是全局变量。

1、全局变量与一些变量 JavaScript

var global = "Global";
test();
function test(){
  var local = "Local";
  document.writeln(global);
  document.writeln(local);
}
document.writeln(global);
document.writeln(local); 

2、三种档案的次序的Cookie

i)长久性cookie,会被存放到顾客端的硬盘上。

ii)回话cookie:不会被储存到客户端的硬盘上,而是放在浏览器进度所处的内部存款和储蓄器其中,当浏览器关闭时则该答复cookie就销毁了。

3、在JavaScript中,函数(function)正是指标

4、在JavaScript中,没有主意(函数)重载的定义

5、Function对象

在JavaScript中有八个Function对象,全数自定义的函数都是Function对象类型的。Function对象接受的享有参数都以字符串类型的,当中最终二个参数便是要实行的函数体,而眼下的参数则是函数真正需求接受的参数。

6、隐含的对象arguments

在JavaScript中,各个函数都有二个满含的对象arguments,表示给函数实际传递的参数。arguments.length就意味着其实传递的参数的个数。

7、函数名.length

每二个函数对象都有一个length属性,表示该函数期望接受的参数个数。它与函数的arguments差别。arguments.length表示函数实际接受的参数个数。

8、JavaScript中有两种原始数据类型

Undefined、Null、Boolean、Number以及String。(注意:在JavaScript中,未有char数据类型)

Undefined数据类型的值唯有贰个:undefined;

Null数据类型的值唯有二个:null;

Boolean数据类型的值有多少个:true和false;

9、typeof运算符

typeof是一元运算符,后跟变量的名称,用于获取变量的数据类型,其再次来到值有5个:undefined、boolean、number、string以及object。

10、在JavaScript中,假设函数未有注脚重返值,那么会重回undefined11、null与undefined的关联

undefined实际上是从null派生出来的。举例:

null与undefined的关系

JavaScript

 alert(undefined == null);
//浏览器返回true 

11、强制类型调换

在JavaScript中有3种强制类型转换:Boolean(value),Number(value),String(value)。

12、Object对象

在JavaScript中,全部指标都以从Object对象继承过来的。

Object对象

JavaScript

var object = new Object();
for(var v in object){
  alert(v);
} 

地点的代码中,浏览器并从未打字与印刷出什么样,并无法证实Object对象不含有另外性质。下边代码测量检验Object对象中的属性是还是不是能够枚举,假如回到false,则证实Object对象中的属性是无法枚举的。

Object对象中的属性是不能够枚举的

JavaScript

alert(object.propertyIsEnumerable("prototype")); 

浏览器弹出false对话框,则证实Object对象中的属性是不能够枚举的。

接下去大家再看看window对象中的属性是或不是能够枚举的

window对象中的属性是能够枚举的

JavaScript

for (var v in window) {
  console.log(v);
} 

在Chrome浏览器中大家寻访到浏览器调节和测验调节台北打印出一大堆属性,表达window对象中的属性是足以枚举的。

13、在JavaScript中,能够动态增加对象的天性,也得以动态删除对象的属性

动态增加/删除对象的属性

JavaScript

var object = new Object();
alert(object.username);//undefined

object.username = "zhangsan";
alert(object.username);//zhangsan

object["password"] = "123";
alert(object.password);//123

delete object.username;//此时,username属性已经被删除
alert(object.username); 

14、JavaScript中定义对象最广泛的点子

概念对象最普及的措施

JavaScript

 var object = {
  username:"zhangsan",
  password:12345
};
alert(object.username);
alert(object.password);

15、数组

数组定义

JavaScript

//方法一
var array = new Array();
array.push(1);
array.push(2);
array.push(3);
alert(array.length);

//方法二(推荐)
var array = [1,25,4];
array.sort();
alert(array); 

调用数组的sort()方法,浏览器打字与印刷1,25,4,那并非大家愿意的结果。

对于JavaScript数组的sort方法来讲,它会先将待排序的内容调换为字符串(调用toString()方法),依照字符串的前后相继顺序进行排序。

下列方法能够获得大家期待的结果(按数组大小举办排序):

数组排序

JavaScript

function compare(num1,num2) {
  var temp1 = parseInt(num1);
  var temp2 = parseInt(num2);
  if (temp1 < temp2) {
    return -1;
  } else if (temp1 == temp2) {
    return 0;
  } else {
    return 1;
  }
}

var array = [1,25,3];
array.sort(compare);
alert(array); 

我们再用无名函数的不二等秘书技完成:

无名氏函数排序

JavaScript

var array = [1,25,3];

array.sort(function(num1,num2){
  var temp1 = parseInt(num1);
  var temp2 = parseInt(num2);
  if (temp1 < temp2) {
    return -1;
  } else if(temp1 == temp2) {
    return 0;
  } else {
    return 1;
  }
});

alert(array); 

16、JavaScript中定义对象的5种格局(JavaScript中未有类的定义,唯有对象)i)基于已有对象扩张其属性和办法

听别人说已有对象增添其性质和办法

JavaScript

 var object = new Object();
//添加name属性
object.name = "zhangsan";
//添加sayName方法
object.sayName = function(name) {
  this.name = name;
  alert(this.name);
};
object.sayName("kyle");//调用sayName方法,name属性被修改为kyle,浏览器将打印kyle 

最简便的一种艺术,使用起来并不便于,适合于一时须要一个对象。

ii)工厂格局制造对象

不带参数的工厂方法:

JavaScript

//工厂方法
function createObject() {
  var object = new Object();//创建一个对象
  object.name = "zhangsan";//为该对象添加一个name属性
  object.password = "123";//为该对象添加一个password属性
  object.get = function() {//为该对象添加一个get方法
    alert(this.name+","+this.password);
  };
  return object;//返回该对象
}

var object1 = createObject();//调用createObject工厂方法创建对象object1
var object2 = createObject();//调用createObject工厂方法创建对象object2
object1.get();//调用对象get方法
object2.get();//调用对象get方法 

带参数的工厂方法:

JavaScript

function createObject(name,password) {
  var object = new Object();
  object.name = name;
  object.password = password;
  object.get = function() {
    alert(this.name+","+this.password);
  };
  return object;
}

var object1 = createObject("zhangsan","123");
var object2 = createObject("lisi","456");
object1.get();
object2.get(); 

地点二种不带参数和带参数的厂子方法劣势:

每创立贰个指标,内部存款和储蓄器中就创办贰个get方法,比较浪费内部存款和储蓄器,且影响属性。而大家的冀望是,创制三个不等的靶子,它们的属性是区别的,但方法是国有的。所以接下去大家须要立异createObject工厂方法。

精耕细作的厂子方法:

JavaScript

function get(){
  alert(this.name+","+this.password);
}

function createObject(name,password) {
  var object = new Object();
  object.name = name;
  object.password = password;
  object.get = get;
  return object;
}

var object1 = createObject("zhangsan","123");
var object2 = createObject("lisi","456");
object1.get();
object2.get(); 

 将get方法定义在createObject函数外面,那样每创制一个目的,get方法都以公家的。让一个函数对象被多少个目的所分享,并非每一个目的都抱有一个函数对象。

iii)构造函数格局创制对象

不带参数的构造函数:

JavaScript

 

 function Person(){
  //在执行第一行代码前,js引擎会为我们生成一个对象
  this.name = "zhangsan";
  this.password = "123";
  this.getInfo = function() {
    alert(this.name+","+this.password);
  };

  //此处有一个隐含的return语句,用于将之前生成的对象返回(也是跟工厂方式不一样的地方)
}

var p1 = new Person();
p1.getInfo(); 

带参数的构造函数

JavaScript

function Person(name,password) {
  this.name = name;
  this.password = password;
  this.getInfo = function() {
    alert(this.name+","+this.password);
  };
}

var p1 = new Person("zhangsan","123");
var p2 = new Person("lisi","456");
p1.getInfo();
p2.getInfo(); 

iv)原型(prototype)格局创造对象

prototype是Object对象里面包车型大巴贰特质量

prototype

JavaScript

function Person(){

}
Person.prototype.name = "zhangsan";
Person.prototype.password = "123";
Person.prototype.getInfo = function() {
  alert(this.name+","+this.password);
};

var p1 = new Person();
var p2 = new Person();
p1.name = "kyle";//对象生成之后再去改变属性
p1.getInfo();
p2.getInfo(); 

独自地使用原型格局有五个难点:第一,你无法在构造函数中为属性赋初值,只好在对象生成之后再去改动属性值。

prototype

JavaScript

function Person(){

}
Person.prototype.name = new Array();
Person.prototype.password = "123";
Person.prototype.getInfo = function() {
  alert(this.name+","+this.password);
};

var p1 = new Person();
var p2 = new Person();
p1.name.push("zhangsan");
p1.name.push("lisi");
p1.password = "456";
p1.getInfo();
p2.getInfo() 

浏览器将会打印:zhangsan,lisi,456 和 zhangsan,lisi,123.

假如使用原型方式成立对象,那么生成的有所目标会分享原型中的属性,那样多个指标改变了该属性也会反射到任何对象其中。所以唯有地使用原型格局是可怜的,还亟需整合其余办法。接下来大家会继续介绍。

应用原型+构造函数方式来定义对象

JavaScript

function Person() {
  this.name = new Array();
  this.password = "123";
}
Person.prototype.getInfo = function() {
  alert(this.name+","+this.password);
};

var p1 = new Person();
var p2 = new Person();
p1.name.push("zhangsan");
p2.name.push("lisi");
p1.getInfo();
p2.getInfo(); 

选用原型+构造函数方式来定义对象,对象时期的性质互不干扰,各类对象间分享同三个方法,那是一种相比较好的法子。

v)动态原型方式

JavaScript

function Person(){
  this.name = "zhangsan";
  this.password = "123";
  if(typeof Person.flag == "undefined"){
    alert("invoked");
    Person.prototype.getInfo = function(){
      alert(this.name + "," + this.password);
    }
    Person.flag = true;
  }    
}

var p1 = new Person();
var p2 = new Person();
p1.getInfo();
p2.getInfo(); 

在动态原型情势中,在构造函数中经过标识量让具备目的分享二个方法,而各种对象具备和煦的习性。上边代码在首先次创造对象时,首先通过三个剖断语句,看flag属性是不是曾经定义,若未有定义,则经过原型方式丰硕getInfo方法,然后将flag设置为true,那么当第贰次成立对象时,if语句判断为假,跳超过实际行。那样就直达了大家所期待的结果,创立的靶子属性是互不困扰的,而指标的格局是分享的。

 17、JavaScript中目的的接续(5种方法)

首先种方法:对象冒充

改朝换代对象承袭

JavaScript

//父类
function Parent(username) {
  this.username = username;
  this.sayHello = function() {
    alert(this.username);
  };
}
//子类
function Child(username,password){
  //下面三行代码是最关键的
  this.method = Parent;
  this.method(username);
  delete this.method;

  this.password = password;
  this.sayWorld = function() {
    alert(this.password);
  };
}

var p = new Parent("zhangsan");
var c = new Child("lisi","123");

p.sayHello();
c.sayHello();
c.sayWorld() 

其次种格局:call()

后续的第二种实现格局,call方法措施,call方法是Function对象中定义的措施,因而大家定义的各类函数都有着该格局。call方法的首先个参数会被传送给函数中的this,从第1个参数起先,逐个赋给函数中的参数。

call 承接父类

JavaScript

function test(str) {
  alert(this.name+","+str);
}
var object = new Object();
object.name = "zhangsan";
//test.call相当于调用了test函数
test.call(object,"html5war");//将object赋给了this 

接下去大家用call方式贯彻指标的承继

JavaScript

//父类
function Parent(username){
  this.username = username;
  this.sayHello = function() {
    alert(this.username);
  };
}
//子类
function Child(username,password) {
  Parent.call(this,username);
  this.password = password;
  this.sayWorld = function() {
    alert(this.password);
  };
}

var p = new Parent("zhangsan");
var c = new Child("lisi","123");
p.sayHello();
c.sayHello();
c.sayWorld(); 

其三种办法:apply()

apply 承继父类

JavaScript

//父类
function Parent(username){
  this.username = username;
  this.sayHello = function(){
    alert(this.username);
  };
}
//子类
function Child(username,password){
  Parent.apply(this,new Array(username));
  this.password = password;
  this.sayWorld = function(){
    alert(this.password);
  };
}

var p = new Parent("zhangsan");
var c = new Child("lisi","123");
p.sayHello();
c.sayHello();
c.sayWorld(); 

apply方法与call方法很临近,apply方法也是概念在Function对象中的方法,由此大家定义的种种函数都有所该办法。

apply方法与call方法有一个分化:Parent.apply(this,new
Array(username));传递的第三个参数为一个数组,而call方法传递的是一些离散的多少参数。那四个艺术并不可能说什么人好什么人坏,要看具体选择情状。

第各种艺术:原型链情势(不恐怕给构造函数字传送递参数)

原型链承袭

JavaScript

function Parent() {

}
Parent.prototype.hello = "hello";
Parent.prototype.sayHello = function() {
  alert(this.hello);
};

function Child() {

}
Child.prototype = new Parent();

Child.prototype.world = "world";
Child.prototype.sayWorld = function() {
  alert(this.world);
};

var c = new Child();

c.sayHello();
c.sayWorld(); 

单独利用原型链方式的弱点:未有主意传递参数,独有等对象创造完现在再去修改。大家接下去结合其余的不二等秘书诀减轻那个主题材料。

第七种艺术:混合格局(推荐)

动用混合情势贯彻指标的接续

JavaScript

function Parent(hello) {
  this.hello = hello;
}
Parent.prototype.sayHello = function() {
  alert(this.hello);
}

function Child(hello,world) {
  Parent.call(this,hello);
  this.world = world;
}
Child.prototype = new Parent();
Child.prototype.sayWorld = function() {
  alert(this.world);
}

var c = new Child("hello","world");
c.sayHello();
c.sayWorld(); 

上述那篇JavaScript基础知识点归咎(推荐)正是我分享给我们的全体内容了,希望能给大家几个参阅,也期待大家多多帮助帮客之家。

定义在函数外的变量一定是全局变量;定义在函数内的变量,假诺声明了var,那该变量就…

typeof

typeof
能够对JS基础数据类型做出确切的论断,而对于援引类型再次来到的大概都以object,
其实重回object也远非错,因为兼具指标的原型链最后都指向了Object,Object是怀有指标的古时候的人。
但当我们须求知道某些对象的具体项目时,typeof 就显示存个别无可奈何了。

typeof ''; // string 有效
typeof 1; // number 有效
typeof true; //boolean 有效
typeof undefined; //undefined 有效
typeof null; //object 无效
typeof [] ; //object 无效
typeof new Function(); // function 有效
typeof new Date(); //object 无效
typeof new RegExp(); //object 无效

其三种格局:apply()

2.原型,原型链

所有因而对象直接量创制的目的都持有同三个原型对象,并能够透过JavaScript代码Object.prototype获得对原型对象的援用。通过重要字new和构造函数调用成立的指标的原型正是构造函数的prototype属性的值。

从没原型的靶子为数相当少,Object.prototype便是当中之一。它不三番五次任何性质。别的原型对象都以常常对象,普通对象都兼备原型。全数的放权构造函数(以及大部分自定义的构造函数)都装有贰个再三再四自Object.prototype的原型。一文山会海链接的原型对象就是所谓的“原型链”(prototype
chain)。

JavaScript

constructor

当几个函数F被定义时,JS引擎会为F增加prototype原型,然后再在prototype上增多三个constructor属性,并让其指向F的援用

f.constructor == F

细节难点:

  1. null和undefined是无效的靶子,由此是不会有constructor存在的,那三种档次的多寡需求通过typeof来推断。
  2. JS对象的constructor是不安静的,那几个根本呈今后自定义对象上,当开垦者重写prototype后,原有的constructor会错失,constructor会暗中认可为Object

8、JavaScript中有各个原始数据类型

7.call() 和 .apply() 的区别

都是用来退换函数的this对象的对准的,不过传参方式不平等,call,
apply方法分别是,从首个参数起,
call方法参数将逐一传递给借用的措施作参数,
而apply直接将这个参数放到八个数组中再传递,
最终借用方法的参数列表是同等的。

3、在JavaScript中,函数(function)便是目的

8.闭包

JavaScript基础知识点归纳,JS常见面试题。闭包是指有权访谈另一个函数功用域中变量的函数。
当某些函数第1回被调用时,会制造一个实践遇到(execution
context)及相应的效能域链,并把效果与利益域链赋值给叁个杰出的中间属性(即[[Scope]])。然后,使用this、arguments和别的命名参数的值来起头化函数的位移指标(activation
object)。

  1. 函数实施进程中,变量的读写要求在功能域中搜索,顺序是从内到外
  2. 闭包会延迟活动目的的灭绝时间
  3. 闭包指点了含有它的函数作用域,因而比另外函数占用更加多的内部存款和储蓄器
 var object = {
  username:"zhangsan",
  password:12345
};
alert(object.username);
alert(object.password);

9.类型决断

骨干类型:string,number,boolean
出奇种类:undefined,null
引用类型:Object,Function,Function,Array,Date,…

JavaScript

3.数码内部存款和储蓄器布满

栈:原始数据类型(Undefined,Null,Boolean,Number、String)
堆:引用数据类型(对象、数组和函数)

两连串型的区分是:存储地点分化;
原本数据类型直接存款和储蓄在栈(stack)中的简单数据段,攻下空间小、大小固定,属于被频繁利用数据,所以放入栈中存款和储蓄;
援用数据类型存款和储蓄在堆(heap)中的对象,攻下空间大、大小不牢固。假诺存款和储蓄在栈中,将会耳熟能详程序运转的特性;引用数据类型在栈中储存了指针,该指针指向堆中该实体的开头地址。当解释器搜索引用值时,会首先检索其在栈中的地址,取得地方后从堆中获取实体

伪造对象承袭

5.什么样创造对象?

  1. 工厂形式
  2. 构造函数情势
  3. 原型模式
  4. 组成使用构造函数和原型情势
  5. 动态原型形式
  6. 寄生构造函数方式
  7. 安妥构造函数形式

切实解说参见《JavaScript高端程序设计》

JavaScript

instanceof

instanceof 是用来判断 A 是或不是为 B 的实例对,表明式为:A instanceof
B,即使A是B的实例,则赶回true,不然重临false。
在那边须求非常注意的是:instanceof检查实验的是原型。不过,instanceof
只好用来剖断三个对象是或不是属于原型链的关联,
而不能够得到对象的现实性品种。例子如

[] instanceof Array; //true
[] instanceof Object; //true

Object对象

1.主干数据类型有哪些?

Undefined、Null、Boolean、Number、String

第七种方法:混合情势(推荐)

6.null和undefine的区别

null表示”没有对象”,即该处不该有值。规范用法是:

  1. 用作函数的参数,表示该函数的参数不是目的。
  2. 作为靶子原型链的终点。

undefined表示”贫乏值”,就是这里应该有叁个值,可是还尚未定义,规范用法是:

  1. 变量被声称了,但并未有赋值时,就等于undefined。
  2. 调用函数时,应该提供的参数未有提供,该参数等于undefined。
  3. 目的未有赋值的习性,该属性的值为undefined。
  4. 函数未有重返值时,暗中同意再次回到undefined。

参照链接undefined与null的区别

动态增进/删除对象的属性

Object.prototype.toString

toString是Object原型对象上的三个艺术,该形式私下认可重回其调用者的求实项目,更严苛的讲,是
toString运行时this指向的靶子类型,
再次回到的品种格式为[object,xxx],xxx是现实的数据类型,比方

Object.prototype.toString.call('') ;   // [object String]
Object.prototype.toString.call(1) ;    // [object Number]
Object.prototype.toString.call(true) ; // [object Boolean]
Object.prototype.toString.call(undefined) ; // [object Undefined]
Object.prototype.toString.call(null) ; // [object Null]
Object.prototype.toString.call(new Function()) ; // [object Function]
Object.prototype.toString.call(new Date()) ; // [object Date]
Object.prototype.toString.call([]) ; // [object Array]

to be continued …

数组排序

4.怎么着达成一而再?

  1. 结构承接:使用call或apply方法,将父对象的构造函数绑定在子对象上
  2. 原型继承:将子类的prototype指向父类的prototype
  3. 拷贝承接:拷贝父对象的富有属性和方法

此伏彼起的第三种完成形式,call方法措施,call方法是Function对象中定义的情势,因而大家定义的各种函数都富有该措施。call方法的率先个参数会被传送给函数中的this,从第3个参数开端,逐条赋给函数中的参数。

function Parent(hello) {
  this.hello = hello;
}
Parent.prototype.sayHello = function() {
  alert(this.hello);
}

function Child(hello,world) {
  Parent.call(this,hello);
  this.world = world;
}
Child.prototype = new Parent();
Child.prototype.sayWorld = function() {
  alert(this.world);
}

var c = new Child("hello","world");
c.sayHello();
c.sayWorld(); 

7、函数名.length

ii)工厂格局成立对象

apply 继承父类

每创立贰个目的,内部存款和储蓄器中就创办多个get方法,相比较浪费内部存储器,且影响属性。而我们的期望是,创立三个区别的对象,它们的属性是分裂的,但方法是公家的。所以接下去咱们需求改进createObject工厂方法。

JavaScript

function Person() {
  this.name = new Array();
  this.password = "123";
}
Person.prototype.getInfo = function() {
  alert(this.name+","+this.password);
};

var p1 = new Person();
var p2 = new Person();
p1.name.push("zhangsan");
p2.name.push("lisi");
p1.getInfo();
p2.getInfo(); 
function Person(){
  this.name = "zhangsan";
  this.password = "123";
  if(typeof Person.flag == "undefined"){
    alert("invoked");
    Person.prototype.getInfo = function(){
      alert(this.name + "," + this.password);
    }
    Person.flag = true;
  }    
}

var p1 = new Person();
var p2 = new Person();
p1.getInfo();
p2.getInfo(); 

undefined实际上是从null派生出来的。举例:

第各种方法:原型链方式(不可能给构造函数字传送递参数)

JavaScript

独有利用原型链格局的劣点:未有主意传递参数,独有等对象成立完未来再去修改。大家接下去结合其他的措施减轻那么些主题素材。

JavaScript

JavaScript

 将get方法定义在createObject函数外面,那样每创设三个对象,get方法都以集体的。让叁个函数对象被三个对象所分享,实际不是每三个对象都独具一个函数对象。

//父类
function Parent(username){
  this.username = username;
  this.sayHello = function(){
    alert(this.username);
  };
}
//子类
function Child(username,password){
  Parent.apply(this,new Array(username));
  this.password = password;
  this.sayWorld = function(){
    alert(this.password);
  };
}

var p = new Parent("zhangsan");
var c = new Child("lisi","123");
p.sayHello();
c.sayHello();
c.sayWorld(); 

v)动态原型格局

下列格局得以赢得我们期望的结果(按数组大小进行排序):

Null数据类型的值独有多个:null;

var global = "Global";
test();
function test(){
  var local = "Local";
  document.writeln(global);
  document.writeln(local);
}
document.writeln(global);
document.writeln(local); 
function Parent() {

}
Parent.prototype.hello = "hello";
Parent.prototype.sayHello = function() {
  alert(this.hello);
};

function Child() {

}
Child.prototype = new Parent();

Child.prototype.world = "world";
Child.prototype.sayWorld = function() {
  alert(this.world);
};

var c = new Child();

c.sayHello();
c.sayWorld(); 

prototype

13、在JavaScript中,能够动态拉长对象的质量,也能够动态删除对象的习性

浏览器将会打字与印刷:zhangsan,lisi,456 和 zhangsan,lisi,123.

若果运用原型形式创设对象,那么生成的具备目的会分享原型中的属性,那样三个指标更换了该属性也会反射到任何对象在这之中。所以唯有地运用原型格局是丰硕的,还亟需结合别的办法。接下来大家会持续介绍。

4、在JavaScript中,未有章程(函数)重载的概念

1、全局变量与局地变量

prototype是Object对象里面包车型地铁贰本品质

在JavaScript中有3种强制类型转变:Boolean(value),Number(value),String(value)。

上述那篇JavaScript基础知识点归结(推荐)就是小编分享给大家的全体内容了,希望能给我们一个参阅,也可望大家多多协助脚本之家。

调用数组的sort()方法,浏览器打字与印刷1,25,4,这并非我们盼望的结果。

16、JavaScript中定义对象的5种方法(JavaScript中尚无类的概念,唯有对象)i)基于已有目的扩张其品质和方法

Undefined数据类型的值独有叁个:undefined;