1、js

1. script元素：

   1. src：同域或不同域的外部脚本

   2. defer：对外部文件有效，脚本可以延迟到文档被完全解析后才会运行不会影响页面

   3. async：对外部文件有效，异步，

   4. type

   5. charset：字符集

2. 在xhtml使用用cdata

3. 嵌入外部文件：可维护性、可缓存、

4. 文档模式

   1. 混杂模式：不同浏览器的样式差别会很大

   2. 标准模式

   3. 区别

      1. 混杂模式给行内元素设置宽高会生效

      2. 混杂模式使用margin：0 auto失效

      3. 混杂模式ie宽高包括 padding和border

5. noscript：浏览器不支持脚本，支持但禁用才会显示这个标签的内容

2、语法基本概念ecmascript

1. 语法

   1. 区分大小写

   2. 标识符：字母_$数字组成，第一个字符不能事数字

   3. 驼峰式命名

   4. ‘use strict‘

2. 变量：松散型 let x = ‘a‘ => x = 2

3. 数据类型：

1. 五种基本类型

   1. undefined：声明未被赋值或者非严格模式下为声明的变量

   2. null：空对象 null==undefined => true

   3. boolean：true false。if（）中false ‘‘ 0 NaN undefined被判断为false

   4. number

      1. 浮点数

      2. 整数

      3. 无穷：+-Infinity，一旦转换成无穷就不会参与计算

         1. 用isFinite()判断 处于最大数和最小数之间返回true

      4. NaN：非数值

         1. 任何数/0 = NaN

         2. 涉及 NaN的操作都返回 NaN

         3. NaN == NaN //false

         4. isNaN()：方法运行步骤：首先尝试将传入的值转换为数值，能转换的比如boolean和字符数值就返回false ，其余返回true

         5. isNaN()判断对象：先调用对象的valueOf()，不能转成数值就调用toString()，再判断

      5. 数值转换：

         1. Number：一元+操作符一样

            1. Boolean => 1,0

            2. null => 0

            3. ‘ ‘ ‘‘=> 0

            4. Undefined => NaN

            5. Number(‘123nnn‘) => NaN

            6. 八进制和十六进制 => 十进制

            7. 数值字符串 => 对应的数值 忽略前面的0

         2. parseInt：（num，基数）

            1. 字符串 ‘‘ ‘ ‘=> NaN

            2. parseInt(‘11nn‘) => 11 只有整数

            3. 能够转换十六和八进制

         3. parseFloat

            1. 只解析十进制

            2. 十六进制 => 0

   5. String：

      1. 一旦创建不可变

      2. 转换：toString

      3. null和undefined每天toString方法用String：步骤 有toString调用 并返回结果=>null返回null =>undefined返回undefined

   6.  

2. 对象：

   1. 属性方法

      1. constructor：创建当前对象的函数

      2. hasOwnProperty(属性名)：检查属性在实例而不是原型中

   2.  

3. 操作符：

   1. typeof：undefined number string boolean object(数组 对象 null） function

   2. 一元

   3. 位

   4. 布尔

   5. *

   6. +-

   7. 关系

   8. 条件

   9. 相等

   10. 条件

   11. 赋值

   12. ，

4. 语句

   1. 循环

   2. 条件

   3. break

   4. continue

   5. switch

5. 函数：参数arguments是伪数组，方法不会被重载只会被覆盖

3、基本类型引用类型 垃圾收集

基本类型

1. 基本类型可以直接操作

2. 引用类型不可以直接操作，因为是被保存在内存中，

3. 函数参数传递的是值， 对象也是传递的引用

   function add(num){
     num += 10
     return num
   }
   let count = 20
   console.log(add(count)) //30
   console.log(count) //20
   //传递对象
   function setname(obj){
     obj.name = ‘123‘
   }
   let person = new Object()
   person.name = ‘456‘
   setname(person) 
   console.log(person.name) //‘123‘
   //
   function setname(obj){
     obj.name = ‘123‘
     obj = new Object()
     obj.name = ‘456‘
   }
   let person = new Object()
   person.name = ‘789‘
   setname(person) 
   console.log(person.name) //‘123‘
   //  函数里面的obj是局部变量 执行完就回被销毁
   ?

    

4. 类型检测

   1. typeof

   2. 变量 instanceof 原型 返回boolean =>所有引用类型都是object都会返回true，基本类型object返回false

5. 执行环境和作用域

   1. 执行环境 =>变量对象：执行到语句时会有一个变量对象，里面保存了能访问到的函数和变量，执行环境的代码执行完就立即销毁，里面的变量和函数也销毁

      1. 全局执行环境

      2. 函数执行环境=>执行到每一个函数就回产生一个函数的执行环境，推入环境栈中，执行完就弹出，到上一个执行环境，依次循环直到所有代码执行完回到全局执行环境

      3. 作用域链： 每到一个执行环境，变量对象有一个作用域链 =>当前变量对象=>外层函数=>最外层=>全局：对执行环境有权访问的变量和函数的有序访问，作用域链的前端，始终都是当前执行的代码所在环境的变量对象，全局变量对象是作用域链的最后一个对象，查询标识符沿着作用域链查找变量和函数来使用

      4. 函数的变量对象=>活动对象(activatiton object)：包含arguments=>变量声明=>函数声明=>赋值，

      5. 作用域链的结构可以看出，在运行期上下文的作用域链中，标识符所在的位置越深，读写速度就会越慢。因为全局变量总是存在于运行期上下文作用域链的最末端，因此在标识符解析的时候，查找全局变量是最慢的。所以，在编写代码的时候应尽量少使用全局变量，尽可能使用局部变量。

   2.  

6. 变量

   1. 全局变量：

      1. 没有使用var声明的变量

   2.  

7. 垃圾收集：找出不再继续使用的变量=>然后释放内存，垃圾收集器跟踪哪个变量有用哪个没有用然后对无用的变量打上标记，已备将来回收-------具体实现分为两种

   1. 标记清除：垃圾收集器会给环境中的所有变量加上标记，然后去掉环境中变量和环境变量引用的变量的标记，=>然后再被加上标记的变量就是准备被删除的----也就是离开作用域的值，因为已经无法访问了

   2. 引用计数：记录每个变量被引用的次数----------声明一个变量a并且赋值引用类型，则这个值引用次数=1，这个值又被赋值给另一个变量b的话=>引用次数就+1，然后如果a或者b又被赋值了另一个值=>这个值的引用次数就-1，引用次数=0就说明可以回收了，垃圾收集器再次运行就可以释放内存了

   3. 引用计数问题：循环引用

   4. 性能问题：垃圾收集器是周期性运行的，根据变量数目启动垃圾收集器，动态改变临界值

   5. 管理内存：解除引用，不在使用的数据手动=null，适用于全局，局部对象在离开执行环境就销毁了

8.  

• 2、引用类型：

  1. object

     1. 创建：

        1. new操作符

        2. 对象字面量{}

     2.  

  2. array

     1. 创建

        1. new

        2. 数组字面量[]

     2. 检测数组：

        1. instanceof Array ----------如果有两个全局执行环境，那么每个执行环境中的array构造函数是不同的

        2. Array.isArray(变量)返回boolean

     3. 不影响原始数组的方法

        1、 concat：参数-----都可以，   返回值------构建的新数组
        2、 slice：参数-----start、end索引位置，可以是负数，  返回值----指定参数开始到结尾或者第二个参数的所有项、不包括end位置，
        位置
        3、indexof：参数-----（item，起点位置），返回值-----找到就返回item的索引没找到返回-1
        4、lastindexof：同上。从后往前
        遍历迭代数组
        5、every：参数-----（函数(item,index,array)，可选参数作用域对象），返回值----所有元素满足返回true否则false
        6、some：参数同上，返回值-----一项满足返回true停止迭代
        7、map：参数同上，返回值----经过处理的新数组
        8、filter：参数同上，返回值----满足函数条件的新数组
        7、foreach：参数同上，没有返回值
        归并数组
        9、reduce：参数同上（函数（pre，cur，index，array）），返回值----构建一个返回值 比如所有元素的和（pre+Cur）
        10、reduceRight：同上，反方向处理数组
        11、join转为字符串:参数----（分隔符字符串），返回值----字符串
        12、tostring：返回逗号连接的字符串
        13、tolocalstring：

     4. 影响原始数组的方法

        1、reverse：参数---无，返回值-----反转后的数组
        2、sort: 参数-----比较函数，  返回值-----比较后的数组，tips：sort是按照字符比较所以用函数，函数的返回值-1，0，1
        3、splice:参数-----（起始位置，删除项数，添加项数），  返回值-----被删除的项的数组（没有删除就是空数组）
        4、push从结尾插入元素：参数-----（数组or数or其他），返回值-----返回新数组的长度
        5、unshift从头插入：同上
        6、pop结尾删除元素：返回值----删除的元素
        7、shift从头删除元素：同上

     5.  

  3. function

     1. 声明

        1. function name(){}会变量提升

        2. 表达式。var 变量名=function执行到才会调用--------：匿名函数

        3. 构造函数：不推荐，因为要解析两次：常规和传入的字符串

           new Function(‘num1‘,‘num2‘,‘return num1 + num2‘)

        4. 闭包只能取得包含函数中任何变量的最后一个值。别忘了闭包所保存的是整个变量对象，而不是某个特殊的变量。
           function createFunctions(){
           var result = new Array();
           for (var i=0; i < 10; i++){
           result[i] = function(){
           return i;
           };
           }
           return result;
           }全是10

        5. 字符串操作方法

           1、concat()：参数----连接的字符串
           2、charAt()和charCodeAt()：参数-----位置；返回值-----匹配的字符或者字符编码
           3、还提供了三个基于子字符串创建新字符串的方法：slice()、substr()和substring()。
           这三个方法都会返回被操作字符串的一个子字符串，而且也都接受一或两个参数。第一个参数指定子字符串的开始位置，第二个参数（在指定的情况下）表示子字符串到哪里结束，。而substr()的第二个参数指的则是返回的字符个
           var stringValue = "hello world";
           alert(stringValue.slice(3)); //"lo world"
           alert(stringValue.substring(3)); //"lo world"
           alert(stringValue.substr(3)); //"lo world"
           alert(stringValue.slice(3, 7)); //"lo w"
           alert(stringValue.substring(3,7)); //"lo w"
           alert(stringValue.substr(3, 7)); //"lo worl"
           slice()方法会将传
           入的负值与字符串的长度相加，substr()方法将负的第一个参数加上字符串的长度，而将负的第二个参数转换为0。最后，substring()方法会把所有负值参数都转换为0
           4、：indexOf()和lastIndexOf()：这两个方法都是从一个字符串中搜索给定的子字符串，然后返子字符串的位置（如果没有找到该子字符串，则返回-1）。
           5、replace（/被替换的/g，替换）只替换第一个，g全局
           6、trim删除前面后面的空格 返回结果
           7、大小写转换：toLowerCase,toUpperCase
           8、match（正则表达式）返回匹配的数组
           let text = ‘cat,bat,sat,fat‘
           let pattern = /.at/
           let match = text.match(pattern)
           match //["cat", index: 0, input: "cat,bat,sat,fat", groups: undefined]
           9、search（正则表达式）返回一个匹配项的索引，没有就返回-1
           let search = text.search(pattern)
           search //1
           10、split转换为数组
           11、localCompare（比较的字符串）比较两个字符串 相等返回0，字符串在字母表中的位置在参数之后返回1，参数之前返回-1
           12、fromCharCode（多个字符编码）返回字符串
           String.fromCharCode(104,101,108,108,111)//‘hello‘

        6. 构造函数

        7. 1. prototype属性：原型====>构造出的对象实例的公共祖先

           2. 构造函数.prototype==实例.proto

           3. 原型也是对象通过

              .prototype.xxx = ....
              function Person(){
                //new的时候隐式创建
                //let this = {__proto__: Person.prototype}
                //this.xxx = xxx
                //return this
              }
              let person = new Person()
              ?

           4.  

              function Person(){
              }
              let person = new Person()
              Person.prototype =>object{
              constructor: ƒ Person()
              __proto__: Object //原型里面还有原型
              }
              person.__proto__ =>object{
                constructor: ƒ Person()
              __proto__: Object
              }
              person.__proto__ === Person.prototype //true
              Person.prototype.name = ‘123‘
              Person.prototype
              {name: "123", constructor: ƒ}
              person.__proto__
              {name: "123", constructor: ƒ} 
              ?
              //
              person.__proto__= {a:1}
              person.__proto__ == Person.prototype //false

           5. 原型链

              Grand.prototype.name = ‘grand‘
              function Grand(){ 
              }
              let grand = new Grand()
               
              Father.prototype = grand
              function Father(){
              }
              let father = new Father()
              ?
              Son.prototype = father
              function Son(){
              }
              let son = new Son()
              son.name //

               

           6. constructor：创建当前对象实例的构造函数，原型上的

           7. 可以用delete删除实例的属性

           8. 实例不能增删改原型上的属性和方法

           9. 把公共的属性和方法放在原型上

           10. 实例本身有的属性就不会往原型上找了

        8. 内存泄露：内存泄露是指当一块内存不再被应用程序使用的时候，由于某种原因，这块内存没有返还给操作系统或者内存池的现象。内存泄漏可能会导致应用程序卡顿或者崩溃。

        9. this====基于函数对象执行环境绑定的，全局==this，作为方法==实例对象

        10. 闭包

            1. 能访问另一个（外部）函数作用域中的变量的函数

            2. 作用域链：代码执行到函数时，创建函数的执行环境，同时产生一个活动对象包含能能访问的函数和变量（函数的所有局部变量、命名参数、参数集合以及this），函数外部的活动对象处在第二位---一直往外-----到全局作用域

            3. 函数的变量对象只在函数执行时存在，函数的作用域链被存在[[scoped]]中，调用函数的时候就创建当前函数的变量对象，执行完毕变量对象就会被销毁，

            4. 闭包的话会把函数外部那个不属于本身的活动对象保存在自己的scope内部属性中，就算外部那个函数执行完毕活动对象被销毁，因为闭包保存下来所以仍然可以访问，直到闭包不存在为止

            5. 闭包会携带包含它的函数的作用域，所以会占用更多的内

        11. 函数的属性和方法

            1. 属性：

               1. length-----函数本身定义的参数的个数

               2. prototype----是保存所有实例方法的所在，而且不能枚举，不能用for-in

               3. firefox、safari、chrome、opera有name属性====函数的名字

            2. 方法：改变this指向，扩充函数作用域，只是传入参数不同

               1. call（改变的作用域，参数数组）：参数为列举的数

               2. apply（改变的作用域，参数数组）：参数为数组

               3. bind：创建函数的实例

               4. 继承的tostring等

            3.  

        12. 函数内部属性

            1. arguments=>类数组对象，保存参数，---------属性：callee---指的是拥有arguments对象的函数本身，--------caller：调用函数的函数，严格模式没有这两个属性

            2. this指的是执行环境变量对象

        13. 没有方法的重载只有覆盖

        14. 作为值，去掉括号是调用指针，加上括号才会执行-------函数名字是指针，

     2.  

     =======基本包装类型：Boolean，Number，Srting

     1. 当读取一个基本类型的数据，后台会经历三步

        1. 创建包装类型的实例
        2. 在实例上调用一些方法
        3. 销毁实例
        var s1 = ‘some text‘
        s2 = s1.substring(2);
        //实际上后台 s2 = s1.substring(2);
        var s1 = new String("some text");
        var s2 = s1.substring(2);
        s1 = null;

     2. 使用new的包装类型和直接使用同名的转型函数：new出来的是对象，后者是基本类型强制转换

     3. 包装类型用typeof返回object ，都会被转换成true

     4. 引用类型和包装类型的区别：对象的生存期；对象离开当前作用域一直都在，自动创建的包装对象只在这一行存在

     • 字符串操作方法

       1、concat()：参数----连接的字符串
       2、charAt()和charCodeAt()：参数-----位置；返回值-----匹配的字符或者字符编码
       3、还提供了三个基于子字符串创建新字符串的方法：slice()、substr()和substring()。
       这三个方法都会返回被操作字符串的一个子字符串，而且也都接受一或两个参数。第一个参数指定子字符串的开始位置，第二个参数（在指定的情况下）表示子字符串到哪里结束，。而substr()的第二个参数指的则是返回的字符个
       var stringValue = "hello world";
       alert(stringValue.slice(3)); //"lo world"
       alert(stringValue.substring(3)); //"lo world"
       alert(stringValue.substr(3)); //"lo world"
       alert(stringValue.slice(3, 7)); //"lo w"
       alert(stringValue.substring(3,7)); //"lo w"
       alert(stringValue.substr(3, 7)); //"lo worl"
       slice()方法会将传
       入的负值与字符串的长度相加，substr()方法将负的第一个参数加上字符串的长度，而将负的第二个参数转换为0。最后，substring()方法会把所有负值参数都转换为0
       4、：indexOf()和lastIndexOf()：这两个方法都是从一个字符串中搜索给定的子字符串，然后返子字符串的位置（如果没有找到该子字符串，则返回-1）。
       5、replace（/被替换的/g，替换）只替换第一个，g全局
       6、trim删除前面后面的空格 返回结果
       7、大小写转换：toLowerCase,toUpperCase
       8、match（正则表达式）返回匹配的数组
       let text = ‘cat,bat,sat,fat‘
       let pattern = /.at/
       let match = text.match(pattern)
       match //["cat", index: 0, input: "cat,bat,sat,fat", groups: undefined]
       9、search（正则表达式）返回一个匹配项的索引，没有就返回-1
       let search = text.search(pattern)
       search //1
       10、split转换为数组
       11、localCompare（比较的字符串）比较两个字符串 相等返回0，字符串在字母表中的位置在参数之后返回1，参数之前返回-1
       12、fromCharCode（多个字符编码）返回字符串
       String.fromCharCode(104,101,108,108,111)//‘hello‘

     •  

     •  

      

8.26js部分复习