保护对象：

保护对象的属性和方法

1、四大特性：

    {
            value: 1001, //实际保存值的地方
            writable: true, //开关：控制着是否可以被修改 - 默认值：都为true
            enumerable: true, //开关：控制着是否可以被for in循环遍历到 - 默认值：都为true
            configurable: true //开关：控制着是否可以被删除 - 默认值：都为true，总开关：一旦设置为false，其他特性不可以在修改，而且它本身也是一旦设置为false，不可逆
    }

修改四大特性：

1、 Object.defineProperty(对象名,"属性名",{ 修改四大特性 }) 调用一次方法只能保护一个属性的四大特性

2、 Object.defineProperties(对象名,{ "属性名":{修改四大特性}, ... }) 至少方法只调用了一次

四大特性甚至不能防止添加

2、三个级别：

1、防扩展：防止添加 Object.preventExtensions(obj);

2、密封：防止添加和删除 Object.seal(obj);

3、冻结：防止添加和删除和修改 Object.freeze(obj);

保护对象不重要，为什么说他不重要？
1、如果你不用面向对象开发，那你也没有对象可保护 2、前辈们都没保护，你保护个啥 3、别人一般来说不可能知道你取的对象名字叫什么

四大特性，其实应该叫六大特性 - 可以帮助我们做出动态数据

            Object.defineProperty(obj,"name",{
                    get:()=>{
                            console.log("获取数据会进行拦截");	
                    },
                    set:v=>{
                            console.log("设置数据会进行拦截");
                            v;//拦截到的新数据
                            d1.innerHTML=v;
                    }
            })
    理解到这一块即可，以后三阶段有一个框架叫做vue，vue中的所有数据都是动态数据，意味着他的底层就是做了拦截操作

对象的深浅拷贝：

1、浅拷贝： var obj1={"name":"obj1"}; var obj2=obj1;

2、深拷贝： var obj1={"name":"obj1"}; var obj2={...obj1}

3、以后如何脱掉后端传来的数据:

后端穿衣服：var jsonText=JSON.stringify(obj1); - Node.js就是这句话，Node.js也是"js"，历史上第一次一门语言可以通吃前后端。
前端脱衣服：var jsonObj=JSON.parse(jsonText); 此方法也能实现深拷贝

Error对象：错误

1、以后工作/学习的目的： 1、快速找到错误 2、记得要放用户

2、浏览器自带4种错误类型：可以快速找到自己的错误

语法错误：SyntaxError - 一定是你的符号写错了

引用错误：ReferenceError - 没有创建就去使用了

类型错误：TypeError - 不是你的方法，你却去使用了

范围错误：RangeError - 只有一个API会碰到：num.toFixed(d);//d取值范围：0~100之间

3、错误处理

只要发生错误，就会报错，会导致后续代码终止（闪退），我们不希望

错误处理：就算发生错误，我们也不希望报错，而是给出一个错误提示，让后续代码可以继续执行

语法：

try{
        只放入你可能出错的代码
}catch(err){
        发生错误后才会执行的代码
        alert(err);//err就是我们的错误提示：只不过是英文的
        alert("中文的错误提示，来提示用户");
}

try...catch...的性能非常差，几乎是所有代码里最差的，放在try中的代码效率会被降到最低

*可以用一个技术代替他：分支结构

*开发经验：记住一切的客户端输入/用户输入都是坏人 - 但是你不必担心，只要你做好该做的防护就不会出错（!isNaN、正则）

4、抛出自定义错误，只要是错误，后续代码都不会执行

    throw new Error("自定义错误消息");

5、ES5：严格模式

开启："use strict"; - 写在任何一个作用域的顶部都可以

作用： 1、禁止了全局污染，使用变量之前必须先创建变量 2、将静默失败升级为了错误

柯里化函数

function add(a){
	return function(b){
		return function(c){
			console.log(a+b+c);
		}
	}
}
add(3)(5)(7)

百度/高德地图：

1、定位技术:

1、GPS - 美国（卫星定位）：1、缴纳版权费用 2、安全性低

2、北斗 - 中国自主：最初并不是民用，而是军用，使用的是惯性定位（定位并不精准）后期发展为了民用，添加了卫星定位了（更精确了）物联网、车联网...

3、基站定位 - 信号的范围发射，可以检测到你现在的信号属于哪个范围。

4、IP定位 - 在网不要乱说话，乱造谣，要坐牢。

2、网站的定位技术都是使用的GPS

而并不需要我们学习如何使用GPS，我们有现成：百度/高德地图

3、开发者如何使用：

1、打开百度：搜索百度地图开放平台

2、注册、登录百度账号

3、拉到最下面、点击立即注册成为开发者

4、进入控制台

5、应用管理->我的应用->创建应用->实名认证->获得密钥（AK）

6、鼠标移动到导航条->放到开发文档上->web开发->JavaScript API->示例DEMO

7、挑选出你喜欢的地图，然后复制全部代码（HTML/CSS/JS），到你需要的位置

8、查询经纬度：api.map.baidu.com/lbsapi/getp…

9、百度地图你看上的每一个都可以混搭在一起，但是一定要注意版本：普通版(老) 和 webGL(新)，是不可以混搭的

匿名函数：

没有名字的函数，有两种用法

1、自调：

只能执行一次，好处：函数中的没用的变量是会自动释放的，他可以用于代替全局代码写法，两者很相似：都只会执行一次，但是自调会释放

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

2、回调：

匿名函数不是自调，就是回调

    elem.on事件名=function(){}
    arr.sort(function(){})
    var obj={
            "方法名":function(){}
    }
    //一切的回调函数，都可以简化为箭头函数

设计模式：21种设计模式

不仅仅局限于前端，它是一种编程思想，越来越复杂，对于我们前端人员要求也越来越高了。

1、单例模式：

也称之为单体模式，保证一个类仅有一个实例对象，并且提供一个访问它的全局访问点，为三阶段的vue，new Vue(); 举例：一个班级只有一个班主任，只有一个太阳，一个国家只有一个主席，"唯一" "便于访问（全局访问的）"，行为对象变成做单例

如何实现：
最简单的单例模式：利用ES6的let不允许重复声明的特性，刚好就符合了单例的特点

    let obj={
            "name":"袍哥1",
            "getName":()=>this.name,
    }

不太推荐这种写法： 1、污染命名空间（容易变量名冲突） 2、维护时不容易管控（搞不好就直接覆盖了）

    推荐写法：
    var h52301=(function(){
            let state=null;
            return function(name,age){
                    this.name=name;
                    this.age=age;
                    if(state){
                            return state;
                    }
                    return state=this;
            }
    })();

    h52301.prototype.sayHello=function(){
            console.log(this.name);
    }

    var pkq=new h52301("皮卡丘",18);
    var zzx=new h52301("猪猪侠",19);

    console.log(pkq);
    console.log(zzx);
    console.log(pkq==zzx);

    pkq.sayHello();
    zzx.sayHello();

何时使用：我们的页面只有一个弹出框

2、发布订阅模式：

为三阶段vue的bus总线用到的底层原理就是我们的发布订阅模式

		let obj={};
		//创建订阅者
		function on(id,fn){
			if(!obj[id]){//判断有没有此id（有没有这个人），没有我就创建了一个空数组
				obj[id]=[];
			}
			obj[id].push(fn);
		}
		on("老袍",(msg)=>{console.log("小兰来了",msg)});
		on("老袍",(msg)=>{console.log("小尹来了",msg)});
		on("老袍",(msg)=>{console.log("小张来了",msg)});
		on("老袍",(msg)=>{console.log("小李来了",msg)});
		on("老袍",(msg)=>{console.log("小赵来了",msg)});
		console.log(obj);//{"老袍":[fn,fn,fn,fn,fn]}
		
		//发布者的操作
		function emit(id,msg){
			obj[id].forEach(fn=>fn(msg));//obj["老袍"].forEach
		}
		btn.onclick=()=>{
			emit("老袍","一支穿云箭");
		}

事件轮询：

js其实是单线程引用，代码必然是从上向下，一步一步的执行，如果某一块代码非常耗时，可能会导致整个页面卡住，尤其如果你把js放在head之中，会看到页面是一个白板

1、宏任务：

不会再卡住我们的单线程应用，可以让后续代码先走，我们慢慢跟着来，但是问题在于，多个宏任务同时存在，到底谁先执行谁后执行，分不清

1、定时器：setInterval和setTimeout

2、Ajax

2、微任务：

ES6提供的Promise对象 - 可以控制异步代码，依然是异步代码，但是可以控制执行的顺序了

        function ajax1(resolve){
                setTimeout(()=>{
                        console.log(1);
                        resolve();
                },Math.random()*5000);
        }

        function ajax2(){
                return new Promise(resolve=>{
                        setTimeout(()=>{
                                console.log(2);
                                resolve();
                        },Math.random()*5000);
                })
        }

        function ajax3(){
                return new Promise(resolve=>{
                        setTimeout(()=>{
                                console.log(3);
                                resolve();
                        },Math.random()*5000);
                })
        }

        new Promise(ajax1).then(ajax2).then(ajax3);//promise的回调函数提供了一个形参函数，可以用于放行
        console.log("后续代码");

Node.js概述：

不是JS，但是语法和JavaScript非常相似，他的竞争对手：Java、C++、C#、Python...

做的功能绝对不是特效！做的事和服务器端其他语言是一致（和数据库进行交互，成为了一个前端到数据库的中间桥梁）

目的： 1、使用代码搭建一个服务器&文件系统（服务器文件可以放在任何位置，但是不在你的电脑里，你可以根据网址来访问到我的东西） 2、Node.js如何沟通前端和数据库 3、全栈：图书管理系统（HTML+CSS+JS+Node+Mongo）

1、Node.js安装：

node-v18.15.0-x64.msi - 一路往下点，哪里点不动了，就把哪里勾上，千万不要取消任何东西

版本：16年初（0.12） 16年中（4.xx） 16年末（6.xx） - 更新速度快，意味着：发展迅速，有前景，其实也没有多大的变化，更新的最多的是提升了性能

检查你安装成功没得：打开cmd输入：node -v - 查看版本号，如果有版本号代表你已经安装成功！

其实你安装的这个node.js就是一个运行环境而已！我们书写“js”不再需要浏览器了，因为根本写的就是不是js，而是node.js，只不过语法和js非常相似

2、Node.js如何运行：3种

1、交互模式 - 临时测试

打开cmd输入：node回车，就可以开始敲你的"js"代码

2、脚本/文件模式 - 正式开发中

1、先创建xx.js，里面书写自己的代码

2、打开cmd输入：node 文件的绝对路径

3、编辑器越来越强大了：安装插件

前提：至少前两个方式能够成功，才可以安装插件

vscode - code runner：对着文件出右键，第一个选项就是code runner，或者右上角有一个开始按钮

Node.js知识：

1、js和node的区别

相同点：都可以使用一切的ECMAScript的东西包括一切的API都可以使用，在服务器端不存在任何浏览器，所以不必担心兼容问题

不同点： 1、JavaScript：DOM+BOM - 做特效 2、Node.js：虽然没有DOM+BOM，但是他却又10万以上+的模块等待我们学习

2、模块（module）：

每一个xx.js文件，都可以称之为是一个模块

1、模块化开发：

如果以一个网站来说，我们可以按功能分为很多模块：商家模块、商品模块、促销模块、用户模块、产品模块....

分工合作：将每个模块交给对应的人，完成，最后再由【主模块】进行引入

1、每一个模块都有一个操作，可以用于公开/暴露自己的成员

exports：Node.js自带的一个预定义变量，可以直接使用，是一个对象，放在此对象里面的东西，就是允许公开的东西

    语法：
            1、exports.属性名=属性值;
            2、module.exports={
                    属性名:属性值,
                    ...
                  }

    错误导出法：
            exports={
                    name:"皮卡丘",
                    age:18,
                    hobby:"放电"
            }

2、每一个模块（主模块）都有一个操作，可以用于导入/引入其他模块

require：Node.js自带的一个预定义变量，可以直接使用，是一个函数，函数中需要书写出引入模块的路径

语法：var x=require("./文件名")

鄙视题：exports和module.exports有什么区别？

1、语法，写法，用法不同
2、都是用于公开暴露自己的成员的
但是exports={}，写法是错误的
其实Node.js底层有一句话：exports=module.exports
其实真正做公开功能的是module.exports
如果你使用了exports={};//你创建了一个新的空对象，把module.exports，所以不再具有公开的功能

2、模块的分类：

1、官方模块

大概有二十几个，但是重要的其实只有几个

2、第三方模块

多到数不清楚，提供了很多官方模块没有的东西，有一个网址npm可以去下载

3、自定义模块

Node.js最大的特点：

1、快、非常快 - 以前最快的是php，js的速度是php的十六倍

2、为什么快： 1、因为官方提供的东西少，甚至连数据库的操作API都没有提供的 2、使用了chrome浏览器的v8引擎

3、官方模块：

不需要下载，在你安装node.js环境的时候就已经带上了，但是某的模块可能需要引入，某的模块可能不需要引入：

1、Global模块：

不需要引入的，可以直接使用, 提供了：

1、五个预定义变量，可以直接使用

1、__filename - 获取当前文件完整的绝对路径
2、*__dirname - 获取当前文件绝对路径，不包含文件的名字，何时：vscode某的同学可能不支持node.js上书写相对路径，只能写绝对路径 - 等我们学习了文件系统
3、*exports - 空对象，可以用于公开暴露自己的成员
4、*require - 函数，可以用于导入其他模块
5、***module - 指代当前模块本身，甚至包含着以上4个操作

2、定时器（周期性、一次性、瞬间定时器）：定时器不是当初的js，只不过用法和当初一模一样

3、console也不是当初的console，只不过用法和当初一摸一样

2、querystring模块：

解析查询字符串，使其变成一个对象，可以获取到前端传到后端的消息

需要引入：var qs = require('querystring');

作用：解析url查询字符串部分的功能

var obj=qs.parse("查询字符串");

想要获得前端传来的每一个部分：obj.键名;
一般：如果前端传来的是一个完整的url网址，他就解析不了了！

3、***url模块

需要引入：var url = require('url');

作用：提供了解析url各个部分的功能

var objUrl=url.parse("网址",true);//支持第二参数，是一个布尔值，默认为false，一旦设置为true，自动使用querystring模块的parse方法去解析查询字符串部分

作用：

查询字符串：objUrl.query.键名; - 前端form表单提交传到后端的东西
路由/文件相对路径/请求地址：objUrl.pathname - 判断路由的不同，去读取不同的HTML发送给我们的用户看

4、Buffer模块：

缓冲区，可以将数据变成一个16进制的数字，你可以理解为是Node.js中的一种新的数据类型，但是我们绝对不会手动使用，因为我们一眼看不懂

但是后面的一些API可能会导致我们被动都到Buffer，但是你也别怕，因为Node.js中大部分的API，是支持Buffer

5、*****fs模块

需要引入：var fs = require('fs');

1、*异步读取文件：fs.readFile("文件路径",(err,buf)=>{ buf->读取到的内容 })

2、异步写入文件：fs.writeFile("文件路径","新内容"/buf,()=>{ console.log("写入完毕后，要做什么，必须放在这里面"); })//会替换掉原来的东西

3、异步追加文件：fs.appendFile("文件路径","新内容"/buf,()=>{ console.log("写入完毕后，要做什么，必须放在这里面"); })//会替换掉原来的东西

强调：只有异步才能更完美的发挥Node.js的特点（快）

思考题：如果没有url模块，我们如何去解析一个完整的url网址

	var str="http://www.baidu.com:443/new/index.html?name=dy&pwd=123123&vip=1&email=610147162@qq.com";
	解析出结果为：
	{
		protocal:"http",
		hostname:"www.baidu.com",
		port:443,
		pathname:"/new/index.html",
		query:{
			name:"dy",
			pwd:"123123",
			vip:"1",
			email:"610147162@qq.com"
		}
	}

6、http模块 - 超级重点：搭建服务器

//引入了http（搭建服务器）、url（区分开路由和请求消息）、fs（读取文件响应给用户看）
var http=require("http");
var url=require("url");
var fs=require("fs");
//创建服务器应用
var app=http.createServer();
//为其绑定监听端口
app.listen(80);
//为其绑定请求事件：http：请求 - 响应模式，必须要有一个请求，才有一个响应
app.on("request",(req,res)=>{
        //req:request（请求）对象，他有一个属性叫做req.url，看了一获取到前端传到后端的路由和请求消息，但是路由和请求消息是融为一体的，不方便我们获取某个部分，所以我们引入了url，进行解析，分开两部分
        var objUrl=url.parse(req.url,true);
        //保存路由
        var router=objUrl.pathname;
        if(router=="/" || router=="/index.html"){//判断路由的不同，读取不同的页面给用户看
                //res:response（响应）对象，他有一个方法：res.end(响应的内容) - 可以响应给前端想要的东西
                fs.readFile("./public/html/index.html",(err,buf)=>{
                        res.end(buf);//res.end只能用一次
                })
        }
})

扩展：字符串有一个API：math
var rs=str.match(reg);和indexOf几乎一致，但是支持正则，我们不关心为多少，只关心为不为null

强调：一切的src和href都是一个请求都是一个路由，这个请求就需要后端来解析，根据不同的请求响应不同的内容

4、模块（每个.js文件）的分类

1、官方模块：

不需要下载，再安装Node.js环境的时候就已经自带了，但是有的模块需要引入：require("模块名");

2、第三方模块

在npm下载的都是第三方模块

3、自定义模块：

自己书写的xx.js：require("./模块名");

为什么有的模块引入要./有的又不用加./

自定义模块：分为2大类

1、文件模块：

创建xx.js去公开需要公开的内容，主模块要引入，必须写为require("./模块名");

2、目录模块：3种用法

1、比如创建m1的文件夹，在其中创建index.js的文件，去公开需要公开的内容，主模块要引入，必须写为require("./m1");

2、比如创建m2的文件夹，在其中创建xx.js的文件，，去公开需要公开的内容，主模块要引入，必须写为require("./m2"); 必须再创建一个package.json的配置文件，写入：{"main":"xx.js"}

3、创建一个文件夹必须名为：node_modules，再在其中创建出m3文件夹，在其中创建index.js的文件，去公开需要公开的内容，主模块要引入，必须写为require("m3");

其实真实开发中，我们程序员用的最多的是文件模块，目录模块的第三种方式其实根本不是给人用的（第三方模块下载后会自动创建此文件夹）

5、如何下载第三方模块：

npm工具：Node Package Manager：Node.js的模块/包管理器，专门用于管理第三方模块的，作用：下载、更新、删除、维护包之间的依赖关系

打开网址：npm官网www.npmjs.com/

搜索你需要用到的模块：尽量用带有完全符合标签的那个包，或者是第一个包： 1、打开cmd：检查npm是否安装成功：npm -v 2、在你的项目之中，再打开cmd 3、下载：npm i 包名 4、更新：npm up 包名 5、删除：npm un 包名

MongoDB

mongo就是基于json的数据库，json就是JavaScript Object Notation

1、安装&启动：

1、解压我提供的mongodb-win32-x86_64-2008plus-ssl-3.6.11.zip文件

2、打开bin文件夹，里面有：mongo.exe（客户端）和 mongod.exe（服务器端）

3、如何启动：

在bin文件夹中打开cmd：输入：.\mongod.exe --dbpath=你想要保存的绝对文件夹路径; - 服务器开启成功，而且那个文件夹就保存着你以后要存储的所有的数据
不要关闭mongo服务器的cmd
再打开一个cmd：输入：.\mongo.exe - 在上一个命令行可以查看我们是否连接成功 - 客户端开启成功

2、mongo的语法：都是在客户端cmd输入

1、数据库的操作

1、查询所有数据库：show dbs

2、创建/切换数据库：没有就创建，有了就切换：use 数据库名称

3、查看当前选中的数据库：db

4、创建数据表：db.createCollection("表名") - 无限，一定要先创建数据表后，我们才能查看到自己创建的数据库

5、删除数据库：db.dropDatabase(); - 一旦删除不能恢复，不推荐，因为要坐牢

2、数据表的操作

1、创建数据表：db.createCollection("表名"，{size:5242880,capped:true,max:5000}) - 最大存储空间为5mb，最多存储500个，意味着这个数据表做了限制，不推荐

2、查看目前所有的数据表：db.getCollectionNames();

3、删除数据表：db.表名.drop();

3、*****数据的操作

1、增：

db.表名.save({键值对,...}) - 一次只能插入一条数据

db.表名.save([{},{},{},....]) - 一次插入多条数据

举例：db.user.save([{name:"皮卡",age:18,pwd:"666666",email:"pk@qq.com",vip:"0"},{name:"皮卡丘",age:19,pwd:"999999",email:"pkq@qq.com",vip:"1"}])

2、删：

db.表名.remove({}) - 不推荐，删除数据库中所有的数据

db.表名.remove({name:"皮卡"}) - 会删除数据库中name:"皮卡"的所有数据

3、改：

db.表名.update({条件},{$set:{新内容}});

举例：db.表名.update({name:"皮卡"},{$set:{pwd:"123123"}});

4、*查：

db.表名.find(); - 找所有

db.表名.find({pwd:"666666"}); - 找到所有的密码为666666的数据

db.表名.find({},{name:1,pwd:1}) - 找到所有的数据，但是只返回name和pwd

db.表名.find().sort({age:1}) - 按照age升序排列，-1为降序排列

db.表名.find({age:{$gte:18}}) - 拿到所有age大于等于18的数据

db.表名.find({name:/正则/}) - 甚至可以用正则（模糊查询）

db.表名.find().skip(5).limit(5) - 跳过前5条，再拿5条，理解为5-10条数据（第几个分页条显示第几条数据-第几条数据）

db.表名.find().count() - 获取到此表有多少条数据（做出分页条）

3、安装mongoDBCompass软件：

图形化界面，直观、好看、方便 - 仅仅只用于给我们方便查看

Node.js操作mongoDB：

1、安装第三方模块：mongoose

2、使用步骤：

1、引入：

const mongoose = require('mongoose');

2、连接数据库：

mongoose.connect("mongodb://127.0.0.1/数据库名称");

3、创建出一个新的数据表的同时，设置数据类型的控制，防止用户乱输

    const UserSchema=mongoose.Schema({
            age: Number,
            pwd: String,
            email: String,
            vip: String,
            name: String,
    })
    //		模型名    类型限制     
    var User=mongoose.model("User",UserSchema,"数据表名");

4、增：

    var x=new User({//仅仅只是创建出了一个x对象，并没有放入到数据库之中
            age: "20",
            pwd: "123123",
            email: "dy@qq.com",
            vip: "0",
            name: "dy",
    })

    x.save((err)=>{
            console.log("新增成功后要干什么");
    })

5、删：

    User.remove/deleteOne/deleteMany({条件},(err)=>{// - 作者不推荐remove在mongoose之中使用
            console.log("删除成功后要干什么");
    })

6、改：

    User.update/updateOne/updateMany({条件},{新内容},(err)=>{// - 作者不推荐update在mongoose之中使用
            console.log("修改成功后要干什么");
    })

7、查：

    User.find({条件},(err,result)=>{
            result就是你的查找到的结果
    })

目前：前端能传到后端的技术，只有一个：form表单，action属性可以随便自定义一个路由名称，后端解析此路由就可以通过objUrl.query.键名得到想要的部分

ajax

1、概念：

同步交互：用户向服务器端发起请求，直到服务器端进行响应的全过程，用户是不可以做其他事情的（等）典型：表单提交、网址请求 - 都属于同步交互

异步交互：用户向服务器端发起请求，直到服务器端进行响应的全过程，用户是可以做其他事情的（不等）典型：ajax请求

2、*****Ajax：

Asynchronous JavaScript And XML - 直译：异步的JavaScript和XML - 前端技术不严格的定义：页面不完全刷新，只会导致页面局部发生改变的技术其实我们早就见过异步技术/代码了： 1、定时器 - 做特效 2、mongoose操作数据库的增删改查 - 操作数据库 3、ajax - 目的：在不刷新页面的情况下和服务器端进行交互 - 可以将服务器端的数据放到前端（比较验证、数据渲染）

3、如何使用：

固定4步：

1、创建ajax核心对象：
	var xhr=new XMLHttpRequest();

2、建立和服务器端的连接
	xhr.open("GET/POST","路由");

3、向服务器端发送请求消息
	xhr.send();//但是此方法很特殊：
		1、如果你是GET请求，send方法会失效，但是还不能省略，必须写为：
			xhr.open("GET","路由?key=value&key=value&...");
			xhr.send(null);

		2、如果你是POST请求，send方法可用，必须写为：- 暂时不能用
			xhr.open("POST","路由");
			xhr.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
			xhr.send("key=value&key=value&...");

		get：获取 - ajax一般都是使用get，去找服务器端那东西的 - 举例：跟安全性不挂钩的，搜索框
		post：发送 - 举例：跟安全性挂钩，登录、注册

4、绑定状态监听事件
	xhr.onreadystatechange=()=>{
		if(xhr.readyState==4&&xhr.status==200){
			xhr.responseText - 服务器端相应的文本，ajax就难在你拿到东西了要干什么
		}
	}

数据格式：

1、XML：

1、面试题：HTML、XHTML、DHTML、XML分别是什么？

HTML - 网页：预定义了很多标签，我们学习后，就可以使用他们写出网页
XHTML - 更严格的网页：HTML5 -> XHTML -> HTML4.01，比如：<input />、<input disabled="disabled"/>
DHTML - 动态效果网页：在离线端，我们的网页也具有动态的特效：其实不是新技术也不是新概念，而是现有技术的一个整合统称：HTML+CSS+JS(dom) XML - 配置文件|数据格式：没有提供过任何预定义标签！全靠自定义

2、如何使用XML，其实就是一个后缀.xml的文件

1、创建xx.xml文件
2、必须写上声明标签： - 必须放在第一行第一列
version - 版本号：目前有的版本只有1.0和1.1，但是1.1升级并不理想，没有人使用，所以1.0可以说是唯一版本，而且你学了以后都不用在学了，以后都不会更新了，因为已经淘汰了，有更棒的人（JSON）
encoding - 编码格式
3、必须写上一个根标签，而且只能写一个根标签，而且必须是双标签
4、里面内容随意，你想放什么就放什么

开发中，正常来说后端会想办法将数据库的数据整理为一个xml格式的文件

前端：依然使用ajax去获取xml：

1、路由写为 "xx.xml"
2、xhr.responseText 换成 xhr.responseXML - 可以使用【核心DOM】去操作你需要的东西 - 淘汰的原因，现在来获取数据都要使用核心DOM，太麻烦了

2、JSON：

JavaScript Object Notation：JS对象表示法，本身就是JS的一部分

作用：数据格式类似于 XML

好处：比XML 更简洁、更快、更容易解析 - 一个优秀的数据格式可以极大的提升我们程序员的开发效率

1、哪些属于JSON字符串：

1、'[1,2,3,4,5]';
2、'{"key":value,...}';
3、'[{},{},{},{}]';
4、'{"names":[1,2,3,4],"ages":[1,2,3,4]}'

2、后端把数据库的数据取出来整理为一个JSON字符串：var jsonTxt=JSON.stringify(jsonObj);

3、前端依然使用ajax去获取响应数据，真正重要的：xhr.responseText;
将JSON字符串解析为一个JSON对象：2种方法

1、eval("("+xhr.responseText+")");
2、*JSON.parse(xhr.responseText);

jQuery

1、jQueryUI：

基于jQuery（基于JavaScript的一个框架，是三大框架出现之前，最火的一个，但是现在已经被淘汰了）的开源网页用户界面代码库 - 提供了HTML、CSS、JS的一个插件库

三大框架：Vue（中国人的框架）、React、Angular（在国内几乎没有市场）

组件库：组件，组成网站一部分的部分，代码重用，一般不具备JS功能：比如导航条、图文显示...

插件库：跟组件差不多，只不过带有JS功能 - 选项卡、轮播...

2、简化了核心DOM

使用jQuery，必须先引入：<script src="jquery-ui-1.13.2.custom/external/jquery/jquery.js" type="text/javascript" charset="utf-8"></script>

jQuery中最有魅力的一个方法叫做$：

作用：

1、查找元素：$("JQ选择器"); - 包含一切css选择器的，不需要记忆：推荐网址：www.w3school.com.cn/jquery/jque… - 底层就是document.querySelectorAll
2、创建元素：$("<标签></标签>"); - document.createElement
3、可以将DOM转为JQ：$(DOM对象);
4、代替了window.onload - $(callback);面试题：两者的区别？
1、window.onload - 等待所有资源（html、css、其他js、图片、视频、音频。。。）加载完毕才会执行，效率降到了最低，而且一个页面只能写一次
2、$(callback) - 只是等待DOM加载完毕就会执行，性能比window.onload要高，而且一个页面能写多次底层用到了一个人：重载：arguments - 可以通过判断用户传入的实参的不同执行不同的操作

1、查找元素：

    1、除了直接查找：$("JQ选择器");
    2、通过关系查找：至少要先找到一个人才可以使用关系：
            父：parent();
            子：children();
            前一个兄弟：prev();
            后一个兄弟：next();
            其他兄弟：siblings();
    JQ自带隐式迭代，不需要遍历，可以对集合直接做操作

2、操作元素：

    1、内容：
            获取：$("xx").html/text/val();
            获取：$("xx").html/text/val("新内容");

    2、属性：
            获取：$("xx").attr("属性名");
            设置：$("xx").attr("属性名","属性值");

    3、样式：
		1、可以操作class：
			1、添加class：$("xx").addClass("新class") - JS中没有此操作，只能替换
			2、删除class：$("xx").removeClass()
					如果不传参，删除所有的class名
					如果传入，删除对应的class名
			3、切换class：$("xx").toggleClass("新class")
	
		2、直接操作css
			获取：$("xx").css("css属性名");
			设置：$("xx").css("css属性名","css属性值");
			一句话设置多个样式：
				$("xx").css({
					css属性名:"css属性值",
					...
				});

3、JQ的遍历：

   $("一堆人").each((i,val)=>{})

4、JQ上树&删除：

上树：父亲.append(儿子)
删除：$("xx").remove();

JQ动画：

1、显示 - $("xx").show();
2、隐藏 - $("xx").hide();
3、切换 - $("xx").toggle();
        如果不传参数，是瞬间显示，瞬间隐藏
        可以传入实参：$("xx").api("动画名称",时长);

JQ不可以用以前DOM的语法，DOM也不可以用JQ的语法，但是两者其实可以互换

JQ->DOM：$("xx")[下标]; DOM->JQ：$(DOM);

jQuery可以称之为是一个类库（小），也可以称之为是一个框架（大）

因为大部分人只知道jQuery有一个.js文件（类库）jquery.js

但是jQuery可以称呼是一个框架，因为它由4部分组成： 1、jquery.js 2、jQueryUI.js 3、jQuery-Mobile.js - 但是现在三阶段有uniapp 4、QUnit - 测试用来测试JavaScript代码的一个工具

工具： 1、百度搜索：jQuery插件库网站 2、百度搜索：jQuery之家，免费的，但是没有jQuery插件库那么好看

express

1、Node.js的第三方框架：express，需要使用npm去下载它，express中有两个核心概念 0、下载：在你的项目路径下打开cmd：npm i express

1、引入后发现express是一个函数，创建服务器应用，还要设置监听端口！ var express=require("express"); var app=express(); app.listen(端口号);

2、路由：

客户端发来的请求中的一部分，也称呼叫做相对路径，通过判断路由的不同响应不同的内容。

1、app.get("路由",(req,res)=>{//req和res不是以前的req和res，用法会与原生Node有所不同 1、req->依然是请求对象，保存着前端传来的请求消息：req.query.键名; 2、res->依然是响应对象，可以为前端发数据，也可以为前端发页面： 1、发数据：res.send("想要发的东西"); 2、发文件：res.sendFile("文件的路径"); })

2、特殊：post请求要稍微麻烦一点点，尤其在于获取前端传到后端的请求消息，因为post是隐式提交，所以需要某些东西才能看得见他

 app.post("路由",(req,res)=>{//req和res不是以前的req和res，用法会与原生Node有所不同
 
    1、req->依然是请求对象，保存着前端传来的请求消息：3步
            1、需要引入一个第三方模块（中间件的语法）：var bp=require("body-parser")
            2、使用中间件的语法：app.use(bp.urlencoded({extended:false}))
            3、req.body.键名;

    2、res->依然是响应对象，可以为前端发数据，也可以为前端发页面：
            1、发数据：res.send("想要发的东西");
            2、发文件：res.sendFile("文件的路径");
 })

现在不管是form表单还是ajax，都可以自行选择使用get还是post了

如果是全栈开发，一个人随便搞，但是如果是前后端分离开发，那么要沟通，路由是什么

3、中间件：

express本身就是一个功能极简的框架，完全路由和中间件两部分构成中间件其实就是一个函数，但是它也可以访问req和res两个对象，处于路由之前 - 可以理解为是现实生活中的一个保安、保镖、秘书

中间件的功能包括：

可以执行任何代码
可以修改请求和响应对象
可以终止请求
可以放行你到下一个中间件/路由 - 中间件可以写多个

语法： app.use((req,res,resolve)=>{ 一切你想要执行的代码，中间件代码 resolve();//放行的函数 })

固定套路： 1、*获取post的请求消息，见上面 - app.use(bp.urlencoded({extended:false})) 2、*内置中间件加载一切静态资源：app.use(express.static("静态资源的文件夹名"));

如何简化ajax：

1、jQuery提供了一个新的ajax：

    $.ajax({
            url:"路由", - 必写
            data:"请求消息", - 可选
            dataType:"HTML/XML/JSON", - 可选，默认值为HTML，如果你写了JSON，则可以省略JSON.parse方法
            type:"GET/POST", - 可选，默认值为GET
            success:(data)=>{ - 必写
                    data->后端响应的内容，你不需要再写xhr.responseText
            }
    })

gulp

（使用率：2-） - 三阶段：webpack（使用率：8+）对应的

自动化构建工具（打包工具）：项目经理/小组长使用的 - 学习目的：体验流程

作用：

*1、复制文件
*2、压缩（css/js/图片...）
*3、降级ES6为ES5，降级语法 - 因为ES5之前语法其实都没有变化，ES5只是提供了一些新的API，目的：支持兼容老IE
4、将scss/less编译为css - 不需要学习，现在的编辑器都自带此功能
5、重命名 - 不推荐，html引入href、src的地方名字都要进行修改

*为什么打包：目的：1、为了提升网站效率(文件更小) 2、安全性（加密）

gulp是基于node.js编写的一个第三方模块（包、独立软件），需要在npm下载：安装的操作一步都不能少

*固定操作安装：

1、cmd必须先全局安装gulp（不安的话，cmd提示：gulp不是内部命令） - 必做（运行gulp必要方式），一次性安装永久可用： npm i --global gulp
2、cmd在你的项目中局部安装： npm i gulp
3、cmd在你的项目初始化gulp - 必做 npm init 注意：名字可以自己写，但是不能有大写&中文，然后一路回车到底
4、配置完成，开始编写属于你自己的gulpfile.js文件！！！必须是这个名字

1、如何使用gulp：

   1、先引入var gulp=require("gulp");
   API：
        1、布置任务：
           gulp.task("任务名",()=>{
                //任务要做什么操作
           })

           执行任务：
             cmd里面输入gulp 任务名; - gulp基于node，但是属于是一个独立的软件
             如果想不写任务名，默认执行default任务名的操作

        2、*复制
           gulp.src("入口文件路径"); -- 选中某个、某些源文件
           gulp.pipe(); -- 管道 -- 输送/插件操作
           gulp.dest("出口路径"); -- 输送到哪里去？

           案例：
           gulp.task("copyAll",()=>{
                gulp.src("源文件路径")
                    .pipe(gulp.dest("出口文件路径"))
           })

        文件的路径写法：
          比如：
            想找到src下面的html下面的1.html：src/html/1.html
            想找到src下面的html下面的所有的html：src/html/*.html
            想找到src下面的html下面的所有的文件：src/html/*
            希望将src下面的/下面的所有内容都复制一份：src/*/*

2、gulp的插件

1、压缩css步骤： gulp-cssmin插件 npm下载插件：npm i gulp-cssmin 查看readme中的example小案例使用前记得引入：

gulp.task("copycssmin",()=>{
	gulp.src("src/css/*.css")
		.pipe(cssmin())
		.pipe(gulp.dest("dist"))
})

2、压缩js步骤：1、删除换行和空白字符以及注释（变小文件） 2、会把【回调函数】中的形参全部简化为一个字母，对应的位置都会简化（变小文件的同时加密保护） gulp-uglify插件 npm下载插件：npm i gulp-uglify 使用前记得引入

gulp.task("copyjsmin",()=>{
	gulp.src("src/js/*.js")
		.pipe(uglify())
		.pipe(gulp.dest("dist"))
})

3、ES降级：gulp-babel; 目的：1、语法变回ES5 老IE也能支持我们写的语法切记用的是babel6 *安装： 1、npm install --save-dev gulp-babel@7 babel-core babel-preset-env 2、npm install --save-dev babel-preset-es2015
3、配置一个文件必须名为.babelrc：写入：{ "presets": ["es2015"] } 用法：

	*使用前记得引入，先降级，在压缩
	gulp.task("copyjsmin",()=>{
	gulp.src("src/js/*.js")
		.pipe(babel())  
		.pipe(uglify())
		.pipe(gulp.dest("dist"))
	})
  注意：
   *1、记得要要把严格模式给删掉
    2、先降级后压缩 - 才能压缩完整

4、图片压缩插件：参考网页：blog.csdn.net/x550392236/… 下载：npm i gulp-tinypng-nokey

动态样式语言：

静态样式语言：css，作为一门语言，并不称职，语言必须具备的基础概念，变量、运算、循环、分支、函数...等等他都没有，所以导致我们在开发和维护大型项目中极其不方便

动态样式语言：sass/scss、less，在css的基础上，添加了新特性，目的：【简化css开发】

常见的动态样式语言：

1、sass/scss
2、less
3、stylus - 和css语法差别较大

2、编译：浏览器只认识css，不认识其他的动态样式语言，动态样式语言-(编译)->自动得到一个css，html网页真正的引入的是css

如何编译：

HBuilder：工具->倒数第一个插件，可以编译less和scss （手动）
VSCode：安装一个插件：easy sass，编译你写的scss，你只要一保存就会自动生成一个css （自动）
网上一大堆这种编译工具

Scss的新特性：

1、*变量：

创建：$变量名: 值;

特殊： 1、使用时，$不能省略 2、不区分中划线和下划线 3、依然具有js的作用域，全局变量和局部变量，如果某个变量在选择器内部创建的，则为局部变量，放在最外面的就是全局变量

2、*****嵌套：选择器可以嵌套：

语法：
        .d1{
                ...
                .d2{
                        ...
                        .d4{
                                ...
                        }
                }
                .d3{
                        ...
                        &:hover{...}
                }
        }
编译后：
        .d1{...}
        .d1 .d2{...}
        .d1 .d3{...}
        .d1 .d3:hover{...}
        .d1 .d2 .d4{...}

特殊：
        1、层级选择器由你自己决定，你可以在选择器前面加>、空格、+、~，如果你没加，默认为空格
        2、&类似于JavaScript中的this，被那个{}所包裹，就是那个选择器

3、*导入：

有了动态语言，可以将多个scss整合编译为一个css，并且js也能获取到css里面的代码： @import "文件路径";

4、注释：只能书写多行注释/****/，css本来就不认识单行注释

5、*****混合器：类似于JavaScript中的函数

    1、创建混合器
            @mixin 混合器名($形参:默认值,...){
                    css属性名: css属性值;
                    ...
            }

    2、调用混合器
            @include 混合起名(实参); - 传参顺序很重要
            @include 混合起名($形参:实参); - 传参顺序不重要

    特殊：
            1、使用时，关键字别掉
            2、不要慌着封装、碰到重复的代码了，在提取出来封装为一个混合器

6、继承：

7、*运算符：主要是用于颜色值的运算：支持+ - * /，越往0靠近数字越小，就越暗淡，越往f靠近数字就越大，就越明亮 #000000 - #ffffff

8、分支和循环：

less：和scss特性几乎一样

1、变量的创建：@变量名: 值;
2、混合器更简单：
	创建：
		.混合起名(@形参:默认值,...){
			css属性名: css属性值;
			...
		}

	使用：
		.混合起名(@形参:实参,...)

SVN工具（1-）：

集中式版本管理控制工具

作用：项目管理

集中式：服务器只有一台电脑，所有人可以把自己完成的工作，传送到服务器上，任何人（客户端）都可以访问

缺点：这台电脑如果坏了，就锤子了
优点：没有放在云端，安全性一定是极高的，如果泄露了一定是内鬼，如果项目真的是需要很安全的，你的电脑应该也会装上监控软件

如何使用：

    1、项目经理：
            1、安装svn服务器端：VisualSVN-Server-4.3.2-x64.msi
            2、为此项目组的每个开发者创建出账号密码
            3、创建项目仓库
            4、把仓库地址和你的账号私发给你
            5、承受压力、核算项目周期、核算项目成本、监督项目进度、陪伴加班...

    2、开发人员
            1、安装svn客户端：TortoiseSVN-1.14.1.29085-x64-svn-1.14.1.msi - 记得重启一下电脑（不重启可能看不到小图标）
            2、对着任意位置右键：svn checkout - 检出/拉取仓库，填上仓库地址
            3、在文件夹（仓库）里面做开发
            4、每天下班前提交到服务器：在项目文件夹里面，写代码的位置，右键svn commit，填入日志，在提交
            5、每天上班前更新一下：右键svn update

GIT工具（9+）：三阶段学习 - 分布式版本管理控制工具

websocket

HTML5提供的了一个新特性，代码并不复杂，重点在于理解上

1、HTML5新特性10个：其实是一个概念，并不是只有标签才叫做HTML5

    一、语义化标签
    二、新增Input表单的类型、和属性
    三、audio、video音频和视频
    四、Canvas绘图
    五、SVG绘图 - 因为程序员大部分都不会画画，就算学会了，画出来也很丑，而现在有框架echart.js，可以帮助你实现画图功能（数据可视化 - 折线图、柱状图、饼状图...）
    六、地理定位
    七、拖拽API
    八、WebStorage - sessionStorage和localStorage
    九、WebWorker - 没用
    十、WebSocket

2、websocket的概念

http协议属于请求-响应模型，只有客户端发起请求，服务器端才能响应消息，没有请求就没有响应，一个请求，只能得到一个响应，有些场景中，此模型就不太行了：比如：实时走势图、在线聊天室等等...

解决： 1、ajax+定时器 - 请求过于复杂了，服务器的压力太大，而且不够频繁（心跳请求、长轮询）
2、websocket协议：简称ws协议：属于广播-收听模型，客户端连接到服务器端就不会再断开了，永久连接的，双方可以随意的向对方发送消息，且是不对等的发送，WS协议专门用于完成实施走势图、在线聊天室等等...

如何使用ws：

            1、基于Node.js的第三方模块包，下载引入：
                    var ws=require("ws");

            2、分为三方面：
                    1、依然使用node.js搭建http服务器和文件系统 - 可以用express简化

                    2、搭建ws服务器
                            //搭建ws服务器并且设置了监听端口号
                            var server=new ws.Server({port:8008});	
                            //绑定了连接事件，是不自己断开的，可向客户端发送消息，或者，接收消息
                            server.on("connection",socket=>{
                                    console.log("11111---有人来连接上了");
                                    //后端->前端
                                    socket.send("消息")
                                    //前端->后端
                                    socket.on("message",data=>{
                                            data->前端说的话，只不过是一个buffer类型
                                    })
                            })

                    3、搭建ws客户端
                            //连接到ws服务器端
                            var socket=new WebSocket("ws:127.0.0.1:8008");
                            //前端想要接收消息
                            socket.onmessage=e=>{
                                    e.data;
                            }
                            //前端说话：
                            socket.send("消息");

ES

1、ES5：

1.1、保护对象：

1、6大特性

    Object.defineProperties(obj,{
            "属性名":{
                    value:,
                    writable:true/false,
                    enumerable:true/false,
                    configurable:true,false
                    get:()=>{
                            拦截操作
                    },
                    set:()=>{
                            拦截操作
                    }
            }
    })

2、3个级别

    1、防扩展：Object.preventExtensions(obj);

    2、密封：Object.seal(obj);

    3、冻结：Object.freeze(obj);

1.2、数组新增的六个API：

    1、判断：arr.every/some((v,i,arr)=>判断条件)

    2、遍历：arr.forEach((v,i,arr)=>操作)
            var newArr=arr.map((v,i,arr)=>操作)

    3、过滤和汇总
            var subArr=arr.filter((v,i,arr)=>判断条件)
            var sum=arr.reduce((prev,v,i,arr)=>prev+v);

1.3、call、apply-借用

    语法：
            Array.prototype.slice.call(借用的人,实参1,....)
            Array.prototype.slice.apply(借用的人,arr)	

 bind-买
    语法：
            var 新的slice=Array.prototype.slice.bind(指定的人,永久实参1)

1.4、严格模式：

"use strict"

2、ES6：

超级大版本：

1、模板字符串：${name}

2、let 变量名=值;

3、箭头函数

4、for(var v of arr){ v - 值 }

5、解构赋值 new Vue({}) - 很多框架底层都用到了解构赋值

6、Set和Map [...new Set(arr)] - 数组去重变回数组

7、class关键字 - 简化面向对象的三大特点：封装、继承、多态

            class plane extends flyer{//extends有两个作用：1、继承自有属性全部都不用再写，只需要写一次super()，2、自动继承到共有方法
                    constructor(name,speed,rl){//放在constructor里面的都是自有属性
                            super(name,speed);
                            this.rl=rl;
                    }
                    fly(){//flyer提供的fly方法不好用，我自己封装了一个，覆盖他的 - 多态
                            return `${this.name}正在以时速${this.speed}飞行,可以容纳${this.rl}人`;
                    }
            }

8、Promise - 让异步有顺序的执行，但是还是异步

    new Promise(ajax1).then(ajax2).then(ajax3); - 记得一定要放行，而且前一个return Promise才可以连.then操作

9、模块化开发 - 目的：1、分工合作 2、新的引入方式

    语法：
            1、分支模块要公开自己的成员
                    export var obj={
                            ...
                    }

            2、主模块要引入：
                    import {obj} from "./文件路径"

            3、HTML在引入主模块的时候要注意设置类型：
                    <script src="主模块路径" type="module"></script>

3、ES7：

1、ArrayAPI：includes

    在ES7之前，如果我们想要判断一个数组中是否包含某个元素，需要通过 indexOf 获取结果，并且判断是否为-1
    在ES7之后，我们可以通过includes来判断数组中是否包含一个指定元素，得到结果直接就是一个布尔值
    var arr=[1,2,3,4,5];
    //原来
    console.log(arr.indexOf(6)!=-1);
    //现在
    console.log(arr.includes(3))
    console.log(arr.includes(6))

2、指数运算符：

    在ES7之前，如果我们想要计算数字的乘方，必须通过 Math.pow(底数,幂);
    在ES7之后，增加了 ** 运算符 ，可以对数字进行乘方操作
    Math.pow(2,3) -> 8
    2**3	         -> 8

4、ES8：

1、Object.values 作用：可以将一个对象转为数组

之前我们可以通过 Object.keys 获取一个对象所有的key

可以针对对象操作：

    var obj={
            name:"袍哥",
            age:18,
            hobby:"学习"
    }
    console.log(Object.keys(obj));//["name","age","hobby"];

在ES8中提供了 Object.values 获取一个对象所有的value

    console.log(Object.values(obj));//["袍哥",18,"学习"]；

2、Object.entries

作用：将对象、数组、字符串变为二维数组

通过 Object.entries 可以获取到一个数组，数组中会存放可枚举属性的键值对数组

    console.log(Object.entries(obj));//[["name","袍哥"],["age",18],["hobby","学习"]]

也可以针对数组、字符串进行操作，数组和字符串会将下标作为key

3、*StringPadding

某些字符串我们需要对其进行前后的填充，来实现某种格式化操作，ES8之中就给字符串添加padStart和padEnd方法，分别填充前面和后面

    //日期格式化，为个位数，前面添加了一个0
    var h="8";
    var m="3";
    var s="50";
    console.log(`${h.padStart(2,"0")}:${m.padStart(2,"0")}:${s.padStart(2,"0")}`)

4、尾部逗号的添加，不会报错了

5、*****async 和 await

async作为一个关键字放到函数前面，用于表示函数是一个异步函数，异步函数也就意味着该函数不会阻塞后续代码

    async function f1(){
            return "我是f1函数";
    }
    f1().then(rs=>{
            console.log(rs);
            console.log("得到结果要干什么就在这里操作")
    });
    console.log("后续代码");

意味着任何函数都可以变为异步

await 关键字只能放在async函数里面

    async function f1(){
            return 1;
    }
    async function f2(){
            return 2;
    }
    async function f3(){
            return await f1() + await f2();
    }
    f3().then(rs=>{
            console.log(rs);
    });
    console.log("后续代码");

JS汇总二

保护对象：

1、四大特性：

2、三个级别：

对象的深浅拷贝：

Error对象：错误

2、浏览器自带4种错误类型：可以快速找到自己的错误

3、错误处理

4、抛出自定义错误，只要是错误，后续代码都不会执行

5、ES5：严格模式

柯里化函数

百度/高德地图：

1、定位技术:

2、网站的定位技术都是使用的GPS

3、开发者如何使用：

匿名函数：

1、自调：

2、回调：

设计模式：21种设计模式

1、单例模式：

2、发布订阅模式 ：

事件轮询：

1、宏任务：

2、微任务：

Node.js概述：

1、Node.js安装：

2、Node.js如何运行：3种

1、交互模式 - 临时测试

2、脚本/文件模式 - 正式开发中

3、编辑器越来越强大了：安装插件

Node.js知识：

1、js和node的区别

2、模块（module）：

1、模块化开发：

2、模块的分类：

1、官方模块

2、第三方模块

3、自定义模块

3、官方模块：

1、Global模块：

2、querystring模块：

3、***url模块

4、Buffer模块：

5、*****fs模块

6、http模块 - 超级重点：搭建服务器

4、模块（每个.js文件）的分类

1、官方模块：

2、第三方模块

3、自定义模块：

1、文件模块：

2、目录模块：3种用法

5、如何下载第三方模块：

MongoDB

1、安装&启动：

2、mongo的语法：都是在客户端cmd输入

1、数据库的操作

2、数据表的操作

3、*****数据的操作

1、增：

2、删：

3、改：

4、*查：

3、安装mongoDBCompass软件：

Node.js操作mongoDB：

1、安装第三方模块：mongoose

2、使用步骤：

ajax

1、概念：

2、*****Ajax：

3、如何使用：

数据格式：

1、XML：

2、JSON：

jQuery

1、jQueryUI：

2、简化了核心DOM

1、查找元素：

2、操作元素：

3、JQ的遍历：

4、JQ上树&删除：

2、发布订阅模式：