前端开发js基础知识总结

阿里前端开发规范
web前端开发规范
前端开发规范 github

Javascript 变量

1.命名

    **1.1方法**
             匈牙利命名法 (变量名 = 类型 + 对象描述)
                   Int整型       i
                   Float浮点     fl
                   Boolean布尔   b
                   String字符串   s
                   Array数组      a
                  Object对象     o
                  Function函数    fn
                  Regular Expresion 正则  re
           驼峰命名法
                  全部小写   单词与单词间用下划线分割
                  大小写混合 大驼峰  每个单词首字母大写
                                    小驼峰  第一个单词首字母小写,其他首字母大写

   ** 1.2规则**
              首字符     英文字母或者下划线
              组成        英文字母/数字/下划线
              禁忌        javascript关键字与保留字

2.声明

         ** 2.1显示声明**  
                     var 变量名
        ** 2.2 陋习**
                      没有类型
                      重复声明
                      隐式声明
                      不声明直接复制
        ** 2.3 正解**
                       先声明 后读写
                      先赋值 后运算

3.变量类型
3.1 值类型
占用空间固定 保存在栈中
保存与赋值的是值本身
使用typeof监测数据的类型
基本类型数据是值类型
3.2 引用类型
占用空间不固定,保存在堆中
保存于复制的是指向对象的一个指针
使用instanceof检测数据的类型
使用new()方法构造出的对象是引用型

          [js中typeof与instanceof的区别](//notes.php?mod=view&u=18271&id=fe447035b1db2c209cd284d264c1bec3)

4.作用域
4.1全局变量
包含
在函数体外定义的变量
在函数体内定义的无var的变量
调用
任何位置
4.2局部变量
包含
在函数内部使用var声明的变量
函数的参数变量
调用
当前函数体内部
4.3优先级
局部变量高于同名全局变量
参数变量高于同名全局变量
局部变量高于同名参数变量
4.4 特性
忽略块级作用域
全局变量是全局对象的属性
局部变量是调用对象的属性
作用域链
内层函数可访问外层函数局部变量
外层函数不能访问内层函数局部变量
生命周期
全局变量
除非被显示删除,否则一直存在
局部变量
自声明起至函数运行完毕或被显示删除
回收机制
标记清除
引用计数

Javascript 运算符

1.算术运算符
1.1运算符

  • 功能 对数字进行代数求和
    对字符串进行连接操作
    将一个数值转换成字符串 (数值+空字符串)
    字符串拼接
    字符串 + 字符串 二者直接拼接
    字符串 + 数值 数值转为字符串再拼接

    • 功能 对操作数进行“取反”操作
      对数字进行减法操作
      将字符串转换为数值 数值型字符串 —0

      • 功能 对两个运算数进行乘法运算
        符号问题 同号的正 异号得负
        / 功能 对两个运算数进行除法运算
        符号问题 同号的正 异号得负
        % 功能 返回两个除数的余数
        符号问题 和第一个运算数的符号相同1.2 符合赋值运算符
        += -= /= %=

2.自增与自减
2.1 功能相反
++ 对唯一的运算数进行递增操作(每次加一)
— 对唯一的运算数进行递减操作(每次减一)
2.2规则相同
运算数必须是一个变量 数组的一个元素 或者对象的属性
如果运算数是非数值的运算符会将它转成数值
2.3 符号位置决定运算结果
运算数之前 先进行递增(递减)操作,在进行求职
运算数之后 先求值,在进行递增(递减)操作

3.关系运算符
3.1 大小关系检测
运算符
< 如果A< B则返回值为true 否则返回值为false
<= 如果A小于等于B 则返回值为true 否则返回值为false
>= 如果A大于等于B 则返回值为true 否则返回值为false
> 如果A大于B 则返回值为true 否则返回值为false
操作规则
数值与数值的比较 比较他们的代数值
仅一个运算数是数值 将另一个运算数转换成数值,并比较他们的代数值
字符串间的比较 逐字符比较他们的unicode数值
字符串与非数值的比较 将运算数转换成字符串并进行比较
运算数即非数字也非字符串 转换为数字或字符串后进行比较
运算数无法被转换成数值或字符串 返回值为false
与NaN的比较 返回值为false
3.2 等值关系检测
相等比较
操作符
== 比较两个运算数的返回值是否相等
!= 比较两个运算数的返回值是否不相等
类型转换
布尔值
true 1
false 0
对象 调用valueOf() 基本类型
字符串与数值的比较 字符串转换为数值
比较原则
null 与 undefined
相等
比较前不进行任何转换
NaN 与任何数值都不相等包括其本身
对象 是否属于同一对象
是 ==
否 !=
相同比较
运算符
=== 比较两个运算数的返回值及数据类型看是否相等
!== 比较两个运算数的返回值及数据类型看是否不同
比较原则
值类型间比较 只有数据类型相同,且数值相等时才能够相同
值类型与引用类型比较 肯定不相同
引用类型间比较 比较他们的引用值(内存地址)

4.对象运算符

 in                         判断左侧运算数是否为右侧运算数的成员
 instancesof         判断对象实例是否属于某个类或构造函数 
 new                     根据构造函数创建一个新的对象,并初始化该对象
 delete                 删除指定对象的属性,数组元素或变量
 .及[]                    存取对象和数组元素
  ()                       函数调用,改变运算符优先级等

5.逻辑运算符
5.1! 逻辑非
返回值
true
空字符串
0
null
NaN
Undefined
False
对象
非空字符串
非0数值(Infinity)
特性
如果运算数的值为false则返回true,否则返回false
连续使用两次!,可将任意类型转为布尔型值

   5.2 &&逻辑与
           规则
                 第一个操作数是对象   返回第二个操作数
                第二个操作数是对象   第一个操作数值为true 时返回该对象
                两个操作数都是对象   返回第二个操作数
                  一个操作数是null      返回null
                 一个操作数是NaN      返回NaN
                一个操作数是undefined  返回undefined
           特性
                 当且仅当两个运算数的值都是true时,才返回true,否则返回false
                 短路操作  当第一个操作数的值为false则不在对第二个操作数进行求值

   5.3 || 逻辑或
          规则
                 第一个操作数是对象  返回第一个操作数
                 第一个操作数值为false 返回第二个操作数
                 两个操作数都是对象  返回第一个操作数
                 两个操作数都是null  返回null
                 两个操作数都是NaN  放回NaN
                 两个操作数是undefined  返回undefined
          特性
                 当且仅当两个运算数的值都是false时,才返回false,否则返回true
                 如果第一个操作数值为true,则不会对第二个操作数进行求值

6.位运算符
6.1基础知识
类型
有符号
数值位 前31位
符号位 第32位 0(正数) 1(负数)
无符号
只能是正数
第32位表示数值
数值范围可以加大
数值范围
-2147483648 ~ 2147483647
存储方式
正数
纯2进制存储
31位中每一位表示2的幂
用0补充无用位
负数
2进制补码存储
补码的计算步骤
确定该数字的非负版本的二进制表示 求得二进制反码,即要把0替换为1,把1替换为0
在二进制反码上加1
当作0来处理的特殊值
NaN
Infinity
6.2逻辑位运算
返回值为1
按位非 ~ 0
按位与 & 对应位全为1
按位或 | 任何一位是1
按位异或^ 即不同时为0,也不同时为1
返回值为0
按位非 ~ 1
按位与 & 任何一位是0
按位或 | 对应位全0
按位异或^ 对应位全0或全1
6.3位移操作
左移 <<
将数值的所有位左移指定的位数
所有空位用0补充
左移1位对其乘2,左移2位对其乘4,以此类推
有符号右移 >>
将数值的所有位右移指定的位数
移出的位被舍弃
保留符号位
右移1位对其除2,右移2位对其除4,以此类推
无符号右移 >>>
正数 与有符号右移
6.4 复合赋值运算符
位操作符与符号结合,复合赋值不会有性能方面的提升
7.其他运算符
7.1 ?: 条件运算符,简洁的if else
7.2 typeof 类型判定运算符
7.3 , 逗号,在一行语句中执行多个不同的操作
7.4 void 舍弃运算数的值,返回undefined作为表达式的值

Javascript 数组

      **1.创建方法**
             1.1 空数组  var obj=new Array();
             1.2 指定长度数组  var obj=new Array(size);
             1.3 指定元素数组  var obj=new Array(元素1,元素2,...,元素n);
             1.4 单维数组 var obj=[元素1,元素2,元素3,...,元素n];
             1.5 多维数组 var a=new Array([数组序列1],[数组序列2],[数组序列N]);
    ** 2.基本操作**
             2.1 存取数组元素
                         单维数组   数组名[下标索引];
                        多维数组   数组名[外层数组下标][内层元素下标]
                        特性
                               数组长度是弹性的,可自由伸缩
                              数组下标从0开始
                              下标类型 
                                        数值
                                        非数值
                                               转为字符串
                                               生成关联数组
                                              下标将作为对象属性的名字
                                        数组元素可添加到对象中
              2.2 增加数组  使用”[]”运算符指定一个新下标
              2.3 删除数组  delete数组名[下标]
              2.4 遍历数组  for (var 数组元素变量 in 数组)
     **3.数组属性**
              3.1 constructor 引用数组对象的构造函数
              3.2 length 返回数组的长度
              3.3 prototype 通过增加属性和方法扩展数组定义
     **4.ECMAScript 3方法**
               4.1 添加
                       1.push() 在数组末尾添加数组
                       2.unshift () 在数组头部添加元素
                       3.concat() 合并两个数组
               4.2  删除
                       1.pop() 删除并返回数组的最后一个元素
                       2.shift() 删除并返回数组的第一个元素
               4.3 子数组
                        1.splice()
                                删除任意数量的项
                                       1.要删除的起始下标
                                       2.要删除的项数
                                在指定位置插入指定的项
                                        1.起始下标
                                        2.0(不删除任何项)
                                        3.要插入的项
                                替换任意数量的项
                                        1.起始下标
                                        2.要删除的项数
                                        3.要插入的项
                          2.slice()
                                    功能  从已有数组中选取部分元素构成新数组
                                    参数
                                               返回项的起始位置
                                               结束项的起始位置
                                    特性
                                              如果是负数,则用数组长度加上该值确定位置
                                              起始位置实为数组的实际下标
                                              结束位置的实际下标为结束数值减1
              4.4 数组排序
                         reverse() 颠倒数组中元素的顺序
                         sort()  
                                 功能   对字符数组或数字数组进行排序
                                 特性
                                          默认按字符串比较
                                          按数值大小比较需函数支持(升序)
             4.5 数组转换
                            toString() 转换为字符串并返回
                            toLocaleString() 转换为本地格式字符串并返回
                            join()  用指定分隔符分割数组并转换为字符串

     **5.ECMAScript 5方法**
               5.1 位置方法
                           IndexOf 从数组的起始位置开始查找
                           lastIndexOf 从数组的结束位置开始查找
                          (参数 1.要查找的项 2.表示查找起点的位置索引)

                5.2 迭代方法
                         every 如果该函数对每一项都返回true,则返回true
                         filter 返回值为true的所有数组成员
                         forEach 无返回值
                         map 返回每次函数调用的结果数组
                         some 有任意一项返回true,则返回true 
                         (参数)
                                  接收参数
                                            要在每一项上运行的函数
                                           运行该函数的作用域对象
                                 传入参数
                                           数组项的值item
                                           该项在数组中的位置index
                                           数组对象本身array

                    5.3 缩小方法
                              reduce 数组起始位开始遍历
                              reduceRight 从数组末尾开始遍历
                            (参数)
                                     接收参数
                                            每一项上调用的函数
                                            作为缩小基础的初始值
                                     传入参数
                                            前一个prev
                                           当前值 cur
                                           项的索引 index
                                           数组对象 array    

Javascript 流程语句

   1.循环语句
          while
                   语法   while(条件表达式){循环执行代码段}
                   流程  
                            判断条件表达式的值
                            当值为true时,循环执行代码段
                            当值为false时,推出循环体
                  特性
                            先检查条件,在执行循环
                            条件不满足,循环一次也不执行
                  时机    一个动作被重复执行到满足某个条件时
         do-while
                  语法    do{循环执行代码段}while(条件表达式);
                  流程  
                             先执行循环体内代码,在判断
                             当值为true时,循环执行代码段
                             当值为false时,推出循环体
                  特性
                             先执行循环,在进行条件判断
                             循环体内代码至少执行一次
                  时机    希望一个动作至少被执行一次时
          for 
                  语法     for(循环变量=初值;循环条件;递增/递减){循环代码段}
                  流程
                               用循环变量初始值与循环体哦阿健相比较,确定返回值
                               如果返回值为true则执行循环体
                               执行完一次后进行递增/递减运算
                               将运算结果与循环条件相比较
                               如果返回值为true,则继续执行循环体
                               如果返回值为false,则退出循环体
                  时机        重复一个动作到一定次数时
          for-in 
                  语法      for(声明变量 in 对象){代码段}
                  作用      枚举对象属性
                  注意事项
                         循环输出的属性顺序不可预知
                         对象的值不能使null或undefined
   2.跳转语句
           return         终止函数体的运行,并返回一个值
           break         终止整个循环,不再进行判断
           continue    结束本次循环,接着去判断是否执行下次循环
   3.选择语句
          if 
              句法
                      if(条件表达式1){代码段1}else if(条件表达式2){代码段2}else{代码段3}
              流程
                      判断条件1,如果返回值为true则执行代码段1
                      如果条件1的返回值为false则跳过语句话1并检测条件2
                      如果所有表达式的值均为false则执行else后面的语句
             特性
                      结构复杂,可嵌套
                      可测试多个条件表达式
                      表达式的值具有线性特征
                      表达式的值是动态的
                      适用于任意类型的数据
                      可处理复杂的逻辑关系
        switch
                语法
                         switch(条件表达式){case 标签1: 代码段1; ......default:代码段n;}
                流程
                         计算表达式的值,并与各标签相比较
                         若找到与之匹配的标签,则执行其后的代码段
                         若没有找到与之匹配的标签则直接执行default之后的代码段
                格式
                         case 标签为常量,,可以是字符串或数字
                         每个标签均为冒号:结束
                         虽然break与default为可选项,但为了逻辑清晰最好不要省略
                         case 标签的值必须和条件表达式的值完全匹配
                特性
                         结构简洁,转为多重选择设计
                         仅可测试一条条件表达式
                         表达式的值具有离散性
                         表达式的值是固定的,不会动态变化的
                        仅能应用整数,枚举,字符串等类型数据
                        仅能处理多个枚举型逻辑关系
   4.异常处理语句
              throw      主动抛出异常
              try       指明需要处理的代码段
              catch     捕获异常
              finally   后期处理

Javascript 字符串函数

   1.查找方法
          字符方法
                 charAt() 
                       功能   返回字符串中第n个字符
                       参数   超出范围 返回空字符串
                       返回值   string 中第n个字符的实际值
                 charCodeAt()
                       功能   返回字符串中第n个字符的代码
                       参数   超出范围 返回NaN
                       返回值  
                              内容    string 中第n个字符的Unicode编码
                              范围    0~65535 之间的16位整数
                 fromCharCode()
                              功能     根据字符编码创建字符串
                              参数     0个或多个整数,代表字符的Unicode编码
                             返回值   由指定编码字符组成的新字符串
                             特性      静态方法,实为构造函数String()的属性
                 charAt()与charCodeAt()与fromCharCode()的关系
                             charAt与charCodeAt共性
                                       功能  根据下标查找指定字符
                                       参数  
                                            n      要查询的字符下标
                                            有效范围  0~length-1之间
                            charCodeAt与fromCharCode
                                       互为反向操作
          位置方法
                 indexOf()      从前向后检索字符串,看其是否含有指定字符串
                 lastIndexOf()  从后向前检索字符串,看其是否含有指定字符串
                 indexOf()与lastIndexOf()的共性
                          功能    根据指定字符串查找下标位置
                          参数 
                                 必选  将要查询的子字符串
                                 可选  开始查找的位置下标
                                          值为负数,视作0
                                          省略 从默认起始位开始查找
                                          超出0~length-1  返回-1
                                 返回值
                                          找到  子串首次出现的下标
                                         未找到  返回-1
          匹配方法
                 match()
                        功能  找到一个或多个正则表达式的匹配
                        参数  
                                 要进行模式匹配的正则表达式
                                 非正则表达式  将其传递给RegExp()构造函数,并转换为正则表达式对象
                        返回值  存放匹配结果的数组
                                   有全局标记g  执行全局检索
                                           找到
                                                  返回数组
                                                          内容  所有匹配的子串
                                                          缺陷  
                                                                   没有派生属性
                                                                   不提供与子表达式匹配的文本信息
                                                                   不声明每个匹配子串的位置
                                                            弥补 
                                                                   使用RegExp.exec()方法
                                             没找到    返回Null
                                      无全局标记g  执行一次匹配
                                              找到
                                                     返回数组
                                                             内容
                                                                     第0个元素  匹配文本
                                                                     其他元素  与正则子表达式匹配的文本
                                                             属性
                                                                      input        调用该方法的字符串对象
                                                                      Index   匹配文本的起始字符在字符串中的位置
                                                                      lastIndex  匹配文本的末尾字符在字符串中的位置
                                               没找到  返回Null
             search()
                     功能  检索字符串中与正则表达式匹配的子串
                     参数 与match相同
                     返回值 
                           找到  字符串中第一个与正则表达式相匹配的子串的起始位置
                          未找到   返回-1
                      特性  忽略全局标记g和lastIndex()属性
            replace()
                     功能  替换一个与正则表达式匹配的子串
                     参数
                             参数1  需要进行替换正则表达式对象或字符串
                             参数2   替换文本或替换函数
                      特性
                             如果参数1仅为字符串则只进行一次匹配替换,若替代所有子串则必须指定全局标记g
                             如果参数2仅为字符串则可使用特殊字符序列
                                    $$    $
                                    $&    匹配整个模式的子字符串
                                    $’     匹配的子字符串之前的子字符串
                                    $’     匹配的子字符串之后的子字符串
                                    $n    匹配第n个捕获组的字字符串  n=0-9
                                    $nn  匹配第nn个捕获组的子字符串 nn=01-99
            split()
                    功能    根据指定分隔符将字符串分割成多个子串,并返回成数组
                    参数
                            必选   指定的分隔符
                            可选   指定数组的长度
   2.操作方法
             拼接方法
                    concat()
                             语法 string.concat(value,...)
                             功能  连接字符串
                             参数  要连接到string上的一个或多个值
                             返回值 把所有参数都连接到字符串string上得到新的字符串
                             特性  功能与“+”相同,原始字符串的实际值并未被真正修改
             截取方法
                    根据下标截取子串
                            slice()  负值传参  与字符长度相加
                            substring()  负值参数  转换为0
                            slice()与substring()共性
                                       参数2的子字符串最后一个字符后面的下标
                     根据长度截取子串
                              substr()
                                      参数2  返回的字符个数
                                      负值传参 
                                               参数1  与字符串长度相加
                                               参数2  转换为0
             空格处理
                    trim     消除前置及后缀空格
                    trimLeft  消除前置空格
                    trimRight 消除后缀空格
             比较方法
                   localCompare()
                          功能  用本地特定顺序比较两个字符串
                          参数  与原字符串进行比较的字符串
                          返回值 
                                 说明比较结果的数字
                                         负数  原字符串 <  参数字符串
                                           0     原字符串 = 参数字符串
                                         正数  原字符串 > 参数字符串
   3.编码方法
             字符串常规编码与解码
                      escape()
                      unescape()
             URI字符串编码与解码
                        encodeURI()
                        decodeURI()
             URI组件编码与解码
                        encodeURIComponent()
                        decodeURIComponent()
   4.转换方法
              大小写转换
                     转为大写
                            toUpperCase()
                            toLocaleUpperCase()  本地
                     转为小写
                             toLowerCase()
                             toLocaleLowerCase()  本地
                     代码转换
                            用js动态格式化html,不具语义性,舍弃

Javascript函数基础

  **1.定义方法**
             静态方法
                     function 函数名([虚参列表]){
                                 函数体;
                                [return [函数返回值;]]
                      }
             动态匿名方法
                      var 函数名 = new Function([“虚参列表”],”函数体”);
             直接量方法
                     函数名 = function([虚参列表]){函数体;}
  **2.调用方法**
             直接调用
                      函数名(实参列表)
            在链接中调用
                     <a href=”javascript:函数名()”>描文字</a>
            在事件中调用
                     事件类型 = “函数名()”
           递归调用
                  定义
                         在函数体内部调用函数自身
                 格式
                        function 函数名(){
                                  代码
                                  函数名();
                         }
  **3.方法**
             apply
                   将函数作为对象的方法来调用
                   将参数以数组形式传递给该方法
             call
                    将函数作为对象的方法来调用
                    将指定参数传递给该方法
             toString 
                     返回函数的字符串表示
  **4.Arguments对象**
             功能 存放实参的参数列表
             特性 
                     仅能在函数体内使用
                     带有下标属性,但并非数组
                     函数声明时自动初始化
             属性
                     Length  获取函数实参的长度
                    Callee   返回当前正在指向的函数
                    Caler    返回调用当前正在执行的函数的函数名
  **5.函数参数**
            参数类型
                   形参
                          定义函数时使用的参数
                          接收调用该函数时传递的参数
                   实参
                          调用函数时传递给函数的实际参数
            特性
                   参数个数没有限制
                           实参 < 形参  多余形参 = undefined
                           实参 > 形参  多余实参被忽略
                  参数的数据类型没有限制
                  通 过arguments对象访问参数数组
                  参数始终按值传递
                         基本类型  传值
                         应用类型  传址
  **6.指针标识**
              this  指向当前操作对象
              callee  指向参数集合所属函数
              prototype  指向函数附带的原型对象
              constructor 指向创建该对象的构造函数

Javascript DOM 基本操作

     获取节点
            Document
                     getElementById
                  语法document.getElementById(元素ID)
                  功能通过元素id获取节点
             getElementsByName
                 语法document.getElementsByName(元素name属性)
                 功能 通过元素的name属性获取节点
             getElementsByTagName
                 语法 document.getElementsByTagName(元素标签)
                功能 通过元素标签获取节点
            节点指针
                    firstChild
                语法 父节点.firstChild
                功能 获取元素的首个子节点
           lastChild
                语法 父节点.lastChild
                功能 获取元素的最后一个子节点
           childNodes
               语法 父节点.childNodes
               功能 获取元素的子节点列表
           previousSibling
               语法 兄弟节点.previousSibling
               功能 获取已知节点的前一个节点
           nextSiblings
               语法 兄弟节点.nextSibling
               功能 获取已知节点的后一个节点
           parentNode
               语法 子节点.parentNode
               功能 获取已知节点的父节点

      节点操作
             创建节点
                    createElement
                    语法document.createElement(元素标签)
                    功能 创建元素节点
            createAttribute
                   语法 document.createAttribute(元素属性)
                   功能 创建属性节点
           createTextNode
                   语法document.createTextNode(文本内容)
                   功能 创建文本节点
             插入节点
                    appendChild
                   语法appendChild(所添加的新节点)
                               功能 向节点的子节点列表的末尾添加新的子节点
            insertBefore
                   语法insertBefore(所要添加的新节点,已知子节点)
                               功能 在已知的子节点前插入一个新的子节点
             替换节点
                    replaceChild
                    语法 replaceChild(要插入的新元素,将被替换的老元素)
                    功能 将某个子节点替换为另一个
             复制节点
                    cloneNode
                语法 需要被复制的节点.cloneNode(true/false)
                功能 创建指定节点的副本
                参数
                     true 复制当前节点及其所有子节点
                     false 仅复制当前节点
             删除节点
                    removeChild
                 语法 removeChild(要删除的节点)
                 功能 删除指定的节点

   属性操作
          获取属性
                  getAttribute
                 语法   元素节点.getAttribute(元素属性名)
                 功能   获取元素节点中指定属性的属性值
          设置属性
                 setAttribute
                           语法  元素节点.setAttribute(属性名,属性值)
                           功能  创建或改变元素节点的属性
          删除属性
               removeAttribute
                           语法   元素节点.removeAttribute(属性名)
                           功能   删除元素中的指定属性  
   文本操作
              insertData(offset,string)  从offset指定的位置插入string
              appendData(string)  将string插入到文本节点的末尾处
              deleteData(offset,count)  从offset起删除count个字符
              replaceData(off,count,string)  从off将count个字符用string替代
              splitData(offset)  从offset起将文本节点分成两个节点
              substring(offset,count)  返回由offset起的count个节点

Javascript 正则表达式

     1.创建
               方式
                       字面量  var 变量名=/表达式/模式修饰符
                       构造函数  var 变量名=new RegExp(“表达式”,”模式修饰符”)
               说明
                       表达式
                              单个字符与数字
                                        .   匹配除换行符之外的任意字符
                                     [a-z0-9]   匹配方括号中的任意字符
                                     [^a-z0-9] 匹配不在方括号中的任意字符
                                         \d 匹配数字
                                         \D       匹配非数字
                                        \w        匹配字母
                                       \W        匹配非字母
                             空白字符
                                        \0  匹配null字符
                                       \b  匹配空格字符
                                       \f   匹配进纸符
                                       \n  匹配换行符
                                       \r   匹配回车符
                                       \s   匹配空白字符/空格/制表符或换行符
                                       \S   匹配非空白字符
                                       \t   匹配制表符
                            定位符
                                       ^    行首匹配
                                      $ 行尾匹配
                                     \A 只匹配字符串的开始处
                                     \b 匹配单词边界,词在[]内无效
                                    \B  匹配非单词边界
                                     \G 匹配当前搜索的开始位置
                                     \Z 匹配字符串结束处或行尾
                                     \z 只匹配字符串结束处
                            限定符
                                     x? 匹配0个或一个x
                                     x* 匹配0个或任意多个x
                                    x+  匹配至少一个
                                  x{m,n}    匹配最少m个,最多n个x
                           分组
                                   (?:x)  匹配x但不记录匹配结果
                                 x(?=y)  当x后接y时匹配x
                                  x(?!y)    当x后不是y时匹配x
                           引用
                                   \1...\9  $1...$9  返回九个在模式匹配期间找到的最近保存的部分
                           或模式
                                   x|y|z 匹配x或y或z
                       模式修饰符
                              g 全局模式,应用于所有字符串
                              i 区分大小写模式
                             m  多行匹配模式
     2.属性
           实例属性
                  global  检测是否设置g标记
                  ignoreCase  检测是否设置i标记
                  multiline  检测是否设置了m标记
                  lastIndex  开始检索下一个匹配项的字符位置
                  source  返回正则表达式的字符串表示
                  lastIndex   返回被查找字符串中下一次成功匹配的开始位置
           构造函数属性
                   $_   input   返回最近一次匹配的字符串
                  $&    lastMatch   返回最近一次的匹配项
                  $+    lastParen       返回最近一次匹配的捕获组
                  $’    leftContext 返回被查找的字符串中从字符串开始位置到最后匹配之前的位置之间的字符
                  $’    rightContext    返回被搜索的字符串中从最后一个匹配位置开始到字符串结尾之间的字符
                  $*    multiline       检测表达式是否采用多行模式匹配m
     3.方法
                实例方法
                       exec
                              功能    在字符串中执行匹配检索,返回结果数组
                              参数    要应用模式匹配的字符串
                              特性    
                                     使用全局标记g  持续查找所有匹配项并返回
                                     不使用全局标记g  始终返回第一个匹配项信息
                               执行过程
                                       检索字符串参数,获取正则表达式匹配文本
                                       找到匹配文本则返回一个数组
                                              第0个元素  与整个模式匹配的字符串
                                              其他元素    与捕获匹配的字符串
                                       否则返回null
                               派生属性
                                        index   匹配项在字符串中的位置
                                        input   应用正则表达式的字符串
                                        length 返回数组元素个数
                      test  
                             功能  在字符串中测试模式匹配,返回true或false
                字符串方法
                       match    找到一个或多个正则表达式的匹配
                       replace  替换与正则表达式匹配的子串
                       search   检索与正则表达式相匹配的值
                       split        把字符串分割为字符串数组

Javascript本地对象和内置对象
Array
Array 对象属性
constructor 返回对创建此对象的数组函数的引用
length 设置或返回数组中元素的数目
prototype 使您有能力向对象添加属性和方法
Array对象方法
concat() 连接两个或更多的数组,并返回结果
join() 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔
pop() 删除并返回数组的最后一个元素
shift() 删除并返回数组中的第一个元素
push() 向数组的末尾添加一个或更多元素,并返回新的长度
unshift() 向数组的开头添加一个或更多元素,并返回新的长度
reverse() 颠倒数组中元素的顺序
slice() 从某个已有的数组返回选定的元素
sort() 对数组的元素进行排序
splice() 删除元素,并向数组添加新元素
toSource() 返回该对象的源代码
toString() 把数组转换为字符串,并返回结果
toLocaleString() 把数组转换为本地数组,并返回结果
valueOf() 返回对象的原始值
Boolean
Boolean 对象属性
constructor返回对创建此对象的 Boolean 函数的引用
prototype使您有能力向对象添加属性和方法。
Boolean 对象方法
toSource() 返回该对象的源代码
toString() 把逻辑值转换为字符串,并返回结果。
valueOf() 返回Boolean对象的原始值
Date

Math
Number
String
RegExp
Global
Browser对象
Window
Navigator
Screen
History
Location

关于前端开发的字体规范
前端开发编码规范
» 本文来自:前端开发者 » 《前端开发js基础知识总结》
» 本文链接地址:https://www.rokub.com/6334.html
» 您也可以订阅本站:https://www.rokub.com
赞(0)
64K

评论 抢沙发

评论前必须登录!