这是个人第一次JavaScript初级技巧

Github来源：这是个人第一次JavaScript初级技巧 | 求星星 ✨ | 给个❤️关注，❤️点赞，❤️鼓励一下做者

你们好，我是魔王哪吒，很高兴认识你~~

哪吒人生信条：若是你所学的东西 处于喜欢 才会有强大的动力支撑。

天天学习编程，让你离梦想更新一步，感谢不负每一份热爱编程的程序员，不论知识点多么奇葩，和我一块儿，让那一颗四处流荡的心定下来，一直走下去，加油，2021加油！欢迎关注加我vx:xiaoda0423，欢迎点赞、收藏和评论

不要惧怕作梦，可是呢，也不要光作梦，要作一个实干家，而不是空谈家，求真力行。

前言

若是这篇文章有帮助到你，给个❤️关注，❤️点赞，❤️鼓励一下做者，接收好挑战了吗？文章公众号首发，关注 程序员哆啦A梦 第一时间获取最新的文章

❤️笔芯❤️~

JavaScript工做原理

1. HTML超文本标记语言 来指定网页的内容和结构
2. CSS层叠样式表 来指定网页的外观，CSS用于指定样式，独立于网页结构的方式实现的
3. JavaScript可以在网页中添加行为

JavaScript的变量和值

1. 声明变量时，老是以关键字var打头。
2. 任何状况下，都应该这样作，尽管省略关键字var，JavaScript也不会报错。
3. 建立变量时，能够不给它指定初始值，之后再给它赋值。（变量说：没有值，那我不是没什么用了，伤害不大，侮辱性极强）

变量说，我也是有（名字）的。--- 可不能随随便便给我命名呢？

• 第一，要以字母，下划线，或者美圆符号开头。
• 第二，而后可使用任意数量的字母，数字，下划线，或者美圆符号。

对了，还有不要使用任何内置的关键字 哦！（达达问：那我怎么知道有哪些关键字呢？变量：哈哈！是的，不少关键字，我也记不住，可是经常使用的，多了解的，慢慢就知道了，也不用去记住。让我变量告诉你哦，因此就别把这些给我命名了哦）

例如如下关键字：

break,delete,for,let,super,void,case,do,function,new,switch,
while,catch,package,this,with,class,enum,implements,
else,if,package,private,throw,yield,const,export,import,
protected,true,continue,extends,in,public,try,debugger,
false,instanceof,return,typeof,default,finally,
interface,static,var

达达问：那什么是关键字呢？

哪吒：关键字就是JavaScript用于特殊目的的，关键字是JavaScript保留字。

达达问：若是变量名中包含关键字

哪吒：能够的，只要变量名不和关键字彻底相同就行。

注意写法规范：第一，每条语句后都要以分号结尾；第二，写代码要进行注解，用于你本身或其余开发人员的解释代码其做用；第三，JavaScript中是区分大小写的哦。

布尔运算符

布尔运算符用于结果为 true或 false的布尔表达式中。

有两种布尔运算符：1.比较运算符 和 2.逻辑运算符。

1. 比较运算符，比较运算符对两个值进行比较。

下面是一些常见的比较运算符：

< 表示小于
> 表示大于
== 表示等于
=== 表示正好等于
<= 表示小于或等于
>= 表示大于或等于
!= 表示不等于

1. 逻辑运算符：

逻辑运算符将两个布尔表达式合而为一，获得一个布尔结果。

|| 表示OR(或)，只要至少有一个表达式为true，结果就为true
&& 表示ADN(与)，仅当两个表达式都为true时，结果才为true
! 表示NOT(非)，仅当表达式为false时，结果才为true

Math.random

1. Math.random生成0~1（不包含1）的数字，使用Math.random可生成的最大数字为0.9999...。
2. Math.floor老是向下取整，如1.2取整为1。

全局变量和局部变量

1. 若是变量在函数外声明的，它就是全局变量；
2. 若是变量是在函数中声明的，它就是局部变量。

了解局部变量和全局变量的做用域

变量的定义位置决定了其做用域，即变量在代码的哪些地方可见，哪些地方不可见。

生命周期：

1. 全局变量是在JavaScript代码中加载到网页以后降生的，在网页消失后死去。从新加载网页时，将销毁并从新建立全部的全局变量。
2. 局部变量通常是在函数结束时消失的，局部变量是在函数被调用后建立的，并一直活到函数返回，不管函数是否有返回值。

注意，别忘记了声明局部变量哦！由于使用未声明的变量时，它将会自动被视为全局变量，即便你在函数中首次使用它也是如此。

若是局部变量和全局变量同名，那么引用的都是局部变量，而不是全局变量，全局变量和局部变量不会相互影响，若是修改其中一个，对另外一个不会有任何影响，它们是彼此独立的变量。

示例：

var dada = 12;
function getName(name) {
 var dada = 123;
 // 有一个名为dada的全局变量，还有一个名为dada的局部变量。
}

达达：因此能够将形参和全局变量同名吗？

哪吒：不能够的，和在函数中声明了与全局变量同名的局部变量同样，若是形参与全局变量同名，该形参会遮挡相应的全局变量。

规范：写代码是要将局部变量写在函数开头声明，在函数开头声明局部变量是一种良好的编程实践，这可让别人阅读你的代码时可以容易找到这些声明，清楚看到函数使用了哪些变量。

函数的读取

JavaScript可将函数在使用前仍是使用后声明。

例如：

var dada = 12;
var jeskson = dadaFun(dada);
console.log(jeskson);

function dadaFun(name) {
 run name;
}

实际上浏览器读取分：

1. 读取全部的函数定义；
2. 开始执行代码。

JavaScript是如何与网页交互

DOM是浏览器在加载网页时建立的。

1. 在浏览器中加载网页时，浏览器不只对HTML进行分析并将其渲染到显示器，还建立一系列表示标记的对象。这些对象存储在DOM中；
2. JavaScript代码可经过与DOM交互来访问元素及其内容，还可使用DOM来建立或删除元素;
3. JavaScript代码修改DOM时，浏览器将动态地更新网页，让用户可以在网页中看到新内容。

getElementById

注意事项：

根据id从DOM获取元素时，若是指定的id不存在，getElementById将返回null，调用getElementById时，检查返回的是不是null是不错的主意，能够确保只在返回了一个元素时才访问其属性。

JavaScript是区分大小写的

JavaScript是区分大小写的语言，关键字，变量，函数名和全部标识符都必须采起一致的大小写形式。

使用注释

写代码时要多使用注解，示例：

// 这是单行注解
/* 这是一段注解 */
/*
* 这是一段注解
* 能够多行
*/

undefined

使用未初始化的变量，访问不存在的属性，使用不存在的数组元素时，你都会遇到undefined。

undefined对于任何尚未值的东西，都会将undefined赋予给它。

示例：

var da;
if (da == undefined) {
 // da未定义
}
// 用于检查变量是否未定义，需和undefined进行比较

可检查属性是不是未定义的，例如：

var daObj = {
 name: 'dadaqianduan.cn'
};

if(daObj.age == undefined) {
 // 获取对象的age
}

使用 undefined，若是你的代码中须要判断（如属性或变量可能没有值），就须要检查它是不是 undefined。

null与NaN

null用于表示对象不存在。

有些数字在JavaScript中没法表示，提供了一个替代值：NaN。在JavaScript中使用NaN，来表示它没法表示的数值结果。NaN不只用来表示全部没法表示的数值，仍是JavaScript中惟一一个与本身不相等的值。

表示：NaN != NaN

由于NaN与任何东西，包含它本身都不相等，因此不能以下使用：

// 错误
if(myNum == NaN) {
 // 错误用法
}

可使用函数isNaN表示：

if(isNaN(myNum)) {
 // 使用函数isNaN，当它传入的值不是数字时返回true
}

NaN表示：没法表示的数字（理解为NaN是一个数字，但只是没有办法表示），因此并不是全部没法表示的数字都相同，则NaN与它本身不相等。

示例：0/0的结果为NaN，而10/0的结果为Infinity，在JavaScript中，Infinity指的是任何超过浮点数上限某值，Infinity的类型为数字。将Infinity与它本身相减时，结果为NaN，null的类型结果为object。

null表示不存在的对象

赋值和相等

示例：

var da = 1;
// = 是赋值运算符，用于给变量赋值

da == 2;
// == 是比较运算符，用于对两个值进行比较，看看它们是否相等

判断两个对象是否相等

检查两个对象变量是否相等时，比较的是指向对象的引用，对象变量存储的是指向对象的引用。

只有两个引用指向的是同一个对象时，它们才相等。

记录为假的值

表示值为假值：5个假值

undefined, null, 0, 空字符串, NaN

标识符

什么是标识符呢，它就是一个名字，在JavaScript中，标识符用来对变量和函数进行命名，或者用作JavaScript代码中某些循环语句中的跳转位置的标记。

JavaScript标识符必须以 字母，下划线，或美圆符号开始，后面的字符能够是 字母，数字，下划线，或者美圆符号。

字符串

在 JavaScript中，支持字符串既可做为基本类型，又可做为对象。

字符串属性：length

属性length指出了字符串包含多少个字符，为迭代字符串中的字符提供了极大的便利。

方法charAt，将一个整数做为参数，这个参数必须在0和字符串长度减1之间，并返回一个字符串，其中包含指定位置处的字符，能够认为字符串像数组，其中每一个字符都有对应的索引，而索引从0开始，若是指定的索引大于或等于字符串的长度，这个方法将返回一个空字符串。

方法indexOf，将一个字符串做为参数，并在字符串中该参数首次出现的位置返回该参数中第一个字符的索引。

第一个参数，目标字符串；第二个参数，它是一个索引，指定从什么位置开始查找；第三，若是没有找到指定的字符串，将返回索引-1。

方法substring，将两个索引做为参数，提取并返回这个两个索引之间的子串。若是省略第二个参数，将提取从指定索引到字符串末尾的子串。

var da = data.substring(1,5);

var da1 = data.substring(1);

方法split，将一个用做分隔符的字符做为参数，并根据这个分隔符分红多个部分。split根据分隔符将字符串分红多个部分，并返回一个包含这些部分的数组。

整理：

1. toLowerCase，将字符串中的全部大写字符都转换为小写，并返回结果
2. slice，删除字符串的一部分，并返回结果
3. substring，返回字符串的一部分
4. lastIndexOf，与indexOf相似，但查找最后一个子串
5. match，在字符串中查找与正则表达式匹配的子串
6. trim，删除字符串开头和末尾的空白字符，为处理用户输入提供了极大的便利
7. replace，查找子串并将它们都替换为另外一个字符串
8. concat，将字符串拼接起来
9. toUpperCase，将字符串中的全部小写字符都转换为大写，并返回结果

事件

什么是事件，如：用户单击按钮，鼠标位置发生变化，经过网络获取数据，窗口大小发生变化，定时器到期，浏览器位置发生变化等，都会触发事件。

建立事件处理程序：

// 处理程序就是一个函数
function da() {
 console.log('dadaqianduan.cn');
}

访问DOM中的图片

var image = document.getElementById('dadapic'); // 获取指向图像元素的引用
// 只有网页加载完毕后，咱们才能从DOM中获取图像
window.onload = init;
function init() {
 var image = document.getElementById('dadapic');
 // 建立init函数，并将其赋给属性onload，从而确保这些代码在网页加载完毕后才执行
}

// 添加图像处理程序
window.onload = init;
function init() {
 var image = document.getElementById("dadapic");
 image.onclick = dadaFun;
}
// 将一个处理程序赋给从DOM中获取的图像对象的onclick属性
// 编写函数dadaFun
function dadaFun() {
 var image = document.getElementById("dadapic");
 image.src = "dadaqianduan.jpg";
 // 将图像元素的src属性更换图片
}

事件和队列

浏览器不断地从这个队列中取出事件，并调用相应的事件处理程序来处理他们。

mousemove事件：

当鼠标在特定元素上移动时，mousemove事件通知相应的处理程序，要指定处理程序，可以使用元素的属性onmousemove，这样会给这种事件处理程序传递一个event对象，其中包含以下属性：

clientX和clientY，鼠标相对于浏览器建立左边缘和上边缘的距离，单位为像素。

screenX和screenY，鼠标相对于设备屏幕左边缘和上边缘的距离，单位为像素。

pageX和pageY，鼠标相对于网页左边缘和上边缘的距离，单位为像素`

规范

编写可维护的代码，很重要，否则被骂得很惨！！！

1. 写代码，无需原始开发者的帮助，写代码要让任何人一看代码就知道它是在干什么，以及它是怎么实现的。
2. 写代码✍，要符合逻辑，不管操做有多么复杂，代码中的一切都要瓜熟蒂落。
3. 要重点思考，写代码，当使用数据发生变化时，也不用重写。
4. 要通过设计（代码架构），可以支持之后的扩展核心功能。
5. 要让本身或别人可以容易进行调试，能让代码能够给出明确的信息，能够经过调试定位问题。
6. 学习前要注重代码编写规范，要让代码容易维护，具备可读性。
7. 注意写注解，在函数和方法地方描述其用途，完成任务所用到的算法。在大型代码块中，复杂的算法中，加入注解。
8. 代码中变量和函数的适当命名对于其可读性和可维护性相当重要的。如变量名应该是名词，函数名应该是动词，返回布尔值的函数常以is开头，对变量和函数都使用符合逻辑的名称（长度适当），变量，函数和方法应该以小写字母开头，使用驼峰大小写形式，类名应该首字母 大写，常量值应该所有大写并如下划线相接，名称要尽可能具备描述性和直观。

ES6以前，初始化方式不适合函数声明中函数的参数，以后，能够在函数声明中为参数指定默认值来标明参数类型。

经过标明变量类型的方式是经过初始化。示例：

// 经过初始化标明变量类型
let daBoolean = false; // 布尔值
let daNumber = -1; // 数值
let daString = ""; // 字符串
let daObject = null; // 对象

经过匈牙利表示法，标明变量类型的方式。

JavaScript传统的匈牙利表示

o 表示 对象
s 表示 字符串
i 表示 整数
f 表示 浮点数
b 表示布尔值

let bDa; // 布尔值
let iDa; // 整数
let sDa; // 字符串

可是这种很差的是使用起来代码可读性降低，不够直观。

还可使用类型注释，可是也不够优美。

setTimeout工做原理

函数setTimeout建立一个倒计时的定时器，并将其关联到一个处理程序。当定时器计时到零后，将调用这个处理程序。

• setInterval返回一个timer对象。要中止该定时器，可将其传递给另外一个函数clearInterval。
• 严格上说，应写window.setTimeout，因window是全局对象，能够省略。
• 调用setTimeout时，能够向处理程序传递任意数量的参数：0个，1个或更多。
• 事件对象主要用于DOM事件处理程序，setTimeout不向处理程序传递事件对象，由于时间事件并不是由特定的元素触发。

事件

1. click，在网页中单击时将触发这个事件。
2. resize，每当用户调整浏览器窗口的大小时，都将触发这个事件。
3. play，用户单击网页中video元素的播放按钮时，将触发这个事件。
4. pause，用户单击video元素的暂停按钮时，将触发这个世界。
5. load，浏览器加载网页完毕后触发的事件。
6. unload，用户关闭浏览器窗口或切换其余网页时，将触发这个事件。
7. dragstart，用户拖拽网页中的元素时，将触发这个事件。
8. drop，用户放下拖拽的元素时，将触发这个事件。
9. mousemove，在元素上移动鼠标时，将触发这个事件。
10. mouseover，用户将鼠标指向元素时，将触发这个事件。
11. touchstart，在触摸设备上，用户触摸并按住元素时，将触发这个事件。
12. touchend，用户中止触摸时，将触发这个事件。
13. keypress，用户按下任何键都将触发这个事件。
14. mouseout，用户将鼠标从元素上移开时将触发这个事件。

鸭子方法

代码示例加描述：

window.onload = dada;
function dada() {
 var image = document.getElementById("dadaqianduan");
 image.onclick = showDa;
}

function showDa() {
 var image = document.getElementById("dadaqianduan");
 image.src="dada.jpg";
}

网页加载时，定义函数 dada和showDa；将 dada指定为加载事件处理程序，网页加载事件发生时，调用加载事件处理程序 dada，获取 id为dadaqianduan的图像元素，将该图像元素的单击事件处理程序设置为 showDa，图像单击事件发生时，调用 showDa，获取 id为dadaqianduan的图像元素。将其 src属性设置为dada.jpg。

函数是一等公民

一个标准的函数声明，由关键字function，函数名，形参和代码块组成。

示例声明函数：

function da(num) {
 for (var i = 0; i < num; i++) {
  console.log("魔王哪吒");
 }
}

// 调用这个函数
da(12);

展现另一种（指向函数的引用）：

var da = function(num) {
 for (var i = 0; i < num; i++) {
  console.log("魔王哪吒");
 }
}
da(12);

函数声明 和 函数表达式

分析：在执行任何代码以前，浏览器查找函数声明，找到函数声明时，浏览器建立相应的函数，并将获得的函数引用赋给与函数同名的变量。

浏览器：遇到了一个函数声明，必须先对其进行处理，再作其余的事情，咱们将这个函数存储起来，以便可以在它被调用时获取它。

这个函数名为da，所以建立一个名为da的变量来存储指向这个函数的引用。

1. 在处理其余代码以前，先处理函数声明。
2. 函数声明是完整的语句，而函数表达式只是语句的一部分。
3. 函数表达式随其余代码一块儿被处理。
4. 对于函数声明和函数表达式建立的函数，用相同的方式处理调用它们的语句。
5. 应尽量使用函数声明，因它们先被处理。
6. 函数声明不返回指向函数的引用，而是建立一个与函数同名的变量，并将指向函数的引用赋给它。
7. 函数表达式返回一个引用，该引用指向函数表达式建立的变量。
8. 可在变量中存储指向函数的引用。

区别

1. 使用函数声明时，函数将在执行代码前建立
2. 使用函数表达式时，函数将在运行阶段执行代码时建立
3. 使用函数声明时，将建立一个与函数同名的变量，并让它指向函数
4. 使用函数表达式时，一般不给函数指定名称，所以你要么在代码中将函数赋给一个变量，要么以其余方式使用函数表达式

一等公民特色

第一，将其赋给变量或存储在数组和对象等数据结构中

第二，将其传递给函数

第三，从函数中返回它们

能够将函数赋给变量；能够将函数传递给函数；能够从函数返回函数。

1. 定义函数的方式：使用函数声明和使用函数表达式
2. 函数引用是一个指向函数的值
3. 函数声明在执行代码前处理
4. 函数表达式在运行阶段随其余代码一块儿执行
5. 处理函数声明时，浏览器建立一个函数以及一个与函数同名的变量，并将指向函数的引用存储到变量中
6. 处理函数表达式时，浏览器建立一个函数，但你必须显式地处理指向这个函数的引用
7. 函数引用是做为一等公民的值
8. 可将做为一等公民的值赋给变量，包含在数据结构中，传递给函数或从函数返回

做用域，闭包

浏览器分两次处理JavaScript代码：

1. 浏览器分析全部的函数声明，并定义这些函数声明建立的函数；
2. 浏览器按从上到下的顺序执行代码，并定义函数表达式建立的函数。

使用函数声明的函数是在使用函数表达式建立的函数以前定义的。

提高：函数声明放在任何地方，且可在任何地方调用它们。在代码任何地方，函数声明建立的函数都是已定义的。

函数表达式，它建立的函数要等到它执行后才被定义，就算你将函数表达式赋给全局变量，也要等到它建立的函数被定义后，才能使用这个全局变量来调用这个函数。

嵌套函数，影响函数的做用域

函数表达式是在它调用的时候，才定义的。

词法做用域介绍

词法，表示只须要查看代码的结构 就 可肯定 变量的做用域，而不是等到代码执行时才明白。

全部的局部变量都存储在一个环境中，它存储了在局部做用域内定义的全部变量。

function da() {
 return daString;
} 
return da;

返回这个函数时，返回的不只仅是函数，还有与之相关联的环境。（每一个函数都有与之相关联的环境，其中包含它所处做用域内的局部变量）

什么是词法做用域

JavaScript的做用域规则彻底基于代码的结构，而不是一些动态的运行阶段属性。（只须要查看代码的结构，就能肯定变量是在什么地方定义的）

在JavaScript中，只有函数会引入新的做用域。

对于函数中引用的变量，要肯定它是在哪里定义的，能够从最里面，既是当前函数中，开始依次向最外面进行查找，直到找到它为止。若是在这些函数中都找不到它，要么是全局，要么未定义。

形参变量包含在环境中，形参视为函数的局部变量，因此它们也在环境中。

闭包

闭包，名词，指的是函数和引用环境（闭包，一个函数及其环境）

示例：

function makeCounter() {
 var count = 0; // 局部变量
 function counter() { // 建立函数counter,它将变量count+1
  count = count + 1;
  return count;
 }
 return counter; // 返回函数counter
}

将函数传递给函数时，也将建立闭包。

示例：

function makeTimer(doDa, n) {
 setTimeout(function() { // 函数setTimeout传入一个函数表达式
  console.log(doDa);  // 函数表达式使用了自由变量doDa。
 }, n);
}

自由变量：不是在本地定义的变量，这些变量称为自由变量。

注意：（若是闭包函数外面的代码修改了变量，闭包函数执行时看到的将是变量的新值。）

点击事件使用闭包

示例：

window.onload = function() {
 var count = 0;
 var message = "dadaqianduan";
 var div = document.getElementById("message");
 
 var button = document.getElementById("clickme");
 button.onclick = function() {
  count++;
  div.innerHTML = message + count + "浏览量";
 };
};

对象

每一个对象，都使用对象字面量来指定其全部属性。

使用对象字面量建立对象

示例：

var dadaqianduan = {
 name: '魔王哪吒',
 age: 'dada',
 name1: 'jeskson',
 name2: 'dada',
}

对象构造函数

构造函数命名时，采用首字母大写的形式，示例：

function Dadaqianduan(name, name1, name2) {
 this.name = name;
 this.name1 = name1;
 this.name2 = name2;
 this.sayName = function() { // this.sayName 属性 一个匿名函数
  console.log("dada");
 }
}

使用构造函数示例：

var dada = new Dadaqianduan("dada1", "dada2", "dada3");

变量dada将包含一个指向新对象的引用，有了构造函数后，能够不断地建立不一样对象。

this，存储了一个引用，指向当前处理的对象。函数执行完毕后，运算符new返回this，指向新建立的对象的引用。

构造函数中返回值，除非返回的是 this，不然这将致使构造函数不返回它建立的对象。

注意：调用构造函数来建立对象时，this被设置为一个引用，值向正在建立的新对象，所以构造函数的全部代码针对的都是这个新对象。

对象建立后，当你对其调用方法时，this被设置为方法被调用的对象。因此，在方法中，this老是表示方法被调用的对象。

对象实例

使用运算符instanceof来肯定对象是由哪一个构造函数建立的，若是对象是由指定的构造函数建立的，运算符instanceof将返回true。（根据建立对象时，运算符new在幕后存储了一些信息，随时都能肯定对象是由哪一个构造函数建立的）

内置构造函数

1. Object，可以使用构造函数Object来建立对象。
2. Math，用于执行数学运算任务的属性和方法。
3. RegExp，用户建立正则表达式对象。
4. Error，在代码中捕获错误。

建立日期对象，示例：

// 只须要使用其构造函数便可
var now = new Date(); // 表示当前日期和时间的日期对象

// 构造函数Date返回一个表示本地当前日期和时间的Date实例

数组对象示例：

var emptyArray = new Array(); // 建立一个长度为零的空数组

var arrArray = new Array("a", "b", "c");

原型

在 JavaScript中，对象从其余对象那里继承行为，称为 原型式继承或基于原型的继承。（被继承的对象称为 原型，继承既有属性包括方法，同时在新对象中添加属性）

JavaScript对象模型基于原型的概念，在这种模型中，可经过**扩展其余
对象**（即原型对象）来建立对象。

原型：对象构造函数。构造函数-继承原型。

如何在代码中访问原型，有一个构造函数Da，示例访问：

// 构造函数Da，将发现它有一个prototype属性，这是一个指向原型的引用
Da.prototype

在JavaScript中，函数也是对象，实际上，在JavaScript中，几乎全部的东西都是对象，数组也是。(函数有属性，而构造函数都包含属性prototype，来访问原型对象)

调用对象的方法时，this被设置为方法被调用的对象。即使在该对象中没有找到调用的方法，而是在原型中找到了它，也不会修改this的值，在任何状况下，this都指向原始对象，即方法被调用的对象，即使该方法位于原型中也是如此。

1. JavaScript对象系统使用原型式继承
2. 使用构造函数建立对象实例时，实例包含本身的自定义属性，还有构造函数中方法的副本
3. 给构造函数的原型添加属性后，使用这个构造函数建立的实例都将继承这些属性
4. 经过在原型中定义属性，可减小对象包含的重复代码
5. 要重写原型中的属性，只需在实例中添加该属性便可
6. 构造函数有默认的原型，你可经过构造函数的属性prototype来访问它
7. 可将你本身建立的对象赋给构造函数的属性prototype
8. 使用自定义的原型对象时，务必将原型的属性constructor设置为相应的构造函数，以保持一致性。
9. 要调用函数并指定函数体中this指向的对象，可调用其方法call

JavaScript事件

setTimeout的描述：给定一个回调及n毫秒的延迟，setTimeout就会在n毫秒后运行该回调。

示例：

for (var i = 1; i <= 3; i++) {
 setTimeout(function() {
  console.log(i);
 }, 0);
}
// 4
// 4
// 4

异步函数

JavaScript环境提供的异步函数一般能够分为两大类：I/O函数和计时函数。

从原型到原型链

使用构造函数建立一个对象，示例：

// 构造函数首字母大写
function Da() {
 // 构造函数
}
var da = new Da(); // 实例化对象
da.name = 'jeskson'; // 添加属性
console.log(da.name); // jeskson

在示例中，Da是一个构造函数，使用new建立一个实例对象da。

记住：每一个函数都有一个prototype属性，示例：

function Da() {
}
// 每一个函数都有prototype属性
Da.prototype.name = 'jeskson';
var da1 = new Da();
var da2 = new Da();
console.log(da1.name); // jeskson
console.log(da2.name); // jeskson

注意：函数的prototype属性指向一个对象，这个对象是调用该构造函数而建立的实例原型。

既是构造函数和实例原型之间的关系：Da（构造函数）经过prototype而建立Da.prototype（实例原型）。

每一个 JavaScript对象，除 null外，在建立的时候就会与之关联另外一个对象，这个对象就是 原型。每一个对象都会从原型“继承”属性。

实例化对象da，实例与实例原型Da.prototype之间的关系：

__proto__，每一个JavaScript对象（new构造函数建立对象，如上述的da），除null外，都具备的一个属性，叫__proto__，这个属性会指向该对象的原型。

示例：

function Da() {
}

var da = new Da();
console.log(da.__proto__ === Da.prototype); // true

既是：Da构造函数，建立实例化对象da，da对象中都有一个属性__proto__，这个属性指向Da.prototype实例原型，而这个实例原型，是经过Da构造函数使用 每一个函数中都有一个属性prototype，指向实例原型（Da.prototype）。

表示：构造函数 和 实例对象，均可以指向 原型。

有人问，那有没有原型 指向 （构造函数或者实例的），答：指向实例没有，指向构造函数就有。没有指向实例是 一个构造函数能够生成多个实例。

记住：每一个原型都有一个constructor属性指向关联的 构造函数。

示例：

function Da() {
}
console.log(Da === Da.prototype.constructor); // true

既是关系：

1. 构造函数Da经过prototype指向实例原型Da.prototype
2. 构造函数Da建立的实例化对象da，经过da中（对象都有的属性）__proto__指向实例原型Da.prototype
3. 实例原型Da.prototype，每一个原型中都有的属性constructor，经过constructor指向构造函数

示例：

function Da() {

}

var da = new Da();

console.log(da.__proto__ == Da.prototype) // true
console.log(Da == Da.prototype.constructor) // true
// 获取对象的原型
console.log(Object.getPrototypeOf(da) === Da.prototype) // true

实例与原型

当读取实例的属性时，若是找不到该属性，就会去查找与对象相关联的原型 中 的属性，若是查找不到， 就会去找 原型 的 原型，一直找到 最顶层为止。

示例：

function Da(){
}
Da.prototype.name = 'jeskson';
var da = new Da();
da.name = 'dadaqianduan';
console.log(da.name); // dadaqianduan
delete da.name;
console.log(da.name); // jeskson

原型的原型

示例：

var obj = new Object();
obj.name = 'jeskson';
console.log(obj.name); // jeskson

关系：构造函数，实例原型，实例化对象，原型的原型Object.prototype，构造函数Object()。

1. Da（构造函数），经过prototype指向，实例原型Da.prototype
2. Da构造函数，建立对象da，其da中的属性__proto__指向，实例原型Da.prototype
3. 实例原型Da.prototype，中属性constructor指向，构造函数Da
4. 实例原型Da.prototype，中原型的原型，（实例原型便是对象）对象中属性__proto__指向Object.prototype
5. Object()构造函数，经过prototype指向，Object.prototype原型
6. Object.prototype原型中属性constructor指向，构造函数Object()

原型链

示例：

// Object.prototype的原型 -> null
console.log(Object.prototype.__proto__ === null); // true
// null 表示 没有对象，即该处不该该有值。就是说Object.prototype没有原型，查找到Object.prototype就能够中止查找了

即 Object.prototype（对象）中的属性 __proto__指向 null

constructor

示例：

function Da() {
}
var da = new Da();
console.log（da.constructor === Da); // true

当获取da.constructor时，da中其实没有constructor属性，当不能读取到constructor属性时，会从da的原型中Da.prototype中读取，找到原型中有该属性，即表示：

da.constructor === Da.prototype.constructor

proto

大部分浏览器支持这个非标准的方法访问原型，它并不存在于Da.prototype中，而是来自于Object.prototype，与其说是一个属性，能够说是getter/setter，当使用obj.__proto__时，能够理解为返回了Object.getPrototype(obj)

注意：Function做为一个内置对象，是运行前就已经存在的东西，因此不会根据本身生成本身。

缘由：

1. 为量保持与其余函数一致
2. 标明是一种关系而已

prototype是函数才会有的属性，而 __proto__是几乎全部对象都有的属性。

接下来，说说什么是做用域：做用域指☞的是 程序源代码中定义变量的区域。

做用域规定了如何查找变量，也就是肯定当前 执行代码 对变量 的访问权限。

词法做用域

在JavaScript中采用的是词法做用域，函数的做用域在函数定义的时候就决定了。

示例：

var name = 'jeskson'

function da1() {
 console.log(name);
}

function da2() {
 var name = 'dadaqianduan.cn';
 da1();
}

da2();
// 结果是jeskson ， 由于采用的是静态做用域

动态做用域

动态做用域 是 在函数调用的时候才决定的

面试题

var scope = "global scope";
function checkscope() {
 var scope = "local scope";
 function f() {
  return scope;
 }
 return f();
}
checkscope();

var scope = "global scope";
function checkscope() {
 var scope = "local scope";
 function f() {
  return scope;
 }
 return f;
}
checkscope()();

其结果都是打印： local scope，因采用的是词法做用域，函数的做用域 基于 函数 建立的位置。 （函数的做用域在函数定义的时候就决定了）

JavaScript是采用词法做用域的，表示函数的执行依赖于函数定义的时候所产生的变量做用域。

结果是10，因变量 a读取不到对象 o的属性 a。改成 console.log(o.a)就能够打印11。

JavaScript设计模式之单例模式

1. 什么是设计模式：

设计模式是一套被反复使用，多数人知晓的，通过分类编目的，代码设计经验的总结

有人说：当封装一个函数时，你是在复用代码，当使用一个设计模式时，你是在复用他人的经验。

1. 设计模式的分类

• 建立型模式：单例模式，抽象工厂模式，建造者模式，工厂模式，原型模式。
• 结构型模式：适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式。
• 行为型模式：模板方法模式，命令模式，迭代器模式，观察者模式，中介者模式，备忘录模式，解释器模式，状态模式，策略模式，职责链模式，访问者模式。

1. 设计模式的好处

• 行之有效的解决方法
• 易于修改和维护
• 便于交流和沟通

1. 传统的单例模式

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

{} 命名空间，防冲突
惰性单例

深刻函数

1. 函数的定义

// 字面量
function fn() {};
函数声明
简洁，直观
声明提早

// 构造函数
var fn = new Function();
赋值语句
画蛇添足，效率低下
必须在调用语句以前

// 赋值表达式
var fn = function() {};
赋值语句
简洁，直观
必须在调用语句以前

1. 函数的调用

// 普通函数
fn()

// 匿名函数
(function() {})()

// 构造函数
new Object()

// 方法
Obj.method()

// 间接
fn.daFun()

1. 函数的参数

// 形参
函数定义时括号内的参数
接收实参的值
个数为fn_name.length

// 实参
函数调用时括号内实际传递的参数
将值赋值给形参
个数为arguments.length

1. 函数的返回值

// return
用在函数中
跳出函数

// continue
用在循环中
跳出本次循环

// break
用在循环中
跳出当前循环

js表单验证案例

用户注册时，用户名，密码，手机的数据再输入的时候可能会格式不正确，因此须要对数据进行合法性校验。

用js的正则对象来进行数据的验证：var reg = /正则表达式/;

js面向对象

面向对象：对代码的一种抽象，对外统一提供调用接口的编程思想。

基于原型的面向对象方式中，对象则是依靠构造器（constructor)利用原型prototype构造出来的。

1. 属性是事物的特性
2. 方法是事物的功能
3. 对象是事物的一个实例
4. 原型 是 js函数中由 prototype 属性引用了一个对象，即原型对象（原型）

闭包：是一个拥有许多变量和绑定了这些变量的环境的表达式

js字面式对象声明对象，示例：

var obj = {
 属性名称： 属性值，
 属性名称： 属性值，
 ...
 方法名称：function() {},
 方法名称：function() {},
 ...
}

new操做符后跟Object构造函数，示例：

var obj = new Object();

obj.属性 = 属性值；
obj.属性 = 属性值；
obj.方法 = function(str) {
 方法代码
};

js中构造函数声明对象，示例：

function Test([参数列表]) {
 this.属性 = 属性值；
 this.方法 = function() {
  // 方法中的代码
 }
}

var obj = new Test(参数列表);

js中工厂方式声明对象，示例：

function createObject(name, age) {
 var obj = new Object();
 obj.name = name;
 obj.age = age;
 obj.run = function() {
  // return 
 };
 return obj;
}

var da1 = createObject('dada', 1);
var da2 = createObject('jeskson', 2);

js中原型模式声明对象，示例：

function test() {

}
test.prototype.属性 = 属性值；
test.prototype.属性 = 属性值；
test.prototype.属性 = function() {
 // 执行代码
}
var obj = new test();

js中混合模式声明对象，示例：

function test(da1, da2, da3) {
 this.da1 = da1;
 this.da2 = da2;
 this.da3 = da3;
}
test.prototype.方法名称 = function() {
 // 执行代码
}
var obj = new Blog(da1, da2, da3);

js遍历对象的属性和方法，示例：

var da = {};
da.name = 'jeskson';
da.age = 1,
da.fn = function() {
 console.log('魔王哪吒');
}
for(var i in da) {
 // 遍历对象 in
 console.log(da[i]);
}

什么是封装

把对象内部数据和操做细节进行隐藏。

原型和原型链

1. 原型，利用prototype添加属性和方法
2. 原型链，js在建立对象的时候，都有一个叫作__proto__的内置属性，用于指向建立它的函数对象的原型对象prototype

原型继承

利用原型让一个引用类型继承另外一个引用类型的属性和方法

构造函数继承

在子类内部构造父类的对象实现继承

call和 apply的用法

• call，调用一个对象的一个方法，以另外一个对象替换当前对象
• apply，应用某一个对象的一个方法，用另外一个对象替换当前对象

传参方式不一样，call是参数列表，apply是数组。

js面向对象的关键词

instanceof, delete, call, apply, arguments, callee, this

• 经过new function()建立的对象都是函数对象，其余的都是普通对象
• js中全部的函数对象都有一个prototype属性这个属性引用了一个对象，便是原型对象，简称原型，普通对象没有prototype，但有__proto__属性。

继承

1. 构造继承示例

function parents(name) {
 this.name = name;
 this.say = function() {
  console.log(this.name);
 }
}
function child(name, age {
 this.pobj = parents;
 this.pobj(name);
 this.age = age;
}

var da = new child('魔王哪吒', 1);

1. 原型继承示例

var da = function(){
};
da.prototype.say = function() {
 console.log('魔王哪吒');
}
da.prototype.name = 1;

var dada = function() {};
dada.prototype = new da();
dada.prototype.name = 2;
var obj = new dada();
// 子元素的成员属性name 会覆盖父元素

变量、做用域和内存问题

1. 变量：基本类型 和 引用类型

// 基本类型
不可修改
保持在栈内存中
按值访问
比较时，值相等即相等
复制时，建立一个副本
按值传递参数
用typeof检测类型

// 引用类型
能够修改
保存在堆内存中
按引用访问
比较时i，同一引用才相等
复制的实际上是指针
按值传递参数
用instanceof检测类型

1. 做用域

• 做用域：全局做用域和局部做用域
• 做用域链 是用来 查询变量的
• js解析机制

1. 内存问题

• 离开做用域的值将被标记为 可回收， 将在垃圾收集期间 删除
• 标记清除 是 目前主流的垃圾收集算法
• 标记清除 是给 不用的值加标记，而后进行回收其内存
• 当变量不用的时候，能够手动解除它的引用
• 引用计算算法 可能 由于 循环引用的问题而得不到释放

执行上下文栈

执行代码顺序，示例（函数表达式）：

var da = function() {
 console.log("da1");
}
da(); // da1

var da = function() {
 console.log("da2");
}
da(); // da2

函数声明，先执行，展现：

function da() {
 console.log("da1");
}
da(); // da2

function da() {
 console.log("da2");
}
da(); // da2

代码是一段一段执行的。在JavaScript中的可执行代码，运行环境有三种，分全局代码（全局环境，代码首先进入的环境），函数代码（函数被调用时执行的环境），eval代码。

执行上下文（当执行到一个函数的时候，就会进行准备工做），概念：当代码运行时，会产生一个对应的执行环境，在这个环境中，全部变量会被事先提出来，有的直接赋值，有的默认值为undefined，代码从上往下开始执行，就叫作执行上下文。

示例：

function fn() {
 console.log(a); // undefined
 var a = 1;
}
fn();

执行上下文栈， Execution context stack, ECS，(如何管理建立的那么多执行上下文呢)，在 JavaScript引擎中建立了执行上下文栈来管理执行上下文。

执行上下文生命周期：

建立-执行-执行完毕后出栈，等待被回收。

建立阶段：1，生成变量对象；2，创建做用域链；3，肯定this指向。

执行阶段：1，变量赋值；2，函数引用；3，执行其余代码。

全局执行上下文

全局执行上下文只有一个，在客户端中通常由浏览器建立，也就是window对象，咱们能经过this直接访问到它。

console.log(this);
// window

全局对象window上预约了大量的方法和属性，咱们在全局环境的任意处都能直接访问这些属性方法，同时window对象仍是var声明的全局变量的载体。

经过 var建立的全局对象，均可以经过 window访问。

函数执行上下文

函数执行上下文可存在无数个，每当一个函数被调用时会建立一个函数上下文，同一个函数被调用屡次，都会建立一个新的上下文。

模拟执行上下文栈的行为，定义执行上下文栈数组：

ECStack = [];

JavaScript开始执行代码的时候，先遇到全局代码，即初始化的时候先向执行上文栈压入一个全局执行上下文，globalContext全局执行上下文，只有整个应用程序结束时，ECStack才会清空。即表示ECStack底部永远有个globalContext。

ECStack = [
 globalContext
];

执行上下文栈，也叫执行栈，或叫 调用栈，执行栈用于存储代码期间 建立的 全部上下文。

示例：

function da1() {
 da2();
 console.log(1);
}

function da2() {
 da3();
 console.log(2);
}

function da3() {
 console.log(3);
}

da1(); // 3 2 1

执行栈 与 上下文的关系，执行过程：

// 代码执行前建立全局执行上下文
ECStack = [
 globalContext
];

ECStack.push("da1 functionContext");

ECStack.push("da2 functionContext");

ECStack.push("da3 functionContext");

// da3 执行完毕，输出 3 并出栈
ECStack.pop();
// da2
ECStack.pop();
// da1
ECStack.pop();
// 最后执行栈中只剩下一个全局执行上下文

执行上下文建立阶段

分：1，建立阶段；2，执行阶段。

示例建立过程代码：

ExecutionContext = {
 // 肯定this的值
 ThisBinding = <this value>,
 // 建立词法环境组件
 LexicalEnvironment = {},
 // 建立变量环境组件
 VariableEnvironment = {},
};

模拟写执行上下文栈的变化

示例1：

var scope = "global scope";

function da(){
    var scope = "local scope";
    function dada(){
        return scope;
    }
    return dada();
}

da();

// 执行上下文栈
ECStack.push(<da> functionContext);
ECStack.push(<dada> functionContext);
ECStack.pop();
ECStack.pop();

示例2：

var scope = "global scope";

function da(){
    var scope = "local scope";
    function dada(){
        return scope;
    }
    return dada;
}

da()();

ECStack.push(<da> functionContext);
ECStack.pop();
ECStack.push(<dada> functionContext);
ECStack.pop();

做用域链

上述说到：每一个执行上下文，都有其三个重要属性：

1. 变量对象
2. 做用域链
3. this

做用域链就是：当查找变量的时候，会先从当前上下文的变量对象中查找，若是没有找到，就会 从父级执行上下文的变量对象中查找，一直找到全局上下文的变量对象为止，就就是全局对象。

像这样，由多个执行上下文的变量对象构成的链表，叫作做用域链。

回顾：函数的做用域在函数定义的时候就决定了，词法做用域。

示例：（函数有一个内部属性[[scope]]存储全部父变量对象）

function da1() {
    function da2() {
        ...
    }
}


da1.[[scope]] = [
  globalContext.VO
];

da2.[[scope]] = [
    da1Context.AO,
    globalContext.VO
];

示例2：

var scope = "global scope";
function da(){
    var scope2 = 'local scope';
    return scoped2;
}
da();

// 函数被建立
da.[[scope]] = [
    globalContext.VO
];

// 执行函数
ECStack = [
    daContext,
    globalContext
];

// 建立做用域链
daContext = {
    Scope: da.[[scope]],
}

// 用 arguments 建立活动对象
daContext = {
    AO: {
        arguments: {
            length: 0
        },
        scope2: undefined
    }
}

// 将活动对象压入 da 做用域链顶端
daContext = {
    AO: {
        arguments: {
            length: 0
        },
        scope2: undefined
    },
    Scope: [AO, [[Scope]]]
}

// 开始执行函数
daContext = {
    AO: {
        arguments: {
            length: 0
        },
        scope2: 'local scope'
    },
    Scope: [AO, [[Scope]]]
}

// 函数执行完毕
ECStack = [
    globalContext
];

事件

什么是事件呢？它是能够被JavaScript侦测到的行为，通俗的将就是当用户与web页面进行某些交互时，解释器就会建立响应的event对象以描述事件信息。

你知道哪些事件呢：

1. 用户点击页面上的某项内容
2. 鼠标通过特定的元素
3. 用户滚动窗口
4. 用户改变窗口大小
5. 用户按下键盘某个键
6. 页面元素加载完成或加载失败

事件周期

1. 第一阶段：事件捕获，事件对象沿DOM树向下传播，向下
2. 第二阶段：目标触发，运行事件监听函数
3. 第三阶段，事件冒泡，事件对象沿DOM树向上传播，向上

IE的事件模型中没有“事件捕获”阶段。

事件的冒泡处理机制（向上）

当处于DHTML对象模型底部对象事件发生时，会依次激活上面对象定义的同类事件处理。

事件句柄

那么什么是事件句柄：事件句柄，称 事件处理函数，事件监听函数，指用于响应某个事件而调用的函数。

每个事件均对应一个事件句柄，在程序执行时，将相应的函数或语句指定给事件句柄，则在该事件发生时，浏览器便执行指定的函数或语句。

事件定义

定义监听函数三种方式：

1. 直接在HTML中定义元素的事件相关属性。（应尽量少用）
2. 在JavaScript中为元素的事件相关属性赋值。
3. 高级事件处理方式，一个事件能够绑定多个监听函数。

DOM事件流

1. 添加事件：addEventListener()

语法：element.addEventListener(event,function,useCapture)，用于指定元素添加事件句柄。

参数：

event: 字符串，指定事件名

function：指定要事件触发时执行的函数

useCapture：指定事件是否在捕获或冒泡阶段执行

1. 移除事件：removeEventListener()

语法：element.removeEventListener(event,function,useCapture)，用于移除addEventListener()方法。

事件列表

通常事件示例

onclick 鼠标点击时触发此事件

ondblclick 鼠标双击时触发此事件

onmousedown 按下鼠标时触发此事件

onmouseup 鼠标按下后松开鼠标时触发此事件

onmouseover 当鼠标移动到某对象范围的上方时触发此事件

onmousemove 鼠标移动时触发此事件

onmouseout 当鼠标离开某对象范围时触发此事件

onkeypress 当键盘上的某个键被按下而且释放时触发此事件

onkeydown 当键盘上某个键被按下而且释放时触发此事件

onkeyup 当键盘上某个按键被放开时触发此事件

页面相关事件

onabort 图片在下载时被用户中断

onbeforeunload 当前页面的内容将要被改变时触发此事件

onerror 出现错误时触发此事件

onload 页面内容完成时触发此事件

onmove 浏览器的窗口被移动时触发此事件

onresize 当浏览器的窗口大小被改变时触发此事件

onscroll 浏览器的滚动条为止发生变化时触发此事件

onstop 浏览器的中止按钮被按下时触发此事件或正在下载的文件被中断

onunload 当前页面将被改变时触发此事件

滚动字幕事件

onbounce 在Marquee内的内容移动至Marquee显示范围以外时触发此事件

onfinish 当Marquee元素完成须要显示的内容后 触发此事件

onfinish 当Marquee元素完成须要显示的内容后触发此事件

onstart 当Marquee元素开始显示内容时触发此事件

表单相关事件

onblur 当前元素失去焦点时触发此事件

onchange 当前元素失去焦点而且元素的内容发生改变而触发此事件

onfocus 当某个元素得到焦点时触发事件

onrest 当表单中reset的属性被激发时触发此事件

onsubmit 一个表单被提交时触发此事件

数据绑定

oncellchange 当数据来源发生变化时
ondetaavailable 当数据接收完成时触发事件
onafterupdate 当数据完成由数据缘对象的传送时触发此事件
onrowexit 当前数据源的数据将要发生变化时触发的事件
onrowsdelete 当前数据记录将被删除时触发此事件
onrowsinserted 当前数据源将要插入新数据记录时触发此事件

小结

1. 在浏览器内部，使用文档对象模型DOM来表示网页
2. 浏览器在加载并分析HTML时建立网页的DOM
3. 在JavaScript代码中，使用document对象来访问DOM
4. document对象包含你能够用来访问和修改DOM的属性和方法
5. 方法document.getElementById根据id从DOM获取一个元素
6. 方法document.getElementById返回一个表示网页中元素的元素对象
7. 元素对象包含一些属性和方法，你可使用它们来读取和修改元素的内容
8. 属性innerHTML包含元素的文本内容和所有嵌套的HTML内容
9. 要修改元素的内容，能够修改其属性innerHTML的值
10. 要获取元素的特性值，可以使用方法getAttribute
11. 要设置元素的特性值，可以使用方法setAttribute
12. 可以使用window对象的onload属性给加载事件指定事件处理程序
13. 网页加载完毕后，将当即调用window对象的onload属性指向事件处理程序
14. undefined是一个值，其undefined的类型是undefined类型，它不是对象，不是数字，字符串或布尔值，也不是任何明确的东西
15. 在JavaScript中，类型分两组，基本类型和对象。不属于基本类型的值都是对象
16. 基本类型包含数字，字符串，布尔值，null和undefined，其余的值都是对象
17. undefined表示变量尚未初始化
18. null表示“无对象”
19. NaN表示的是“非数字”，但应该说在JavaScript中没法表示的数字，NaN的类型为数字
20. NaN与包含它本身在内的任何值都不相等，所以要检查一个值是不是NaN，应该使用函数isNaN
21. 在JavaScript中总共有5个假值：undefined, null, 0, "", false，其余值都是真值
22. 要响应事件，能够编写并注册一个事件处理程序。如，要指定单击事件处理程序，可将事件处理程序赋给元素的onclick属性。
23. 匿名韩寒是没有名称的函数表达式
24. 函数声明建立的函数是在执行其余代码前定义的
25. 函数表达式是在运行阶段与其余代码一块儿执行的，所以在函数表达式所在的语句执行前，它建立的函数是未定义的
26. 可将函数表达式传递给函数，还可从函数返回函数表达式
27. 闭包指的是函数及其引用的环境
28. 闭包捕获其建立时所处做用域内的变量的值
29. 自由变量指的是在函数体内未绑定的变量
30. typeof返回其操做数的类型，若是向它传递一个字符串，它将返回string
31. 须要建立少许对象时，使用对象字面量；须要建立大量对象时，使用构造函数
32. 使用构造函数可建立包含相同属性和方法的一致对象
33. 使用new来调用构造函数时，将新建一个空对象，并在构造函数中将其赋给this
34. 在构造函数中，使用this来访问正在建立的对象，进而给它添加属性，构造函数 自动返回 它建立的 新对象

回看笔者往期高赞文章，也许能收获更多喔！

• 一个合格的初级前端工程师须要掌握的模块笔记
• Vue.js笔试题解决业务中常见问题
• 【初级】我的分享Vue前端开发教程笔记
• 长篇总结之JavaScript，巩固前端基础
• 前端面试必备ES6全方位总结
• 达达前端我的web分享92道JavaScript面试题附加回答
• 【图文并茂，点赞收藏哦！】重学巩固你的Vuejs知识体系
• 【思惟导图】前端开发-巩固你的JavaScript知识体系
• 14期-连肝7个晚上，总结了计算机网络的知识点！（共66条）

❤️关注+点赞+收藏+评论+转发❤️，原创不易，鼓励笔者创做更好的文章

点赞、收藏和评论

我是Jeskson(达达前端)，感谢各位人才的：点赞、收藏和评论，咱们下期见！(如本文内容有地方讲解有误，欢迎指出☞谢谢，一块儿学习了)

咱们下期见！

文章持续更新，能够微信搜一搜「 程序员哆啦A梦 」第一时间阅读，回复【资料】有我准备的一线大厂资料，本文 http://www.dadaqianduan.cn/#/ 已经收录

github收录，欢迎Star：https://github.com/webVueBlog/WebFamily