保护对象

每个属性都有四大特性：

{
  value:'',
  writable:true,
  enumerableL:true,
  configurable,true
}

修改四大特性： 1.

   Object.defineProperty(对象名,"属性名",{
   四大特性:
   })
  2.Object.defineProperties(对象名,{
  "属性名":{四大特性},
  ...
  )

2.三个级别：

  1.防扩展:防添加
  Object.preventExtensions(obj);
  2.密封：防添加防删除
  Object.seal(obj);
  3.冻结：防添加防删除防修改
  Object.freeze(obj);

3.set拦截操作：

Object.defineProperty(lhl,"name"),{
  get:()=>{
   console.log("");
          },
   set:v=>{
   console.log(""+v);
   h1.innerHTML=v
          },
   })

对象的深浅拷贝 1.浅拷贝：按值传递

  var obj1={"name":"obj1"};
  var obj2=obj1;

2.浅拷贝：两者互不影响

  var obj1={"name":"obj1"};
  var obj2={...obj1}

3.以后如何拖点后端传来的数据的衣服：

var JSONtxt=JSON.stringify(obj);//后端穿衣服
var jsonObj=JSON.parse(JSONtxt);//前端穿衣服

3.Error对象 1.浏览器自带四种错误

1.语法错误：SyntaxError

2.引用错误：ReferenceError

3.类型错误：TypeError

4.方位错误：RangeError //只会在num.toFixed(d)0-100之间碰到

错误处理：

try{
   只放入你可能出错的代码
 }catch(err){
   发生错误后才会执行的代码
 }

try...catch的性能非常的差，正式发开常用分支技术代替。

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

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

5.严格模式

开启："use strict"

作用： 1.可以禁止全局污染，使用变量必须先创建

2.将静默失败升级为报错

4、柯里化函数：

 function add(a){
   return function(b){
      return function(c){
         console.log(a+b+c)
     }
   }
}

     add(3)(5)(7);

第二天

匿名函数 1.自调：

  (function(){
     })();

2.回调

 elem.on事件名=function(){}
 arr.sort(function(){})
 xxx.api(function(){})
 var obj={
    "方法名":function(){}
 }

设计模式 1.单例模式

var h52302=(function(){
				let state=null;//state=dll
				return function(name,age){
					this.name=name;//dll.name="邓灵力"
					this.age=age;//dll.age=18
					if(state){//dll->{} -> true
						return state;
					}
					return state=this;
				}
			})();
			
			h52302.prototype.sayHello=function(){
				console.log(this.name);
			}
			
			var dll=new h52302("邓灵力",18);
			var wr=new h52302("王锐",19);
			
			console.log(dll);
			dll.sayHello();
			
			console.log(wr);//其实还是return了dll
			wr.sayHello();

2.观察者模式 let obj={};

		//创建订阅者
		function on(id,fn){
			if(!obj[id]){//判断有没有此id（有没有这个人），没有我就创建了一个空数组
				obj[id]=[];//obj["袍哥"]=[]
			}
			obj[id].push(fn);//obj["袍哥"]=[(msg)=>{console.log("小胡来了",msg)},(msg)=>{console.log("小罗来了",msg)},(msg)=>{console.log("小向来了",msg)}]
		}
		
		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)})
		on("袍哥",(msg)=>{console.log("小李来了",msg)})
		
		//发布者的操作
		function emit(id,msg){//id="袍哥"
			obj[id].forEach(fn=>fn(msg));//obj["袍哥"].forEach(fn=>fn("一支穿云箭"))
		}
		
		btn.onclick=()=>{
			emit("袍哥","一支穿云箭");
		}

3.事件轮询 宏任务：不会卡住单线程应用，可以让后续代码先走，但是多个宏任务同时存在并不知道执行顺序。

1.定时器：setInterval和setTimeout() 2.AJAX

微任务：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);
			console.log("后续代码");

第三天

1.交互模式

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

2.脚本/文件模式

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

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

模块

exports.属性名=值;//公开
module.exports.属性名=值;
module.exports={
    属性名:属性值,
    ...
}
exports={}错误导出法

在主模块引入require(是一个方法)。

    var x=require("./路径")

面试鄙视题：

exports和module.exports有什么区别？

exports={}，写法是错误的

其实Node.js底层有一句话：exports={}

其实真正做公开功能的是module.exports

如果你使用了exports={};//

你创建了一个新的空对象，把module.exports覆盖了，所以不再具有公开的功能

模块分为：

1.官方模块

2.第三方模块

3.自定义模块

1.Global模块

五个预定义变量 1.filename当前文件的完整绝对路径

2.dirname不包含自己的名字

3.exports公开

4.require导入其他模块

5.module包含以上4个操作

2.querystring模块：解析查询字符串

var qs=require('querystring');//解析查询字符串部分
var obj=qs.parse("查询字符串");

url模块

var url=require("url");//解析url各个部分的功能
var objUrl=url.parse("url",true)//true会自动使用querystring的parse方法去解析字符串

查询字符串：

objUrl.query.键名;
objUrl.path //路由

fs模块

var fs=require("fs");
fs.readFile(文件路径,(err,buf)=>{
       console.log(buf);//异步读取文件
})
fs.writeFile(文件路径,"新内容"/buf,(err)=>{
     console.log();//异步写
})
fs.appendFile(文件路径,"新内容"/buf,(err)=>{
     console.log();//异步追加
})

第四天

http模块:搭建服务器&文件系统

    var http=require("http");
    var url=require("url");
    var fs=require("fs");
    var app=http.createSever();//创建服务器应用
    app.listen(80)//绑定端口号;
    app.on("request",(req,res)=>{绑定请求事件，只要有人请求，就会触发,有一个属性叫做req.url获取前端传到后端的路由和请求消息
    var objUrl=url.parse(req.url,true);
    var router=objUrl.pathname;//保存路由
    if(router=="/"||router=="index.html")//判断路由引入fs文件模块
   //res:response有个方法叫做res.end("响应的内容"/buf);
   fs.readFile(__dirname+"/public/html/index.html",(err,buf)=>{
   res.end(buf)  
   })
 }else if(router.match(/html)!=null){
   fs.readFile(__dirname+`public/html${router}`,(err,buf)=>{
   res.end(buf)
   })
 }else if(router.match(/css|js/jpg/png/gif/wof/woff2/ttf2)!=null){
 fs.readFile(__dirname+`public${router}`,(err,buf)=>{
  res.end(buf)
   })
 }

强调:一切的src和href都是一个请求都是一个路由，这个请求需要后端来解析。

第五天

1、安装第三方模块：mongoose
		
	2、使用步骤：
		1、引入：var mongoose=require("mongoose");
		2、连接数据库：mongoose.connect("mongodb://127.0.0.1/h52302");
		3、创建出一个新的数据表的同时，设置数据类型的控制，防止用户乱输
			var UserSchema=mongoose.Schema({
				name:String,
				pwd:String,
				age:Number,
				email:String,
				vip:String
			})
			//		模型名随意的        数据的控制         表名，没有则为创建，有了则为选中！
			var User=mongoose.model("User",UserSchema,"user")


		4、增：2步
			1、创建要插入的对象
			var x=new User({
				name:"袍哥1",
				pwd:"123456",
				age:"123",
				email:"pg@qq.com",
				vip:"1"
			})
			2、创建好的对象插入到数据表中
			x.save().then(()=>{
				console.log("插入完毕了，你要干什么，必须放在这个里面，因为他也是异步")
			})

		5、删：
			User.deleteOne/deleteMany({条件}).then(()=>{
				console.log("删除完毕了，你要干什么，必须放在这个里面，因为他也是异步")
			})

		6、改：
			User.updateOne/updateMany({条件}).then(()=>{
				console.log("修改完毕了，你要干什么，必须放在这个里面，因为他也是异步")
			})

		7、查：
			User.find({条件}).then((rs)=>{
				rs->查询到的数据
			})