js总结

17.获取子数组：

var subArr=arr1.slice(starti,endi+1);

下标：含头不含尾

特殊：省略第二个参数：从starti位置一直选取到结尾

  不写参数：复制整个数组

       如果离结尾近，选取倒数第n到倒数第m的元素

arr.slice(-n,-m+1);

 

18.删除、插入、替换、翻转：

删除：splice(starti,n);：从arr中starti开始，删除n个元素

  直接修改原数组，starti支持附属参数，表示倒数第n个位置。

插入：arr.splice(starti,0,v1,v2...);将starti位置的值及其后面的值进行后移

  替换：arr.splice(starti,n,v1,v2...);将starti之后的n个元素删除，并插入新元素

翻转：arr.reverse();

19.排序：

sort();

特殊：默认比较字符串，会将其他类型转换为字符串，所以需要一个自定义函数

function compare(a,b){return a-b;}

将函数作为参数传入另一个函数时不加()，

默认字符串比较：先sort升序，再reverse()降序。

20.栈stack和队列queue：

栈stack：只能一端进出，last in first out

结尾出入栈：

入栈：arr.push(value);==>arr[arr.length]=value   

出栈：var last=arr.pop();

无论出入栈都不影响已有元素的位置----->效率高

开头出入栈：

入栈：arr.unshift(value);

出栈：var last=arr.shift();

每次出入栈都影响所有剩余元素的位置发生顺移---->效率低

队列queue：从两端进出   FIFO

只要希望按先后顺序使用数组中的元素时

1. 结尾入:
入: arr.push(值)

2. 开头出: var first=arr.shift()

21.内置对象: ES标准中规定的，浏览器厂商已经实现的现成的对象和API

    11个: Number  String  Boolean

          Array Date RegExp Math

          Error

          Function  Object   Global(浏览器中被替换为window)

22.包装类型对象：

    什么是: 专门封装基础类型的值，并提供操作基础类型值的API的对象

    为什么: 基础类型的值，本身不包含任何API功能

    何时: 只要试图对基础类型的值调用API时，都会自动创建对应类型的包装类型对象来封装基础类型的值。

    调用后: 包装类型对象，自动释放！

23.String的API：

str.toUpperCase();：大写

str.toLowerCase();：小写

str.charAt(i);：获取指定位置的字符

str.charCodeAt(i);：获取指定字符的unicode号

String.fromCharCode(unicode);：将unicode号反向转回文字

选取子字符串：

str.slice(starti,endi+1);

str.substring(starti,endi+1);不支持负参数

str.substr(starti,n);选取starti开始的n个元素

查找关键字：

var i=str.indexOf("关键词",fromi);

在str中，从fromi位置开始查找"关键词"的位置,如果找到，返回关键词所在位置的下标,找不到，返回-1，简写:
省略fromi，默认从0开始。只能找第一个关键词

var i=str.lastIndexOf("关键词");

在str中，找最后一个关键词出现的位置

24.正则表达式：

var i=str.search(/正则表达式/);

           在str中查找第一个符合正则表达式要求的关键词的位置

           返回值:
找到的关键词的下标, 如果找不到返回-1

           何时:
仅判断是否包含敏感词时，就用search

           如果返回不是-1，说明包含，否则说明没找到

           忽略大小写: /正则/i

           问题: 1.
只能获得第一个的位置，不能获得所有敏感词

                2. 只能返回位置，不能返回内容

var arr=str.match(/正则/ig);

        默认只找第一个，找所有，必须加g

        返回值:
所有敏感词组成的数组

               没找到返回null！

           强调:
如果一个API有可能返回null，就必须先判断不是null，再使用！

        arr.length 表示找到的关键词个数

        问题: 仅返回所有关键词的内容，无法返回每个关键词位置

reg.exec();

即找所有关键词内容，又找每个关键词的位置。

str=str.replace(/正则/ig,“替换值”);

替换: 将字符串中所有敏感词替换为新内容

问题: 不能根据不同的关键词，选择不同的值替换

高级替换:

      str=str.replace(/正则/ig,function(kw){

          //kw会自动获得本次找到的关键词内容

          return //根据不同kw，返回不同的替换值

      })

     何时: 只要根据不同的关键词，替换不同内容时

固定套路: 只要希望字符串和正则从头到尾完全匹配

          比如同时前加^后加$

 切割: 将原字符串，按指定字符，分隔为多个子字符串

      如何: var substrs=str.split(/正则/)

         返回切割后的多个子字符串组成的数组

                结果中，不再包含分隔符

      固定套路: 将字符串打散成字符数组: var chars=str.split("")

arr["index"]: 当前关键词位置 ->
可简写为arr.index

固定套路: 找所有关键词:

         while((arr=reg.exec(str))!=null){

              arr[0] 关键词内容

                 arr
 自动获得第n个分组的子内容

              arr.index 当前关键词位置

         }

如果只需要分组的子字符串，不需要完整关键词:

            可省略arr，用RegExp.$n

         while(reg.exec(str)!=null){

               RegExp.$n   自动获得第n个分组的子内容

         }

验证: 检查字符串是否完全符合正则表达式的要求！

      如何: var bool=reg.test(待检测字符串)

         强调:
只要验证，reg中必须前加^后加$

贪婪模式: 正则表达式默认匹配最长的符合条件的子字符串

              默认使用贪婪模式

              .*    .+

懒惰模式: 仅匹配最短的符合条件的子字符串

          贪婪->懒惰:  .*?   .+?

25.Math：

取整:

    Math.ceil(num) 上取整:
只要超过，就取下一个整数

    Math.floor(num) 下取整:
省略小数部分

Math.round(num) 四舍五入取整

toFixed(d):

    1. 小数位数: Math.round()只能取整,不能规定小数位数

        toFixed(d)可取整，也可规定小数位数

    2. 返回值: Math.round()返回number

        toFixed(d)返回string

26.重写与重载

重写(override):
如果子对象觉得，父对象的成员不好用，可在本地定义同名的自有成员，覆盖父对象中的。

重载(overload):

  相同函数名，不同参数列表的多个函数，在调用时，可根据传入参数的不同，自动选择对应的函数调用！

27. 回调callback:
将函数作为参数传递给另一个函数去调用  

            比如: arr.sort(function (a,b){return a-b});

                     str.replace(/reg/g,function(kw,$1,...){return ...})

28.自调:
创建函数后立刻调用自己！

            何时:
如果一个函数只执行一次，不会再重用时

            为什么:
建立临时作用域！避免全局污染！

            如何:

               (function(参数列表){函数体; return
返回值})();

29.作用域和作用域链：

作用域scope:

     什么是: 一个变量的使用范围——使用

                 本质上作用域是一个对象——存储

                     作用域中的变量都是对象的成员

     程序/函数的执行过程:

        1. 开始执行程序前:

            创建ECS(执行环境栈):

                依次保存每个调用的函数的执行环境

            在ECS中压入第一个全局执行环境(全局EC)

            创建window对象，全局EC引用window对象

            window就是全局作用域对象

        2. 开始执行程序:

            所有全局变量都保存在全局作用域对象window中

        3. 定义函数时:

            在全局添加函数名变量

            创建函数对象封装函数定义

            函数名变量引用函数对象

            函数对象中有一个scope属性，引用回创建函数时的作用域对象。通常都是window。

        4. 调用函数时:

            在ECS中压入一个新的EC

            为本次函数调用创建专门的活动对象(AO)

            在AO中创建所有函数定义中规定的局部变量

            其实AO就是函数作用域对象

                 所有局部变量都是AO的成员

            新的EC引用活动对象AO

            AO的parent指向window

            变量的使用顺序:

               先用AO(函数作用域)中的局部变量

               如果AO中没有，才去window(全局作用域)中找

        5. 函数调用后:

            本次函数调用的EC出栈

                导致函数作用域对象AO释放

                       导致局部变量一同释放

   作用域链(scope chain):
由多个作用域对象连续引用形成的链式结构。

      顺序: 先函数作用域对象AO->全局作用域对象window

      所有的变量都保存在作用域链上的对象中

          局部变量都保存在函数作用域对象AO中

          全局变量都保存在全局作用域对象window中

      控制了: 变量的使用顺序

        先用AO(函数作用域)中的局部变量

               如果AO中没有，才去window(全局作用域)中找

 

30.原型和原型链：

原型对象: 集中存储同一类型的子对象所需的所有共有属性和方法的父对象

原型链: 多级父对象连续继承，形成的链式结构

      保存了: 对象的属性和方法

      控制了: 对象的成员的使用顺序

         优先使用自有成员

         自己没有才延原型链向父级查找，只要找到就不再向上

         如果整个原型链上都没有，才返回undefind

31.解决浏览器兼容问题: 2步:

      如果类型.prototype.方法===undefined

         类型.prototype.方法=function(...){

            this->自动获得将来调用该方法的当前对象

         }

32.判断自有还是共有:

      自有: var bool=obj.hasOwnProperty("属性名")

          判断obj中是否包含自有属性"属性名"

33.对象原型：

判断一个对象是不是数组类型,有几种方法: 4种

typeof只能区分基础类型和function无法进一步区分对象的类型

a)如果obj的原型是Array.prototype说明是数组

     obj.__proto__==Array.prototype

_proto__是内部属性，可能不允许使用

var a=Object.getPrototypeOf(obj) 获得obj的原型对象

var bool=father.isPrototypeOf(child)

   判断father是否是child的父级对象

   不但检查直接父对象，且检查整个原型链！

b)判断构造函数:

obj.constructor==Array

还可以用: obj instanceof Array

c)检查对象的class属性

调用Object.prototype.toString();->"[object Class]"

d)Array.isArray(obj);

34.自定义继承关系:

修改单个对象的继承关系

obj.__proto__=father;

批量修改多个对象的继承关系

obj.prototype=father

内部属性: Object.setPrototypeOf(child,father);

    设置child继承father

两种类型间的继承: 最像Java的继承

      何时: 只要两种类型间包含相同的属性结构定义或相同的方法。

      如何: 3步:

         1. 抽象出一个父类型

             共同的属性定义，集中到父类型的构造函数中

             共同的方法，集中到父类型的原型对象中

         2. 在子类型构造函数中借用父类型构造函数

              不能直接调用: this->window

             应该用call，将this替换为当前正在创建的新对象

               父类型构造.call(this,参数...)

         3. 让子类型原型对象继承父类型原型对象

35.对对象的属性提供保护

 数据属性

默认属性为true

新添加的属性是false

value: 实际存储属性值,

writable: true/false, //是否可修改

enumerable: true/false,//是否可for in遍历

configurable: true/false,

    //1. 是否可修改前两个特性

    //2. 是否可删除当前属性

    //一旦改为false，不可逆！

特殊: 如果要定义的属性不存在:

                           defineProperty会自动添加:

                               自动添加后，属性的特性值都为false

                        问题:
只能提供基本(只读,遍历,删除)保护

                                无法按照自定义规则保护属性

 访问器属性：

get:function(){return 受保护的属性值},

     set:function(val){

     验证要赋的新值val

     验证通过才将val保存到受保护的属性中

     },

     enumerable:true/false,

     configurable:true/false,

 当通过访问器属性获取受保护的属性值时

     自动调用get方法

     当通过访问器属性为受保护的属性赋值时

     自动调用set方法

     参数val,自动获得要赋的新值

     大问题: 受保护的属性值应该保存在哪儿?

         才能做到被人不能直接用，只能通过访问器属性访问

      解决: 闭包！

36.防篡改: 禁止修改对象的属性结构

1. 防扩展:
禁止向对象中添加新属性

         Object.preventExtensions(obj)

2. 密封:
即防扩展，又禁止删除旧属性

         Object.seal(obj)

            其实是将所有属性的configurable设置为false

3. 冻结:
即密封，又禁止修改所有属性值！

          何时:
如果一个对象中保存了大量不变的属性值时

             Object.freeze(obj);

             其实是将所有属性的writable设置为false！

37.Object.create():

   var newObj=Object.create(father,{扩展的新属性})

    创建一个新对象newObj，继承father，并为newObj扩展新的自有属性

   何时: 只要继承一个现有对象，创建一个新的子对象时

   相当于: var newObj={};

               newObj.__proto__=father;

               Object.defineProperties(newObj,{

 扩展的新属性

               })

38.1. 判断:
数组中的元素是否符合要求

      1. 所有元素是否都符合要求

          var bool=

arr.every(function(val,i,arr){ return 判断条件
})              

      2. 是否包含符合要求的元素

          var bool=

           arr.some(function(val,i,arr){ return 判断条件
})

   2. 遍历API:
依次对数组中每个元素执行相同的操作

      1. 对原数组中每个元素执行相同的操作，结果保存回原数组

        arr.forEach(function(val,i,arr){  arr[i]=新值;  });

      2. 取出原数组中每个元素的值，执行相同的操作后，保存到一个新数组中

        var newArr=arr.map(function(val,i,arr){  

            return 操作后的元素值

        });

   3. 过滤和汇总:

       过滤: 选择原数组中符合条件的元素，组成新数组

       var subArr=arr.filter(function(val,i,arr){

          return 判断条件;

       });

 

       汇总: 将原数组中每个元素统计出一个汇总结果

         var r=arr.reduce(function(prev,val,i,arr){

             return prev+val;

         },0);

         其中: 0:
表示初始值

                  prev: 截止到目前的阶段汇总值

                  回调函数的返回值，自动作为下次的prev值