diff --git a/README.md b/README.md
index fa6af2a..fe08612 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,24 @@
-# 朱邦邦的JavaScript学习笔记
-我的学习笔记
+# 安邦的JavaScript学习笔记
+
+这是当初学习JS时候的笔记，
+
+因小伙伴反应Github不适合阅读，
+
+我在我的个人网站(阿西河前端教程)上也有整理一份，详情参见；
+
+[朱安邦的JavaScript学习笔记](https://www.axihe.com/anbang/js/edu/home.html) （我的个人网站）
+
+后期主要更新在我的个人网站上，感觉我整理后的还是很适合学习和阅读的，服务器放在国内，访问速度也超级快；
+
+然后每年的年底统一把新增的内容更新到当前的Github仓库；
+
+欢迎大家关注我的小网站: https://www.axihe.com/
+
+同时我也在Bilibili上开频道做UP主；欢迎在B站关注我: https://space.bilibili.com/59312814
> 基于ES5,包含ES6的，笔记最近正在重新整理，有些链接可能失效；会尽快整理好；
-1. [前端开发初识](./前端开发初识/README.MD)
+1. [前端开发初识](./前端开发初识/)
- [编辑器的选择/开发环境介绍](./前端开发初识/README.MD#one)
- [HTML文档和标签介绍](./前端开发初识/README.MD#two)
- [JS由哪些部分组成、DOM初识](./前端开发初识/README.MD#three)
@@ -17,7 +32,7 @@
- [前端技术方向的选择,编程语言是做什么的？](./前端开发初识/README.MD#eleven)
- [JS代码检测的一些小方法](./前端开发初识/README.MD#twelve)
-1. [数据类型初识](./数据类型初识/README.MD)
+1. [数据类型初识](./数据类型初识/)
- [String](./数据类型初识/README.MD#one)
- [Number](./数据类型初识/README.MD#two)
- [Boolean](./数据类型初识/README.MD#three)
@@ -26,6 +41,15 @@
- [null和undefined的区别和联系](./数据类型初识/README.MD#six)
- [Symbol](./数据类型初识/README.MD#footer)
- [练习题](./数据类型初识/README.MD#footer)
+
+1. [函数初识](./函数初识/)
+ - [初识函数](./数据类型初识/README.MD#one)
+ - [函数的定义](./数据类型初识/README.MD#two)
+ - [函数的调用](./数据类型初识/README.MD#three)
+ - [函数的方法](./数据类型初识/README.MD#four)
+ - [arguments对象](./数据类型初识/README.MD#five)
+ - [函数的参数](./数据类型初识/README.MD#six)
+ - [this关键字的指向](./数据类型初识/README.MD#seven)
1. [变量声明和原理](./变量声明和原理/README.MD)
- [变量的命名](./变量声明和原理/README.MD#one)
@@ -160,4 +184,3 @@
-
diff --git "a/\345\207\275\346\225\260\345\210\235\350\257\206/1.\345\207\275\346\225\260\345\256\232\344\271\211.js" "b/\345\207\275\346\225\260\345\210\235\350\257\206/1.\345\207\275\346\225\260\345\256\232\344\271\211.js"
new file mode 100644
index 0000000..c63960c
--- /dev/null
+++ "b/\345\207\275\346\225\260\345\210\235\350\257\206/1.\345\207\275\346\225\260\345\256\232\344\271\211.js"
@@ -0,0 +1,17 @@
+//function语句的定义方法
+function test1(arg1,arg2){
+ console.log("function语句的定义方法:",arg1+arg2);
+}
+
+//函数直接量的定义方法
+var test2 = function(arg1,arg2){
+ console.log("函数直接量的定义方法:",arg1+arg2);
+};
+var utility={
+ init:function () {
+ console.log("执行")
+ }
+};
+
+//构造函数的定义方法
+var test3 = new Function("arg1","arg2","console.log('构造函数的定义方法:',arg1+arg2)");
\ No newline at end of file
diff --git "a/\345\207\275\346\225\260\345\210\235\350\257\206/2.toString.js" "b/\345\207\275\346\225\260\345\210\235\350\257\206/2.toString.js"
new file mode 100644
index 0000000..6371573
--- /dev/null
+++ "b/\345\207\275\346\225\260\345\210\235\350\257\206/2.toString.js"
@@ -0,0 +1,5 @@
+console.log(test1.toString());
+
+function test1(){
+ console.log("最开始的调用方法");
+}
\ No newline at end of file
diff --git "a/\345\207\275\346\225\260\345\210\235\350\257\206/README.md" "b/\345\207\275\346\225\260\345\210\235\350\257\206/README.md"
new file mode 100644
index 0000000..3496b8b
--- /dev/null
+++ "b/\345\207\275\346\225\260\345\210\235\350\257\206/README.md"
@@ -0,0 +1,374 @@
+
+
+# 函数的初识
+- 知识点一、[初识函数](#one)
+- 知识点二、[函数的定义](#two)
+- 知识点三、[函数的调用](#three)
+- 知识点四、[函数的方法](#four)
+- 知识点五、[arguments对象](#five)
+- 知识点六、[函数的参数](#six)
+- 知识点七、[this关键字的指向](#seven)
+- [面试题](#footer)s
+
+
+# 一、初识函数
+
+### 函数的意义：**高内聚，低耦合，复用与多态**；
+
+可以通过函数封装任意多条语句，而且可以在任何地方，任何时候进行调用，使用非常灵活；
+
+```$xslt
+// 基本的语法
+function functionName(argument1,argument2){
+ /*一堆的代码*/
+}
+//下面是函数的一个实例，
+function diff(a,b){
+ console.log(a-b);
+}
+diff(10,5);//输出5
+diff(20,2);//输出18
+```
+
+**函数可以通过它的函数名来调用，后面加()，就可以执行了**；
+
+上面的diff分别输出的是5和18；a和b是函数的两个参数，最终的结果是打印在控制台的；
+
+### return
+
+函数还有一个属性，就是可以 return；
+
+**知识点1：函数的返回值只能通过return来返回,除了return以外，没有任何声明可以表示返回值**
+
+ECMA中函数在定义的时候，不要求函数是否返回一个值，但是每个函数都有return的权利；
+
+任何函数在任何时候都可以通过return语句返回的值来实现把值返回给外部变量（return的位置是任意的）；
+
+```$xslt
+function diff(a,b){
+ return a-b;
+}
+var diffNumber=diff(10,5);
+console.log(diffNumber);
+//diffNumber用来接收函数的返回值，如果return了一个值，但是外部没有变量去接收它，就失去了return的意义了；
+```
+
+知识点2：**return的特性**：无论return在哪里，只要有执行了return同一条的代码后，函数立即停止，并且立即退出，因此位于return语句之后的任何代码都永远不会执行；
+```$xslt
+function diff(a,b){
+ return a-b;
+ console.log("测试的代码");//这条语句，永远不会执行；
+}
+var diffNumber=diff(10,5);
+console.log(diffNumber);
+```
+
+
+**知识点3**：一个函数可以多条return；
+
+写一个函数，计算两个数之间的相差多少；
+
+```$xslt
+function diff(a,b){
+ if(a>b){
+ return a-b;
+ }else{
+ return b-a;
+ }
+}
+var diffNumber1=diff(10,5);
+var diffNumber2=diff(5,10);
+console.log(diffNumber1);//5
+console.log(diffNumber2);//5
+```
+这个函数diff用来计算两个数之间才差值；如果a比b小，则用b-a；否则a-b；函数中用if分为两个分支，分别具有自己的return语句来执行正确的计算逻辑；
+
+**知识点4**：return语句可以不带任何返回值，这种情况下，函数返回值是undefined；这种写法，一般用在需要提前停止函数又不需要返回值的情况；
+
+```$xslt
+function testReturn (arg){
+ console.log("arg的值是："+arg);
+ //如果传的值是空字符串，参数不对， 没必要处理了，直接return停止函数了，可以优化性能；；
+ if(arg===""){return}
+ console.log("一些处理参数的代码")
+}
+testReturn("");
+```
+
+**return的总结**
+
+- 1、任何一个函数都有return关键字，用来导出函数内部的值；（闭包的思路）；
+- 2、return是非必须的，可以写也可以不写；如果不写，或者return后面没有值，函数的返回结果都是undefined；
+- 3、无论return写在哪里，只要函数执行到了return这条代码了，执行完以后，立即停止执行并且跳出函数；会导致return下面的代码将不会执行；
+- 4、推荐的做法是要么让函数始终都返回一个值，要么永远不要返回值，；否则函数有时候有返回值，有时候没有返回值，调试起来不方便；
+
+
+**[↑ 返回目录](#zero)**
+
+
+# 二、函数的定义
+
+- function语句的定义方法
+- 函数直接量的定义方法（需要考虑变量的预解释）
+- 构造函数的定义方法
+
+```
+//function语句的定义方法
+function test1(arg1,arg2){
+ console.log("function语句的定义方法:",arg1+arg2);
+}
+
+//函数直接量的定义方法
+var test2 = function(arg1,arg2){
+ console.log("函数直接量的定义方法:",arg1+arg2);
+};
+var utility={
+ init:function () {
+ console.log("执行")
+ }
+};
+
+//构造函数的定义方法
+var test3 = new Function("arg1","arg2","console.log('构造函数的定义方法:',arg1+arg2)");
+
+```
+
+前两种定义方式，比较常见，最后一种做了解即可
+
+**[↑ 返回目录](#zero)**
+
+
+# 三、函数的调用
+
+1.直接调用： 函数名(实参列表)
+
+```$xslt
+function test1(arg1,arg2){
+ console.log("function语句的定义方法:",arg1+arg2);
+ return;
+}
+
+//直接调用
+test1(1,2);//function语句的定义方法: 3
+```
+
+2.在链接中调用
+
+```$xslt
+
+
+
+
+```
+
+3.在事件中调用
+
+```$xslt
+
+
+
+
+```
+
+4.递归调用
+
+**在函数内部调用函数自身**
+
+```$xslt
+
+
+```
+
+函数的调用还是非常灵活的；
+
+**[↑ 返回目录](#zero)**
+
+# 四、函数的方法
+
+- call：将函数作为对象的方法来调用，将参数传递给该方法，在后面this关键字时候详细总结
+- apply：将函数作为对象的方法来调用，将参数以数组的形式传递给该方法，在后面this关键字时候详细总结
+- toString：返回函数的字符串表示
+
+```
+console.log(test1.toString());
+
+function test1(){
+ console.log("最开始的调用方法");
+}
+```
+
+**[↑ 返回目录](#zero)**
+
+
+# 五、arguments对象
+
+### 功能：存放实参的参数列表
+```
+test1(1,2);//[1,2]
+test1(1,2,3,4,5);//[1, 2, 3, 4, 5]
+function test1(){
+ console.log(arguments);
+}
+
+```
+argutments在普通模式里，可以在函数内部修改函数的值，但是不建议那么做；这点在严格模式下也有限制
+
+- 在严格模式，函数内部不能修改argument的值，即使修改了，操作也是无效的；
+- 其次重写arguments值会导致语法错误，代码不执行；
+
+### 特性：
+- 仅能在函数体内使用
+
+```
+test1(1,2);//[1,2]
+function test1(){
+ console.log(arguments);
+}
+console.log(arguments);//Uncaught ReferenceError: arguments is not defined
+
+```
+- 带有下标属性，但是并非数组
+
+```
+test1(1,2);//1 2 undefined
+function test1(){
+ console.log(arguments[0],arguments[1],arguments[2]);
+}
+
+```
+- 函数声明时自动初始化
+
+- 属性
+ - 1.length 获取函数实参的长度
+
+ ```$xslt
+ test1(1,2,3,4,5);// 输出5
+ function test1(){
+ console.log(arguments.length);
+ }
+ ```
+ - 2.callee 返回当前正在指向的函数
+
+ ```$xslt
+ test1(1,2,3,4,5);// 输出函数本身
+ function test1(){
+ console.log(arguments.callee);
+ }
+ ```
+
+ - 3.caller 返回调用当前正在执行函数的函数名;在chrome里是没有的；尽量不要用arguments的这个属性；
+ - 在chrome里的callee是arguments.callee.caller
+ - 对于函数来说，caller 属性只有在函数执行时才有定义。 如果函数是由 Javascript 程序的顶层调用的，那么 caller 包含的就是 null 。
+
+ ```
+ function callerDemo() {
+ if (arguments.callee.caller) {
+ var a = callerDemo.caller.toString();
+ console.log(a);
+ } else {
+ console.log("this is a top function");
+ }
+ }
+ function handleCaller() {
+ callerDemo();
+ }
+ handleCaller();
+ function calleeDemo() {
+ console.log(arguments.callee);
+ }
+ calleeDemo();
+ ```
+
+**函数的参数是函数的灵魂**；ECMA中的函数不在乎传来多少个参数，也不在乎你传进来的是什么类型的，即使你定义的函数值接受两个参数，在调用的时候未必严格的传进两个实参，你传一个，三个，不传都是没有问题的、`这就是函数的多态`；
+
+原理是因为ECMA是把函数用在内部用一个”数组”来表示的，函数接受到的始终都是这个数组，并不关心这个”数组”是否包含参数，已经包含的都是什么参数，可以通过`arguments[index]`这种的方式来访问，也可以通过`arguments.length`的值来确定传进来了多个参数；
+
+```$xslt
+function testArgument(){
+ console.log("hello argument[0]:"+arguments[0]+" and argument[1]:"+arguments[1]);
+}
+testArgument("1","2");//hello argument[0]:1 and argument[1]:2
+testArgument("1");//hello argument[0]:1 and argument[1]:undefined
+testArgument();//hello argument[0]:undefined and argument[1]:undefined
+```
+
+函数的一个特点，形参只是提供了操作的便利，但并不是必须的；函数的定义和调用与参数是没有关系的，只有在函数内部引用了形参才与实参个数和值有关系；
+
+如果函数只是定义了，但是没有执行，那就是脱裤子放屁了；因为对程序不会有任何意义；
+
+```$xslt
+function sum(a,b){
+ if(arguments.length===2){
+ console.log("第1个参数和第二个参数的和是:"+a+b);
+ }else if(arguments.length===1){
+ console.log("block,只传了一个参数 "+a+"，让我如何相加")
+ }else{
+ console.log("我拒绝运算！")
+ }
+}
+sum(10,8);//第1个参数和第二个参数的和是:108
+sum(10);//block,只传了一个参数 10，让我如何相加
+sum();//我拒绝运算！
+```
+
+上面就牵扯到了函数的多态，根据不同的参数来做不同的事情;
+
+
+
+**[↑ 返回目录](#zero)**
+
+
+# 六、函数的参数
+
+- 参数类型；
+ 1. 形参，定义函数时使用的参数，接收调用该函数时传递的参数
+ 2. 实参，调用函数时传递给函数的实际参数；
+- 特性；
+ 1. 参数个数没有限制；（实参<形参，多余形参==undefined；实参>形参，多余实参被忽略；）
+ 2. 参数的数据类型没有限制，通过arguments对象访问参数数组；
+ 3. 参数始终按值传递
+ - a) 基本类型-传值；
+ - b) 引用类型-地址；
+
+
+**[↑ 返回目录](#zero)**
+
+
+
+### 七、this关键字的指向
+
+- this，指向当前操作对象；
+- callee，指向参数集合所属函数
+- prototype，指向函数附带的原型对象；
+- constructor，指向创建该对象的构造函数；
+
+### 面试题
\ No newline at end of file
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/1.\345\274\200\345\217\221\347\216\257\345\242\203\344\273\213\347\273\215.html" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/1.\345\274\200\345\217\221\347\216\257\345\242\203\344\273\213\347\273\215.html"
new file mode 100644
index 0000000..962fd77
--- /dev/null
+++ "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/1.\345\274\200\345\217\221\347\216\257\345\242\203\344\273\213\347\273\215.html"
@@ -0,0 +1,16 @@
+
+
+
+
+ Title
+
+
+
+
编辑器：webstorm/vscode
+
浏览器：chrome
+
5
5
-22222>
+
22222
22222
这是DIV1的内容
222
@@ -46,8 +46,6 @@
oDiv2.style.color="red";//通过JS来改变CSS；
console.log("ID",oDiv1);
-
-
var oDivClass=document.getElementsByClassName("div-class");//这是一对标签的集合
console.log(oDivClass);
console.log(oDivClass[0]);
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/JS\347\224\261\345\223\252\344\272\233\351\203\250\345\210\206\347\273\204\346\210\220.html" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/4.JS\347\224\261\345\223\252\344\272\233\351\203\250\345\210\206\347\273\204\346\210\220.html"
similarity index 100%
rename from "\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/JS\347\224\261\345\223\252\344\272\233\351\203\250\345\210\206\347\273\204\346\210\220.html"
rename to "\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/4.JS\347\224\261\345\223\252\344\272\233\351\203\250\345\210\206\347\273\204\346\210\220.html"
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/HTML\344\270\255\346\200\216\344\271\210\345\206\231JS.html" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/5.HTML\344\270\255\346\200\216\344\271\210\345\206\231JS.html"
similarity index 100%
rename from "\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/HTML\344\270\255\346\200\216\344\271\210\345\206\231JS.html"
rename to "\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/5.HTML\344\270\255\346\200\216\344\271\210\345\206\231JS.html"
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/HTML\344\270\255\346\200\216\344\271\210\345\206\231CSS.html" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/6.HTML\344\270\255\346\200\216\344\271\210\345\206\231CSS.html"
similarity index 98%
rename from "\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/HTML\344\270\255\346\200\216\344\271\210\345\206\231CSS.html"
rename to "\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/6.HTML\344\270\255\346\200\216\344\271\210\345\206\231CSS.html"
index 28a1033..d1a4b9e 100644
--- "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/HTML\344\270\255\346\200\216\344\271\210\345\206\231CSS.html"
+++ "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/6.HTML\344\270\255\346\200\216\344\271\210\345\206\231CSS.html"
@@ -29,7 +29,7 @@
body .test-demo{ color: orange; }
- \
+
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/HTML\344\270\255\346\200\216\344\271\210\345\206\231CSS2.html" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/6.HTML\344\270\255\346\200\216\344\271\210\345\206\231CSS2.html"
similarity index 100%
rename from "\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/HTML\344\270\255\346\200\216\344\271\210\345\206\231CSS2.html"
rename to "\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/6.HTML\344\270\255\346\200\216\344\271\210\345\206\231CSS2.html"
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/noscript\346\240\207\347\255\276\345\274\225\347\224\263\347\232\2042\347\247\215\347\274\226\347\250\213\346\200\235\346\203\263.html" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/7.noscript\346\240\207\347\255\276\345\274\225\347\224\263\347\232\2042\347\247\215\347\274\226\347\250\213\346\200\235\346\203\263.html"
similarity index 100%
rename from "\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/noscript\346\240\207\347\255\276\345\274\225\347\224\263\347\232\2042\347\247\215\347\274\226\347\250\213\346\200\235\346\203\263.html"
rename to "\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/7.noscript\346\240\207\347\255\276\345\274\225\347\224\263\347\232\2042\347\247\215\347\274\226\347\250\213\346\200\235\346\203\263.html"
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/CSS3\344\270\255\344\270\244\347\247\215\346\226\271\346\241\210.html" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/8.CSS3\344\270\255\344\270\244\347\247\215\346\226\271\346\241\210.html"
similarity index 100%
rename from "\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/CSS3\344\270\255\344\270\244\347\247\215\346\226\271\346\241\210.html"
rename to "\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/8.CSS3\344\270\255\344\270\244\347\247\215\346\226\271\346\241\210.html"
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/9.\345\217\230\351\207\217\347\232\204\345\256\232\344\271\211\345\222\214\350\265\213\345\200\274.js" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/9.\345\217\230\351\207\217\347\232\204\345\256\232\344\271\211\345\222\214\350\265\213\345\200\274.js"
new file mode 100644
index 0000000..3380332
--- /dev/null
+++ "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/9.\345\217\230\351\207\217\347\232\204\345\256\232\344\271\211\345\222\214\350\265\213\345\200\274.js"
@@ -0,0 +1,18 @@
+// tb='淘宝';
+
+var jd="京东商城";
+// var z="亚马逊';// 双引号" 和单引号' 不能混合使用
+var xx;
+/*
+* var variable 变量 let const 声明变量的关键字；
+* tb 这是变量名
+* = 这是操作符
+* "京东商城" 这个是数据
+*
+* 把"京东商城"，这段数据，通过=来赋值给jd这个变量名；
+* */
+console.log(jd);
+console.log(xx);//undefined
+// console.log(tb);
+
+//"京东商城" 字符串"" 和 '' 包裹的内容 属于字符串类型
\ No newline at end of file
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/ES6\347\232\204\344\273\213\347\273\215\345\222\214Javascript\346\226\207\346\241\243\346\250\241\345\274\217.html" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/ES6\347\232\204\344\273\213\347\273\215\345\222\214Javascript\346\226\207\346\241\243\346\250\241\345\274\217.html"
deleted file mode 100644
index a672889..0000000
--- "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/ES6\347\232\204\344\273\213\347\273\215\345\222\214Javascript\346\226\207\346\241\243\346\250\241\345\274\217.html"
+++ /dev/null
@@ -1,19 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
-
\ No newline at end of file
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/README.MD" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/README.MD"
index 0b12589..61c9e9d 100644
--- "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/README.MD"
+++ "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/README.MD"
@@ -17,18 +17,19 @@
# 一、编辑器的选择/开发环境介绍
- WebStorm/IDEA,内置支持zen coding 、nodejs、拿来即用的，遇到gulp、git、markdown文件会智能提示对应的插件等，前端开发的神器，因为需要建立索引，启动时间比较长，占用内存大；
- zen coding写法：div#page>div.logo+ul#navigation>li*5>a
-- sublime text 启动快，短小精悍型的，配合插件，可实现强大功能，适合喜欢捣腾的，不建议没有编程基础的初学者直接使用，可以编程一段事件后再用；
+- sublime text 启动快，短小精悍型的，配合插件，可实现强大功能，适合喜欢捣腾的；
+- vscode 类似sublime，但是比sublime好很多；
- Editplus 、 Notepad 、 Dreamweaver 这些都不推荐前端开发初学者使用；很多老开发者还在使用，因为习惯，再就是配置了相关的插件，懒得折腾了，所以一直在用，毕竟干活效率才是最重要的；但是对于初学者，还是建议选择合适的；
- Atom，github；WEB端编辑器；
- 如果您会VIM，编辑器可以还可以用您以前的，主流的编辑器都有VIM语法插件；VIM+webStorm/sublime 等都比较顺手的；
- 推荐使用webStorm，把精力放在研究代码上，不要在编辑器上浪费过多时间；
-- webstorm官网：http://www.jetbrains.com/webstorm/ (这个网站的下载速度还是可以的，如果有下载不来，联系我下，我贴网盘链接上来 )
+- webstorm官网：http://www.jetbrains.com/webstorm/ (这个网站的下载速度还是可以的，如果有下载不来，可以找第三方下载 )
##### 开发环境介绍
相比其他语言，JavaScript的优势之一在于不用安装或配置任何复杂的环境就可以开始学习。
-- 编辑器推荐使用webstorm；
+- 编辑器推荐使用webstorm/vscode；
- 浏览器用Chrome；
这样就可以学习javascript，这门语言了，因为JS代码是执行时候才进行编译，所以环境比较简单；当然，请你不要纠结JavaScript 和 Java之间有什么关系，就好比雷锋和雷峰塔的区别，研究这些问题没有区别，你只需要问自己，想不想了解一些WEB方面的知识，如果你喜欢网页程序，那么跟着敲代码就好了，不要浪费时间；
@@ -62,33 +63,33 @@ HTML文件是由N个标签组成的，这些标签元素构成了搭建网站的
- 类型声明（!DOCTYPE）的作用是告诉浏览器，以什么格式渲染下面的文件；
- html标签是HTML文件的基础；(HTML标签内一般还会有head和body标签)
+
例如上面这张图片中的HTML代码，就是最基础的HTML文件格式；
##### HTML4和HTML5的区别
最重要的标志，就是看类型声明；
-- HTML5是用 这种的声明
-- HTML4是用 这种的声明；
+- HTML5是用 ` ` 这种的声明
+- HTML4是用 `` 这种的声明；
- 声明推荐是放在 HTML 文档的第一行，位于 标签之前。
+`` 声明推荐是放在 HTML 文档的第一行，位于 标签之前。
-** 为什么HTML和HTML5声明的类型不同？ **
+> 为什么HTML和HTML5声明的类型不同？
-- 在 HTML 4.01 中， 声明引用 DTD，因为 HTML 4.01 基于 SGML。DTD 规定了标记语言的规则，这样浏览器才能正确地呈现内容。
+- 在 HTML 4.01 中，`` 声明引用 DTD，因为 HTML 4.01 基于 SGML。DTD 规定了标记语言的规则，这样浏览器才能正确地呈现内容。
- HTML5 不基于 SGML，所以不需要引用 DTD。
-**注释**： 声明没有结束标签，并且 声明对大小写不敏感。
+**注释**：`` 声明没有结束标签，并且对大小写不敏感。
-因为这里是告诉浏览器的渲染方式，所以这里绝对此文件是HTML4还是5，不过并没有什么软用，现在一般都是HTML5的声明格式；记住第一个就可以了；这些都不是重点
+因为这里是告诉浏览器的渲染方式，所以这里决定此文件是HTML4还是5，不过并没有什么软用，现在一般都是HTML5的声明格式；记住第一个就可以了；这些都不是重点
-另外HTML5为了更好的符合语义化和升级，新增了下面的标签;
-> header、footer、section、audio、video等；
+另外HTML5为了更好的符合语义化和升级，新增了 `header`、`footer`、`section`、`audio`、`video` 等标签；
##### 常用标签的简单介绍
-div、ul、li、p、span、a、img、table、tr、th、td、br/hr、h1/h2/h3
+`div`、`ul`、`li`、`p`、`span`、`a`、`img`、`table`、`tr`、`th`、`td`、`br`、`hr`、`h1`、`h2`、`h3`
@@ -99,24 +100,26 @@ div、ul、li、p、span、a、img、table、tr、th、td、br/hr、h1/h2/h3
- id
- title
-**class**：一个名字可以多个class公用；
+`class`：一个名字可以多个class公用；
-**id**：一个名字在一个页面里，只能一个标签使用；
+`id`：一个ID名在一个页面里，只能被一个标签使用、ID名具有唯一性；
-title：title里是自定义的内容，表现是鼠标放上去时候的，文字提示；
+`title`：title里是自定义的内容，表现是鼠标放上去时候的，文字提示；
-** a标签中的。href**
+**a标签中的 `href`**
href是Hypertext Reference的缩写。意思是指定超链接目标的URL。href已经是缩写了，很多不知道其中原理的人会念成"赫尔夫"，其实这是不正确的；href并不是一个单词，而是一个缩写；
-##### HTML规则
+##### HTML书写规范规则
其实个人觉得为了总结而总结是一件很痛苦的事情，记得用zencoding生成的就是标准的书写规范，然后注意下面这句话就可以了；
-- 书写HTML标签的规范：标签要闭合，层级要明确，双引号和单引号不能混合使用；
+- 标签要闭合
+- 层级要明确
+- 单引号和双引号不要混用；
##### script标签的属性：
-script是属性有async，defer，charset，languge，src，type六个；一般常用的就是src，type；而且type是属于可忽略的属性，推荐不写；
+script是属性有 `async`，`defer`，`charset`，`languge`，`src`，`type` 六个；一般常用的就是src，type；而且type是属于可忽略的属性，推荐不写；
因为HTML不是这个笔记的总结重点，就先这样了；
@@ -137,14 +140,14 @@ script是属性有async，defer，charset，languge，src，type六个；一般
一个完整的javascript实现应该有下列三个不同部分组成：
-- 核心(ECMAScript)：提供核心语言功能；
+- `ECMAScript`：提供核心语言功能,是核心，规定了这们语言的书写规范；
- var jd="京东商城";
-- 文档对象模型(document object model 简称DOM)：提供访问和操作网页内容的方法和接口；
+- `DOM`：提供访问和操作网页内容的方法和接口,(document object model 简称DOM 文档对象模型)
var oDiv=document.getElementById("div1");
oDiv.innerText="现在已经被我占领了";
-- 浏览器对象模型(browser object model 简称 BOM)：提供与浏览器交互的方法和接口；BOM最蛋疼的部分是没有统一的标准；从根本上讲BOM只处理浏览器窗口和框架
+- `BOM`：提供与浏览器交互的方法和接口；BOM最蛋疼的部分是没有统一的标准；从根本上讲BOM只处理浏览器窗口和框架,(browser object model 简称 BOM 浏览器对象模型)
windows.location.href
@@ -171,7 +174,7 @@ ECMAScript规定了Javascript这门语言的组成部分；主要规定了语法
```
-> HTML页面，通过DOM可以看成树形图，借助DOM提供的API，可以轻松的增删改查；下面是几个标签的层级关系
+HTML页面，通过DOM可以看成树形图，借助DOM提供的API，可以轻松的增删改查；下面是几个标签的层级关系
```
@@ -202,7 +205,7 @@ DOM的几个级别的介绍；DOM目前分为三个级别；DOM1级，DOM2级，
- DOM3级：引入了以统一方式加载和保存文档的方法（在DOM加载和保存模块中定义）；新增了验证文档的方法（在DOM验证模块中定义）；DOM3级也对DOM核心进行了扩展，开始支持XML1.0，涉及XML infoset，Xpath和XML Base。
- ##### 3、BOM部分；
+##### 3、BOM部分；
BOM最蛋疼的部分是没有统一的标准；从根本上讲BOM只处理浏览器窗口和框架；主要有
- 弹出新浏览器窗口的功能；
- 移动、缩放和关闭浏览器窗口的功能；
@@ -306,7 +309,7 @@ JavaScript中我们学的所有的知识点其实都是基于浏览器内置类
##### 3、外联式；
-** 注意编码格式统一,否则中文会乱码 **
+**注意编码格式统一,否则中文会乱码**
通过script的src属性引用一个文件；关于script的标签位置，按照传统的做法，是写在head元素中；这种做法的目地是把所有外部文件(CSS,JS)的引用都放在相同的地方；可是如果放在顶部；HTML加载的时候，是从上到下依次解析的；页面加载很多HTML的时候，就会堵塞后面的DOM节点加载；导致页面呈现的内容出现延迟，而延迟期间浏览器窗口将是空白的；
@@ -365,7 +368,7 @@ JavaScript中我们学的所有的知识点其实都是基于浏览器内置类
项目中，很少会遇到行内写JS的，工作中我只在给wifi组做支撑的时候见到过这么写的；当时他们的wifi管理页面，用luci lua 一个开源项目修改的，页面的HTML CSS,JS是直接渲染出来的，里面的CSS,JS大都是行内写的，维护起来真的太坑了；我在写JS的时候，把需要我写的JS代码和模块，全部外链式引导页面，把CSS，JS和他们lua代码分开；不和他们的代码掺合在一起，否则以后维护起来就太蛋疼了；
-##### 嵌入式与外链式的区别？
+> 嵌入式与外链式的区别？
在HTML中嵌入javascript代码虽然没有问题，但是一般认为最好的做法还是尽可能使用外部文件来包含javascript代码，不过，并不存在必须使用外链式的规定；但外链式的优点如下
- 维护性好：JS代码和HTML代码混在一起，维护的时候需要改动HTML页面，而现在为了专注和分工明确，基本都是前后端分离的做法；页面输入都是后端的页面；如果是外链式的，只需要维护自己的JS文件即可，不需要接触HTML文件；
@@ -389,21 +392,21 @@ href 用于标示资源和文档关系,src 用于替换标签内容
百度
-** 为什么 style不用src**
+**为什么 style不用src**
至于说为什么当初就决定外部样式表用link href来链接，而不是用style src来载入，可能是因为第一批互联网人认为样式表更符合外部链接资源的特征，它更接近附属的资源，而不是内嵌的内容。比如考虑alternate stylesheets，在同一时间只需要链接一组样式表，而不是载入所有。当然你可以简单的归结为历史遗留（也就是当初某个浏览器开发者的一个偶然决定导致）。这是一个扯淡的问题，制作标准的人不是中国人，是老外；
-** 其它的一些意外**
+**其它的一些意外**
-有些名词是中国第一批程序员，翻译的问题；最明显的一个名次[上下文]，就是代码所在的执行环境，英文
+有些名词是中国第一批程序员，翻译的问题；最明显的一个名次`上下文`，就是代码所在的执行环境，英文
-context，这个应该翻译成[代码运行环境] 才更符合语义，但是第一批互联网人翻译成中文书，都这么写，然后我们这些小辈们为了统一，也都这么叫了；
+context，这个应该翻译成`代码运行环境` 才更符合语义，但是第一批互联网人翻译成中文书，都这么写，然后我们这些小辈们为了统一，也都这么叫了；
在HTTP协议的知识里，有一个叫HTTP Referer的；属于请求头（header）的一部分，当浏览器向web服务器发送请求的时候，一般会带上Referer，告诉服务器我是从哪个页面链接过来的，服务器籍此可以获得一些信息用于处理。
比如从我的博客链接到一个朋友那里，他的服务器就能够从HTTP Referer中统计出每天有多少用户点击我主页上。链接访问他的网站，以前自己倒腾过网站的朋友，在百度统计,55LA统计之类的，会有这方面的统计信息供查看；
-这里的Referer其实应该是英文单词referrer，也不知道是拼错的人太多了导致标准跟着拼错，还是编写标准的人拼错了，开发者讲错纠错，反正现在的情况就都写成HTTP Referer了，只能将错就错的写了。历史遗留问题，无解的；
+这里的Referer其实应该是英文单词referrer，也不知道是拼错的人太多了导致标准跟着拼错，还是编写标准的人拼错了，开发者讲错纠错，反正现在的情况就都写成HTTP Referer了，只能将错就错的写了。历史遗留问题，无解；
**css中的行内、嵌入式、外链式**
下面就是css的各种写法；
@@ -457,7 +460,7 @@ context，这个应该翻译成[代码运行环境] 才更符合语义，但是
不过狭义而言，渐进增强一般说的是使用CSS3技术，在不影响老浏览器的正常显示与使用情形下来增强体验，而优雅降级则是体现html标签的语义，以便在js/css的加载失败/被禁用时，也不影响用户的相应功能。
-#####CSS3中的方案
+##### CSS3中的方案
.transition { /* 渐进增强写法 */
-webkit-transition: all .5s;
@@ -519,8 +522,8 @@ CSS不是笔记的重点，所以就不多写了；
- 英文全称是variable，定义变量是关键字就是var
var a="hello word";
- //var 是变量声明富豪，同样的还有 let const(后面会介绍)
- //a 是变量名，可以任意起，但是有些单词是不能用的，后面会介绍
+ //var 是变量声明符号，同样的还有 let const(后面会介绍)
+ //a 是变量名，可以任意起，但是有些单词属于关键字和保留字是不能用的，后面会介绍
//"hello word" 是代表了JS中的数据值；
//函数的写法
@@ -531,7 +534,7 @@ CSS不是笔记的重点，所以就不多写了；
greetMe("broszhu"); // "Hi broszhu"
- 用等号把a和"hello word"连接起来的意思，就是把数据hello word这个字符串赋值给a这个变量；等号右边赋值给等号左边；
-- 其中""和''这种包裹的类型，在JS中称为数据类型；
+- 其中""和''这种包裹的类型，在JS中称为字符串，是一种数据类型；
- 下面这些在JS中都是合规的写法，分别代表不同的类型
var string="2222";//字符串
@@ -601,6 +604,12 @@ Javascript中代表的数据的变量，可以随意修改类型；但是不建
console.log方法能接收多个参数，除了console.log("string" + num)还可以写成console.log("string", num);
+ console.log("info","haha");
+ console.log("info2"+"haha2");
+
+ console.warn("这是一段警告信息");
+ console.error("出错啦，你的配置信息有误");
+
当然单个的也是可以的；
**[↑ 返回目录](#zero)**
@@ -640,7 +649,11 @@ ECMAScript 是JavaScript语言的下一代标准，已经在2015年6月正式发
要学习Javascript，ES5是必须会的，如果ES5的基础打的好，ES6一个礼拜就熟练入手了，因为他是ES6是基于ES5的改变和优化，你知道其中的原理后，很容易过渡，现在浏览器也没有全面支持，你有大把的时间研究ES5，ES5才是根基，等ES6,ES8全面普及了，笔记里会总结ES6,但是正常的演示代码基于ES5；
-代码初衷是兼容到IE8的；但是很多时候,在IE8兼容的JS，IE67中也就基本没大问题了，最多有点小问题，兼容到IE6，和兼容到IE8的代码量几乎差不多，所以就向下兼容，最多会兼容到IE6
+ //ES6- 是ECMAScrip2015 不是ECMAScrip5
+ //ES8- 是ECMAScrip2017 不是ECMAScrip8
+ 主流开发方式是：ES6+开发，客户端应用会转成ES5
+
+代码初衷是兼容到IE8的；但是很多时候,在IE8兼容的JS，IE67中也就基本没大问题了，最多有点小问题，兼容到IE6，和兼容到IE8的代码量几乎差不多，所以就向下兼容，最多会兼容到IE6,现在都2018年了，企业的开发，很多只兼容chrome了；
**[↑ 返回目录](#zero)**
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/console.html" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/console.html"
deleted file mode 100644
index 4902b31..0000000
--- "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/console.html"
+++ /dev/null
@@ -1,37 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
-
\ No newline at end of file
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/index.html" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/index.html"
deleted file mode 100644
index f4b77a7..0000000
--- "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/index.html"
+++ /dev/null
@@ -1,60 +0,0 @@
-
-
-
-
-
-
- 浏览器的标题头11
-
-
- 这是DIV标签
- 这是p标签1
-
-
-
- 这是p标签2
- 百度一下，你就知道
-
-
- 百度一下，你就知道2
-
- ddasdasdasdasdasdasd
- ddasdasdasdasdasdasd
-
- ddasdasdasdasdasdasd
-
- 222
-
- - 1
- - 222
- - 333
- - 444
-
- 
-
- 这是h1
- 这是h2
- 这是h3
- 这是h4
- 这是h5
-
-
- | 1 |
- 2 |
- 3 |
-
-
- | 1 |
- 2 |
- 3 |
-
-
-
-
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/\345\217\230\351\207\217\347\232\204\345\256\232\344\271\211\345\222\214\350\265\213\345\200\274.html" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/\345\217\230\351\207\217\347\232\204\345\256\232\344\271\211\345\222\214\350\265\213\345\200\274.html"
deleted file mode 100644
index f858c0e..0000000
--- "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/\345\217\230\351\207\217\347\232\204\345\256\232\344\271\211\345\222\214\350\265\213\345\200\274.html"
+++ /dev/null
@@ -1,66 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/\345\217\230\351\207\217\347\232\204\347\261\273\345\236\213\345\217\257\344\273\245\350\242\253\351\232\217\346\227\266\346\224\271\345\217\230.html" "b/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/\345\217\230\351\207\217\347\232\204\347\261\273\345\236\213\345\217\257\344\273\245\350\242\253\351\232\217\346\227\266\346\224\271\345\217\230.html"
deleted file mode 100644
index 8cb58bb..0000000
--- "a/\345\211\215\347\253\257\345\274\200\345\217\221\345\210\235\350\257\206/\345\217\230\351\207\217\347\232\204\347\261\273\345\236\213\345\217\257\344\273\245\350\242\253\351\232\217\346\227\266\346\224\271\345\217\230.html"
+++ /dev/null
@@ -1,38 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
\ No newline at end of file
diff --git "a/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/1.var.js" "b/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/1.var.js"
new file mode 100644
index 0000000..7ed4017
--- /dev/null
+++ "b/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/1.var.js"
@@ -0,0 +1,4 @@
+var name="朱安邦",
+ gender;
+console.log(name,typeof name); //朱安邦 string
+console.log(gender,typeof gender); //undefined "undefined"
\ No newline at end of file
diff --git "a/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/2.const\345\222\214let.js" "b/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/2.const\345\222\214let.js"
new file mode 100644
index 0000000..d28edfc
--- /dev/null
+++ "b/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/2.const\345\222\214let.js"
@@ -0,0 +1,5 @@
+const myName="zhu";
+let age=2;
+age =22;
+// myName=4;//Error
+console.log(age);
\ No newline at end of file
diff --git "a/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/3.let\345\222\214var.js" "b/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/3.let\345\222\214var.js"
new file mode 100644
index 0000000..5d590da
--- /dev/null
+++ "b/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/3.let\345\222\214var.js"
@@ -0,0 +1,8 @@
+if(true){
+ var a=2;
+}
+if(true){
+ let b=3;
+}
+console.log(a);
+console.log(b);//b is not defined
\ No newline at end of file
diff --git "a/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/README.MD" "b/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/README.MD"
index aab81ee..f1e52ce 100644
--- "a/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/README.MD"
+++ "b/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/README.MD"
@@ -10,20 +10,24 @@
在javascript里 声明变量简写为 var ；通过var name 就可以声明一个变量了；
注意变量的声明和定义是两回事；
-- var name ->变量的声明
-- name="朱安邦" ->变量的定义
-- var name=”朱安邦” ->变量的声明加定义；
+```$xslt
+var name; //变量的声明
+name="朱邦邦"; //变量的定义
+var name="朱邦邦"; //变量的声明加定义
+```
-> var name=”朱安邦”；其实是实现两步；
+> var name=”朱邦邦”；其实是实现两步；
> 第一步 var name；先声明一个name的变量；
-> 第二步 name=”朱安邦” 创建数据"朱安邦"这个字符串，并且把字符串"朱安邦"这条数据赋值给name这个变量；在定义(赋值)变量的name值；
+> 第二步 name=”朱邦邦” 创建数据"朱邦邦"这个字符串，并且把字符串"朱邦邦"这条数据赋值给name这个变量；在定义(赋值)变量的name值；
>
> 这个时候name的类型就是所代表值的类型；可以通过typeof来检测；通过检测可以知道这个变量所代表的值是一个字符串类型的数据；
- var name="朱安邦",
- gender;
- console.log(name,typeof name); //朱安邦 string
- console.log(gender,typeof gender); //undefined "undefined"
+```$xslt
+var name="朱邦邦",
+ gender;
+console.log(name,typeof name); //朱邦邦 string
+console.log(gender,typeof gender); //undefined "undefined"
+```
虽然关键字var不是必须的，但是最好每次声明一个新变量都加上；
@@ -46,7 +50,7 @@
- 关于关键字和保留字，这个可以拿生活中的现象举例子，大人给小孩起名字的时候，小孩的名字一定不能和他父亲母亲的名字一样；当然也不能和爷爷，奶奶，外公，外婆，舅舅，姑姑等等这些名字一样；这个就是现实中约定俗成的规则；
- 在JS中，也有些单词是有特殊意义的，或者是为了以后语言升级做准备的；而这些单词就不能作为变量名；比如前面接触的typeof，function；这样的单词就不能作为变量名；
-- 4、变量区分大小写，test和Test是不一样的,必须严格一样，才算是一个变量的；(在javascript里，onclick必须要写出onclick，不能写成onClick；)
+- 4、变量区分大小写，test和Test是不一样的,必须严格一样，才算是一个变量的；(在javascript里，`onclick` 必须要写出`onclick`，不能写成`onClick`；)
##### 变量命名的优化方法（推荐遵守的，非强制）；
@@ -80,18 +84,27 @@
- Class名：用”-”连接符的方法；class=”header-nav” 比如这样的；
- JS变量名：myRoomDoorKey；小驼峰
- data-diy_attr 自定义属性；
-- j-trigger-target JS中需要用的雷类名
+- j-trigger-target JS中需要用的类名
- jQuery对象名：$myKey；小驼峰前面加$；这种方法是从匈牙利+驼驼峰总结出来的；其实真实项目中，很少有匈牙利命名法的；匈牙利命名法见过最多的都是出现在写DEMO的时候用；
-- 除非特别难起的变量名，否则不要用中文拼音做变量名；不要听信某些教材和视频中说的严禁用拼音命名的话，有的甚至还把linux创始人林纳斯的代码风范拿出来说事。其实那些并没有什么软用；开始就和大家说了变量是用来区别不同数据的；而优化变量名的意义在于能够快速识别这个变量名所代表的数据；比如你要记录游戏场景下的角色出血值；你还要想半天单词，或者找翻译，然后起出来的变量名，自己下次看到或者别人看到的时候还要去翻译或者思考下；这种情况下，为什么不直接用 chuxue这种的方式呢？只需要后面加一行注视说明什么意思就可以了；我个人是很反感为了遵守优化规则而脱裤子放屁的方式的；曾经在项目中遇到过一个真实的事；某个变量看了半天不知道到底代表什么意思（因为当时有接触到差不多10种的用户相关类型的金额数），查了翻译也没有查到；后来问了下，才知道那个坑货把单词给拼错了两个字母；
+- 除非特别难起的变量名，否则不要用中文拼音做变量名，但是遇到难起的变量名，使用中文也别有负担，但是禁止中英文混搭；
+- 注释可以辅助整理思路；
-
+不要听信某些教材和视频中说的严禁用拼音命名的话，有的甚至还把linux创始人林纳斯的代码风范拿出来说事。其实那些并没有什么软用；开始就和大家说了变量是用来区别不同数据的；而优化变量名的意义在于能够快速识别这个变量名所代表的数据；
+
+比如你要记录游戏场景下的角色出血值；你还要想半天单词，或者找翻译，然后起出来的变量名，自己下次看到或者别人看到的时候还要去翻译或者思考下；这种情况下，为什么不直接用 chuxue这种的方式呢？只需要后面加一行注视说明什么意思就可以了；
+
+很反感为了遵守优化规则而脱裤子放屁的方式的；曾经在项目中遇到过一个真实的事；某个变量看了半天不知道到底代表什么意思（因为当时有接触到差不多10种的用户相关类型的金额数），查了翻译也没有查到；后来问了下，才知道那个坑货把单词给拼错了两个字母；
+
+```$xslt
+
+```
**[↑ 返回目录](#zero)**
@@ -101,7 +114,7 @@
变量通过var来声明；
-有些要避免的，否则后面写代码的时候可能会把自己给坑了；
+下面是要避免的，否则写代码的时候可能会把自己给坑了；
- 重复声明；
- 不声明直接赋值
@@ -110,38 +123,49 @@
> 推荐：先声明，后定义；
- 需要读写的变量，读写前，一定要声明；
-- 需要运算的变量，运算器，一定要赋值；
+- 需要运算的变量，运算前，一定要赋值；
- 书写的时候，推荐把变量名放在页面的上面（上部分）去声明+定义；这样不仅可以放心大胆的用，而且可以方便查找变量；
- 在任何情况下声明变量都要用var先声明；在使用一个变量之前应当先声明，变量是使用关键字var来声明的；
- var a=1;
- function test(){
- var b=c=2;//这时候会隐式声明全局变量；
- }
- test();
- console.log(a,c)
-> 这种是非常不好的写法；不要写var a=b=c=1;这种声明；上面代码中c就会被隐式声明为全局变量；下面这种写法是可以的
+```$xslt
+ var a=1;
+ function test(){
+ var b=c=2;//这时候会隐式声明全局变量；
+ }
+ test();
+ console.log(a,c)
+```
- var a= 1,c;
- function test(){
- var b=c=2;
- }
- test();
- console.log(a,c)
+上面是非常不好的写法；不要写 `var b=c=2` 这种声明；上面代码中c就会被隐式声明为全局变量；
-> 因为开始c已经声明了；后面是给c赋值；
+下面这种写法是可以的
-推荐下面这种写法；
+```$xslt
+var a= 1,c;
+function test(){
+ var b=c=2;
+}
+test();
+console.log(a,c)
+```
+
+因为开始c已经声明了，后面只是给c赋值；
+
+多个变量声明赋值时候，同一类的变量推荐下面这种写法；
var name="zhuanbang",
age=26,
height="174cm";
这样既可以简洁，又保证可读性；
-注意：任何变量赋值前都需要声明变量，不要隐式创建全局变量；
+
+**注意：任何变量赋值前都需要声明变量，不要隐式创建全局变量；**
##### 重复声明和遗漏声明的区别：
-在javascript里使用var重复声明是合法而且不会有任何事情的，如果重复声明带有初始化的值，那么就和一条简单的赋值语句没有什么两样，但是如果你忘记声明了，视图读取一个没有声明的变量的值，javascript可能会报错；在严格模式中，给一个没有声明的变量赋值也是会报错的；非严格模式下虽然不会报错，但是不要抱着侥幸的心理；这是一个不好的习惯，会造成很多bug；建议始终使用var来声明变量；
+
+在javascript里使用 `var` 重复声明是合法而且不会有任何事情的，如果重复声明带有初始化的值，那么就和一条简单的赋值语句没有什么两样，但是如果你忘记声明了，试图读取一个没有声明的变量的值，javascript可能会报错；
+
+在严格模式中，给一个没有声明的变量赋值也是会报错的；非严格模式下虽然不会报错，但是不要抱着侥幸的心理；这是一个不好的习惯，建议始终使用var来声明变量；
ES6扩展了2种声明方法；
@@ -158,8 +182,27 @@ ES6扩展了2种声明方法；
常量不可以通过赋值改变其值，也不可以在脚本运行时重新声明。它必须被初始化为某个值。
+```$xslt
+const myName="zhu";
+let age=2;
+age =22;
+// myName=4;//Error
+console.log(age);
+```
+
常量的作用域规则与 let 块级作用域变量相同。若省略const关键字，则该标识符将被视为变量。
+```$xslt
+if(true){
+ var a=2;
+}
+if(true){
+ let b=3;
+}
+console.log(a);
+console.log(b);//b is not defined
+```
+
在同一作用域中，不能使用与变量名或函数名相同的名字来命名常量。
**[↑ 返回目录](#zero)**
@@ -186,18 +229,20 @@ ES6扩展了2种声明方法；
ECMAScript规定变量包含两种不同数据类型的值，基本类型值和引用类型值；在给变量赋值的时候，解析器必须要明确这个值是基本类型还是引用类型值，因为他们的赋值方式是不同的；string/number/boolean/null/undefined都是基本数据类型；因此可以操作保存在变量中是实际值，此时变量储存的是实际的值；而引用类型的值是保存在内存中的，此时变量储存的是内存的地址，而不是真实的值；而我们操作引用类型的变量时，实际操作的是它引用地址对应的对象，而不是直接操作对象的；
基本类型和引用类型的操作原理
- var number1= 1,
- number2=number1;
- number1=2;//改变了number1的值
- console.log(number1);//2
- console.log(number2);//1
- console.log(number1===number2);//false
-
- var obj1={name:"zhu"},
- obj2=obj1;
- obj1.name="zhuanbang";
- console.log(obj1.name,obj2.name);//zhuanbang,zhuanbang
- console.log(obj1.name===obj2.name);//true
+```$xslt
+var number1= 1,
+ number2=number1;
+number1=2;//改变了number1的值
+console.log(number1);//2
+console.log(number2);//1
+console.log(number1===number2);//false
+
+var obj1={name:"zhu"},
+obj2=obj1;
+obj1.name="zhuanbang";
+console.log(obj1.name,obj2.name);//zhuanbang,zhuanbang
+console.log(obj1.name===obj2.name);//true
+```
@@ -264,33 +309,39 @@ ECMAScript规定变量包含两种不同数据类型的值，基本类型值和
###### 注释
javascript的注释。单行注释是"//注释文字"，多行注释是/*注释文字*/
- //注释文字
+```$xslt
+//注释文字
- /*
- * 多行注释1
- * 多行注释2
- * /
+/*
+* 多行注释1
+* 多行注释2
+* /
+```
##### 语法建议：
+```$xslt
//bad
var a=2 //没有分号，也是可以的，但是不推荐这么做；压缩的时候可能会出错； 理论上加分号性能会更好，浏览器不必花时间判断是否要加分号了(无论加不加分号，浏览器解析的时候会判断的，如果需要加的地方没有加，浏览器解析时候会加上去之后再解析)
//good
var b=3;
+```
##### 不建议使用var a=b=c=1;这种的写法；
if-else 推荐加上{}；
- //bad
- if(true)
- console.log("bad");//有效，但是容易出错，不要使用；
+```$xslt
+//bad
+if(true)
+ console.log("bad");//有效，但是容易出错，不要使用；
- //good
- if(true){
- console.log("good");//推荐使用,可以降低修改代码时出错的几率，可以让代码的意图更明确；
- }
+//good
+if(true){
+ console.log("good");//推荐使用,可以降低修改代码时出错的几率，可以让代码的意图更明确；
+}
+```
分号很多地方是可选的，推荐除了{}外都给加上；语句也可以换行的，但是有两个例外不能换行
@@ -300,7 +351,7 @@ if-else 推荐加上{}；
**[↑ 返回目录](#zero)**
-## 六、面试题：
+## 六、练习题：
01-02-01、var a=b=c=d=1是什么意思？如果接下来在写一句a=9;a,b,c的值分别是多少？
01-02-02、var a=b=c=d=[1,2,3,4,5]是什么意思？如果接下来再写一句d[5]=0,a,b,c的值分别是多少？
01-02-03、var a=b=c=d=[1,2,3,4,5]是什么意思？如果接下来在写一句d=[0],a,b,c的值会发生变化吗？
@@ -311,10 +362,12 @@ if-else 推荐加上{}；
01-02-08、说一说html代码，css代码和js代码的注释写法；
01-02-09、以下哪些单词不属于javascript保留字
- A、with
- B、parent
- C、class
- D、void
+```$xslt
+ A、with
+ B、parent
+ C、class
+ D、void
+```
-
diff --git "a/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/var.html" "b/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/var.html"
deleted file mode 100644
index af9cf29..0000000
--- "a/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/var.html"
+++ /dev/null
@@ -1,23 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
-
\ No newline at end of file
diff --git "a/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/\346\225\260\346\215\256\345\202\250\345\255\230\345\216\237\347\220\206.js" "b/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/\346\225\260\346\215\256\345\202\250\345\255\230\345\216\237\347\220\206.js"
new file mode 100644
index 0000000..4756d05
--- /dev/null
+++ "b/\345\217\230\351\207\217\345\243\260\346\230\216\345\222\214\345\216\237\347\220\206/\346\225\260\346\215\256\345\202\250\345\255\230\345\216\237\347\220\206.js"
@@ -0,0 +1,71 @@
+//基本类型
+var a=2;
+var b=a;
+a.aaa="adjklasjdk";
+console.log(a.aaa);
+console.log(a,b);//2 2
+b=4;
+console.log(a,b);//2 4
+
+
+//引用数据类型；
+var oDemo1={
+ name:"zhu",
+ say:"hello"
+};
+var oDemo2=oDemo1;
+console.log(oDemo1);//{name: "zhu", say: "hello"}
+console.log(oDemo2);//{name: "zhu", say: "hello"}
+
+oDemo2.name="changeName";//这个时候修改，其实已经把oDemo1的数据给修改了
+console.log(oDemo1);//{name: "changeName", say: "hello"}
+console.log(oDemo2);//{name: "changeName", say: "hello"}
+
+oDemo1.hahahahahah="ddddddd";
+console.log(oDemo1);//{name: "changeName", say: "hello", hahahahahah: "ddddddd"}
+console.log(oDemo2);//{name: "changeName", say: "hello", hahahahahah: "ddddddd"}
+
+
+var sy=Symbol();//sy是Symbol的一个实例；
+console.log(sy.__proto__);
+sy.aaa="hahah";
+console.log(sy.aaa);
+
+
+//
+var oDemo3={
+ name:"zhu",
+ say:"hello"
+};
+var oDemo4=oDemo3;//AAA
+console.log("---------------------");
+console.log(oDemo3);
+console.log(oDemo4);
+oDemo4={name:"changeName"};//把{name:"changeName"} 对应的堆内存地址赋值给oDemo4 BBB
+console.log(oDemo3);//{name: "zhu", say: "hello"}
+console.log(oDemo4);//{name: "changeName"}
+
+var sourcesDate={
+ date:[
+ {
+ pro:"浙江省",
+ city:"杭州市",
+ cityCode:"330001",
+ total:"13.05"
+ },
+ {
+ pro:"浙江省",
+ city:"宁波市",
+ cityCode:"330002",
+ total:"78.05"
+ },
+ {
+ pro:"浙江省",
+ city:"温州市",
+ cityCode:"330003",
+ total:"66.05"
+ }
+ ]
+};
+var beauDate=sourcesDate;
+//$.exetend({},sourcesDate);
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/0.\345\220\204\347\247\215\346\225\260\346\215\256\347\261\273\345\236\213.js" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/0.\345\220\204\347\247\215\346\225\260\346\215\256\347\261\273\345\236\213.js"
new file mode 100644
index 0000000..e492c74
--- /dev/null
+++ "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/0.\345\220\204\347\247\215\346\225\260\346\215\256\347\261\273\345\236\213.js"
@@ -0,0 +1,33 @@
+console.log(typeof "hello");//console.log()控制台输出内容
+console.log(typeof 222);//"number"
+console.log(typeof '222');//"string"
+console.log(typeof false);
+console.log(typeof "false");//这个上面的都是基本数据类型/
+console.log(typeof null);//object//object function 是引用数据类型；
+console.log(typeof {});
+console.log(typeof function () {});//function
+
+//变量是数据的代言人；
+var demoStr="hello";
+console.log("-----------------------");
+console.log(typeof demoStr);//string
+demoStr=22;//不推荐这么做 ；
+console.log(typeof demoStr);//number
+
+//typeof 总是返回string类型的； typeof()
+console.time("123");
+console.log("+++++++++++++++++++++");
+console.log(typeof (typeof "hello"));
+console.log(typeof (typeof 222));
+console.log(typeof typeof '222');
+console.log(typeof typeof false);
+console.log(typeof typeof "false");
+console.log(typeof typeof null);
+console.log(typeof typeof {});
+console.log(typeof typeof function () {});
+console.timeEnd("123");
+
+console.assert(1==1,"打脸了");
+
+var aloneVal=Symbol();
+console.log(typeof aloneVal);//symbol 存在的意义，避免多人开发时，变量覆盖；
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/1.String.js" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/1.String.js"
new file mode 100644
index 0000000..b356733
--- /dev/null
+++ "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/1.String.js"
@@ -0,0 +1,53 @@
+//string 单引号'' / 双引号""包裹的内容
+/*alert(typeof "22");
+alert(typeof '22');
+alert(typeof "");
+alert(typeof '');*/
+console.log(typeof "22");
+console.log(typeof '2');
+console.log(typeof '');
+console.log(typeof "");
+console.log(typeof "false");
+
+console.log(typeof "null");
+
+//length,一般作为用户输入店名/用户名的长度限制；需要注意双字符精准度的问题；
+var str="123123123123123123123123123123";
+var chinaStr="哈喽";//双字节，不精确 4字节；
+console.log(str.length);
+console.log(chinaStr.length);//2
+
+//字符串创建的原理；
+var str1="12345";//把"12345"这个字符串赋值给str1这个变量；
+str1="1234";//把"1234"这个字符串赋值给str1这个变量；
+/*
+* 并不是把"12345"修改为"1234"然后赋值给str1
+*
+* */
+console.log(str1);//"1234"
+console.log('1"23\'4\n56\'78');
+// alert("1213123\naaaaaa")
+
+//toString方法；
+//22 - > "22"
+console.log(typeof 22);
+console.log(typeof (22).toString());
+var testStr=22+"";//隐式调用toString方法
+console.log(typeof 22+"");//+ - * / 2*2+10
+console.log(typeof testStr);//2*(2+10)
+
+//eval()
+console.log("00000000000000000");
+console.log(eval("22+12"));//"22+12" -> 22+12 ->34
+
+
+//
+console.log("**********************");
+console.log(typeof (22+""));//string 22 -> "22"
+console.log(typeof (+"22"));//"22" -> 22 单目运算符+
+console.log([1,2,3,4]+"");//1,2,3,4
+
+console.log("**********************");
+console.log("1.1" + 1.1);
+console.log(+"1.1" + 1.1);
+console.log((+"1.1") + (+1.1));
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/2.Number.js" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/2.Number.js"
new file mode 100644
index 0000000..838c098
--- /dev/null
+++ "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/2.Number.js"
@@ -0,0 +1,68 @@
+//正数，负数，零，NaN都是属于Number
+// ***NaN -> Not a Number不是一个数，但是属于数字类型；**
+console.log(typeof 222);
+console.log(typeof 222.22);
+console.log(typeof -10);
+console.log(typeof -10.34);
+console.log(typeof 0);
+console.log(typeof -0);
+
+//NaN
+console.log((22*"aa"));//NaN number
+console.log(typeof (22*"aa"));//number
+console.log(22==22);//true 单个等于号是赋值的意思； Invalid left-hand side in assignment
+//== 两个等于号才是判断；
+console.log((22*"aa")==(22*"bb"));//false
+console.log((22*"aa")==22);//false
+
+//inNaN
+console.log(isNaN(22*"aa"));//true (22*"aa")计算出的值不是一个数，对吗？ 对；
+console.log(isNaN(22));// 22这个值不是一个数，对吗？ 不对； false (NaN -> Not a Number不是一个数，)
+
+//number的转换方法； 别的数据类型转为数字类型；(不一定是字符串)
+/* 五种 转为数字的；
+* +"22" 字符串转为数字；
+* "22"-0
+* Number()
+* parseInt()
+* parseFloat()
+* */
+console.log("+++++++++++++++++++++++++");//隐式
+console.log(+"22");//隐式
+console.log(Number("22"));//显式 22
+console.log(Number(false));//显式 ->0
+console.log(Number(true));//显式 ->1
+console.log(Number(null));//显式 -> 0
+console.log(Number(undefined));//显式 NaN
+console.log(Number({}));//显式
+console.log(Number("22.22"));
+console.log(Number("22.22a"));//失败了 NaN
+
+
+console.log(parseInt("22.22a"));//22
+console.log(parseFloat("22.22a222"));//22.22
+console.log(parseFloat("22.22.22"));//22.22
+
+// + - * /
+
+console.log(("++++++++"));
+console.log(13%10); //13/10 3 多余的3 会被输出
+console.log(5%3);//2
+
+var time=623648364569346563463;//time单位是秒；转为X分X秒；
+var minis=parseInt(time/60);//保存是分钟
+var second=time%60;//3
+var targetVal=minis+"分"+second+"秒";
+
+console.log(" minis:"+minis+" second:"+second);
+console.log(targetVal);
+//小练习：
+/*
+* var time=623648364569346563463;//time是怎么得到的》当前的服务器时间 - 双11 这个阶段多少秒；
+* 是多少天，多少小时，多少分钟，多少秒；
+* */
+
+
+console.log("***********************");
+console.log("22"-1);//"22" -> 22 -> (22-1) -> 21
+console.log("22"-0);
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/3.Boolean.js" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/3.Boolean.js"
new file mode 100644
index 0000000..9eac1e6
--- /dev/null
+++ "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/3.Boolean.js"
@@ -0,0 +1,64 @@
+var a=52;
+var b=30;
+
+function demoBoolean(a, b) {
+ if (a>b){//2>30 -> false
+ console.log(a+" 大于 " +b)
+ }else if(a==b){//2==30 -> false
+ console.log(a+" 等于 " +b)
+ }else{
+ console.log(a+" 小于 " +b)
+ }
+ console.log(a>b);
+ console.log(a==b);
+
+
+ if(null){
+ console.warn("条件为真的时候才输出")
+ }else{
+ console.warn("if条件为假的时候才输出")
+ }
+}
+
+demoBoolean(a,b);
+/*
+* 如果a>B； ->"a的值"大于"b的值"
+* 如果a==B；->"a的值"等于"b的值"
+* 如果a"a的值"小于"b的值"
+*
+* */
+
+
+/* ................................非常重要。。。。。。。。。。
+* 哪些值是false（false本身）
+* 数字：0、-0 、NaN、
+* 字符串：''（空字符串）
+* null 、
+* undefined、
+* */
+
+console.log("---------------------------------");
+console.log(Boolean(0)); //false
+console.log(Boolean(-0)); //false
+console.log(Boolean(1)); //true
+console.log(Boolean(-5)); //true
+console.log(Boolean("222"));//true
+console.log(Boolean('')); //false 空的字符串
+console.log(Boolean(" ")); //true 包含空格的字符串
+console.log("---------------------------------");
+console.log(Boolean("0"));//true
+console.log(Boolean(null));//false
+console.log(Boolean(undefined));//false
+console.log(Boolean({}));//true
+console.log(Boolean(function () {}));//true
+console.log(Boolean(false));//false
+console.log("---------------------------------");
+console.log(Boolean(55*"asd"));// NaN false
+
+
+// ! !!
+console.log("************************");
+console.log(Boolean(0));//false
+console.log(Boolean(!0));//true
+console.log(!0);//true 原理: 0 隐式的调用Boolean方法Boolean(0) -> false -> !false ->true
+console.log(!!0);// !(!false)->!true ->false
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/4.null\345\222\214undefined.js" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/4.null\345\222\214undefined.js"
new file mode 100644
index 0000000..68e6709
--- /dev/null
+++ "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/4.null\345\222\214undefined.js"
@@ -0,0 +1,75 @@
+// var NULL=2;
+console.log(typeof null);//object 这是一个空的指针；
+console.log(typeof NULL);// NULL- >undefined
+
+//结果是undefined 除了用在typeof外，会报错；
+console.log(undefined*15);//NaN
+// console.log(undefined*aa);//aa is not defined
+// console.log(NULL+15);//NULL is not defined 相当于NULL 这个变量没有找到；
+
+//
+var js;
+console.log(js);//undefined
+console.log(typeof undefined);//undefined
+console.log(typeof typeof undefined);//string
+
+
+//null和undefined比较
+/*
+* === 相同比较，首先判断是否是同一个类型；不是的话，直接false；
+* == 比较是否相等；(如果是不一样的类型，会转为相同的类型，然后再进比较)
+* */
+console.log(null == null);//true
+console.log(null == undefined);//true
+console.log(undefined == undefined);//true
+console.log(undefined === undefined);//true
+console.log(null === undefined);//false null->Null undefined -> Undefined
+console.log(false == 0);//true false->0 0==0? true
+console.log(Number("22") == 22);//true "22"隐士的调用Number->22 -> 22== 22 -> true
+
+
+console.log("---------------------------");
+console.log(null == 1);//false
+console.log(null == "2312312");//false
+console.log(null == false);//false
+console.log(null == 0);//false
+console.log(null == "");//false
+console.log(null == NaN);//false
+
+console.log("++++++++++++++++++++++++++");
+console.log(undefined == 1);//false
+console.log(undefined == "2312312");//false
+console.log(undefined == false);//false
+console.log(undefined == 0);//false
+console.log(undefined == "");//false
+console.log(undefined == NaN);//false
+
+
+//应用场景经常出现在 做定时器的时候；
+var timer=null;
+
+
+
+// 对象的属性
+var oDemo={
+ // aaa:"这是oDemo的aaa值"
+};
+oDemo.bbb="Hello";
+
+console.log(oDemo.aaa);//undefined
+console.log(oDemo.bbb);//Hello
+
+
+//ByIn
+var oDiv1=document.getElementById("div1"),
+ oDiv2=document.getElementById("div2");
+console.log(oDiv1);
+console.log(oDiv2);//null
+
+//function 返回值 默认是undefined；
+
+function demo() {
+ return;
+}
+var aDemo=demo();
+console.log(aDemo);//undefined
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/5.Object.js" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/5.Object.js"
new file mode 100644
index 0000000..c03faf3
--- /dev/null
+++ "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/5.Object.js"
@@ -0,0 +1,68 @@
+var num=2;
+console.dir(num);//number 实例
+console.dir(num.__proto__);//Number 类
+/*
+*
+* constructor :Object
+*
+*
+* */
+
+var str="haha";
+console.dir(str);//string 实例
+console.dir(str.__proto__);//String 类
+
+
+/*判断是否一致*/
+console.log(num.__proto__.__proto__=== str.__proto__.__proto__);//true
+
+
+//万物皆对象,并不等于只有一个对象类型的；
+// Number / String / Object / Boolean
+
+
+//key:value
+//1、字面量的创建方式；推荐的方式
+var o={
+ name:"zhu",
+ say:"hello"
+};
+console.log(o);//{name: "zhu", say: "hello"}
+
+var oDemo={};
+// oDemo.name1=
+if(!oDemo.flagVal){
+ oDemo.flagVal="Test"
+}
+oDemo.name="bang";
+oDemo.say="hahahahahahahha";
+console.log(oDemo.flagVal);//Test
+console.log(oDemo);//{flagVal: "Test", name: "bang", say: "hahahahahahahha"}
+
+//new
+var demo1=new Object();//不推荐的使用方法；
+demo1.haha="hahahahahahah";
+console.log(demo1);//{haha: "hahahahahahah"}
+
+//jQuery的AJAX；
+/*var options={
+ url:"babababab",
+ type:"",
+ date:{}
+};
+$.ajax(options);*/
+
+
+function Test(opt) {
+ //bala bala
+}
+var testVal=Test({a:"",b:""});
+
+//Array;
+var a=[1,2,3,4,5,6,7];//var a=[1,2,3,4,5,6,7,] 低版本浏览器，length的;
+console.log(a);//编程语言里，index是以0为开始的；
+console.log("第一位,a[0]",a[0]);
+console.log(a[1]);
+console.log(a.length);//7
+
+// -> //
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/6.Symbol.js" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/6.Symbol.js"
new file mode 100644
index 0000000..9e07bf9
--- /dev/null
+++ "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/6.Symbol.js"
@@ -0,0 +1,38 @@
+//创建
+let aloneVal = Symbol();//注意不要用new来生成new；即时在ES5中，除了使用自己定义构造函数外，也不推荐加new；
+console.log(typeof aloneVal);//symbol
+
+//Symbol里面的参数，是描述使用的；仅仅是为了控制输出时候方便识别，没有别的用了；
+const s1 = Symbol('foo');
+const s2 = Symbol('bar');
+console.log(s1,s2);//Symbol(foo) Symbol(bar)
+
+//和NaN一样，连自己都不等于自己：因为里面的参数只是一个描述;
+console.log(Symbol("foo") == Symbol("foo"));//false
+console.log(Symbol("") == Symbol(""));//false
+console.log(Symbol() == Symbol());//false 连自己都不等于自己：
+const foo = Symbol();
+const bar = Symbol();
+const symbolVal = Symbol("11");
+console.log(typeof foo , typeof bar);//symbol symbol
+console.log(typeof foo === "symbol");//true
+console.log(typeof bar === "symbol");//true
+console.log(bar === bar);//true 当然如果用变量储存，俩个变量是相等的，但这并不说明2个相同Symbol值是相同的
+console.log(bar === foo);//false
+console.log(symbolVal);//Symbol(11)
+
+//Symbol不可以进行运算，但是可以转换为字符串和布尔值，但是不能转为数值；
+const sym=Symbol("flag");
+//console.log(sym+"hello baby");// Cannot convert a Symbol value to a string
+console.log(String(sym)+"hello one");//Symbol(flag)hello one
+console.log(sym.toString()+"hello two");//Symbol(flag)hello two
+console.log(Boolean(sym),typeof Boolean(sym));//true "boolean"
+console.log(Number(sym));//Cannot convert a Symbol value to a number
+
+let obj = {};
+obj[foo] = "foo";
+obj[bar] = "bar";
+JSON.stringify(obj); // {}
+Object.keys(obj); // []
+Object.getOwnPropertyNames(obj); // []
+Object.getOwnPropertySymbols(obj); // [ foo, bar ]
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/6.Symbol2.js" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/6.Symbol2.js"
new file mode 100644
index 0000000..6e2c039
--- /dev/null
+++ "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/6.Symbol2.js"
@@ -0,0 +1,46 @@
+var validateId={};//用来验证身份证的；
+validateId.age=1900;
+console.log(validateId.age);//1900
+
+validateId.age=1940;
+console.log(validateId.age);//1900
+
+//模块内部的
+validateId.demo1=Symbol();// AAXX111 demo1
+console.log(validateId.demo1);//Symbol()
+
+// 外部的
+validateId.demo1=1900; //demo1
+console.log(validateId.demo1);//1900
+
+var aaa=Symbol("a");// //AAXX222
+var bbb=Symbol("a");// //AAXX333 生成的实例是唯一的，和其他任何实例都不相等，包括其他相同生成的实例
+console.log(aaa);
+console.log(bbb);
+console.log(aaa==bbb);//相当于NaN
+console.log(Symbol()==Symbol());//
+
+
+var age1=2;
+var age2=2;
+console.log(age1,age2);
+console.log(age1==age2);//true
+
+//模块/插件里面的
+var age=Symbol("age");//AAXX666
+validateId[age]=222;
+/*
+*
+*
+*
+*
+*
+* */
+
+//other
+// var age=Symbol("age");//AAXX777
+validateId[Symbol("age")]=333;
+
+
+validateId.aaa=222;
+validateId.bbb=222;
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/7\347\247\215\346\225\260\346\215\256\347\261\273\345\236\213\345\222\214\347\211\271\346\256\212\347\232\204Function.html" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/7\347\247\215\346\225\260\346\215\256\347\261\273\345\236\213\345\222\214\347\211\271\346\256\212\347\232\204Function.html"
deleted file mode 100644
index d672416..0000000
--- "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/7\347\247\215\346\225\260\346\215\256\347\261\273\345\236\213\345\222\214\347\211\271\346\256\212\347\232\204Function.html"
+++ /dev/null
@@ -1,46 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
-
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Boolean\347\261\273\345\236\213.html" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Boolean\347\261\273\345\236\213.html"
deleted file mode 100644
index 7f48c5c..0000000
--- "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Boolean\347\261\273\345\236\213.html"
+++ /dev/null
@@ -1,76 +0,0 @@
-
-
-
-
- Boolean
-
-
-
-
-
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Number\347\261\273\345\236\213.html" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Number\347\261\273\345\236\213.html"
deleted file mode 100644
index 4629a31..0000000
--- "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Number\347\261\273\345\236\213.html"
+++ /dev/null
@@ -1,80 +0,0 @@
-
-
-
-
- Number
-
-
-
-
-
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Object\347\261\273\345\236\213.html" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Object\347\261\273\345\236\213.html"
deleted file mode 100644
index 8b4300c..0000000
--- "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Object\347\261\273\345\236\213.html"
+++ /dev/null
@@ -1,80 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/README.MD" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/README.MD"
index d0b923e..5fcac0e 100644
--- "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/README.MD"
+++ "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/README.MD"
@@ -1,7 +1,7 @@
# 数据类型初识
-> JS的数据类型；通过typeof来检测，得到的数据类型有 String、number、boolean、null、undefined、Object(一切数据的基础)；
+JS的数据类型；通过typeof来检测，得到的数据类型有 `String`、`number`、`boolean`、`null`、`undefined`、`Object` (Object是一切数据的基础)；
- 一、[String](#one)
- 二、[Number](#two)
@@ -12,9 +12,13 @@
- 七、[Symbol](#footer)
- 八、[练习题](#footer)
-ECMAScript中有5种简单的数据类型，也称为基本数据类型；Undefined、Null、Boolean、Number、String。
+ECMAScript中有5种简单的数据类型，也称为基本数据类型；
-一种复杂的数据类型，Object;(typeof检测还有一种特殊的Funtion)；
+`String`、`number`、`boolean`、`null`、`undefined`
+
+一种复杂数据类型，也称为引用数据类型(typeof检测还有一种特殊的Funtion)
+
+`Object`
object本质是由一组无序的键值对组成的；
@@ -76,7 +80,7 @@ length计算包括空格
//字符串长度
var strTest1="zhuanbang";//共9个
- var strTest2="朱安邦的JavaScript学习笔记";//共18
+ var strTest2="朱邦邦的JavaScript学习笔记";//共18
console.log(strTest1.length);//9
console.log(strTest2.length);//18
//这只是个简单的判断，如果想用JavaScript判断或者获取所占的字节，就不能这么判断了，因为中文和英文字符所占的字节长度不同，所以要想获得中文字符的真正长度，就需要对输入的字符进行判断或过滤(可以unicode区间进行判断)，如果符合中文字符，则使用不同的标准。
@@ -108,17 +112,18 @@ length计算包括空格
适用类型
Number/Boolean/String/Object
参数：number类型的数值基数；一般不需要写，仅作了解，如果需要按照2/8/16进制来转换，需要写；
-
- //toString()和String()
- var testNum=1;
- console.log(typeof testNum);//number
- var testTarget1=toString(testNum);
- var testTarget2=testNum.toString();//推荐用法
- var testTarget3=String(testNum);
- //var testTarget4=testNum.String();//错误的用法
- console.log(typeof testTarget1);//string
- console.log(typeof testTarget2);//string
- console.log(typeof testTarget3);//string
+
+toString()和String()
+
+ var testNum=1;
+ console.log(typeof testNum);//number
+ var testTarget1=toString(testNum);
+ var testTarget2=testNum.toString();//推荐用法
+ var testTarget3=String(testNum);
+ //var testTarget4=testNum.String();//错误的用法
+ console.log(typeof testTarget1);//string
+ console.log(typeof testTarget2);//string
+ console.log(typeof testTarget3);//string
- String()
@@ -141,7 +146,7 @@ length计算包括空格
var evalComputed=eval(evalVal);
console.log(evalComputed,typeof evalComputed);//26 "number"
-##### 如果把某个数据转化为字符串，可以有一个快捷的方式，就是把它与一个字符串""相加就可以了；
+#####如果把某个数据转化为字符串，可以有一个快捷的方式，就是把它与一个字符串""相加就可以了；
//+""用来转换字符串
@@ -161,7 +166,7 @@ length计算包括空格
某个数据并不仅限于Number类型；数组也可以的；
- console.log([1,2,3,4]+"")
+ console.log([1,2,3,4]+"");//1,2,3,4
再看一组的加法(将字符串转为数字,注意浮点数的运算精度)；
@@ -269,11 +274,11 @@ length计算包括空格
console.log(-"10"+ 10);//了解下
-详细的解读
+类型转转
##### Number()
-> 一般用在数据类型的系统默认转换；
+数据类型的系统默认转换；
- Boolean转换为数值的时候
- true转为1；
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/README_FUNCRTION.md" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/README_FUNCRTION.md"
deleted file mode 100644
index 8625184..0000000
--- "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/README_FUNCRTION.md"
+++ /dev/null
@@ -1,344 +0,0 @@
-
-
-# 函数的初识
-- 知识点一、[初识函数](#one)
-- 知识点二、[函数的定义](#two)
-- 知识点三、[函数的调用](#three)
-- 知识点四、[函数的方法](#four)
-- 知识点五、[arguments对象](#five)
-- 知识点六、[函数的参数](#six)
-- 知识点七、[this关键字的指向](#seven)
-- [面试题](#footer)s
-
-
-### 一、初识函数
-
-- 函数的意义，高内聚，低耦合，复用与多态；可以通过函数封装任意多条语句，而且可以在任何地方，任何时候进行调用，使用非常的灵活；
-
- // 基本的语法
- function functionName(argument1,argument2){
- /*一堆的代码*/
- }
- //下面是函数的一个实例，
- function diff(a,b){
- console.log(a-b);
- }
- diff(10,5);//输出5
- diff(20,2);//输出18
-
- > 函数可以通过它的函数名来调用，后面加()，就可以执行了；上面的diff分别输出的是5和18；a和b是函数的两个参数，最终的结果是打印在控制台的；
-
-- 函数还有一个属性，就是可以return；ECMA中函数在定义的时候，不要求函数是否返回一个值，但是每个函数都有return的权利；任何函数在任何时候都可以通过return语句返回的值来实现把值返回给外部变量；
-
- function diff(a,b){
- return a-b;
- }
- var diffNumber=diff(10,5);
- console.log(diffNumber);//diffNumber用来接收函数的返回值，如果return了一个值，但是外部没有变量去接收它，就失去了return的意义了；
-
-- 函数的返回值只能通过return来返回,除了return以外，没有任何声明可以表示返回值
-
- > return的特性：无论return在哪里，只要有执行了return同一条的代码后，函数立即停止，并且立即退出，因此位于return语句之后的人和代码都永远不会执行；
-
- function diff(a,b){
- return a-b;
- console.log("测试的代码");//这条语句，永远不会执行；
- }
- var diffNumber=diff(10,5);
- console.log(diffNumber);
-
- > 一个函数可以多条return；
-
- function diff(a,b){
- if(a>b){
- return a-b;
- }else{
- return b-a;
- }
- }
- var diffNumber1=diff(10,5);
- var diffNumber2=diff(5,10);
- console.log(diffNumber1);//5
- console.log(diffNumber2);//5
-
- 这个函数diff用来计算两个数之间才差值；如果a比b小，则用b-a；否则a-b；函数中用if分为两个分支，分别具有自己的return语句来执行正确的计算逻辑；
-
-- return语句可以不带任何返回值，这种情况下，函数返回值是undefined；这种写法，一般用在需要提前停止函数又不需要返回值的情况；
-
- function testReturn (arg){
- console.log("arg的值是："+arg);
- if(arg===""){return}//如果传的值是空字符串，参数不对， 没必要处理了，直接return停止函数了，可以优化性能；；
- console.log("一些处理参数的代码")
- }
- testReturn("");
-
-- ** return的总结 **
- - 1、任何一个函数都有return关键字，用来导出函数内部的值；（闭包的思路）；
- - 2、return是非必须的，可以写也可以不写；如果不写，或者return后面没有值，函数的返回结果都是undefined；
- - 3、无论return写在哪里，只要函数执行到了return这条代码了，执行完以后，立即停止执行并且跳出函数；return下面的代码将不会执行；
- - 4、推荐的做法是要么让函数始终都返回一个值，要么永远不要返回值，；否则函数有时候有返回值，有时候没有返回值，调试起来不方便；
-
-
-**[↑ 返回目录](#zero)**
-
-
-### 一、函数的定义
-
-- function语句的定义方法
-- 函数直接量的定义方法
-- 构造函数的定义方法
-
- ```
- //function语句的定义方法
- function test1(arg1,arg2){
- console.log("function语句的定义方法:",arg1+arg2);
- return;
- }
-
- //函数直接量的定义方法
- var test2 = function(arg1,arg2){
- console.log("函数直接量的定义方法:",arg1+arg2);
- return;
- }
-
- //构造函数的定义方法
- var test3 = new Function("arg1","arg2","console.log('构造函数的定义方法:',arg1+arg2)");
-
- ```
-
-
-**[↑ 返回目录](#zero)**
-
-
-### 三、函数的调用
-
-- 直接调用： 函数名(实参列表)
-
- ```
- function test1(arg1,arg2){
- console.log("function语句的定义方法:",arg1+arg2);
- return;
- }
-
- //直接调用
- test1(1,2);//function语句的定义方法: 3
-
- ```
-
-- 在链接中调用
-
- ```
-
-
-
-
-
- ```
-
-- 在事件中调用
-
- ```
-
-
-
-
-
- ```
-
-- 递归调用
-
- > 在函数内部调用函数自身
-
-
-
-
-
-**[↑ 返回目录](#zero)**
-
-
-### 四、函数的方法
-
-- call：将函数作为对象的方法来调用，将参数传递给该方法，在后面this关键字时候详细总结
-- apply：将函数作为对象的方法来调用，将参数以数组的形式传递给该方法，在后面this关键字时候详细总结
-- toString：返回函数的字符串表示
-
- ```
- var oBtn1=document.getElementById("btn1");
- oBtn1.onclick=function(){
- console.log(test1.toString());
- };
-
- function test1(){
- console.log("最开始的调用方法");
- }
-
- ```
-
-
-**[↑ 返回目录](#zero)**
-
-
-### 五、arguments对象
-
-- 功能：存放实参的参数列表
- ```
- test1(1,2);//[1,2]
- test1(1,2,3,4,5);//[1, 2, 3, 4, 5]
- function test1(){
- console.log(arguments);
- }
-
- ```
- argutments在普通模式里，可以在函数内部修改函数的值，但是不建议那么做；这点在严格模式下也有限制
- - 在严格模式，函数内部不能修改argument的值，即使修改了，操作也是无效的；
- - 其次重写arguments值会导致语法错误，代码不执行；
-
-- 特性：
- - 仅能在函数体内使用
- ```
- test1(1,2);//[1,2]
- function test1(){
- console.log(arguments);
- }
- console.log(arguments);//Uncaught ReferenceError: arguments is not defined
-
- ```
- - 带有下标属性，但是并非数组
- ```
- test1(1,2);//1 2 undefined
- function test1(){
- console.log(arguments[0],arguments[1],arguments[2]);
- }
-
- ```
- - 函数声明时自动初始化
-- 属性
- - length 获取函数实参的长度
-
- test1(1,2,3,4,5);// 输出5
- function test1(){
- console.log(arguments.length);
- }
-
- - callee 返回当前正在指向的函数
-
- test1(1,2,3,4,5);// 输出函数本身
- function test1(){
- console.log(arguments.callee);
- }
-
- - caller 返回调用当前正在执行函数的函数名;在chrome里是没有的；尽量不要用arguments的这个属性；
- - 在chrome里的callee是arguments.callee.caller
- - 对于函数来说，caller 属性只有在函数执行时才有定义。 如果函数是由 Javascript 程序的顶层调用的，那么 caller 包含的就是 null 。
-
-
-
- ```
- function callerDemo() {
- if (arguments.callee.caller) {
- var a = callerDemo.caller.toString();
- console.log(a);
- } else {
- console.log("this is a top function");
- }
- }
- function handleCaller() {
- callerDemo();
- }
- handleCaller();
- function calleeDemo() {
- console.log(arguments.callee);
- }
- calleeDemo();
-
- ```
-
- > 函数的参数是函数的灵魂；ECMA中的函数不在乎传来多少个参数，也不在乎你传进来的是什么类型的，即使你定义的函数值接受两个参数，在调用的时候未必严格的传进两个实参，你传一个，三个，不传都是没有问题的[这就是函数的多态]；
-
-
- > 原理是因为ECMA是把函数用在内部用一个”数组”来表示的，函数接受到的始终都是这个数组，并不关心这个”数组”是否包含参数，已经包含的都是什么参数，可以通过arguments[index]这种的方式来访问，也可以通过arguments.length的值来确定传进来了多个参数；
-
-
- function testArgument(){
- console.log("hello argument[0]:"+arguments[0]+" and argument[1]:"+arguments[1]);
- }
- testArgument("1","2");//hello argument[0]:1 and argument[1]:2
- testArgument("1");//hello argument[0]:1 and argument[1]:undefined
- testArgument();//hello argument[0]:undefined and argument[1]:undefined
-
-函数的一个特点，形参只是提供了操作的便利，但并不是必须的；函数的定义和调用与参数是没有关系的，只有在函数内部引用了形参才与实参个数和值有关系；如果函数只是定义了，但是没有执行，那就是脱裤子放屁了；因为对程序不会有任何意义；
-
- function sum(a,b){
- if(arguments.length===2){
- console.log("第1个参数和第二个参数的和是:"+a+b);
- }else if(arguments.length===1){
- console.log("block,只传了一个参数 "+a+"，让我如何相加")
- }else{
- console.log("我拒绝运算！")
- }
- }
- sum(10,8);//第1个参数和第二个参数的和是:108
- sum(10);//block,只传了一个参数 10，让我如何相加
- sum();//我拒绝运算！
-
-上面就牵扯到了函数的多态，根据不同的参数来做不同的事情;
-
-
-
-**[↑ 返回目录](#zero)**
-
-
-### 六、函数的参数
-
-- 参数类型；
- 1. 形参，定义函数时使用的参数，接收调用该函数时传递的参数
- 2. 实参，调用函数时传递给函数的实际参数；
-- 特性；
- 1. 参数个数没有限制；（实参<形参，多余形参==undefined；实参>形参，多余实参被忽略；）
- 2. 参数的数据类型没有限制，通过arguments对象访问参数数组；
- 3. 参数始终按值传递
- - a) 基本类型-传值；
- - b) 引用类型-地址；
-
-
-**[↑ 返回目录](#zero)**
-
-
-
-### 七、this关键字的指向
-
-- this，指向当前操作对象；
-- callee，指向参数集合所属函数
-- prototype，指向函数附带的原型对象；
-- constructor，指向创建该对象的构造函数；
-
-### 面试题
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/String\347\261\273\345\236\213.html" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/String\347\261\273\345\236\213.html"
deleted file mode 100644
index a6dbdb3..0000000
--- "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/String\347\261\273\345\236\213.html"
+++ /dev/null
@@ -1,61 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
-
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Symbol.html" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Symbol.html"
deleted file mode 100644
index 2ca68f9..0000000
--- "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Symbol.html"
+++ /dev/null
@@ -1,59 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
-
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Symbol\347\261\273\345\236\213.html" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Symbol\347\261\273\345\236\213.html"
deleted file mode 100644
index fe2081a..0000000
--- "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/Symbol\347\261\273\345\236\213.html"
+++ /dev/null
@@ -1,49 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/null\345\222\214undefined.html" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/null\345\222\214undefined.html"
deleted file mode 100644
index d9649ca..0000000
--- "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/null\345\222\214undefined.html"
+++ /dev/null
@@ -1,88 +0,0 @@
-
-
-
-
- NUll
-
-
-
-asdhasdasl
-
-
-
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/\346\225\260\346\215\256\345\202\250\345\255\230\345\216\237\347\220\206.html" "b/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/\346\225\260\346\215\256\345\202\250\345\255\230\345\216\237\347\220\206.html"
deleted file mode 100644
index e185deb..0000000
--- "a/\346\225\260\346\215\256\347\261\273\345\236\213\345\210\235\350\257\206/\346\225\260\346\215\256\345\202\250\345\255\230\345\216\237\347\220\206.html"
+++ /dev/null
@@ -1,84 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
\ No newline at end of file
diff --git "a/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/3.\345\205\203\345\255\227\347\254\246\347\232\204\345\272\224\347\224\250.md" "b/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/3.\345\205\203\345\255\227\347\254\246\347\232\204\345\272\224\347\224\250.md"
index 4026ecb..c2d83bc 100644
--- "a/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/3.\345\205\203\345\255\227\347\254\246\347\232\204\345\272\224\347\224\250.md"
+++ "b/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/3.\345\205\203\345\255\227\347\254\246\347\232\204\345\272\224\347\224\250.md"
@@ -146,3 +146,41 @@
console.log("test 34222819000428111x",reg2.test("34222819000428111x"));//true
console.log("test 34222819000428111X",reg2.exec("34222819000428111X"));//["34222819000428111X", "34", "2228", "1900", "04", "28", "11", "1", "X", index: 0, input: "34222819000428111X"]
+- 6.匹配整数或者0-8位小数；
+
+ const test0 = "01";//true
+ const test1 = "1.";//true
+ const test2 = "5";//true
+ const test3 = "999999999.34546782";//true
+ const test4 = "5.10";//true
+
+ const test5 = "123.45678.908";//false
+ const test6 = "1s34.5678";//false
+ const test7 = "1s34.3454678332";//false
+ const test8 = "123.45678.";//false
+
+代码如下
+
+ const reg=/^\d{1,}\.?\d{0,8}$/;
+
+ const test0 = "01";//true
+ const test1 = "1.";//true
+ const test2 = "5";//true
+ const test3 = "999999999.34546782";//true
+ const test4 = "5.10";//true
+
+ const test5 = "123.45678.908";//false
+ const test6 = "1s34.5678";//false
+ const test7 = "1s34.3454678332";//false
+ const test8 = "123.45678.";//false
+
+ console.log(reg.test(test0));
+ console.log(reg.test(test1));
+ console.log(reg.test(test2));
+ console.log(reg.test(test3));
+ console.log(reg.test(test4));
+ console.log("----");
+ console.log(reg.test(test5));
+ console.log(reg.test(test6));
+ console.log(reg.test(test7));
+ console.log(reg.test(test8));
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/%\350\277\220\347\256\227\347\254\246.html" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/%\350\277\220\347\256\227\347\254\246.html"
deleted file mode 100644
index 73a691c..0000000
--- "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/%\350\277\220\347\256\227\347\254\246.html"
+++ /dev/null
@@ -1,15 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
\ No newline at end of file
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/1.%\350\277\220\347\256\227\347\254\246.js" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/1.%\350\277\220\347\256\227\347\254\246.js"
new file mode 100644
index 0000000..0cecf01
--- /dev/null
+++ "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/1.%\350\277\220\347\256\227\347\254\246.js"
@@ -0,0 +1,4 @@
+var times=123453;//求多少分，多少秒；
+var targetTime=parseInt(times/60)+"分"+times%60+"秒";
+console.log(targetTime);
+//思考：等于多少天，多少小时，多少分，多少秒
\ No newline at end of file
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/2.\347\256\227\346\234\257\350\277\220\347\256\227\347\254\246.js" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/2.\347\256\227\346\234\257\350\277\220\347\256\227\347\254\246.js"
new file mode 100644
index 0000000..aa09bbc
--- /dev/null
+++ "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/2.\347\256\227\346\234\257\350\277\220\347\256\227\347\254\246.js"
@@ -0,0 +1,35 @@
+//连接字符串，把数值转换为字符串
+var strOne="abc",
+ strTwo="xyz";
+console.log(strOne+strTwo);//abcxyz
+console.log(strOne+123);//abc123
+
+//多次运算
+var testOne="字符串";
+console.log(testOne+2+5);//字符串25
+console.log(testOne+(2+5));//字符串7
+
+var strEmpty="";
+var testNum=222;
+var targetData=strEmpty+testNum;
+console.log(typeof testNum);//number
+console.log(typeof targetData);//string
+
+var num=0;
+num=num+2;
+num=num*3;
+num=num/2;
+num++;
+num--;
+num+=1;
+num-=2;
+num*=3;
+num/=2;
+num%3;
+console.log(num);
+
+//操作数类型和结果类型
+console.log("5"+"3");//53
+console.log("5"-"3");//2
+console.log("5"*"3");//15
+console.log("15"/"3");//5
\ No newline at end of file
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/3.\345\205\263\347\263\273\350\277\220\347\256\227\347\254\246.js" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/3.\345\205\263\347\263\273\350\277\220\347\256\227\347\254\246.js"
new file mode 100644
index 0000000..cdbdb5e
--- /dev/null
+++ "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/3.\345\205\263\347\263\273\350\277\220\347\256\227\347\254\246.js"
@@ -0,0 +1,14 @@
+console.log("20">"100000");//true
+console.log(null>2);//false
+console.log(NaN>2);//false
+
+//关系操作符
+var testNum=3;
+console.log("下面是关系操作符");
+console.log(testNum==1);
+console.log(testNum===1);
+console.log(testNum!=1);
+console.log(testNum>1);
+console.log(testNum>=1);
+console.log(testNum<1);
+console.log(testNum<=1);
\ No newline at end of file
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/4.\347\233\270\347\255\211\350\277\220\347\256\227\347\254\246.js" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/4.\347\233\270\347\255\211\350\277\220\347\256\227\347\254\246.js"
new file mode 100644
index 0000000..201518e
--- /dev/null
+++ "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/4.\347\233\270\347\255\211\350\277\220\347\256\227\347\254\246.js"
@@ -0,0 +1,33 @@
+console.log(null==0);//false
+console.log(false==0);//true
+console.log({}=="");//true
+
+//转换分析1
+console.log("zhuanbang"?true:false);//true,因为非空的字符串是一个真值；
+
+//转换分析2
+console.log("zhuanbang"==true);//这个时候输出什么呢？在分析一里非空字符串是一个true，那么非空字符串==true吗？
+
+//转换分析3
+console.log("zhuanbang"==false);//如果上面的的返回不是true，那么这个会返回true吗？
+
+/*转换分析2-解析
+* 1、右边的布尔值会转为数字,true->1;"zhuanbang"==1
+* 2、左边的字符串会转为数字，"zhuanbang"因为里面有字母，所以转换为NaN;NaN==1
+* 3、NaN和任何数据都不想等，包括自己，所以结果是false，并不是true；
+* */
+
+/*
+* 1、右边的布尔值会转为数字,false->0;"zhuanbang"==0
+* 2、左边的字符串会转为数字，"zhuanbang"因为里面有字母，所以转换为NaN;NaN==0
+* 3、NaN和任何数据都不想等，包括自己，所以结果是false，结果也不是true
+* */
+
+
+//相同的小分析
+console.log("zhuanbang"===true);
+console.log("1"===1);
+console.log("zhuanbang"==="zhuanbang");
+var person1={name:"zhuanbang"};
+var person2={name:"zhuanbang"};
+console.log(person1===person2);//false, 是不同的引用地址；在堆内存中储存是不一样的；
\ No newline at end of file
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/5.\351\200\273\350\276\221\350\277\220\347\256\227\347\254\246.js" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/5.\351\200\273\350\276\221\350\277\220\347\256\227\347\254\246.js"
new file mode 100644
index 0000000..6b13f44
--- /dev/null
+++ "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/5.\351\200\273\350\276\221\350\277\220\347\256\227\347\254\246.js"
@@ -0,0 +1,10 @@
+console.log(!true);//false
+console.log(true && false);//false
+console.log(true || false);//true
+
+var a="",
+ b="B有值";
+var result=a||"A的值是假的",
+ result2=b||"B的值是假的";
+console.log(result);
+console.log(result2);
\ No newline at end of file
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/6.\344\275\215\350\277\220\347\256\227\347\254\246.js" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/6.\344\275\215\350\277\220\347\256\227\347\254\246.js"
new file mode 100644
index 0000000..379eebc
--- /dev/null
+++ "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/6.\344\275\215\350\277\220\347\256\227\347\254\246.js"
@@ -0,0 +1,6 @@
+console.log('5 & 1:', (5 & 1));
+console.log('5 | 1:', (5 | 1));
+console.log('~ 5:', (~5));
+console.log('5 ^ 1:', (5 ^ 1));
+console.log('5 << 1:', (5 << 1));
+console.log('5 >> 1:', (5 >> 1));
\ No newline at end of file
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/7.\344\270\211\345\205\203\350\277\220\347\256\227\347\254\246.js" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/7.\344\270\211\345\205\203\350\277\220\347\256\227\347\254\246.js"
new file mode 100644
index 0000000..f50faea
--- /dev/null
+++ "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/7.\344\270\211\345\205\203\350\277\220\347\256\227\347\254\246.js"
@@ -0,0 +1,14 @@
+function trueOrFalse(val) {
+ return val?console.log(val+" is true"):console.log(val+" is false")
+}
+trueOrFalse(null);
+trueOrFalse(undefined);
+trueOrFalse(0);
+trueOrFalse(NaN);
+trueOrFalse(-0);//0===-0
+trueOrFalse(false);
+trueOrFalse("");
+trueOrFalse(" ");
+trueOrFalse({});
+trueOrFalse([]);
+trueOrFalse(1);
\ No newline at end of file
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/README.MD" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/README.MD"
index ecb0dd6..f2d7082 100644
--- "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/README.MD"
+++ "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/README.MD"
@@ -4,7 +4,7 @@
这个就是一个表达式，把等号右边的字符串，赋值到左边myName这个变量名上；表达式在各个类型里会介绍，这里主要总结运算符；
-大多数的运算符是有+-==这种标点符号来表现，但是也有一些运算符是由关键字表示的，比如delete和instanceof，不过无论标点符号表示的运算符还是关键字表示的运算符，都是合法的运算符；
+大多数的运算符是有`+`、 `-` 、`==`这种标点符号来表现，但是也有一些运算符是由关键字表示的，比如delete和instanceof，不过无论标点符号表示的运算符还是关键字表示的运算符，都是合法的运算符；
# 运算符；
@@ -96,27 +96,27 @@ ECMAScript里用于操作数据值的运算符也叫操作符，只是叫法不
##### 赋值操作符
-**=**:赋值
+`=`:赋值
var a=10;
-**+=**:加赋值
+`+=`:加赋值
x+=y // x=x+y;
-**-=**:减赋值
+`-=`:减赋值
x-=y // x=x-y;
-***=**:乘赋值
+`*=`:乘赋值
x*=y // x=x*y;
-**/=**:除赋值
+`/=`:除赋值
x/=y // x=x/y;
-**%=**:取余赋值
+`%=`:取余赋值
x%=y // x=x%y;
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\344\270\211\345\205\203\350\277\220\347\256\227\347\254\246.html" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\344\270\211\345\205\203\350\277\220\347\256\227\347\254\246.html"
deleted file mode 100644
index de13fdc..0000000
--- "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\344\270\211\345\205\203\350\277\220\347\256\227\347\254\246.html"
+++ /dev/null
@@ -1,25 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
\ No newline at end of file
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\344\275\215\350\277\220\347\256\227\347\254\246.html" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\344\275\215\350\277\220\347\256\227\347\254\246.html"
deleted file mode 100644
index 1696865..0000000
--- "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\344\275\215\350\277\220\347\256\227\347\254\246.html"
+++ /dev/null
@@ -1,17 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
\ No newline at end of file
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\345\205\263\347\263\273\350\277\220\347\256\227\347\254\246.html" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\345\205\263\347\263\273\350\277\220\347\256\227\347\254\246.html"
deleted file mode 100644
index 18796f6..0000000
--- "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\345\205\263\347\263\273\350\277\220\347\256\227\347\254\246.html"
+++ /dev/null
@@ -1,25 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
\ No newline at end of file
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\347\233\270\347\255\211\350\277\220\347\256\227\347\254\246.html" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\347\233\270\347\255\211\350\277\220\347\256\227\347\254\246.html"
deleted file mode 100644
index 5bb24cb..0000000
--- "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\347\233\270\347\255\211\350\277\220\347\256\227\347\254\246.html"
+++ /dev/null
@@ -1,45 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
\ No newline at end of file
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\347\256\227\346\234\257\350\277\220\347\256\227\347\254\246.html" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\347\256\227\346\234\257\350\277\220\347\256\227\347\254\246.html"
deleted file mode 100644
index 22f6abb..0000000
--- "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\347\256\227\346\234\257\350\277\220\347\256\227\347\254\246.html"
+++ /dev/null
@@ -1,49 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
\ No newline at end of file
diff --git "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\351\200\273\350\276\221\350\277\220\347\256\227\347\254\246.html" "b/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\351\200\273\350\276\221\350\277\220\347\256\227\347\254\246.html"
deleted file mode 100644
index 1f2e766..0000000
--- "a/\350\241\250\350\276\276\345\274\217\345\222\214\350\277\220\347\256\227\347\254\246/\351\200\273\350\276\221\350\277\220\347\256\227\347\254\246.html"
+++ /dev/null
@@ -1,21 +0,0 @@
-
-
-
-
- Title
-
-
-
-
-
\ No newline at end of file