精华内容
下载资源
问答
  • Web前端知识点总结.doc

    2019-10-04 10:04:13
    Web前端知识点总结
  • web前端知识点总结

    2021-03-23 08:16:55
    出现相应头部结构 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l8ScSYqF-1616458490628)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\1614654069426.png)] 此进行预览 ...

    一、Axure

    下载元件库网址 https://www.axure.com.cn/5216/

    二、vscode

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yGOUFkJO-1616458490622)(file:///C:\Users\asus\Documents\Tencent Files\1264657821\Image\Group2\A6\NS\A6NSAXZHIH7N]NOIB21UN$L.png)]

    html:5 或者!出现相应头部结构

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l8ScSYqF-1616458490628)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\1614654069426.png)]

    点此进行预览

    三、html(结构)

    超文本标记语言,是一种用于创建网页的标准标记语言

    1、基本语法

    三、 HTML基本语法

    注释 <!--------------!>

    常规标记(双标记) (标签 标记 元素)

    <标签 属性=“属性值” 属性=“属性值 属性值”></标签>

    空标记(单标记)

    <标签 属性=“属性值” 属性=“属性值”/>

    说明:

    1.写在<>中的第一个单词叫做标记,标签,元素。

    2.标记和属性用空格隔开,属性和属性值用等号连接,属性值必须放在“”内。

    3.一个标记可以没有属性也可以有多个属性,属性和属性之间不分先后顺序。

    4.空标记没有结束标签,但是必须关闭,用“/”代替。

    5.一个属性可以有多个属性值,多个属性值之间用空格隔开,不分先后顺序。

    代码解释


    //换行


    // 下划线

    class(.) id(#) //标签
    border-radius:50% // 圆角效果
    calss=“div1 div2” //属性值与属性值之间用空格隔开
    //倾斜 行内元素
    //加粗 行内元素 (行内元素即不能换行)
    //不能设置宽高,由字体大小长度决定 只能左右margin和padding ,行内元素
    display :inline 默认。此元素会被显示为内联元素,元素前后没有换行符。

    target="_blank" //在新窗口打开 _self //当前窗口打开

    2、超链接的应用

    语法:

      链接文本/图片

    属性:target 页面打开方式 //a是行内元素
    属性值:_blank 新窗口打开 ; _self 当前窗口打开

    新页面打开
    链接 空链接

    拓展:

    定义书签:第一处
    我在这_
    邮箱跳转:1342802646@qq.com
    文件下载:最好是压缩包; 下载飞秋

    3、图片

    图片替换文本 alt 图片没了用文本替换 title鼠标悬停 绝对路径 相对路径

    当前文件所处的文件夹与目标文件在同一目录下 (…/目标文件文件名+扩展名)

    当前文件与目标文件所处的文件夹在同一目录下 (文件夹名/目标文件全称+扩展名)

    插入图片

    图片替换文本

    注:所要插入的的图片必须放在站点下

    路径:绝对路径、相对路径;

    绝对路径:不需要参照物,放哪里都能找到,可以跨盘符(本地的图片不可跨电脑);—本地,网络
    相对路径:当前文件为参照物,从当前文件出发去寻找目标文件,不可跨盘符;

    *相对路径的写法:

    1)当 当前文件与目标文件在同一目录下,直接书写 目标文件(文件名+扩展名);
    2)当 当前文件与目标文件所处的文件夹在同一目录下,写法如下:
    文件夹名/目标文件全称+扩展名;
    3)当 当前文件所处的文件夹和目标文件在同一目录下,写法如下:
    …/目标文件文件名+扩展名;
    …/…/ 出两层的情况

    title的作用: 在你鼠标悬停在该图片上时显示一个小提示,鼠标离开就没有了,
    HTML的绝大多数标签都支持title属性,title属性就是专门做提示信息的

    alt的作用:alt属性是在你的图片因为某种原因不能加载时在页面显示的提示信息,
    它会直接输出在原本加载图片的地方。

    width 图片宽度
    height 图片高度

    为了保证图片不发生变形,width和height最好只写一个;

    img是inline元素,但是他同时也是replace元素,他有着特殊的表现:

    \1. 可以设置width/height;
    \2. 默认的,img元素在屏幕占据的空间与其图片的实际像素一致,除非CSS有设置或者自身的width/height HTML 属性有设置
    \3. 如果img标签的包裹元素为也为inline元素,则img的边界可以超出其直接父元素的边界,直到自己的宽、高达到最大或者设定值为止,而且文档流中img的兄弟元素也不能遮盖住img。最常见的就是里面包含的
    \4. 所以从行为上看,img元素作为替换元素,有着类似于Inline-block的行为,尽管在SPEC里面,他的确是一个inline元素

    Eric Meyer曾经很详细的解释过替换元素的概念,请参考他的CSS权威指南

    4、表格

    无序列表ul 有序ol 自定义dl list-style: none;去掉前面的符号

    8)列表(ul,ol,dl)
    HTML中有三种列表,分别是:无序列表,有序列表,自定义列表
    *无序列表
    无序列表组成:

    • ......

    属性 type=“square(实心方块)/circle(空心圆)/disc(实心圆)”
    *有序列表
    有序列表组成:

    1. ......

    属性 type=“1/a/A/i/I” start=“数字”

    *自定义列表

    名词
    解释
    ......

    一个dl里面只能有一个dt,可以有多个dd;
    多应用于图文混排;

    1、无序列表ul

    属性type square(实心方块) disc(实心圆)

    • 花生
    • 花生
      • 袋装
      • 散装
    • 花生

    2、有序ol

    属性type=“1/a/A/i/I” start = “开始数字” ; start后面的值只为数字

    3、自定义dl

       <dt>名词</dt>  (一个<dl>只能有一个dt)
       <dd></dd>     (一个<dl>可以多个dd)
    
    代表行
    代表列
    cellspacing 单元格与单元格之间间距 
    cellpadding 单元格与文字之间距离
    

    algin 对齐方式

    bgcolor 背景颜色

    1280元 颜色设置为红色

    rowspan=“2” 合并行

    colspan=“2” 合并列

    表格的基本结构:

    :定义表格 定义表格中的表头内容 定义表格对的行
    ...
    定义表格对的列 .....

    属性:

    width: 宽度
    height: 高度
    bgcolor: 背景颜色
    border: 边框的宽度

    align: 表格内容水平方向调整
    left 左对齐内容
    right 右对齐内容
    center 居中对齐内容
    justify 对行进行伸展

    valign: 表格内容竖直方向调整
    top 对内容进行上对齐
    middle(默认) 对内容进行居中对齐
    bottom 对内容进行下对齐
    baseline 与基线对齐

    如果要实现跨行和跨列需要设置以下两个属性:
    colspan( x ) 跨x列
    rowspan( y ) 跨y行

    4、属性定义及使用说明

    padding 简写属性在一个声明中设置所有填充属性。该属性可以有1到4个值。

    实例:

    • padding:10px 5px 15px 20px;

      • 上填充是 10px
      • 右填充是 5px
      • 下填充是 15px
      • 左填充是 20px
    • padding:10px 5px 15px;

      • 上填充是 10px
      • 右填充和左填充是 5px
      • 下填充是 15px
    • padding:10px 5px;

      • 上填充和下填充是 10px
      • 右填充和左填充是 5px
    • padding:10px;

      • 所有四个填充都是 10px

    11) 数据表格的作用及组成
    作用:显示数据

    注:1个tr表示一行;一个td表示一列(一个单元格)
    *数据表格的相关属性

    1)width=“表格的宽度”
    2)height=“表格的高度”
    3)border=“表格的边框”
    4)bgcolor=“表格的背景色”
    5)cellspacing=“单元格与单元格之间的间距”
    6)cellpadding=“单元格与内容之间的间距”
    7)水平对齐方式:align=“left/center/right”;(写在td身上)

    5、表单

    //





    // password 密码*





    // radio 单选框

    学习
    骑车
    <input type=“checkbox” name=“hobby” id="hobby"checked/> 打球
    学习


    // checkbox复选框 checked默认选中 disabled默认选不了

    18岁以下 18-28岁 28-38岁 38岁以上

    //下拉列表 selected 被默认选中

    //文本框

    邮箱: //可以检验邮箱格式

    网址
    提交
    //可以检验网址格式

    最大数最小数

    //日


    //月


    //周


    //时间

    //搜索

    表单
    作用:收录用户信息
    form 表单框

    1)文本框

    2)密码框

    3)单选框/单选按钮

    女(默认选中)
    4)复选框/复选按钮
    游泳
    敲代码 (禁用)
    当属性值与属性名相同时,属性值可以省略不写
    5)按钮



    6)下拉菜单

    7)多行文本域

    此处为红色  //改变相应颜色

    6、html5拓展内容

    //定义一个页面或者区域头部

    //用在文档中插入图片

    //插入音频

    //controls 属性是一个布尔属性。如果属性存在,它指定音频控件的显示方式。
    音视频控件包括

    您的浏览器不支持 audio 元素。//插入音频 //插入视频 //内联标签

    一个画布在网页中是一个矩形框,通过 元素来绘制.

    注意: 默认情况下 元素没有边框和内容。

    简单实例如下:

    注意: 标签通常需要指定一个id属性 (脚本中经常引用), width 和 height 属性定义的画布的大小.

    **提示:**你可以在HTML页面中使用多个 元素.

    使用 style 属性来添加边框:

    首先,找到 元素:

    var c=document.getElementById(“myCanvas”);

    然后,创建 context 对象:

    var ctx=c.getContext(“2d”);

    getContext(“2d”) 对象是内建的 HTML5 对象,拥有多种绘制路径、矩形、圆形、字符以及添加图像的方法。

    下面的两行代码绘制一个红色的矩形:

    ctx.fillStyle="#FF0000";
    ctx.fillRect(0,0,150,75);

    设置fillStyle属性可以是CSS颜色,渐变,或图案。fillStyle 默认设置是#000000(黑色)。

    fillRect(x,y,width,height) 方法定义了矩形当前的填充方式。

    四、css(表现、层叠样式表)

    注释: 单行 /注释内容/

    实例化三属性:width height background

    1、文本的对齐方式

    文本排列属性是用来设置文本的水平对齐方式。

    文本可居中或对齐到左或右,两端对齐.

    当text-align设置为"justify",每一行被展开为宽度相等,左,右外边距是对齐(如杂志和报纸)。

    h1 {text-align:center;}

    p.date {text-align:right;}

    p.main {text-align:justify;}

    .align-center{
    margin:0 auto; /* 居中 这个是必须的,,其它的属性非必须 /
    width:500px; /
    给个宽度 顶到浏览器的两边就看不出居中效果了 /
    background:red; /
    背景色 /
    text-align:center; /
    文字等内容居中 */
    }

    实例化三属性: width height background

    样式表三种:内部、外部、内联 (优先级排序:内联>内部>外部) 后写的覆盖前面写的

    2、多重样式

    如果某些属性在不同的样式表中被同样的选择器定义,那么属性值将从更具体的样式表中被继承过来。

    例如,外部样式表拥有针对 h3 选择器的三个属性:

    h3 { color:red; text-align:left; font-size:8pt; }

    而内部样式表拥有针对 h3 选择器的两个属性:

    h3 { text-align:right; font-size:20pt; }

    假如拥有内部样式表的这个页面同时与外部样式表链接,那么 h3 得到的样式是:

    color:red; text-align:right; font-size:20pt;

    即颜色属性将被继承于外部样式表,而文字排列(text-alignment)和字体尺寸(font-size)会被内部样式表中的规则取代。

    3、选择符

    我是类型选择符
    我是id选择符
    我是class选择符
    我是class选择符
    //可以放两个class选择器

    *{

    font-style:italic; //通配符 控制所有选择器

    }

    #div1,#p1,#p2{

    height: 400px;

    width: 400px;

    background: darkblue;

    } //群组选择符

    你好

    .hello p{

    }

    .hello h1{

    } //包含选择符

    div.div1{

    } //指定选择符 (单独指定一个标签)

    a{background: darkgreen;}

    a:hover{ background: turquoise;

    } //伪类选择符(在原基础上进行变换)

    权重

    类型选择符权重:0001

    class : 0010

    id :0100

    内联样式权重 :1000

    伪类选择符权重:0010 加上***!important*** 变成最大的

    padding:0 4 个内边距

    padding:10px 5px 15px 20px;
    
    • 上内边距是 10px
    • 右内边距是 5px
    • 下内边距是 15px
    • 左内边距是 20px
    padding:10px 5px 15px;
    
    • 上内边距是 10px
    • 右内边距和左内边距是 5px
    • 下内边距是 15px
    padding:10px 5px;
    
    • 上内边距和下内边距是 10px
    • 右内边距和左内边距是 5px
    padding:10px;
    
    • 所有 4 个内边距都是 10px

    margin:0 外边距

    • margin:10px 5px 15px 20px;
      • 上边距是 10px
      • 右边距是 5px
      • 下边距是 15px
      • 左边距是 20px
    • margin:10px 5px 15px;
      • 上边距是 10px
      • 右边距和左边距是 5px
      • 下边距是 15px
    • margin:10px 5px;
      • 上边距和下边距是 10px
      • 右边距和左边距是 5px
    • margin:10px;
      • 所有四个边距都是 10px

    文本大小 font-size:value

    谷歌浏览器识别的最小字体为 12px

    4、文字

    3、文本字体:{font-family:“中文字体1”,字体2,字体3;}
    拓展:
    衬线体------有额外修饰的字体–宋体
    非衬线体------没有额外修饰的字体–黑体,微软雅黑

    说明:浏览器首先会寻找字体1、如存在就使用改字体来显示内容,如在字体1不存在的情况下,则会寻找字体2,如字
    体2也不存在,按字体3显示内容,如果字体3 也不存在;则按系统默认字体显示;

    当字体是中文字体时,需加双引号

    当英文字体中有空格时,需加双引号如(“Times New Roman”)

    当英文字体只有一个单词组成是不加双引号;如:(Arial);

    Windows中文版本操作系统下,中文默认字体为宋体或者新宋体,英文字体默认为Arial.

    系统字体所在位置:C:\Windows\Fonts

    font-weight:bold; //加粗

    4、加粗:{font-weight:bolder(更粗)、lighter(更细)/bold(加粗)/normal(常规)/100—900;}

    说明:在css规范中,把字体的粗细分为9个等级,分别为100——900,其中100对应最轻的字体变形,而900对应最重的
    字体变形,

    一般
    500常规字体
    600-900加粗字体
    100-400变细(常规)

    bold 加粗
    100 变细

    h1-h6{font-weight:normal}

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0yBU2Ube-1616458490631)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\1614839878396.png)]

    //引入字体

    其他的也不多废话了直接上代码:

    <! 这里的图片路径我放在网页的当前目录> ————————————————

    5、CSS核心属性

    A、关于文本的css声明

    1、文本大小:{font-size:value;}

    例:div{font-size:12px;}

    div{font-size:14px;}
    

    说明:

    1) 属性值为数值时,必须给属性值加单位,属性值为0时除外。
    2) 单位还可以是pt,pt是绝对单位,在dpi是96的情况下,9pt=12px,12pt=16px。
    3) 单位还可以是em,1em叫一个字节,默认情况下,1em=16px,0.75em=12px;

    px
    px是pixel缩写,是基于像素的单位.在浏览网页过程中,屏幕上的文字、图片等会随屏幕的分辨率变化而变化,一个100px宽度大小的图片,在800×600分辨率下,要占屏幕宽度的1/8,但在1024×768下,则只占约1/10。所以如果在定义字体大小时,使用px作为单位,那一旦用户改变显示器分辨率从800到1024,用户实际看到的文字就要变“小”(自然长度单位),甚至会看不清,影响浏览。

    em
    em:即%,是相对单位,是一个相对长度单位,最初是指字母M的宽度,故名em。现指的是字符宽度的倍数,用法类似百分比,如:0.8em, 1.2em,2em等。通常1em=16px。,一般用来测量长度的通用单位(例如元素周转的页边空白和填充),当用于指定字体大小时,em单位是指父元素的字体大小。
    在一个页面上给定了一个父元素的字体大小,这样就可以通过调整一个元素来成比例的改变所有元素大小.它可以自由缩放,比如用来制作可伸缩的样式表。

    pt
    PT是point(磅)缩写,是一种固定长度的度量单位,大小为1/72英寸。如果在web上使用pt做单位的文字,字体的大小在不同屏幕(同样分辨率)下一样,这样可能会对排版有影响,但在Word中使用pt相当方便。因为使用Word主要目的都不是为了屏幕浏览,而是输出打印。当打印到实体时,pt作为一个自然长度单位就方便实用了:比如Word中普通的文档都用“宋体 9pt”,标题用“黑体 16pt”等等,无论电脑怎么设置,打印出来永远就是这么大。

    4)使用关键字(不是绝对相等的)
    xx-small = 9px
    x-small = 11px
    small = 13px
    medium = 16px
    large = 19px
    x-large = 23px
    xx-large = 27px

    以 medium 作为基础参照,
    xx-small:相当于medium 3/5 ,
    x-small: 相当于medium 3/4 (h6),
    small: 相当于medium 8/9 (h5),
    medium: 相当于medium 1 (h4),
    large: 相当于medium 6/5 (h3),
    x-large: 相当于medium 3/2 (h2),
    xx-large: 相当于medium 2/1 (h1)

    谷歌浏览器识别最小字体为12px;

    3、文本字体:{font-family:“中文字体1”,字体2,字体3;}
    拓展:
    衬线体------有额外修饰的字体–宋体
    非衬线体------没有额外修饰的字体–黑体,微软雅黑

    说明:浏览器首先会寻找字体1、如存在就使用改字体来显示内容,如在字体1不存在的情况下,则会寻找字体2,如字
    体2也不存在,按字体3显示内容,如果字体3 也不存在;则按系统默认字体显示;

    当字体是中文字体时,需加双引号;

    当英文字体中有空格时,需加双引号如(“Times New Roman”)

    当英文字体只有一个单词组成是不加双引号;如:(Arial);

    Windows中文版本操作系统下,中文默认字体为宋体或者新宋体,英文字体默认为Arial.

    系统字体所在位置:C:\Windows\Fonts

    4、加粗:{font-weight:bolder(更粗)、lighter(更细)/bold(加粗)/normal(常规)/100—900;}

    说明:在css规范中,把字体的粗细分为9个等级,分别为100——900,其中100对应最轻的字体变形,而900对应最重的
    字体变形,

    一般
    500常规字体
    600-900加粗字体
    100-400变细(常规)

    bold 加粗
    100 变细

    h1-h6{font-weight:normal}

    5、倾斜:font-style:italic(倾斜)/normal(常规显示);

    i,em{ font-style:normal;}

    6、水平对齐方式{text-align:left/right/center/justify(两端对齐,存在一定的兼容性问题);}

    7、垂直对齐方式{vertical-align:top/bottom/middle;}

    vertical-align对 单元格显示方式:table-cell 的元素才会起作用.

    要实现上下垂直居中对齐,可以采用如下样式

    display(元素类型的转换):table-cell; /*按照单元格的样式显示元素*/
    
    vertical-align:middle; top和bottom  /*垂直居中对齐*/
    
    //display 和vertical-align一起用才会起作用
    

    10、文字属性简写:font:12px(字号)/100px(行高)

    font属性的简写:

    说明:font的属性值应按以下次序书写(各个属性之间用空格隔开)

    顺序: font-style font-weight font-size / line-height font-family

    (1)简写时 , font-size和line-height只能通过斜杠/组成一个值,不能分开写。

    (2) 顺序不能改变 ,这种简写法只有在同时指定font-size和font-family属性时

    才起作用,你没有设定font-weight , font-style,他们会使用缺省值(默认值)。

    11、字间距{letter-spacing:value;}控制英文字母和汉字的字距。(英文字母和字母)

    12、词间距{word-spacing:value;}控制英文单词词距。(通用于英文词和词之间的间距)

    // 文字下划线

    text-decoration: none/underline/overline/line-through;

    ​ 去掉下划线 下划线 上划线 删除线

    p
      {
         text-indent:50px;   2em  //将段落的第一行缩进 50 像素:  2个字符
         line-height:50px;            //行高
      }
    
    
    p{
        width: 400px;
        height: 400px;
        background-color: chartreuse;
        line-height: 400px; 
        /* 1)当单行文本的行高( line-height)等于容器高时,可实现单行文本在容器中垂直方向居中对齐
        2)当单行文本的行高小于容器高时,可实现单行文本在容器中垂直方向居中对齐以上任意位置的定位
        3)当单行文本的行高大于容器高时,可实现单行文本在容器中垂直方向居中对齐以下任意位置的定位  */
    }
    
    line-height=height             //可实现单行文本在容器中垂直方向居中对齐
    
    

    6、 伪类选择器(伪类选择符)

    语法 :
    a:link{属性:属性值;}超链接的初始状态;
    a:visited{属性:属性值;}超链接被访问后的状态;
    a:hover{属性:属性值;}鼠标悬停,即鼠标划过超链接时的状态;
    a:active{属性:属性值;}超链接被激活时的状态,即鼠标按下时超链接的状态; */

    7、对于列表的css

    list-style: none //没有列表符号

    一)、list-style 列表符号
    list-style:none; 去掉列表符号
    ul{list-style-type:square/circle/disc/none;}
    ul{list-style-position:inside/outside;} li的里和外 li和文字一体(inside) li和文字不一体(outside)
    li{ list-style-image:url(images/list.jpg);}

    8、关于背景图片

    )、关于背景的css声明
    1、背景颜色
    语法:选择符{background-color:颜色值;}
    2、背景图片的设置
    语法:background-image:url(背景图片的路径及全称);
    说明:
    网页上有两种图片形式:插入图片、背景图;
    插入图片:属于网页内容,也就是结构,以内容的形式呈递。
    背景图:属于网页的表现,主要用来装饰页面。
    3、背景图片的显示原则
    1)容器尺寸等于图片尺寸,背景图片正好显示在容器中;
    2)容器尺寸大于图片尺寸,背景图片将默认平铺,直至铺满容器;
    3)容器尺寸小于图片尺寸,只显示元素范围以内的背景图。
    4、背景图片平铺属性
    语法:选择符{background-repeat:no-repeat/repeat/repeat-x/repeat-y }
    no-repeat:不平铺 repeat:平铺(默认值)repeat-x:横向平铺 repeat-y :纵向平铺
    5、背景图片的位置
    语法:选择符{background-position:水平方向 垂直方向;}
    水平方向上的对齐方式(left/center/right)或具体数值
    垂直方向上的对齐方式(top/center/bottom)或具体数值
    用英文关键字时,方向可以对调;top right。只要有数字就不能对调。
    只写一个值,第二个默认是center。
    6、背景属性的缩写语法:background:属性值1 属性值2 属性值3;
    背景缩写:background:#f60 url(背景图片的路径及全称) no-repeat center top;
    注意:背景定位的两个值要挨着,并且顺序不能颠倒。

    在css标签内**,使用background-size调整背景图片的大小**,第一个参数值是宽度,第二个参数值是高度,例如,这时设置背景图片的高宽为原来一半,即50%。

    background-size:100% 100% //铺满屏幕 或者 background-size:cover

    background-attachment: fixed; //使背景固定 不随着鼠标移动而滑动

    img {

    ​ width: 100%;

    ​ height: 100%;

    ​ } //使图片充满盒子

    9、浮动

    float : left / rigth /none;

    一直向左或向右,直到遇到父盒子边缘或者浮动盒子的边缘为止

    clear:both;清除浮动 (放在不想被浮动影响的盒子身上)

    10、内边距和外边距

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-clVCjwz2-1616458490636)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\1615164522684.png)]

    四)盒模型

    盒模型是css布局的基石,它规定了网页元素如何显示以及元素间相互关系。
    css定义所有的元素都可以拥有像盒子一样的外形和平面空间,即都包含: 外边距、边框、内边距、内容区,这就是盒模型。
    margin border padding content(width height)

    1) padding的使用方法
    内边距:padding,在设定页面中一个元素内容到元素的边缘(边框) 之间的距离。
    也称补白、填充。
    用法:
    1、用来调整内容在容器中的位置关系
    2、用来调整子元素在父元素中的位置关系。
    3、padding值是额外加在元素原有大小之上的,如想保证元素大小不变,需从元素宽或高上减掉后添加的padding值。(width height-----容积)(子元素不变,父元素变动)
    4、支持背景
    属性值的4种方式:
    四值法:上 右 下 左 {padding:10px 20px 30px 40px;}
    三值法:上 右左 下 {padding:10px 20px 30px ;}
    二值法:上下 右左 {padding:10px 20px ;}
    一值法:四个方向 padding:2px;/定义元素四周填充为2px/
    说明:可单独设置一方向填充(内边距),
    如:padding-top:10px;
    padding-right:10px;
    padding-bottom:10px;
    padding-left:10px;

    //做之前先对浏览器所有边距清0

    * {

    ​ margin: 0px;

    ​ padding: 0px;

    ​ }

    3) margin的使用方法
    边界:margin,在元素外边的空白区域,被称为外边距。

    属性值的4种方式:
    四个值:上 右 下 左
    三个值:上 左右 下
    二个值:上下 左右
    一个值:四个方向

    margin:0 auto; /*定义元素上、下边界为0px,在浏览器中横向居中。

    说明:可单独设置单一方向边界,
    如:
    margin-top:10px;
    margin-right:10px;
    margin-bottom:10px;
    margin-left:10px;

    总结:margin一般在平级盒子,padding一般在嵌套盒子之间

    2) border的使用方法 border:3px solid red; (1px solid #ccc)

    边框border:线型(solid/dashed/dotted/double) 粗细(数值+单位) 颜色;

    solid:实线,dashed:线状虚线,dotted:点状虚线,double:双线(至少3px),

    border按功能分:
    边框大小 border-width;
    边框类型 border-style;
    边框颜色 border-color;

    border按方向分:
    右边框 border-right;
    左边框 border-left;
    上边框 border-top;
    下边框 border-bottom:

    继承:子盒子继承父盒子的字体各种属性,但是父盒子背景大小不继承

    11、定位(相对、绝对、固定)

    position 定位属性
    一、语法:position:static /relative(相对)/absolute/fixed
    取值:
    1、static:默认值,无特殊定位,对象遵循HTML原则(标准流);
    2、relative :相对定位,将依据right,top,left,bottom(相对自己定位)等属性在正常文档流中偏移位置;
    3、absolute:绝对定位,将对象从文档流中脱离出来,使用left/right/top/bottom等属性相对其 相对定位(绝对定位)的父盒子 进行定位;如果不存在这样的父对象,则依据body对象;
    4、fixed:固定定位,相对窗口定位;

    各个定位的特点

    相对定位——脱标占位,相对自身(标准流里的位置)定位,跟父盒子毫无关系

    绝对定位——脱标不占位,
    如果不写坐标,脱标留原位(标准流里的位置)
    子绝父相,
    如果父盒子没有相对定位,那么就相对body定位

    固定定位——相对窗口定位(如:返回顶部,定位在上方的导航)

    display:block; //转化成块

    z-index

    12、定位元素层叠属性:

    z-index : auto |
    表示一个元素在叠加顺序上的上下立体关系。
    auto:默认值。遵从其父对象
    number:无单位的整数值。可为负数
    说明:
    1)z-index值较大的元素将叠加在值小的元素之上,对于未指定此属性的定位元素,z-index值为正数的对象会在其之上,而z-index值为负数的对象在其之下。
    2)这个属性适用于定位元素,用来确定定位元素在垂直于显示屏方向的层叠顺序,也就是说如果元素没有定位,设置这个属性是无效的。
    3)如果两个元素z-index相同,那么按文档流顺序,后面的覆盖前面的。
    4)如果两个元素没有设置z-index,一个定位一个没定位,那么定位的覆盖不定位的。
    5)如果父元素z-index有效,那么子元素无论是否设置z-index都和父元素一致,会在父盒子上方,即使子元素的z-index比父盒子的小,也会在父盒子上方,如果父元素的z-index失效,那么子元素生效。

    13、关于溢出:

    1、溢出属性(容器的)
    overflow:visible/hidden(隐藏)/scroll/auto(自动)/inherit;
    visible: 默认值,内容不会被修剪,会出现在元素框之外;
    hidden: 内容会被修剪,并且其余内容是不可见的;
    scroll: 内容会被修剪,但是浏览器会显示滚动条,以便查看其余的内容;
    auto: 如果内容被修剪,则浏览器会显示滚动条,以便查看其他的内容;
    inherit: 规定应该从父元素继承overflow属性的值。

    /* 在文档流中,
    父元素的高度默认是被子元素撑开的,
    也就是子元素多高,父元素就多高。
    但是当子元素设置浮动之后,子元素会完全脱离文档流,
    此时将会导致子元素无法撑起父元素的高度,导致父元素的高度塌陷。 */

    解决方法在父元素中加入 overflow:hidden;

    /* 文本溢出:text-overflow:clip/ellipsis
    clip:不显示省略号(…),而是简单的裁切
    ellipsis:当对象内文本溢出时,显示省略标记

        text-overflow属性仅是...,当文本溢出时是否显示省略标记,
        并不具备其他的样式属性定义,要实现溢出时产生省略号的效果还需定义
    
        1、容器宽度:width.value;
        2、强制文本在一行内显示:white-space:nowrap;
        3、溢出内容为隐藏:overflow:hidden;
        4、溢出文本显示省略号:text-overflow:ellipsis */
    

    opacity: .5; //透明度 指定不透明度。从0.0(完全透明)到1.0(完全不透明)
    filter: alpha(opacity=50); // ie浏览器兼容性

    大小盒子一起向下 解决方法在父元素中加入 overflow:hidden;

    14、结构伪类 IE9+

    E:first-child 作为父元素的第一个子元素的元素E
    E:last-child 作为父元素的最后一个子元素的元素E
    E:root 选择匹配元素E所在文档的根元素(多只html)
    E F:nth-child(n) 选择父元素E的第n个子元素F
    E F:nth-last-child(n) 选择元素E的倒数第n个元素F
    E:nth-of-type(n) 选择父元素内具有指定类型的第n个E元素
    E:nth-last-of-type(n) 选择父元素内具有指定类型的倒数第n个E元素
    E:first-of-type 选择父元素内具有指定类型的第1个E元素
    E:last-of-type 选择父元素内具有指定类型的最后一个E元素
    E:only-child 选择父元素内只包含一个子元素,且匹配为E元素
    E:only-of-type 选择父元素只包含一个同类型的子元素,且匹配为E元素
    E:empty 选择没有子元素的元素,而且该元素也不包含任何文本节点

    :root 选择匹配元素E所在文档的根元素

    nth-child用在父子关系

    nth-of-type(n)type指同级关系(只去找同级的关系)

    15、/* 层级选择符

    ​ 1、后代选择器(E F) 包含选择器
    ​ 2、子代选择器(E > F)其中E为父元素,F为子元素,一定是父子元素
    ​ 3、相邻兄弟选择器(E+F) E和F是兄弟是同辈,F在E后面,并且相邻
    ​ 4、通用选择器(E~F) E后面所有兄弟F */

    用到啥标签就 padding margin0

    图片display block

    li list-style

    body文字三属性 大小文字颜色

    a text decoration none

    公共部分

    写好注释

    16、display用法

    1.inline 行内元素 元素会在一行内显示,超出屏幕宽度自动换行,
    不能设置宽度和高度,元素的宽度和高度只能是靠元素内的内容撑开。
    示例元素:span,b,i,a,u,sub,sup,strong,em
    2.block 块级元素 会独占一行,如果不设置宽度,其宽度会自动填满父元素的宽度,
    可以设置宽高,即使设置了宽度,小于父元素的宽度,块级元素也会独占一行。
    示例元素:div,h1-h6,ul,ol,dl,p
    3、inline-block 行内块元素 与行内元素一样可以再一行内显示,而且可以设置宽高,
    可以设置margin和padding。
    示例元素:input,button,img
    4.none 此元素不会被显示,

    line和line-block 属性都可在一行显示

    box-shadow: 2px 2px 0 blue //阴影效果 右、下、模糊度、颜色

    17、渐变色彩

    background: linear-gradient();

    /* 从上到下,蓝色渐变到红色 */ *

    linear-gradient(blue, red); /

    渐变轴为45度,从蓝色渐变到红色 */ *

    linear-gradient(45deg, blue, red); /

    从右下到左上、从蓝色渐变到红色 /

    linear-gradient(to left top, blue, red);

    /* 从下到上,从蓝色开始渐变、到高度40%位置是绿色渐变开始、最后以红色结束 */

    linear-gradient(0deg, blue, green 40%, red);

    一、渐变 IE10+

    线性渐变linear-gradient
    background-image:linear-gradient(方向,起始颜色,结束颜色)

    处理兼容:
    background-image:-webkit-linear-gradient(to top,red,yellow)
    background-image:-moz-linear-gradient(to top,red,yellow)
    background-image:-o-linear-gradient(to top,red,yellow)
    background-image:-ms-linear-gradient(to top,red,yellow)
    background-image:linear-gradient(to top,red,yellow)

    方向可以使用角度(30deg)也可以使用关键字(to right等);

    多色线性渐变,只需在后面添加更多的颜色即可;
    background-image:linear-gradient(to top,red,yellow,blue,green,orange)

    自定义线性渐变
    background-image:linear-gradient(
    to top,
    rgba(255,206,0,.5) 0%,
    rgba(255,255,0,.4) 10%,
    rgba(255,104,0,.6) 15%,
    rgba(255,0,255,.5) 20%,
    rgba(255,0,206,.8) 40%,
    rgba(255,0,200,.5) 50%,
    rgba(255,0,222,.9) 60%,
    rgba(255,123,0,.2) 80%,
    rgba(255,108,0,.5) 100%
    )

    重复线性渐变
    background-image:repeating-linear-gradient(
    to top,
    rgba(255,206,0,.5) 40px,
    rgba(255,255,0,.4) 80px
    )

    径向渐变radial-gradient
    background-image:radial-gradient(形状 at 圆心坐标,颜色)

    background-image:radial-gradient(主要半径 次要半径 at 水平 垂直,red,yellow)
    background-image:radial-gradient(50px 100px at 200px 250px,red,yellow)

    background-image:radial-gradient(主次半径相等就是圆 at 水平 垂直,red,yellow)
    background-image:radial-gradient(circle at right bottom,red,yellow)

    background-image:radial-gradient(主次半径不相等是椭圆 at 水平 垂直,red,yellow)
    background-image:radial-gradient(ellipse at top,red,yellow)

    background-image:radial-gradient(圆心与中心重合,red,yellow)
    background-image:radial-gradient(circle,red,yellow)

    重复径向渐变
    background-image:repeating-radial-gradient(
    to top,
    rgba(255,206,0,.5) 40px,
    rgba(255,255,0,.4) 80px
    )

    关于浏览器前缀:

    现在的规范还不是最终版本,在执行中有一些漏洞,因此执行这些功能时,使用供应商的前缀提供数值,并且使用无前缀声明来提供每个属性的永久版本,当规范成为最终版本且经过完善后,浏览器前缀将会被取消。

    firefox(gecko) -moz-
    chrome(webkit) -webkit-
    IE(trident) -ms-
    opera(presto) -o-

    18、二、过渡 IE10+

    //只有宽高 和 盒子里的背景图片能设置过度效果 主要在子类里写 不在父类里写的

    transition:all 2s linear 1s;

    transition:过渡属性 过渡所需时间 过渡动画函数 过渡延迟时间;
    transition:property duration timing-function delay;

    各个属性可以分开写,一次可以过渡多个属性:
    -webkit-transition-property:background,width,height;
    -webkit-transition-duration:1s,1s,1s;
    -webkit-transition-timing-function:linear,linear,linear;
    -webkit-transition-delay:1s,0s,2s;

    -moz-transition-property:background,width,height;
    -moz-transition-duration:1s,1s,1s;
    -moz-transition-timing-function:linear,linear,linear;
    -moz-transition-delay:1s,0s,2s;

    -ms-transition-property:background,width,height;
    -ms-transition-duration:1s,1s,1s;
    -ms-transition-timing-function:linear,linear,linear;
    -ms-transition-delay:1s,0s,2s;

    -o-transition-property:background,width,height;
    -o-transition-duration:1s,1s,1s;
    -o-transition-timing-function:linear,linear,linear;
    -o-transition-delay:1s,0s,2s;

    transition-property:background,width,height;
    transition-duration:1s,1s,1s;
    transition-timing-function:linear,linear,linear;
    transition-delay:1s,0s,2s;

    过渡动画函数timing-function
    ease 先快后慢,逐渐变慢
    linear 匀速
    ease-in 速度越来越快,称为渐显效果
    ease-out 速度越来越慢,称为渐隐效果
    ease-in-out 先加速再减速,称为渐显渐隐效果
    cubic-bezier(.61,.17,.92,.1) 三次贝塞尔曲线

    19、四)3D变形

    3D位移
    transform: translate3d(30px,30px,800px)
    transform:translateZ(800px) translateX(30px) translateY(30px);
    transform:translateZ(800px) translate(30px,30px);

    3D旋转
    transform:rotate3d(x,y,z,a);

    transform:rotate3d(1,0,0,45deg);
    transform:rotateX(45deg);

    transform:rotate3d(0,1,0,45deg);
    transform:rotateY(45deg);

    transform:rotate3d(0,0,1,45deg);
    transform:rotateZ(45deg);

    20、动画

    四、动画

    相关动画属性:

    animation:动画名称 动画所需时间 动画播放方式 动画开始时间 循环次数 播放方向 播放状态 动画时间外属性

    animation-name:动画名称-----声明的动画名称
    animation-duration:动画所需时间—完成0%-100%动画所需时间
    animation-timing-function:动画播放方式 ----同过渡
    step-start 马上跳到动画每一结束桢的状态
    animation-delay:等待动画的时间
    animation-iteration-count:循环次数----默认为1,infinite循环播放
    animation-direction:播放方向----默认normal,向前播放;alternate,播放次数为偶数则向前播放,为奇数时向反方向播放;
    animation-play-state:播放状态-----running播放和pause暂停
    animation-fill-mode:动画时间外属性----forwards动画结束后保持最后状态;backforwards会向元素应用动画样式时迅速应用动画初始值。

    四、动画

    相关动画属性:

    animation:动画名称 动画所需时间 动画播放方式 动画开始时间 循环次数 播放方向 播放状态 动画时间外属性

    animation-name:动画名称-----声明的动画名称
    animation-duration:动画所需时间—完成0%-100%动画所需时间
    animation-timing-function:动画播放方式 ----同过渡
    step-start 马上跳到动画每一结束桢的状态
    animation-delay:等待动画的时间
    animation-iteration-count:循环次数----默认为1,infinite循环播放
    animation-direction:播放方向----默认normal,向前播放;alternate,播放次数为偶数则向前播放,为奇数时向反方向播放;
    animation-play-state:播放状态-----running播放和pause暂停
    animation-fill-mode:动画时间外属性----forwards动画结束后保持最后状态;backforwards会向元素应用动画样式时迅速应用动画初始值。

    关键帧声明动画@keyframes:
    @keyframes name{
    from{
    css样式;
    }
    percentage{
    css样式;
    }
    to{
    css样式;
    }
    }

    @keyframes name{
    0%{
    css样式;
    }
    percentage{
    css样式;
    }
    100%{
    css样式;
    }
    }

    **、写页面的注意事项:

    任何线上案例都需要在书写css之前做3步准备工作;(作用:这3步准备工作可以让你在后期的代码当中省很多时间)

    1.清空默认的边距和列表样式;

    2.设置正文的全局样式----指的就是给body设置文字三属性;

    3.设置超链接的默认样式;

    总结:这是写任何网站都必须要设置的3步工作;

    /=reset部分===/
    body,
    h1,
    h2,
    h3,
    h4,
    p,
    ol,
    ul,
    li,
    a,
    p,
    span,
    img,
    input,
    dl,
    dd,
    dt {
    padding: 0;
    margin: 0;
    }

    ul,
    ol {
    list-style: none;
    }

    img {
    display: block;
    border: 0;
    }

    input {
    outline: none;
    }

    body {
    font-size: 12px;
    color: #666;
    font-family: “微软雅黑”;
    background: url(…/images/bg.jpg) no-repeat #f3f3f3 top;
    }

    a {
    text-decoration: none;
    }

    a:hover {
    color: #53cac3;
    }

    /=public部分===/
    .w {
    width: 1000px;
    margin: 0 auto;
    }

    .l {
    float: left;
    }

    .r {
    float: right;
    }

    .clear_both {
    clear: both;
    }

    五、js(行为)

    ​ window.alert(“hellow”); //弹出警告框

    ​ document.write("

    hello

    ");//将内容写到html文档中

    ​ document.getElementById(“hello”).innerHTML = “helloasdasd”; //写入到html元素

    ​ console.log(“你真帅”); //写入到浏览器控制台

    注释 //

    1、命名规则

    变量的命名不能以数字开头,

    ​ var message = “helloWorld”;

    ​ console.log(message);

    ​ var name = “王蒙”;

    ​ var age = “18”;

    ​ console.log(name + “今年” + age);

    2、数据类型

    基本类型(undefine,null,boolean,number,string)

    ​ /*值类型(基本类型):字符串(String)、数字(Number)、布尔(Boolean)、对空(Null)、未定义(Undefined)、Symbol。

    ​ 引用数据类型:对象(Object)、数组(Array)、函数(Function)。/
    ​ /

    ​ 1.undefined
    ​ 取值:undefined
    ​ 含义:当声明了变量,未对其初始化的时候会被赋值
    ​ 注意:包含了undefined值的变量与尚未定义的变量还是不一样的
    ​ */

    1、undefine定义一个变量,不赋值,即undefine

    ​ var aa;

    ​ console.log(aa);

    2、null 表示一个空对象指针,因此如果定义了一个变量,想让这个变量将来用来保存对象,最好初始化为null

    ​ var bb = null;

    ​ console.log(bb);

    3、布尔类型 取值 true 或 false

    4、字符串

    ​ var hello = " hello zhengrong"

    ​ console.log(hello);

    ​ var helloh = ‘hello wanmeng’;

    ​ console.log(helloh);

    ​ var helloa = ’ “hello wanmeng” '; //单引号可以放双引号

    ​ console.log(helloa);

    ​ var hellob = "‘hello wanmeng’ "; //双引号可以放单引号

    ​ console.log(hellob);

    ​ var message = " “asd” "; //双引号放单引号 需要转义符

    ​ console.log(message);

    ​ var message1 = ’ ‘asd’ ';

    ​ console.log(message1); //单引号放双引号 也需要转义符

    5、number类型

    取值:整数、浮点数、NaN、infinity

    含义:代表一个有意义或者无意义的数字

    ​ var a1 = 100;

    ​ console.log(a1);

    ​ var a2 = 1.1;

    ​ console.log(a2);

    ​ var a3 = 100e6;

    ​ console.log(a3);

    NaN是数字类型,但不是一个数字

    var x=Number(“abcd”);

    console.log(x) NaN

    console.log(Number.isNaN(x)); true

    任何两个NaN都是不相同的,所以"NaN==NaN"返回false

    var x=Number(‘abcd’);

    var y=Number(‘abcd’);

    console.log(x==y); //false

    Number()数据类型转换
    Number()
    如果是 Boolean 值, true和false将分别被转换为1和0。如果是数字值,只是简单的传入和返回。
    如果是null值,返回0。
    如果是undefined,返回NaN。如果是字符串,遵循下列规则:
    如果字符串中只包含数字(包括前面带正号或负号的情况),则将其转换为十进制数值,即"1"会变成1,“123"会变成123,而"011"会变成11 (注意:前导的零被忽略了) ﹔
    如果字符串中包含有效的浮点格式,如"1.1”,则将其转换为对应的浮点数值(同样,也会忽略前导零);
    如果字符串中包含有效的十六进制格式,例如"Oxf",则将其转换为相同大小的十进制整数值;
    如果字符串是空的(不包含任何字符),则将其转换为0;
    如果亨符串中包含除上述格式之外的字符,则将其转换为NaN。

    /*产生:将其他类型向Number类型转换时
    Infinity:
    含义:无穷大
    判断方法:
    Number.isFinite() === Infinity
    产生:超出 1.7976931348623157E+103088 的数值即为Infinity,
    小于 -1.7976931348623157E+103088 的数值为无穷小。
    Infinity 有正负 */

    infinity 无穷大

    ​ var y = 46;

    ​ console.log(Number.isFinite(y)); //有穷返回true

    ​ console.log(Number.isFinite(Infinity)); //无穷返回false

    console.log(Number.isFinite(NaN)); // false

    console.log(Number.isFinite(“0”)); //字符串返回false

    只有数值类型,且是有穷的(finite)返回true,其他全返回false

    var a=“2”;

    var b=1;

    a+b=“21” 转化为字符串

    引用数据类型

    ​ var obj = {}

    ​ obj.name = “asd”;

    ​ obj.age = 18;

    ​ console.log(obj);

    ​ var person = {}

    ​ person.sex = “男”;

    ​ person.age = 18;

    ​ person.sex = “女”; //下面覆盖上面

    ​ console.log(person);

    ​ console.log(person.sex); //取数据

    ​ //通过构造函数创建对象

    ​ var person_1 = new Object();

    ​ person_1[‘name’] = “longlong”;

    ​ person_1[‘age’] = 18;

    ​ console.log(person_1);

    ​ console.log(person_1[‘name’]); //取数据

    //typeof 判断数据类型

    ​ console.log(typeof “joj”); //string

    ​ console.log(typeof 3.14);

    ​ console.log(typeof NaN); //number

    ​ console.log(typeof false); //boolean

    ​ console.log(typeof [1, 2, 2, 4]); //object 数组

    ​ console.log(typeof { name: ‘asd’ }); //object 对象

    ​ console.log(typeof new data()); //object

    ​ console.log(typeof function () { }); //function

    ​ console.log(typeof null); //object

    NaN、Array、Date、null 都为object

    未定义为undefined

    //constructor

    ​ console.log(“joj”.constructor); //string

    ​ console.log(3.14.constructor); //number

    ​ console.log(NaN.constructor); //number

    ​ console.log(false.constructor); //boolean

    ​ console.log([1, 2, 2, 4].constructor); //array

    ​ console.log({ name: ‘asd’ }.constructor); //object

    ​ console.log(new Date().constructor); //date

    ​ console.log(function () { }.constructor); //function

    3、数组

    ​ //构造函数创建数组

    ​ var arr = new Array(“张三”, “李四”, “王二”)

    ​ console.log(arr);

    ​ var arr1 = new Array(5) //可直接设置数组属性

    ​ console.log(arr1);

    //字面量创建数组

    ​ var arr3 = [“ad”, “asd”, “asdasd”]

    ​ console.log(arr3);

    //push()返回数组中元素的个数,向尾部增加元素,括号有多少加多少

    ​ var a = [1, 2, 3, 4, 5];

    ​ var b = a.push(6, 7, 8, 9);

    ​ console.log(a);

    //unshif() 返回数组中元素的个数,向尾部增加元素,括号有多少加多少

    ​ var a = [1, 2, 3, 4, 5];

    ​ var b = a.unshift(6, 7, 8, 9);

    ​ console.log(a);

    ​ var a = [1, 2, 3, 4, 5];

    ​ var b = a.pop();

    ​ console.log(a);

    //shift从数组的头部删除一个元素,返回删除后的元素,不接受参数

    ​ var a = [1, 2, 3, 4, 5];

    ​ var b = a.shift();

    ​ console.log(a);

    //splice().把原数截断,一个参数,从输入的下标到数组结束,两个参数第一个输入下标,第一个截取长度

    ​ var a = [1, 2, 3, 4, 5];

    ​ var b = a.splice(2);

    ​ console.log(a); //1,2

    ​ console.log(b); //3,4,5

    ​ var a = [1, 2, 3, 4, 5]; b

    ​ var b = a.splice(2, 1); //包括自己

    ​ console.log(b); //3

    ​ console.log(a); //1,2,4,5

    //添加,第一个是起始位置,第二个为长度,第三个到后面是数,

    ​ var a = [1, 2, 3, 4, 5];

    ​ var b = a.splice(2, 1, 3, 6, 7); //将第三个位置包括(2),换成3,6,7

    ​ console.log(a); //1,2,3,6,7,4,5

    ​ var a = [1, 2, 3, 4, 5];

    ​ var b = a.splice(2, 0, 3, 6, 7); //将第三个位置不包括(2),以前加上3,6,7

    ​ console.log(a); //1,2,3,6,7,3,4,5

    ​ //是数组反转,会改变原来的数组,不会创建新的数组

    ​ var a = [1, 2, 3, 4, 5];

    ​ var b = a.reverse();

    ​ console.log(b); //【5,4,3,2,1】

    ​ console.log(a); //【5,4,3,2,1】

    //sort()无参数默认从小到大排序,判断方法,不会创建新的数组,直接在原数组上面改

    ​ var x = [1, 5, 8, 9, 7];

    ​ var y = x.sort();

    ​ console.log(x);

    ​ console.log(y);

    ​ x.sort(function (a, b) {

    ​ return a < b ? 1 : -1 //>号小到大,<从大到小

    ​ })

    ​ console.log(x);

    join() 方法用于把数组中的所有元素转换一个字符串。元素是通过指定的分隔符进行分隔的。//不改变原数组

    使用不同的分隔符:

    var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
    var energy = fruits.join(" and ");

    energy 结果输出:

    Banana and Orange and Apple and Mango

    4、函数

    ​ //函数 function

    ​ // 当调用函数时候,会执行函数被的代码

    ​ function myFunction() {

    ​ var x = 5;

    ​ return x;//通过return关键字,为函数指定返回指

    ​ }

    ​ var myVar = myFunction();

    ​ console.log(myVar);

    5、类型转换

    //数字类型转换为字符串

    ​ var i = 10;

    ​ var s = i.toString();

    ​ console.log(typeof s);

    ​ var a = 10 + 3;

    ​ var b = a.toString();

    ​ console.log(typeof b);

    ​ //布尔转字符串

    ​ var a = true;

    ​ var b = a.toString();

    ​ console.log(typeof b);

    ​ console.log(b);

    ​ //将布尔值转换为数字

    ​ var test1 = new Boolean(false);

    ​ document.write(Number(test1) + “
    ”);

    ​ //日期转化为数字

    ​ var test3 = new Date();

    ​ console.log(test3);

    ​ document.write(Number(test3) + “
    ”);

    6、变量的计算

    ​ var a = 1;

    ​ console.log(a + b); //1aaa

    ​ var a = 1;

    ​ var b = “30”;

    ​ var c = true;

    ​ console.log(a + b + c); //130true

    var a = 10;

    ​ var b = 3;

    ​ console.log(a % b); //1

    7、变量的比较

    1、===:称为等同符,当两边值的类型相同时,直接比较值,若类型不相同,直接返回false;

    2、==:称为等值符,当等号两边的类型相同时,直接比较值是否相等,若不相同,则先转化为类型相同的值,再进行比较;

    /* 关系运算(返回Boolean型的值)
    <、>、<=、>=
    1、如果都是数字,就直接比较
    2、如果都是字符串,就比较字符编码(ASCII)
    3、如果一个是数字,则将另一个转换为数字
    4、如果一个是布尔值,则将其转换为数字

        ==、!=、!==、===
        5、如果一个是Boolean,则将Boolean转换为数值
        6、如果一个是字符串,一个是数值,则将字符串转换成数值
        7、null和undefined相等,不向其他值转换
        8、NaN跟任何值都不相等
        
        赋值操作:=; *=; /=;  %=;  +=;  -=;*/
        //1、
        var a=1;
        var b=2;
        console.log(a<b);  //true
    
    
    
    
        //2、
        var a="a";
        var b="b";
        console.log(a<b);    //true 都是字符 比较阿斯克码
    
    
    
    
        //3、
        var a=1;
        var b=Number('2');
        console.log(a>b);   //false
        
        //4、
        var a="124";
        var b=Number(false);
        console.log(a<b);   //false  
        
        //5、
        var a="124";
        var b=Number(false);
        console.log(a==b); //false
    
        //6、
        var a=Number("1");
        var b=123;
        console.log(a!=b);   //true
        
        //7、
        var a=null;
        var b=undefined;  
        console.log(a==b);   //true
    
    
    
        //8、
        var a=NaN;
        var b=NaN;
        console.log(a==b);   //false
    

    8、逻辑运算

    /* 逻辑运算
    &&与 ||或 !否 */

        //&&操作符(逻辑与),操作符两边的值均为true,则返回true,否则返回false
        // console.log(true&&true);  //true
        // console.log(true&&false); //false
        // console.log(false&&false);  //false
        // console.log(false&&true);  //false
    
        //||操作符(逻辑或),操作符两边的值均为false,则返回false,否则返回true
        // console.log(true||true); //true
        // console.log(true||false);  //true
        // console.log(false||true);  //true
        // console.log(false||false); //false
    
        //!
        /* 1、如果运算数是true,返回值为false
        2、如果运算数是false,返回值是true
        3、如果运算时是0,返回值是true
        4、如果运算数是非零数值,返回值是false
        5、如果运算数是null,返回值是true
        6、如果运算数是NaN,返回值是true
        7、如果运算数是对象,返回值是false
        8、如果运算数是undefined,返回值是true */
    

    9、字符串对象

    //通过[index]获取对应位置的字符,第一个字符的index必须为0

    ​ var ss = “hello”;

    ​ console.log(ss[4]); // o

    ​ var aa = ‘hello’;

    ​ console.log(aa.charAt(4)); // o

    ​ //通过charCodeAt查找第n个字符的阿斯克吗

    ​ var aa = ‘hello’;

    ​ console.log(aa.charCodeAt(3)); //l的字符编码108

    //index查找,返回第一个匹配字符在原字符串中的索引 ,从0开始

    ​ var ss = “hello”;

    ​ console.log(ss.indexof(“h”)); // 0

    //lastindexof 从头到尾检索a,看他是否含有字串 “hao”,找不到返回-1

    ,找到返回"hao"的第一个字符在a中的位置

    var a=“ni hao me”

    document.write(a.lastindexof(“hao”));

    //concat()将一个或多个字符串拼接起来,返回拼接得到新的字符串

    var a=“aaa”;

    var b=“bbb”;

    var c=“ccc”;

    console.log(a.concat(b,c)); aaabbbccc

    //str.slice(a,b) 字符串截取 从a(包含)截取到b(不包含),不改变原有的字符串

    var str = “abcdef”;

    ​ console.log(str.slice(0, 3));

    // substring()字符串截取,只有一个参数,输出a(包括)到结尾的string

    var str = “abcdef”;

    console.log(str.substring(2));

    console.log(str.substring(2, 4)); //(a包含 b不包含)

    console.log(str.substring(4, 2)); //(当a>b的情况,系统会自动调整a,b的位置并输出)

    console.log(str.substring(1, -1)); // (如果b是负值,直接输出a(不包含)之前的字符串)

    // substr(index,length)

    ​ var str = “abcdef”;

    ​ console.log(str.substr(0, 2)); //从0(包括)开始,截取2个

    // trim()会创建一个字符串副本,删除迁至以及后缀的所有空格

    ​ var str = " abcdef ";

    ​ console.log(str); //有空格

    ​ console.log(str.trim()); //无空格

    // replace()替换

    ​ var str = “abcdef world aa aa aa”;

    ​ console.log(str.replace(/world/, “王蒙”)); //换world

    ​ console.log(str.replace(/aa/g, “王蒙”)); // 后面加入g(全局)则替换所有匹配 换所有的 aa

    ​ //不加g ,只换第一个aa

    //match()用于原字符串是否匹配给定的字符串或正则表达式,返回一个数组

    ​ var str = “abcdef 123456789”;

    ​ console.log(str.match(/[0-9]+/g)); //【123456789】

    var str = “abcdef 123456789”;

    ​ console.log(str.replace(/[0-9]+/g, “王蒙”)); // abcdef 王蒙

    //search()返回到匹配的第一个字符串的索引,没有返回-1

    ​ var str = “abcdef 123456789”;

    ​ console.log(str.search(/[0-9]+/g));

    //split()将字符串按照给定的字符切割成数组

    ​ var str = “11 22 33 44 55 66”;

    ​ console.log(str);

    ​ console.log(str.split(" "));

    10、函数

    ​ function functionName(name, age) {

    ​ alert(“姓名:” + name + “年龄:” + age);

    ​ }

    functionName(“王蒙”, 18); // 姓名:王蒙年龄:18

    //函数返回值 return后面代码不再执行

    ​ function eat(a, b) {

    ​ var c = a + b;

    ​ return c;

    ​ }

    ​ console.log(eat(“泡椒”, “凤爪”));

    /* 使用function来声明
        functionName函数名(可选)
        param1、param2参数列表
        
        形参和实参
        形参:定义函数时,规定的参数  (a,b)
        实参:函数调用时,传递的参数   (2,3)
        在函数调用时,实际上是把实参的值复制了一个副本给形参
        函数调用时传递的参数个数,不是必须与函数定义时传递的参数个数一致 */
    
        // function functionName(param1,param2) {
        //     //函数体
        //     alert("hello world")
        // }
        // functionName(2,3)  //定义函数名
    
        /* 函数在定义的时候,函数体内的语句是不会被执行的,只有函数在调用的时候
        才会执行函数体
    
        调用方法functionName函数定义时的名字  param1,param2函数定义时的函数 */
    //     function functionName(name,age) {
    //         //函数体
    //         console.log("姓名:"+ name +":年龄:"+ age );
    //     }
    //     functionName("xiaoming");  //年龄那里是undefined
    //     functionName("xiaoming","18");  //姓名:xiaoming:年龄:18
    //     functionName("xiaoming","20","aaa");  //姓名:xiaoming:年龄:age,aaa不显示
    //    //函数调用时传递的参数个数,不是必须与函数定义时传递的参数个数一致
    
    
    
        //函数的返回值
        /* 通过return关键字,可以为函数指定返回值
        作用:可以将函数内部的计算或者操作的结果,返回给函数外部
        特别:函数内部执行return后,函数将退出,return之后的所有代码将不再执行
        可以只写return,函数按照返回undefined处理 */
        // function eat(a,b) {
        //     debugger;
        //     var c = a+b;
        //     return c;
        // }
        // var receive = eat(3,6);
        // console.log(receive);
    
        //创建一个变量
        var a = 10;
        var b = 11;
        function fun() {
            var a = "我是fun函数中的变量a";
            var b = 20;
            d = 50;  //没有使用var关键字,则会设置为全局变量
            console.log("a = "+a);
            function fun2() {
                console.log("a = "+ window.a);
            }
            fun2();
        }
        fun();
        console.log("b = "+b);
        console.log("d = "+d);
    

    js 的指数表示法,浮点数字面值(Floating-point_literals)简单描述就是0的个数,比如 1e3 就是 1000,12e5 就是 1200000,就是0的个数。相反 1e-3 就是 0.001 3个零跑到前面去了,12e-5 要从2开始算位数0.00012,而不是 0.000012。

    //选择结构

    ​ var a = 500000;

    ​ if (a < 100) {

    ​ console.log(“汇丰为” + 1 + “元”);

    ​ }

    ​ else if (a >= 100 && a < 5000) {

    ​ console.log(“汇丰为” + a * 0.01);

    ​ }

    ​ else {

    ​ console.log(“汇丰为” + 1e3);

    ​ }

    //switch

    ​ var b = 6;

    ​ switch (b) {

    ​ case 6:

    ​ console.log(“asd”);

    ​ break;

    ​ default:

    ​ break;

    ​ }

    11、循环

    ​ console.log(sum);

    ​ var obj = {

    ​ “name”: “小明”,

    ​ “age”: “12”,

    ​ “hobby”: “swim”,

    ​ }

    ​ var person;

    ​ for (person in obj) {

    ​ console.log(obj[person]); //person只能代指key或者数组下标

    ​ }

    ​ var arr = [1, 2, 3, 4, 5, 6, 7];

    ​ arr.forEach(function (a) {

    ​ console.log(a); //代表每一个值

    ​ }

    ​ )

    ​ var arr = [4, 2, 3, 4, 5, 6, 7];

    ​ arr.forEach(function (index, a) {

    ​ console.log(a, index);

    ​ }

    ​ ) //索引和数值

    ​ var arr = [1, 2, 3, 4, 5, 6, 7];

    ​ arr.forEach((a) => { //与function作用一直

    ​ console.log(a);

    ​ }

    ​ )

    for (var i = 0; i <= this.checkGroup.length - 1; i++) {

    ​ all += this.checkGroup[i].number * this.checkGroup[i].price;

    ​ }

    12、dom元素对象(取对象)

  • asd
  • 123
  • 点我

    ​ function myFunciton() {

    ​ var list = document.getElementsByTagName(“ul”)[0];

    ​ list.getElementsByTagName(“li”)[1].innerHTML = “new”;

    ​ } //取类型

  • asd
  • 123
  • 点我

    ​ function myFunciton() {

    ​ var list = document.getElementsByClassName(“example”)[0];

    ​ list.getElementsByClassName(“child”)[1].innerHTML = “new”; //去class

    对象

    我要变了

    点我

    function myFunciton() {

    ​ var a1 = document.getElementsByTagName(“a”)[0];

    ​ document.getElementById(“demo”).innerHTML = a1.getAttribute(“target”); //取属性值

    ​ }

    function myFunciton() {

    ​ var a1 = document.getElementsByTagName(“a”)[0];

    ​ var a2 = document.getElementById(“demo”);

    ​ a2.innerHTML = a1.getAttributeNode(“target”).value; //获取节点 ,value如果是class,获取到class属性值

    // getAttributeNode() 方法从当前元素中通过名称获取属性节点。
    仅想返回属性值请使用 getAttribute 方法

    ​ }

    元素添加事件

    <!-- <p>元素添加事件</p>
    <button id="myBth">click</button>
    <p id="demo"></p> -->
    

    document.getElementById(“myBth”).addEventListener(“click”, function () {

    ​ document.getElementById(“demo”).innerHTML = “hello world”;

    ​ }

    // element.calssName设置或返回元素的class属性

    var x = document.getElementsByTagName(‘div’)[0];

    ​ document.write(“div元素css类为:” + x.className);

    ​ document.write("
    ");

    ​ document.write(“另一种方式:”);

    ​ document.write(document.getElementById(‘myid’).className);

  • coffee
  • tea
  • 单机按钮将项目添加到列表中

    点我

    //elem.appendchild 为元素添加子节点

    ​ alert(“asd”)

    ​ var node = document.createElement(“li”); //createElement(“li”) 创建一个li节点

    ​ var textnode = document.createTextNode(“water”) //创建一个文本节点

    ​ node.appendChild(textnode); //然后将文本节点添加到li节点

    ​ document.getElementById(“myList”).appendChild(node);

    ​ }

    单机按钮显示第一个属性的名称

    点我

    ​ var btn = document.getElementsByTagName(“button”)[0];

    ​ var x = document.getElementById(“demo”);

    ​ x.innerHTML = btn.attributes[0].name;

    ​ console.log(btn.attributes);

    ​ }

    hello world

        

    单机按钮改变上面标题样式

    点我

    ​ function myFuntion() {

    ​ var h = document.getElementsByTagName(“h1”)[0];

    ​ h.getAttributeNode(“style”).value = “color:green”; //改变颜色

    ​ }

    //   

    双机按钮改变上面标题样式

    //  点我     //ondblclick双击

    //  

    单机改变颜色

    elmnt.style.color = clr;
            }

    <img οnmοuseenter=“bigImg(this)” οnmοuseleave=“normalImg(this)” border=“0” src="…/images网页/li4.png" alt=""

    ​ width=“32” height=“32”>

    ​ function bigImg(x) {

    ​ x.style.height = “64px”;

    ​ x.style.width = “64px”;

    ​ }

    ​ function normalImg(x) {

    ​ x.style.height = “32px”;

    ​ x.style.width = “32px”;

    ​ }

    Document
    <!-- <p>单击按钮触发函数</p>
    <button onclick="myFunction()">点我</button>
    <p id="demo"></p> -->
    
    <!-- <p ondblclick="myFunction()">双击点我</p>
    <p id="demo"></p> -->
    
    <!-- <p onmousedown="myFunction(this,'red')" onmouseup="myFunction(this,'green')">
    单击文本改变颜色,触发一个带参数函数</p> -->
    
    <img onmouseenter="bigImg(this)" onmouseleave="normalImg(this)" border="0" src="cat-011.jpg"
    width="32" height="32">
    <p>bigImg() 函数在用户将鼠标指针移动到该图像时触发</p>
    <p>normalImg() 函数在用户将鼠标指针移出图像时触发</p>
    
    <!-- <p>当你在输入框内按下一个按键是函数被触发</p>
    <input type="text" onkeydown="myFunction()"> -->
    
    <!-- <p>当用户在输入字段释放一个按键时触发函数,函数将字符转换为大写</p>
    输入你的名称:<input type="text" id="fname" onkeyup="myFunction()"> -->
    
    <!-- 7.某个键盘按下并松开  onkeypress -->
    <p>当用户在输入框内按下一个按键时函数被触发</p>
    <input type="text" onkeypress="myFunction()">
    
    
    
    
    <script type="text/javaScript">
    

    /* 1.点击事件 onclick当用户点击某个对象时调用的句柄 */
    // function myFunction() {
    // document.getElementById(“demo”).innerHTML=“Hello World”;
    // }

    /* 2.双击事件 ondblclick */
    // function myFunction() {
    // document.getElementById(“demo”).innerHTML=“Hello World”;
    // }

    /* 3.鼠标按钮抬起,按下 onmouseup onmousedown */
    // function myFunction(elmnt,clr) {
    // console.log(elmnt);
    // console.log(clr);
    // elmnt.style.color=clr;
    // }

    /* 4.鼠标移入 移出 onmouseenter onmouseleave */
    // function bigImg(x) {
    // console.log(x);
    // x.style.height=“64px”;
    // x.style.width=“64px”;
    // }
    // function normalImg(x) {
    // x.style.height=“32px”;
    // x.style.width=“32px”;
    // }

    /* 5.onkeydown 键盘按下事件 */
    // function myFunction() {
    // alert(“你在输入框内按下一个键”);
    // }

    /* 6.某个键盘键被松开 */
    // function myFunction() {
    // var x=document.getElementById(“fname”);
    // x.value=x.value.toUpperCase(); //将字符转为大写
    // //toLocaleLowerCase() 将字符转为小写
    // }

    /* 7.某个键盘按下并松开 onkeypress */
    function myFunction() {
    alert(“你在输入框内按下一个按键”);
    }

    </script>
    

    13、正则表达式

    //1.\b 单词的开始或结束
    //2… 任意[一个]非换行字符
    //3.* 前面的字符(可以是普通字符,也可以是元字符)重复
    //4.\d 任意[一个]数字
    //5.{n} 前面的字符,重复n次(n是一个数字)
    //6.{n,m} 前面的字符,重复n到m次(m,n都是数字)
    //7.^ 字符串开始的位置
    //8.$ 字符串结束的位置

    //元字符(meta character)

    // .匹配除换行符以外的任意字符
    // \w 匹配字母或数字或下划线或汉字 等价于 ‘[^A-Za-z0-9_]’。
    // \s 匹配任意的空白符
    // \d 匹配数字
    // \b 匹配单词的开始或结束
    // ^ 匹配字符串的开始
    // $ 匹配字符串的结束
    // \w能不能匹配汉字要视你的操作系统和你的应用环境而定

    // 2.表示重复次数
    // */

    \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如,‘n’ 匹配字符 “n”。’\n’ 匹配一个换行符。序列 ‘\’ 匹配 “” 而 “(” 则匹配 “(”。
    ^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性,^ 也匹配 ‘\n’ 或 ‘\r’ 之后的位置。
    $ 匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性,$ 也匹配 ‘\n’ 或 ‘\r’ 之前的位置。
    * 匹配前面的子表达式零次或多次。例如,zo* 能匹配 “z” 以及 “zoo”。* 等价于{0,}。
    + 匹配前面的子表达式一次或多次。例如,‘zo+’ 能匹配 “zo” 以及 “zoo”,但不能匹配 “z”。+ 等价于 {1,}。
    ? 匹配前面的子表达式零次或一次。例如,“do(es)?” 可以匹配 “do” 或 “does” 中的"do" 。? 等价于 {0,1}。
    {n} n 是一个非负整数。匹配确定的 n 次。例如,‘o{2}’ 不能匹配 “Bob” 中的 ‘o’,但是能匹配 “food” 中的两个 o。
    {n,} n 是一个非负整数。至少匹配n 次。例如,‘o{2,}’ 不能匹配 “Bob” 中的 ‘o’,但能匹配 “foooood” 中的所有 o。‘o{1,}’ 等价于 ‘o+’。‘o{0,}’ 则等价于 ‘o*’。
    {n,m} m 和 n 均为非负整数,其中n <= m。最少匹配 n 次且最多匹配 m 次。例如,“o{1,3}” 将匹配 “fooooood” 中的前三个 o。‘o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格。
    ? 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时,匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串,而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如,对于字符串 “oooo”,‘o+?’ 将匹配单个 “o”,而 ‘o+’ 将匹配所有 ‘o’。
    . 匹配除 “\n” 之外的任何单个字符。要匹配包括 ‘\n’ 在内的任何字符,请使用象 ‘[.\n]’ 的模式。
    (pattern) 匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到,在VBScript 中使用 SubMatches 集合,在JScript 中则使用 $0…$9 属性。要匹配圆括号字符,请使用 ‘(’ 或 ‘)’。
    (?:pattern) 匹配 pattern 但不获取匹配结果,也就是说这是一个非获取匹配,不进行存储供以后使用。这在使用 “或” 字符 (|) 来组合一个模式的各个部分是很有用。例如, 'industr(?:y|ies) 就是一个比 ‘industry|industries’ 更简略的表达式。
    (?=pattern) 正向预查,在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。例如,‘Windows (?=95|98|NT|2000)’ 能匹配 “Windows 2000” 中的 “Windows” ,但不能匹配 “Windows 3.1” 中的 “Windows”。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始。
    (?!pattern) 负向预查,在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。例如’Windows (?!95|98|NT|2000)’ 能匹配 “Windows 3.1” 中的 “Windows”,但不能匹配 “Windows 2000” 中的 “Windows”。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始
    x|y 匹配 x 或 y。例如,‘z|food’ 能匹配 “z” 或 “food”。’(z|f)ood’ 则匹配 “zood” 或 “food”。
    [xyz] 字符集合。匹配所包含的任意一个字符。例如, ‘[abc]’ 可以匹配 “plain” 中的 ‘a’。
    [^xyz] 负值字符集合。匹配未包含的任意字符。例如, ‘[^abc]’ 可以匹配 “plain” 中的’p’。
    [a-z] 字符范围。匹配指定范围内的任意字符。例如,’[a-z]’ 可以匹配 ‘a’ 到 ‘z’ 范围内的任意小写字母字符。
    [^a-z] 负值字符范围。匹配任何不在指定范围内的任意字符。例如,’[^a-z]’ 可以匹配任何不在 ‘a’ 到 ‘z’ 范围内的任意字符。
    \b 匹配一个单词边界,也就是指单词和空格间的位置。例如, ‘er\b’ 可以匹配"never" 中的 ‘er’,但不能匹配 “verb” 中的 ‘er’。
    \B 匹配非单词边界。‘er\B’ 能匹配 “verb” 中的 ‘er’,但不能匹配 “never” 中的 ‘er’。
    \cx 匹配由 x 指明的控制字符。例如, \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则,将 c 视为一个原义的 ‘c’ 字符。
    \d 匹配一个数字字符。等价于 [0-9]。
    \D 匹配一个非数字字符。等价于 [^0-9]。
    \f 匹配一个换页符。等价于 \x0c 和 \cL。
    \n 匹配一个换行符。等价于 \x0a 和 \cJ。
    \r 匹配一个回车符。等价于 \x0d 和 \cM。
    \s 匹配任何空白字符,包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
    \S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
    \t 匹配一个制表符。等价于 \x09 和 \cI。
    \v 匹配一个垂直制表符。等价于 \x0b 和 \cK。
    \w 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。
    \W 匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]’。
    \xn 匹配 n,其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如,’\x41’ 匹配 “A”。’\x041’ 则等价于 ‘\x04’ & “1”。正则表达式中可以使用 ASCII 编码。.
    \num 匹配 num,其中 num 是一个正整数。对所获取的匹配的引用。例如,’(.)\1’ 匹配两个连续的相同字符。
    \n 标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式,则 n 为向后引用。否则,如果 n 为八进制数字 (0-7),则 n 为一个八进制转义值。
    \nm 标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式,则 nm 为向后引用。如果 \nm 之前至少有 n 个获取,则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足,若 n 和 m 均为八进制数字 (0-7),则 \nm 将匹配八进制转义值 nm。
    \nml 如果 n 为八进制数字 (0-3),且 m 和 l 均为八进制数字 (0-7),则匹配八进制转义值 nml。
    \un 匹配 n,其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如, \u00A9 匹配版权符号 (?)。

    ​ var telNo = “012-12345678”;

    ​ var telReg = /^0\d{2,3}-\d{7,8}$/

    ​ //以0开头,随机一个数重复23次,中间有-,随机一个数重复78次

    console.log(telReg.test(telNo)) //true

    var telNo = “1123asd”;

    var telReg = /^\w{6,20}$/

    //数字可以开头,6-20位,数字、字母、下划线

    console.log(telReg.test(telNo)) //true

    ​ var telNo = “11313”;

    ​ var telReg = /1+$/ //+是重复一次或者更多,[]其中一个

    ​ //匹配一个奇数数字

    ​ console.log(telReg.test(telNo)) //true

    // 试一下

    ​ var userReg = /2\w{5,19}$/

    ​ document.querySelector(‘button’).onclick = function () {

    ​ var username = document.querySelector(‘input’).value;

    ​ //queryselector返回文档中匹配指定css选择器的一个元素

    ​ console.log(userReg.test(username));

    ​ }

    ​ var mood = “xihahaxi”

    ​ var moodRef = /^xi((ha){2}|he)xi$/

    ​ console.log(moodRef.test(mood)); //true

    14、json

    ​ var text = ‘{“sites”:[’ + ‘{“name”:“runoob1”,“url”:“www.runoob.com1”},’ +

    ​ ‘{“name”:“runoob2”,“url”:“www.runoob.com2”},’ +

    ​ ‘{“name”:“runoob3”,“url”:“www.runoob.com3”}] }’;

    ​ obj = JSON.parse(text); //JSON.parse()将json文本转化为 js

    ​ console.log(obj);

    ​ document.getElementById(“demo”).innerHTML = obj.sites[1].name + obj.sites[2].url;

    ​ console.log(str_pretty1);

    ​ document.write(“只有一个参数情况:”);

    ​ document.write("
    ");

    ​ document.write("

    " + str_pretty1 + “
    ”);

    ​ str_pretty2 = JSON.stringify(str, null, 4) //使用四个空格缩放

    ​ document.write(“只有一个参数情况:”);

    ​ document.write("
    ");

    ​ document.write("

    " + str_pretty2 + “
    ”); //pre代表 保留空格和换行符

    语法

    JSON.stringify(value[, replacer[, space]])
    
    

    参数说明:

    • value:

      必需, 要转换的 JavaScript 值(通常为对象或数组)。

    • replacer:

      可选。用于转换结果的函数或数组。

      如果 replacer 为函数,则 JSON.stringify 将调用该函数,并传入每个成员的键和值。使用返回值而不是原始值。如果此函数返回 undefined,则排除成员。根对象的键是一个空字符串:""。

      如果 replacer 是一个数组,则仅转换该数组中具有键值的成员。成员的转换顺序与键在数组中的顺序一样。

    • space:

      可选,文本添加缩进、空格和换行符,如果 space 是一个数字,则返回值文本在每个级别缩进指定数目的空格,如果 space 大于 10,则文本缩进 10 个空格。space 也可以使用非数字,如:\t。

    返回值:

    返回包含 JSON 文本的字符串。

    六、vue

    构建数据驱动的应用开发框架,改变数据就能驱动页面的一个更新,再也不需要开发者自己去操作dom


        

    1、   数据更新原理,响应式原理

    Object.defineProperty(myvue, “name”, {
                get: function () {
                    console.log(“get”);  //返回经过处理后的变量
                    return obox.innerHTML
                },

    set: function (value) {
                    console.log(value);
                    console.log(“set”);
                    return obox.innerHTML = value;
                }})

    //      

    {{site}}


      //      

    {{detail()}}

    var vm = new Vue({
                el: “#app”,   //element需要获取的元素,一定是html的根元素
                data: {       //data:用于数据的存储
                    site: “vue”,
                    url: “asdasas”,
                    alexa: “none”,

    },

    methods: {  //方法
                    detail: function () {
                        return this.site + “-学的不仅是技术,更是梦想”
                    }

    }

    }
            )

    // v-html一个是自动识别标签 {{}}一个不识别


            
            {{myhtml}}
            

    {{a}}


            
            

        

        

    var vm = new Vue({
                el: “#box”,
                data: {
                    myhtml: “

    啊大苏打

    ”,         //,必须有
                    a: “asd”

    }

    })

    2、bind对属性的绑定

    11
    动态更改class名字
    </div>
    <script>
        var vm = new Vue({
            el: "#box",
            data: {
                imgsrc: "https://www.baidu.com/img/flexible/logo/pc/result.png",
    
                mystyle: {
                    background: "red",
                    fontSize: "lighter",           //font-size 对比 fontSize
                    height: "70px"
                },
    
                classObj: {
                    red: false,
                    blue: true                  //true  改div的calss名字classObJ为red,并且调用css中的red
    
                }
            }
        })
    </script>
    

    3、对于事件的绑定 v-on:


            
            
            增加1
            <button @click=“subtract()”>减少1
            

    我是{{number}}

       

        

    }

    })
        

    //传入参数

                              增加10         

    }

    })
        

    //鼠标移动、双击、input弹出

    <div id=“box” :style=“mystyle” @mousemove=“updateXY”>{{x}}    {{y}}

    <div @dblclick=“dbFunc()”>双击我有惊喜

    ​ <input type=“text” @keyup=“logName”>

    ​ var vm = new Vue({

    ​ el: “#box”,

    ​ data: {

    ​ number: 50, //只有data里定义了数值,后面用到都要加this

    ​ x: 0,

    ​ y: 0,

    ​ mystyle: {

    ​ width: “100px”,

    ​ height: “100px”

    ​ }

    ​ },

    ​ methods: {

    ​ //鼠标移动的时候取到x轴,y轴的值

    ​ updateXY: function () {

    ​ this.x = event.offsetX;

    ​ console.log(event.offsetX);

    ​ console.log(event.offsetY);

    ​ this.y = event.offsetY;

    ​ },

    ​ dbFunc: function () {

    ​ alert(“你好啥比”)

    ​ },

    ​ logName: function () {

    ​ alert(“正在输入”)

    ​ }

    ​ }

    ​ })

    4、v-show(做显示和隐藏,style=“display:none”)


            <button @click=“handleClick()”>点我
            

                我是v-show的被人
            

        

        

    el: “#box”,
                data: {
                    myShow: false
                },
                methods: {
                    handleClick: function () {
                        this.myShow = true
                    }

    }
            })
        

    区别

    v-show:只是简单的css隐藏显示

    v-if: 消除数据

    5、v-if(直接后台被销毁)


            <button @click=“handleClick()”>点我
            

                我是v-show的被人
            

        

        

    6、v-if-else

    //    

    //    

    //   

    相等

    //       

    不相等

    ​ //销毁和重新生成dom,

    ​ var vm = new Vue({

    ​ el: “#box”,

    ​ data: {

    ​ type: ‘B’

    ​ },

    ​ methods: {

    ​ }

    ​ })

    7、v-for

      ​ <li v-for="(zdata,zindex) in dataList" :key=“zindex” @click=“handleClick(zindex)”

      ​ :class="currentIndex==zindex?‘active’:’’ ">{{zdata}}

      ​ //销毁和重新生成dom,

      ​ var vm = new Vue({

      ​ el: “#box”,

      ​ data: {

      ​ dataList: [“首页”, “详情页”, “列表页”],

      ​ currentIndex: 0,

      ​ handleClick: function (index) {

      ​ this.currentIndex = index;

      ​ console.log(this.currentIndex);

      ​ }

      ​ }

      ​ })

      7、methods( methods方法,每当触发重新渲染时,调用方法将总是再次执行函数 )

              

      age + a={{addToA()}}


              

      age + b={{addToB()}}


              

      addToA() {
                              console.log(“ADD TO A”);
                              return this.a + this.age;
                          },
                          addToB() {
                              console.log(“ADD TO B”);
                              return this.b + this.age;
                          }

      }

      })
              

      8、计算属性computed

      –>

      ​ <button type=“primary” @click=“a++”>ADD TO A

      ​ <button type=“primary” @click=“b–”>ADD TO B

      A:{{a}}

      B:{{b}}

      age + a={{addToA}}

      //addToA不能加括号

      age + b={{addToB}}

      ​ //销毁和重新生成dom,

      ​ var vm = new Vue({

      ​ el: “#app”,

      ​ data: {

      ​ a: 0,

      ​ b: 0,

      ​ age: 20

      ​ },

      ​ computed: {

      ​ addToA() {

      ​ console.log(“ADD TO A”);

      ​ return this.a + this.age;

      ​ },

      ​ addToB() {

      ​ console.log(“ADD TO B”);

      ​ return this.b + this.age;

      ​ }

      ​ }

      ​ })

      9、vue监听

              

      counter: 1
                  },

      methods: {
                  },
                  watch: {
                      counter: function (nval, oval) {
                          console.log(nval);
                          console.log(oval);
                          alert(“计数器由” + oval + “变为” + nval);
                      }

      }

      })

      vm.$watch(‘counter’, function (nval, oval) { //对全局进行实例化

      ​ console.log(nval);

      ​ console.log(oval);

      ​ alert(“计数器由” + oval + “变为” + nval);

      v-model可以将表单输入绑定到对应的模型数据。

      10、表单绑定

      ​ {{mytext}}

       记住用名户

      ​ {{isChecked}}

      ​ //销毁和重新生成dom,

      ​ var vm = new Vue({

      ​ el: “#box”,

      ​ data: {

      ​ mytext: “”,

      ​ isChecked: true

      ​ },

      ​ methods: {

      ​ },

       react


              

       vue


              

       jquery

      ​ {{checkedngroup}}

      ​ var vm = new Vue({

      ​ el: “#box”,

      ​ data: {

      ​ checkedngroup: [],

      ​ },

      ​ methods: {

      ​ },

      react 


              

       vue

      ​ {{picked}}

      ​ //销毁和重新生成dom,

      ​ var vm = new Vue({

      ​ el: “#box”,

      ​ data: {

      ​ checkedngroup: “asd”,

      ​ picked: “vue”

      ​ },

      ​ methods: {

      ​ },

      11、修饰符

      lazy

      // 


              
              

      number

      //   


              
              

      })
          

      trim

      //


              
              

      })
          

      self

      //


              

      <ul @click.self=“clickUL”>
                  我是ul
                  

    • 我是li

    •         

      })

      stop(组织了 从下往上冒泡传递)

      //


              

      <div @click=“div1”>
                  我是div1
                  <div @click=“div2”>我是div2
                      <p @click.stop=“p1”>我是p1


                  
              

      capture

      //


              

      <div @click=“div1”>
                  我是div1
                  <div @click.capture=“div2”>我是div2
                      <p @click=“p1”>我是p1


                  
              

      prevent

      //


              
              <a href=“http://www.baidu.com” @click.prevent=“a1”>点我直达 
          

      })
          

      once

      //


              
              <a @click.once=“a1”>点我直达 
          

      })
          

      *keyup

      //


              
              <input type=“text” @keyup=“handleky”>
              <input type=“text” @keyup.enter=“handleky”>
              <input type=“text” @keyup.alt.enter=“handleky”>
          

      })
          

      12、自定义指令

      13、全局组件(`反斜杠很重要)

      老师文件:

      Document

      //


              
              

      Vue.component(“hello”, {
                  template: <div>我是hello组件</div>
              })

      Vue.component(“hello-compoment”, {
                  template: ` //里面的内容最外层一定要套一个div


                  

                        
      • asd

      •                 
      • asd

      •                 
      • asd

      •                 
      • asd

      •                 

                      


                          {{name}}
                          <button @click=“handleclick”>点击
                      


                      
      `,

      data() {
                      return {
                          name: “我是组件”
                      }
                  },

      methods: {
                      handleclick() {
                          this.name = “我是组件修改”
                      }
                  }
              })

      el: “#box”,
                  data: {
                      name: “”,
                      color: “red”,
                      fontsiz: “green”
                  },
                  methods: {

      },

      })
          

      14、局部组件

      老师文件:

      Document


      // 


              
              
          

      },
                  components: {
                      “hello1”: {
                          template: <div>我是hello1组件</div> //里面的内容最外层一定要套一个div
                      },
                      “hello2”: {
                          template: <div>我是hello2组件</div>

      }
                  }

      })
          

      15、prop父子通信

      老师文件:

      Document

      我是父组件

      <script type="text/javaScript">
          Vue.component("hello",{
              template:
                  `<button @click="myClick()">点我</button>`,
                  props: ['msg'],
                  // 儿子在实例中的props属性获取
                  methods:{
                      myClick:function(){
                          console.log(this.msg);
                      }
                  }
          }),
          new Vue({
           el: '#box'
          })                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
      </script>
      

      //  

      {{name}}


              
              
              
          

      },

      16、组件props

      老师文件:

      Examples

      我是父亲

      //

      {{name}}


              
              
              
              
          

      el: “#box”,
                  data: {
                      name: ‘我是父组件’,
                      myobj: {
                          name: “王蒙”,
                          age: 18,
                          hobby: “guitar”
                      }
                  },
                  methods: {

      },

      components: {
                      “child”: {
                          template: `


                              

      {{message}}


                              

      {{obj}}


                              

      `,

      data() {
                              return {
                                  message: “我是子组件”
                              }

      },

      obj: {
                                  type: Object,
                                  default: “”
                              }
                          }
                      }

      }

      17、子传父(组件自定义事件)

      老师文件:

      Examples

      // 


              
          

      Vue.component(“hello”, {
                  template:
                      <div>我父组件                         <hellochild  @myEvent="handleParent"></hellochild>                                 </div>,
                  //接收儿子给的myEvent
                  methods: {
                      handleParent(val) {
                          console.log(“子组件传来的值是:”, val)
                      }
                  },

      ​ var vm = new Vue({

      el: “#box”,
                  data: {

      },

      })

      18、solt

      老师文件:

      slot
      我是slota
      我是slotb
      </div>
      
      
      
      <script type="text/javascript">
          var hello = {
              template: `
              <div>
                 <slot name="slota"></slot>
                 hello 组件
                  <slot name="slotb"></slot>
              </div>
            `
          }
          new Vue({
              el: "#box",
              data: {
                  // isShow: true
              },
              components: {
                  hello
              }
          })
      </script>
      

      //


              
              
                  

      我是slota

                  
      我是slotb


          

      var hello = {
                  template: `


                  
                  hello 组件
                  
                  

      `
              }

      var vm = new Vue({

      el: “#box”,
                  data: {

      hello
                  }

      })

      19、search 和indexOf

      search找到返回0 找不到返回-1 用于字符串查找

      indexof 检索字符串是否出现,如果没有检索到返回-1

      console.log(this.dataList[0].name.indexOf("")) //如果是空字符串返回0 相当于都能查到

      console.log(this.dataList[0].name.search ("")) //如果是空字符串返回0 相当于都能查到

      20、动态数组

      Document
          <keep-alive>
              <!-- component元素,动态地绑定多个组件到它的is属性 -->
              <component :is='current'></component>
          </keep-alive>
          <!-- keep-alive保留状态,避免重新渲染,多用于手机端
          不用keep-alive 节省内存,但浪费性能,用户切换时等待时间长 -->
          <footer>
      
      
      
              <ul>
                  <li><a @click="current='home'">首页</a></li>
                  <li><a @click="current='list'">列表页</a></li>
                  <li><a @click="current='shopcar'">购物车页面</a></li>
              </ul>
      
          </footer>
      </div>
      
      
      
      <script type="text/javascript">
          var home = {
              template: `
      
              <div>home页面
                  <input type="text"/>
              </div>
            `
          }
          var list = {
              template: `
      
              <div>list页面</div>
            `
          }
          var shopcar = {
              template: `
      
              <div>shopcar页面</div>
            `
          }
          var vm = new Vue({
              el: "#box",
              data: {
                  current: 'home'
              },
      
              components: {
                  home,
                  list,
                  shopcar
              }
          })
      </script>
      

      21、生命周期(beforecreate指的是内部的new Vue)

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r0vz8Y3K-1616458490641)(file:///C:\Users\asus\Documents\Tencent Files\1264657821\Image\Group2\JA\9E\JA9EX$N1EII9TQ039BXLBSR.png)]

      node -v

      npm run dev 运行服务器

      vue 各文件介绍

      1. bulid ========= 构建脚本目录
        1)bulid.js =========生产环境构建简本
        2) check-versions.js ======= 检查 npm node.js 版本
        3)tuils.js =======构建相关工具方法
        4)vue-loader.conf.js ======= 配置css 加载器以及编译css之后自动添加前缀
        5)weback.base.conf.js ====== webpack 基本配置
        6)webpack.dev.js ======= webpack 开发环境配置
        7)webpack.prod.conf.js ====== webpack 生产环境配置

      2. config ==========项目配置
        1)dev.env.js =========开发环境变量
        2)index.js ========= 项目配置文件
        3)prod.env.js ======== 生产环境变量

      3. node_modules =======npm 加载的项目依赖模块

      4. src ===============这里就是我们要开发的目录,开发基本要做的事情都在这里

        1. assets 静态文件 包括图片,字体等, webpack 打包,重新编译。
          2)components ===== 组件目录 ,要写的组件放在这个目录里
          3)app.vue ========= 根组件
          4)router
          = 前端路由 我们需要配置的路由写在index.js里面
          5)main.js ========== 入口js文件
      5. static ===============静态资源目录,如图片,字体等,打包后不会被wabpack处理。

      6. .xxxxx文件============= 包括语法配置,git配置等

      7. index.html =============首页入口文件

      8. package.json ===========npm 配置文件,定义了项目的npm脚本,依赖包等信息

      9. README.md ============ 项目的说明文档

      vue 路由嵌套注意斜杆问题

      如果 路由组件 是一个另一个 路由组件 的 子路由组件 的话:

      在配置路由规则是,path 路径,前面不能添加 /, 他代表根路径;加上他就不会拼接上

      父路由组件的 path 路径的,如:

      演员:Hone.vue (父), New(子), Message(子)

      2个子路由组件想要显示在 父路由组件中;

      router > index.js

      import Home from ‘…/views/Home.vue’
      import New from ‘…/views/New.vue’
      import Message from ‘…/views/Message.vue’

      const router = new VueRouter({
      routers:[
      {
      path: ‘/home’,
      component: Home,
      children:[
      // 全写
      { path: ‘/home/new’, component: New },
      // 也可以简写,不过前面不能添加 斜杠
      { path: ‘message’, component: Message },
      ]
      }
      ]
      })

      view > Home.vue

      home

      new message

      *scoped //只对当前界面有效,防止界面污染

      path: ‘/’, 只写一个/ 表明直接跳这个相当于8080 就是这个

      router路由详解

      import Vue from ‘vue’

      import Router from ‘vue-router’

      import HelloWorld from ‘@/components/HelloWorld’ // @等于src

      import Home from ‘@/components/Home’

      import Card from ‘@/components/Card’

      import Film from ‘@/components/Film’

      import NowPlaying from ‘@/components/NowPlaying’

      import ComingSoon from ‘@/components/ComingSoon’

      import Detail from ‘@/components/Detail’

      import Hello from ‘@/components/Hello’

      import Table from ‘@/components/Table’

      Vue.use(Router)

      export default new Router({

      // 路由有两种模式,一种hash模式,一种history模式,如果用原始的a标签跳转,会出现兼容问题,只支持hash模式,history模式会失效

      routes: [

      {

      path: ‘/’,

      name: ‘table’,

      component: Table

      },

      ​ {

      path: ‘/hello’, //path后面是路径

      name: ‘hello’,

      component: Hello //组件

      },

      {

      path:"/home",

      name:“home”,

      component:Home

      },

      {

      path:"/card",

      name:“card”,

      component:Card

      },

      {

      path:"/film",

      component:Film,

      children:[{

      path:“nowplaying”,

      component:NowPlaying

      },

      {

      path:“comingsoon”,

      component:ComingSoon

      },

      {

      path:"/",

      redirect:"/film/nowplaying" //重定向,跳转到指定界面

      },

      {

      path:"/detail/:id", // /detail/dwa 动态路由

      name:“detail”,

      component:Detail

      }

      ]

      }

      ]

      })

      app

      home

      card

      film

      vuex

      安装

      vuex (全局状态管理)
      管理的数据是多页面需要共享的数据

      安装
      \1. npm install vuex --save

      \2. 在src 下新建store文件夹,然后新建 index.js 文件

      \3. main.js 引入注册

      import Vue from ‘vue’

      import Vuex from ‘vuex’

      const store = new Vuex.Store({

      ​ state:{

      ​ //存放的键值就是管理状态

      ​ name:“xiaomenb”,

      ​ age:18,

      ​ sex:“女”,

      ​ hobby:“sing”

      ​ }

      vuex (全局状态管理)
      管理的数据是多页面需要共享的数据

      安装

      1. npm install vuex --save
      
      2. 在src 下新建store文件夹,然后新建 index.js 文件
      3. main.js 引入注册
         4.挂载vuex
          vue.use(Vuex)
      
      1. // 创建vuex对象
        const store = new Vuex.Store({
        state: {
        // 存放的键值对就是管理状态
        name: “hello”
        }
        })

      2. 取数据
        this.KaTeX parse error: Expected '}', got 'EOF' at end of input: …tate.message {{store.state.message}}

      this.$router.push({path:"/home"}) //编程时路由

      router-link //声明式路由

      安装element

      npm i element-ui -S

      import ElementUI from ‘element-ui’;

      import ‘element-ui/lib/theme-chalk/index.css’

      Vue.config.productionTip = false

      Vue.use(ElementUI);


      1. 13579 ↩︎

      2. a-zA-Z ↩︎

      展开全文
    • Web 前端知识点总结

      千次阅读 2016-10-23 15:17:02
      3.如何看待前端开发? 4.平时是如何学习前端开发的? 5.未来三到五年的规划是怎样的? position的值, relative和absolute分别是相对于谁进行定位的? absolute :生成绝对定位的元素, 相对于最近一级的 ...

      一些开放性题目

      1.自我介绍:除了基本个人信息以外,面试官更想听的是你与众不同的地方和你的优势。
      
      2.项目介绍
      
      3.如何看待前端开发?
      
      4.平时是如何学习前端开发的?
      
      5.未来三到五年的规划是怎样的?
      


      position的值, relative和absolute分别是相对于谁进行定位的?

      • absolute :生成绝对定位的元素, 相对于最近一级的 定位不是 static 的父元素来进行定位。

      • fixed (老IE不支持)生成绝对定位的元素,通常相对于浏览器窗口或 frame 进行定位。

      • relative 生成相对定位的元素,相对于其在普通流中的位置进行定位。

      • static 默认值。没有定位,元素出现在正常的流中

      • sticky 生成粘性定位的元素,容器的位置根据正常文档流计算得出


      如何解决跨域问题

      JSONP:

      原理是:动态插入script标签,通过script标签引入一个js文件,这个js文件载入成功后会执行我们在url参数中指定的函数,并且会把我们需要的json数据作为参数传入。

      由于同源策略的限制,XmlHttpRequest只允许请求当前源(域名、协议、端口)的资源,为了实现跨域请求,可以通过script标签实现跨域请求,然后在服务端输出JSON数据并执行回调函数,从而解决了跨域的数据请求。

      优点是兼容性好,简单易用,支持浏览器与服务器双向通信。缺点是只支持GET请求。

      JSONPjson+padding(内填充),顾名思义,就是把JSON填充到一个盒子里

      <script>
          function createJs(sUrl){
      
              var oScript = document.createElement('script');
              oScript.type = 'text/javascript';
              oScript.src = sUrl;
              document.getElementsByTagName('head')[0].appendChild(oScript);
          }
      
          createJs('jsonp.js');
      
          box({
             'name': 'test'
          });
      
          function box(json){
              alert(json.name);
          }
      </script>

      CORS

      服务器端对于CORS的支持,主要就是通过设置Access-Control-Allow-Origin来进行的。如果浏览器检测到相应的设置,就可以允许Ajax进行跨域的访问。

      通过修改document.domain来跨子域

      将子域和主域的document.domain设为同一个主域.前提条件:这两个域名必须属于同一个基础域名!而且所用的协议,端口都要一致,否则无法利用document.domain进行跨域

      主域相同的使用document.domain

      使用window.name来进行跨域

      window对象有个name属性,该属性有个特征:即在一个窗口(window)的生命周期内,窗口载入的所有的页面都是共享一个window.name的,每个页面对window.name都有读写的权限,window.name是持久存在一个窗口载入过的所有页面中的

      使用HTML5中新引进的window.postMessage方法来跨域传送数据

      还有flash、在服务器上设置代理页面等跨域方式。个人认为window.name的方法既不复杂,也能兼容到几乎所有浏览器,这真是极好的一种跨域方法。

      XMLJSON的区别?

      (1).数据体积方面。
      
      JSON相对于XML来讲,数据的体积小,传递的速度更快些。
      
      (2).数据交互方面。
      
      JSON与JavaScript的交互更加方便,更容易解析处理,更好的数据交互。
      
      (3).数据描述方面。
      
      JSON对数据的描述性比XML较差。
      
      (4).传输速度方面。
      
      JSON的速度要远远快于XML。

      谈谈你对webpack的看法

      WebPack 是一个模块打包工具,你可以使用WebPack管理你的模块依赖,并编绎输出模块们所需的静态文件。它能够很好地管理、打包Web开发中所用到的HTML、Javascript、CSS以及各种静态文件(图片、字体等),让开发过程更加高效。对于不同类型的资源,webpack有对应的模块加载器。webpack模块打包器会分析模块间的依赖关系,最后 生成了优化且合并后的静态资源。

      webpack的两大特色:

      1.code splitting(可以自动完成)
      
      2.loader 可以处理各种类型的静态文件,并且支持串联操作
      

      webpack 是以commonJS的形式来书写脚本滴,但对 AMD/CMD 的支持也很全面,方便旧项目进行代码迁移。

      webpack具有requireJsbrowserify的功能,但仍有很多自己的新特性:

      1. 对 CommonJS 、 AMD 、ES6的语法做了兼容
      
      2. 对js、css、图片等资源文件都支持打包
      
      3. 串联式模块加载器以及插件机制,让其具有更好的灵活性和扩展性,例如提供对CoffeeScript、ES6的支持
      
      4. 有独立的配置文件webpack.config.js
      
      5. 可以将代码切割成不同的chunk,实现按需加载,降低了初始化时间
      
      6. 支持 SourceUrls 和 SourceMaps,易于调试
      
      7. 具有强大的Plugin接口,大多是内部插件,使用起来比较灵活
      
      8.webpack 使用异步 IO 并具有多级缓存。这使得 webpack 很快且在增量编译上更加快
      

      说说TCP传输的三次握手四次挥手策略

      为了准确无误地把数据送达目标处,TCP协议采用了三次握手策略。用TCP协议把数据包送出去后,TCP不会对传送 后的情况置之不理,它一定会向对方确认是否成功送达。握手过程中使用了TCP的标志:SYNACK

      发送端首先发送一个带SYN标志的数据包给对方。接收端收到后,回传一个带有SYN/ACK标志的数据包以示传达确认信息。 最后,发送端再回传一个带ACK标志的数据包,代表“握手”结束。 若在握手过程中某个阶段莫名中断,TCP协议会再次以相同的顺序发送相同的数据包。


      断开一个TCP连接则需要“四次握手”:

      • 第一次挥手:主动关闭方发送一个FIN,用来关闭主动方到被动关闭方的数据传送,也就是主动关闭方告诉被动关闭方:我已经不 会再给你发数据了(当然,在fin包之前发送出去的数据,如果没有收到对应的ack确认报文,主动关闭方依然会重发这些数据),但是,此时主动关闭方还可 以接受数据。

      • 第二次挥手:被动关闭方收到FIN包后,发送一个ACK给对方,确认序号为收到序号+1(与SYN相同,一个FIN占用一个序号)。

      • 第三次挥手:被动关闭方发送一个FIN,用来关闭被动关闭方到主动关闭方的数据传送,也就是告诉主动关闭方,我的数据也发送完了,不会再给你发数据了。

      • 第四次挥手:主动关闭方收到FIN后,发送一个ACK给被动关闭方,确认序号为收到序号+1,至此,完成四次挥手。

      TCP和UDP的区别

      TCP(Transmission Control Protocol,传输控制协议)是基于连接的协议,也就是说,在正式收发数据前,必须和对方建立可靠的连接。一个TCP连接必须要经过三次“对话”才能建立起来

      UDP(User Data Protocol,用户数据报协议)是与TCP相对应的协议。它是面向非连接的协议,它不与对方建立连接,而是直接就把数据包发送过去! UDP适用于一次只传送少量数据、对可靠性要求不高的应用环境。

      说说你对作用域链的理解

      作用域链的作用是保证执行环境里有权访问的变量和函数是有序的,作用域链的变量只能向上访问,变量访问到window对象即被终止,作用域链向下访问变量是不被允许的。

      创建ajax过程

      (1)创建XMLHttpRequest对象,也就是创建一个异步调用对象.
      
      (2)创建一个新的HTTP请求,并指定该HTTP请求的方法、URL及验证信息.
      
      (3)设置响应HTTP请求状态变化的函数.
      
      (4)发送HTTP请求.
      
      (5)获取异步调用返回的数据.
      
      (6)使用JavaScript和DOM实现局部刷新.

      渐进增强和优雅降级

      渐进增强 :针对低版本浏览器进行构建页面,保证最基本的功能,然后再针对高级浏览器进行效果、交互等改进和追加功能达到更好的用户体验。

      优雅降级 :一开始就构建完整的功能,然后再针对低版本浏览器进行兼容。

      常见web安全及防护原理

      sql注入原理

      就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串,最终达到欺骗服务器执行恶意的SQL命令。

      总的来说有以下几点:

      
          1.永远不要信任用户的输入,要对用户的输入进行校验,可以通过正则表达式,或限制长度,对单引号和双"-"进行转换等。
      
          2.永远不要使用动态拼装SQL,可以使用参数化的SQL或者直接使用存储过程进行数据查询存取。
      
          3.永远不要使用管理员权限的数据库连接,为每个应用使用单独的权限有限的数据库连接。
      
          4.不要把机密信息明文存放,请加密或者hash掉密码和敏感的信息。
      

      XSS原理及防范

      Xss(cross-site scripting)攻击指的是攻击者往Web页面里插入恶意 html标签或者javascript代码。比如:攻击者在论坛中放一个

      看似安全的链接,骗取用户点击后,窃取cookie中的用户私密信息;或者攻击者在论坛中加一个恶意表单,

      当用户提交表单的时候,却把信息传送到攻击者的服务器中,而不是用户原本以为的信任站点。

      XSS防范方法

      首先代码里对用户输入的地方和变量都需要仔细检查长度和对”<”,”>”,”;”,”’”等字符做过滤;其次任何内容写到页面之前都必须加以encode,避免不小心把html tag 弄出来。这一个层面做好,至少可以堵住超过一半的XSS 攻击。

      首先,避免直接在cookie 中泄露用户隐私,例如email、密码等等。

      其次,通过使cookie 和系统ip 绑定来降低cookie 泄露后的危险。这样攻击者得到的cookie 没有实际价值,不可能拿来重放。

      如果网站不需要再浏览器端对cookie 进行操作,可以在Set-Cookie 末尾加上HttpOnly 来防止javascript 代码直接获取cookie 。

      尽量采用POST 而非GET 提交表单

      XSS与CSRF有什么区别吗?

      XSS是获取信息,不需要提前知道其他用户页面的代码和数据包。CSRF是代替用户完成指定的动作,需要知道其他用户页面的代码和数据包。

      要完成一次CSRF攻击,受害者必须依次完成两个步骤:

      登录受信任网站A,并在本地生成Cookie。
      
      在不登出A的情况下,访问危险网站B。
      

      CSRF的防御

      • 服务端的CSRF方式方法很多样,但总的思想都是一致的,就是在客户端页面增加伪随机数。

      • 通过验证码的方法

      Web Worker 和webSocket

      worker主线程:

          1.通过 worker = new Worker( url ) 加载一个JS文件来创建一个worker,同时返回一个worker实例。
      
          2.通过worker.postMessage( data ) 方法来向worker发送数据。
      
          3.绑定worker.onmessage方法来接收worker发送过来的数据。
      
          4.可以使用 worker.terminate() 来终止一个worker的执行。

      WebSocketWeb应用程序的传输协议,它提供了双向的,按序到达的数据流。他是一个HTML5协议,WebSocket的连接是持久的,他通过在客户端和服务器之间保持双工连接,服务器的更新可以被及时推送给客户端,而不需要客户端以一定时间间隔去轮询。

      HTTP和HTTPS

      HTTP协议通常承载于TCP协议之上,在HTTPTCP之间添加一个安全协议层(SSLTSL),这个时候,就成了我们常说的HTTPS。

      默认HTTP的端口号为80,HTTPS的端口号为443。

      为什么HTTPS安全

      因为网络请求需要中间有很多的服务器路由器的转发。中间的节点都可能篡改信息,而如果使用HTTPS,密钥在你和终点站才有。https之所以比http安全,是因为他利用ssl/tls协议传输。它包含证书,卸载,流量转发,负载均衡,页面适配,浏览器适配,refer传递等。保障了传输过程的安全性

      对前端模块化的认识

      AMD 是 RequireJS 在推广过程中对模块定义的规范化产出。

      CMD 是 SeaJS 在推广过程中对模块定义的规范化产出。

      AMD 是提前执行,CMD 是延迟执行。

      AMD推荐的风格通过返回一个对象做为模块对象,CommonJS的风格通过对module.exportsexports的属性赋值来达到暴露模块对象的目的。

      CMD模块方式

          define(function(require, exports, module) {
      
            // 模块代码
      
          });

      Javascript垃圾回收方法

      标记清除(mark and sweep)

      这是JavaScript最常见的垃圾回收方式,当变量进入执行环境的时候,比如函数中声明一个变量,垃圾回收器将其标记为“进入环境”,当变量离开环境的时候(函数执行结束)将其标记为“离开环境”。

      垃圾回收器会在运行的时候给存储在内存中的所有变量加上标记,然后去掉环境中的变量以及被环境中变量所引用的变量(闭包),在这些完成之后仍存在标记的就是要删除的变量了

      引用计数(reference counting)

      在低版本IE中经常会出现内存泄露,很多时候就是因为其采用引用计数方式进行垃圾回收。引用计数的策略是跟踪记录每个值被使用的次数,当声明了一个 变量并将一个引用类型赋值给该变量的时候这个值的引用次数就加1,如果该变量的值变成了另外一个,则这个值得引用次数减1,当这个值的引用次数变为0的时 候,说明没有变量在使用,这个值没法被访问了,因此可以将其占用的空间回收,这样垃圾回收器会在运行的时候清理掉引用次数为0的值占用的空间。

      在IE中虽然JavaScript对象通过标记清除的方式进行垃圾回收,但BOM与DOM对象却是通过引用计数回收垃圾的, 也就是说只要涉及BOM及DOM就会出现循环引用问题。

      你觉得前端工程的价值体现在哪

      为简化用户使用提供技术支持(交互部分)
      
      为多个浏览器兼容性提供支持
      
      为提高用户浏览速度(浏览器性能)提供支持
      
      为跨平台或者其他基于webkit或其他渲染引擎的应用提供支持
      
      为展示数据提供支持(数据接口)
      

      谈谈性能优化问题

      代码层面:避免使用css表达式,避免使用高级选择器,通配选择器。

      缓存利用:缓存Ajax,使用CDN,使用外部js和css文件以便缓存,添加Expires头,服务端配置Etag,减少DNS查找等

      请求数量:合并样式和脚本,使用css图片精灵,初始首屏之外的图片资源按需加载,静态资源延迟加载。

      请求带宽:压缩文件,开启GZIP,

      代码层面的优化

      • hash-table来优化查找

      • 少用全局变量

      • innerHTML代替DOM操作,减少DOM操作次数,优化javascript性能

      • setTimeout来避免页面失去响应

      • 缓存DOM节点查找的结果

      • 避免使用CSS Expression

      • 避免全局查询

      • 避免使用with(with会创建自己的作用域,会增加作用域链长度)

      • 多个变量声明合并

      • 避免图片和iFrame等的空Src。空Src会重新加载当前页面,影响速度和效率

      • 尽量避免写在HTML标签中写Style属性

      移动端性能优化

      • 尽量使用css3动画,开启硬件加速。
      • 适当使用touch事件代替click事件。
      • 避免使用css3渐变阴影效果。
      • 可以用transform: translateZ(0)来开启硬件加速。
      • 不滥用Float。Float在渲染时计算量比较大,尽量减少使用
      • 不滥用Web字体。Web字体需要下载,解析,重绘当前页面,尽量减少使用。
      • 合理使用requestAnimationFrame动画代替setTimeout
      • CSS中的属性(CSS3 transitions、CSS3 3D transforms、Opacity、Canvas、WebGL、Video)会触发GPU渲染,请合理使用。过渡使用会引发手机过耗电增加
      • PC端的在移动端同样适用

      相关阅读:如何做到一秒渲染一个移动页面

      什么是Etag?

      当发送一个服务器请求时,浏览器首先会进行缓存过期判断。浏览器根据缓存过期时间判断缓存文件是否过期。

      情景一:若没有过期,则不向服务器发送请求,直接使用缓存中的结果,此时我们在浏览器控制台中可以看到 200 OK(from cache) ,此时的情况就是完全使用缓存,浏览器和服务器没有任何交互的。

      情景二:若已过期,则向服务器发送请求,此时请求中会带上①中设置的文件修改时间,和Etag

      然后,进行资源更新判断。服务器根据浏览器传过来的文件修改时间,判断自浏览器上一次请求之后,文件是不是没有被修改过;根据Etag,判断文件内容自上一次请求之后,有没有发生变化

      情形一:若两种判断的结论都是文件没有被修改过,则服务器就不给浏览器发index.html的内容了,直接告诉它,文件没有被修改过,你用你那边的缓存吧—— 304 Not Modified,此时浏览器就会从本地缓存中获取index.html的内容。此时的情况叫协议缓存,浏览器和服务器之间有一次请求交互。

      情形二:若修改时间和文件内容判断有任意一个没有通过,则服务器会受理此次请求,之后的操作同①


      ① 只有get请求会被缓存,post请求不会

      Expires和Cache-Control

      Expires要求客户端和服务端的时钟严格同步。HTTP1.1引入Cache-Control来克服Expires头的限制。如果max-age和Expires同时出现,则max-age有更高的优先级。

          Cache-Control: no-cache, private, max-age=0
      
          ETag: abcde
      
          Expires: Thu, 15 Apr 2014 20:00:00 GMT
      
          Pragma: private
      
          Last-Modified: $now // RFC1123 format

      ETag应用:

      Etag由服务器端生成,客户端通过If-Match或者说If-None-Match这个条件判断请求来验证资源是否修改。常见的是使用If-None-Match。请求一个文件的流程可能如下:

      ====第一次请求===

      1.客户端发起 HTTP GET 请求一个文件;
      
      2.服务器处理请求,返回文件内容和一堆Header,当然包括Etag(例如"2e681a-6-5d044840")(假设服务器支持Etag生成和已经开启了Etag).状态码200
      

      ====第二次请求===

      客户端发起 HTTP GET 请求一个文件,注意这个时候客户端同时发送一个If-None-Match头,这个头的内容就是第一次请求时服务器返回的Etag:2e681a-6-5d0448402.服务器判断发送过来的Etag和计算出来的Etag匹配,因此If-None-Match为False,不返回200,返回304,客户端继续使用本地缓存;流程很简单,问题是,如果服务器又设置了Cache-Control:max-age和Expires呢,怎么办
      

      答案是同时使用,也就是说在完全匹配If-Modified-SinceIf-None-Match即检查完修改时间和Etag之后,

      服务器才能返回304.(不要陷入到底使用谁的问题怪圈)

      为什么使用Etag请求头?

      Etag 主要为了解决 Last-Modified 无法解决的一些问题。

      栈和队列的区别?

      栈的插入和删除操作都是在一端进行的,而队列的操作却是在两端进行的。
      
      队列先进先出,栈先进后出。
      
      栈只允许在表尾一端进行插入和删除,而队列只允许在表尾一端进行插入,在表头一端进行删除
      

      栈和堆的区别?

      栈区(stack)—   由编译器自动分配释放   ,存放函数的参数值,局部变量的值等。
      
      堆区(heap)   —   一般由程序员分配释放,   若程序员不释放,程序结束时可能由OS回收。
      
      堆(数据结构):堆可以被看成是一棵树,如:堆排序;
      
      栈(数据结构):一种先进后出的数据结构。
      

      快速 排序的思想并实现一个快排?

      "快速排序"的思想很简单,整个排序过程只需要三步:

        (1)在数据集之中,找一个基准点

        (2)建立两个数组,分别存储左边和右边的数组

        (3)利用递归进行下次比较

          <script type="text/javascript">
      
              function quickSort(arr){
                  if(arr.length<=1){
                      return arr;//如果数组只有一个数,就直接返回;
                  }
      
                  var num = Math.floor(arr.length/2);//找到中间数的索引值,如果是浮点数,则向下取整
      
                  var numValue = arr.splice(num,1);//找到中间数的值
                  var left = [];
                  var right = [];
      
                  for(var i=0;i<arr.length;i++){
                      if(arr[i]<numValue){
                          left.push(arr[i]);//基准点的左边的数传到左边数组
                      }
                      else{
                         right.push(arr[i]);//基准点的右边的数传到右边数组
                      }
                  }
      
                  return quickSort(left).concat([numValue],quickSort(right));//递归不断重复比较
              }
      
              alert(quickSort([32,45,37,16,2,87]));//弹出“2,16,32,37,45,87”
      
          </script>

      你觉得jQuery或zepto源码有哪些写的好的地方

      (答案仅供参考)

      jquery源码封装在一个匿名函数的自执行环境中,有助于防止变量的全局污染,然后通过传入window对象参数,可以使window对象作为局部变量使用,好处是当jquery中访问window对象的时候,就不用将作用域链退回到顶层作用域了,从而可以更快的访问window对象。同样,传入undefined参数,可以缩短查找undefined时的作用域链。

          (function( window, undefined ) {
      
               //用一个函数域包起来,就是所谓的沙箱
      
               //在这里边var定义的变量,属于这个函数域内的局部变量,避免污染全局
      
               //把当前沙箱需要的外部变量通过函数参数引入进来
      
               //只要保证参数对内提供的接口的一致性,你还可以随意替换传进来的这个参数
      
              window.jQuery = window.$ = jQuery;
      
          })( window );

      jquery将一些原型属性和方法封装在了jquery.prototype中,为了缩短名称,又赋值给了jquery.fn,这是很形象的写法。

      有一些数组或对象的方法经常能使用到,jQuery将其保存为局部变量以提高访问速度。

      jquery实现的链式调用可以节约代码,所返回的都是同一个对象,可以提高代码效率。

      ES6的了解

      新增模板字符串(为JavaScript提供了简单的字符串插值功能)、箭头函数(操作符左边为输入的参数,而右边则是进行的操作以及返回的值Inputs=>outputs。)、for-of(用来遍历数据—例如数组中的值。)arguments对象可被不定参数和默认参数完美代替。ES6promise对象纳入规范,提供了原生的Promise对象。增加了letconst命令,用来声明变量。增加了块级作用域。let命令实际上就增加了块级作用域。ES6规定,var命令和function命令声明的全局变量,属于全局对象的属性;let命令、const命令、class命令声明的全局变量,不属于全局对象的属性。。还有就是引入module模块的概念

      js继承方式及其优缺点

      原型链继承的缺点

      一是字面量重写原型会中断关系,使用引用类型的原型,并且子类型还无法给超类型传递参数。
      

      借用构造函数(类式继承)

      借用构造函数虽然解决了刚才两种问题,但没有原型,则复用无从谈起。所以我们需要原型链+借用构造函数的模式,这种模式称为组合继承
      

      组合式继承

      组合式继承是比较常用的一种继承方法,其背后的思路是 使用原型链实现对原型属性和方法的继承,而通过借用构造函数来实现对实例属性的继承。这样,既通过在原型上定义方法实现了函数复用,又保证每个实例都有它自己的属性。
      

      具体请看:JavaScript继承方式详解

      关于Http 2.0 你知道多少?

      HTTP/2引入了“服务端推(server push)”的概念,它允许服务端在客户端需要数据之前就主动地将数据发送到客户端缓存中,从而提高性能。

      HTTP/2提供更多的加密支持

      HTTP/2使用多路技术,允许多个消息在一个连接上同时交差。

      它增加了头压缩(header compression),因此即使非常小的请求,其请求和响应的header都只会占用很小比例的带宽。


      defer和async

      defer并行加载js文件,会按照页面上script标签的顺序执行 async并行加载js文件,下载完成立即执行,不会按照页面上script标签的顺序执行

      谈谈浮动和清除浮动

      浮动的框可以向左或向右移动,直到他的外边缘碰到包含框或另一个浮动框的边框为止。由于浮动框不在文档的普通流中,所以文档的普通流的块框表现得就像浮动框不存在一样。浮动的块框会漂浮在文档普通流的块框上。

      如何评价AngularJS和BackboneJS

      backbone具有依赖性,依赖underscore.jsBackbone + Underscore + jQuery(or Zepto) 就比一个AngularJS 多出了2 次HTTP请求.


      BackboneModel没有与UI视图数据绑定,而是需要在View中自行操作DOM来更新或读取UI数据。AngularJS与此相反,Model直接与UI视图绑定,Model与UI视图的关系,通过directive封装,AngularJS内置的通用directive,就能实现大部分操作了,也就是说,基本不必关心Model与UI视图的关系,直接操作Model就行了,UI视图自动更新。


      AngularJSdirective,你输入特定数据,他就能输出相应UI视图。是一个比较完善的前端MVW框架,包含模板,数据双向绑定,路由,模块化,服务,依赖注入等所有功能,模板功能强大丰富,并且是声明式的,自带了丰富的 Angular 指令。

      用过哪些设计模式?

      工厂模式:

      主要好处就是可以消除对象间的耦合,通过使用工程方法而不是new关键字。将所有实例化的代码集中在一个位置防止代码重复。
      
          工厂模式解决了重复实例化的问题 ,但还有一个问题,那就是识别问题,因为根本无法 搞清楚他们到底是哪个对象的实例。
      
      
      function createObject(name,age,profession){//集中实例化的函数var obj = new Object();
          obj.name = name;
          obj.age = age;
          obj.profession = profession;
          obj.move = function () {
              return this.name + ' at ' + this.age + ' engaged in ' + this.profession;
          };
          return obj;
      }
      var test1 = createObject('trigkit4',22,'programmer');//第一个实例var test2 = createObject('mike',25,'engineer');//第二个实例
      


      构造函数模式

      使用构造函数的方法 ,即解决了重复实例化的问题 ,又解决了对象识别的问题,该模式与工厂模式的不同之处在于:

      1.构造函数方法没有显示的创建对象 (new Object());
      
      2.直接将属性和方法赋值给 this 对象;
      
      3.没有 renturn 语句。
      

      说说你对闭包的理解

      使用闭包主要是为了设计私有的方法和变量。闭包的优点是可以避免全局变量的污染,缺点是闭包会常驻内存,会增大内存使用量,使用不当很容易造成内存泄露。在js中,函数即闭包,只有函数才会产生作用域的概念

      闭包有三个特性:

      1.函数嵌套函数

      2.函数内部可以引用外部的参数和变量

      3.参数和变量不会被垃圾回收机制回收

      具体请看:详解js闭包

      请你谈谈Cookie的弊端

      cookie虽然在持久保存客户端数据提供了方便,分担了服务器存储的负担,但还是有很多局限性的。

      第一:每个特定的域名下最多生成20个cookie

      1.IE6或更低版本最多20个cookie
      
      2.IE7和之后的版本最后可以有50个cookie。
      
      3.Firefox最多50个cookie
      
      4.chrome和Safari没有做硬性限制
      

      IEOpera 会清理近期最少使用的cookieFirefox会随机清理cookie

      cookie的最大大约为4096字节,为了兼容性,一般不能超过4095字节。

      IE 提供了一种存储可以持久化用户数据,叫做userdata,从IE5.0就开始支持。每个数据最多128K,每个域名下最多1M。这个持久化数据放在缓存中,如果缓存没有清理,那么会一直存在。

      优点:极高的扩展性和可用性

      1.通过良好的编程,控制保存在cookie中的session对象的大小。
      
      2.通过加密和安全传输技术(SSL),减少cookie被破解的可能性。
      
      3.只在cookie中存放不敏感数据,即使被盗也不会有重大损失。
      
      4.控制cookie的生命期,使之不会永远有效。偷盗者很可能拿到一个过期的cookie。
      

      缺点:

      1.`Cookie`数量和长度的限制。每个domain最多只能有20条cookie,每个cookie长度不能超过4KB,否则会被截掉.
      
      
      2.安全性问题。如果cookie被人拦截了,那人就可以取得所有的session信息。即使加密也与事无补,因为拦截者并不需要知道cookie的意义,他只要原样转发cookie就可以达到目的了。
      
      3.有些状态不可能保存在客户端。例如,为了防止重复提交表单,我们需要在服务器端保存一个计数器。如果我们把这个计数器保存在客户端,那么它起不到任何作用。
      

      浏览器本地存储

      在较高版本的浏览器中,js提供了sessionStorageglobalStorage。在HTML5中提供了localStorage来取代globalStorage

      html5中的Web Storage包括了两种存储方式:sessionStoragelocalStorage

      sessionStorage用于本地存储一个会话(session)中的数据,这些数据只有在同一个会话中的页面才能访问并且当会话结束后数据也随之销毁。因此sessionStorage不是一种持久化的本地存储,仅仅是会话级别的存储。

      localStorage用于持久化的本地存储,除非主动删除数据,否则数据是永远不会过期的。

      web storage和cookie的区别

      Web Storage的概念和cookie相似,区别是它是为了更大容量存储设计的。Cookie的大小是受限的,并且每次你请求一个新的页面的时候Cookie都会被发送过去,这样无形中浪费了带宽,另外cookie还需要指定作用域,不可以跨域调用。

      除此之外,Web Storage拥有setItem,getItem,removeItem,clear等方法,不像cookie需要前端开发者自己封装setCookie,getCookie

      但是cookie也是不可以或缺的:cookie的作用是与服务器进行交互,作为HTTP规范的一部分而存在 ,而Web Storage仅仅是为了在本地“存储”数据而生

      浏览器的支持除了IE7及以下不支持外,其他标准浏览器都完全支持(ie及FF需在web服务器里运行),值得一提的是IE总是办好事,例如IE7、IE6中的userData其实就是javascript本地存储的解决方案。通过简单的代码封装可以统一到所有的浏览器都支持web storage

      localStoragesessionStorage都具有相同的操作方法,例如setItem、getItemremoveItem

      cookie 和session 的区别:

       1、cookie数据存放在客户的浏览器上,session数据放在服务器上。
      
       2、cookie不是很安全,别人可以分析存放在本地的COOKIE并进行COOKIE欺骗
      
          考虑到安全应当使用session。
      
       3、session会在一定时间内保存在服务器上。当访问增多,会比较占用你服务器的性能
      
           考虑到减轻服务器性能方面,应当使用COOKIE。
      
       4、单个cookie保存的数据不能超过4K,很多浏览器都限制一个站点最多保存20个cookie。
      
       5、所以个人建议:
      
          将登陆信息等重要信息存放为SESSION
      
          其他信息如果需要保留,可以放在COOKIE中
      

      display:nonevisibility:hidden的区别?

      display:none  隐藏对应的元素,在文档布局中不再给它分配空间,它各边的元素会合拢,就当他从来不存在。
      
      visibility:hidden  隐藏对应的元素,但是在文档布局中仍保留原来的空间。
      

      CSS中link 和@import的区别是?

      (1) link属于HTML标签,而@import是CSS提供的;
      
      (2) 页面被加载的时,link会同时被加载,而@import被引用的CSS会等到引用它的CSS文件被加载完再加载;
      
      (3) import只在IE5以上才能识别,而link是HTML标签,无兼容问题;
      
      (4) link方式的样式的权重 高于@import的权重.
      

      position:absolutefloat属性的异同

      • 共同点:对内联元素设置floatabsolute属性,可以让元素脱离文档流,并且可以设置其宽高。

      • 不同点:float仍会占据位置,absolute会覆盖文档流中的其他元素。

      介绍一下box-sizing属性?

      box-sizing属性主要用来控制元素的盒模型的解析模式。默认值是content-box

      • content-box:让元素维持W3C的标准盒模型。元素的宽度/高度由border + padding + content的宽度/高度决定,设置width/height属性指的是content部分的宽/高

      • border-box:让元素维持IE传统盒模型(IE6以下版本和IE6~7的怪异模式)。设置width/height属性指的是border + padding + content

      标准浏览器下,按照W3C规范对盒模型解析,一旦修改了元素的边框或内距,就会影响元素的盒子尺寸,就不得不重新计算元素的盒子尺寸,从而影响整个页面的布局。

      CSS 选择符有哪些?哪些属性可以继承?优先级算法如何计算? CSS3新增伪类有那些?

          1.id选择器( # myid)
      
          2.类选择器(.myclassname)
      
          3.标签选择器(div, h1, p)
      
          4.相邻选择器(h1 + p)
      
          5.子选择器(ul > li)
      
          6.后代选择器(li a)
      
          7.通配符选择器( * )
      
          8.属性选择器(a[rel = "external"])
      
          9.伪类选择器(a: hover, li:nth-child)

      优先级为:

      !important > id > class > tag

      important 比 内联优先级高,但内联比 id 要高

      CSS3新增伪类举例:

          p:first-of-type 选择属于其父元素的首个 <p> 元素的每个 <p> 元素。
      
          p:last-of-type  选择属于其父元素的最后 <p> 元素的每个 <p> 元素。
      
          p:only-of-type  选择属于其父元素唯一的 <p> 元素的每个 <p> 元素。
      
          p:only-child    选择属于其父元素的唯一子元素的每个 <p> 元素。
      
          p:nth-child(2)  选择属于其父元素的第二个子元素的每个 <p> 元素。
      
          :enabled  :disabled 控制表单控件的禁用状态。
      
          :checked        单选框或复选框被选中。

      CSS3有哪些新特性?

      CSS3实现圆角(border-radius),阴影(box-shadow),
      
      对文字加特效(text-shadow、),线性渐变(gradient),旋转(transform)
      
      transform:rotate(9deg) scale(0.85,0.90) translate(0px,-30px) skew(-9deg,0deg);//旋转,缩放,定位,倾斜
      
      增加了更多的CSS选择器  多背景 rgba
      
      在CSS3中唯一引入的伪元素是::selection.
      
      媒体查询,多栏布局
      
      border-image
      

      CSS3中新增了一种盒模型计算方式:box-sizing。盒模型默认的值是content-box, 新增的值是padding-boxborder-box,几种盒模型计算元素宽高的区别如下:

      content-box(默认)

      布局所占宽度Width:

      Width = width + padding-left + padding-right + border-left + border-right
      

      布局所占高度Height:

      Height = height + padding-top + padding-bottom + border-top + border-bottom
      

      padding-box

      布局所占宽度Width:

      Width = width(包含padding-left + padding-right) + border-top + border-bottom
      

      布局所占高度Height:

      Height = height(包含padding-top + padding-bottom) + border-top + border-bottom
      
      

      border-box

      布局所占宽度Width:

      Width = width(包含padding-left + padding-right + border-left + border-right)

      布局所占高度Height:

      Height = height(包含padding-top + padding-bottom + border-top + border-bottom)

      对BFC规范的理解?

            BFC,块级格式化上下文,一个创建了新的BFC的盒子是独立布局的,盒子里面的子元素的样式不会影响到外面的元素。在同一个BFC中的两个毗邻的块级盒在垂直方向(和布局方向有关系)的margin会发生折叠。
      
          (W3C CSS 2.1 规范中的一个概念,它决定了元素如何对其内容进行布局,以及与其他元素的关系和相互作用。
      

      说说你对语义化的理解?

      1,去掉或者丢失样式的时候能够让页面呈现出清晰的结构
      
      2,有利于SEO:和搜索引擎建立良好沟通,有助于爬虫抓取更多的有效信息:爬虫依赖于标签来确定上下文和各个关键字的权重;
      
      3,方便其他设备解析(如屏幕阅读器、盲人阅读器、移动设备)以意义的方式来渲染网页;
      
      4,便于团队开发和维护,语义化更具可读性,是下一步吧网页的重要动向,遵循W3C标准的团队都遵循这个标准,可以减少差异化。
      

      Doctype作用? 严格模式与混杂模式如何区分?它们有何意义?

      1)、<!DOCTYPE> 声明位于文档中的最前面,处于 <html> 标签之前。告知浏览器以何种模式来渲染文档。

      2)、严格模式的排版和 JS 运作模式是 以该浏览器支持的最高标准运行。

      3)、在混杂模式中,页面以宽松的向后兼容的方式显示。模拟老式浏览器的行为以防止站点无法工作。

      4)、DOCTYPE不存在或格式不正确会导致文档以混杂模式呈现。

      你知道多少种Doctype文档类型?

       该标签可声明三种 DTD 类型,分别表示严格版本、过渡版本以及基于框架的 HTML 文档。
      
       HTML 4.01 规定了三种文档类型:Strict、Transitional 以及 Frameset。
      
       XHTML 1.0 规定了三种 XML 文档类型:Strict、Transitional 以及 Frameset。
      
      Standards (标准)模式(也就是严格呈现模式)用于呈现遵循最新标准的网页,而 Quirks
      
       (包容)模式(也就是松散呈现模式或者兼容模式)用于呈现为传统浏览器而设计的网页。
      

      HTML与XHTML——二者有什么区别

      区别:
      
      1.所有的标记都必须要有一个相应的结束标记
      
      2.所有标签的元素和属性的名字都必须使用小写
      
      3.所有的XML标记都必须合理嵌套
      
      4.所有的属性必须用引号""括起来
      
      5.把所有<和&特殊符号用编码表示
      
      6.给所有属性赋一个值
      
      7.不要在注释内容中使“--”
      
      8.图片必须有说明文字
      

      常见兼容性问题?

      png24位的图片在iE6浏览器上出现背景,解决方案是做成PNG8.也可以引用一段脚本处理.
      
      浏览器默认的margin和padding不同。解决方案是加一个全局的*{margin:0;padding:0;}来统一。
      
      IE6双边距bug:块属性标签float后,又有横行的margin情况下,在ie6显示margin比设置的大。
      
      浮动ie产生的双倍距离(IE6双边距问题:在IE6下,如果对元素设置了浮动,同时又设置了margin-left或margin-right,margin值会加倍。)
      
      #box{ float:left; width:10px; margin:0 0 0 100px;}
      
      这种情况之下IE会产生20px的距离,解决方案是在float的标签样式控制中加入
      _display:inline;将其转化为行内属性。(_这个符号只有ie6会识别)
      
      渐进识别的方式,从总体中逐渐排除局部。
      
      
        首先,巧妙的使用“\9”这一标记,将IE游览器从所有情况中分离出来。
      
        接着,再次使用“+”将IE8和IE7、IE6分离开来,这样IE8已经独立识别。
      
        css
      
            .bb{
      
             background-color:#f1ee18;/*所有识别*/
      
            .background-color:#00deff\9; /*IE6、7、8识别*/
      
            +background-color:#a200ff;/*IE6、7识别*/
      
            _background-color:#1e0bd1;/*IE6识别*/
      
            }
      
      
      怪异模式问题:漏写DTD声明,Firefox仍然会按照标准模式来解析网页,但在IE中会触发
      怪异模式。为避免怪异模式给我们带来不必要的麻烦,最好养成书写DTD声明的好习惯。现在
      可以使用[html5](http://www.w3.org/TR/html5/single-page.html)推荐的写法:`<doctype html>`
      

      上下margin重合问题

      ie和ff都存在,相邻的两个div的margin-left和margin-right不会重合,但是margin-top和margin-bottom却会发生重合。
      
      解决方法,养成良好的代码编写习惯,同时采用margin-top或者同时采用margin-bottom。
      

      解释下浮动和它的工作原理?清除浮动的技巧

      浮动元素脱离文档流,不占据空间。浮动元素碰到包含它的边框或者浮动元素的边框停留。
      
      
      1.使用空标签清除浮动。
      
         这种方法是在所有浮动标签后面添加一个空标签 定义css clear:both. 弊端就是增加了无意义标签。
      
      2.使用overflow。
      
         给包含浮动元素的父标签添加css属性 overflow:auto; zoom:1; zoom:1用于兼容IE6。
      
      3.使用after伪对象清除浮动。
      
         该方法只适用于非IE浏览器。具体写法可参照以下示例。使用中需注意以下几点。一、该方法中必须为需要清除浮动元素的伪对象中设置 height:0,否则该元素会比实际高出若干像素;
      

      浮动元素引起的问题和解决办法?

      浮动元素引起的问题:
      
      (1)父元素的高度无法被撑开,影响与父元素同级的元素
      
      (2)与浮动元素同级的非浮动元素(内联元素)会跟随其后
      
      (3)若非第一个元素浮动,则该元素之前的元素也需要浮动,否则会影响页面显示的结构
      

      解决方法:

      使用CSS中的clear:both;属性来清除元素的浮动可解决2、3问题,对于问题1,添加如下样式,给父元素添加clearfix样式:

          .clearfix:after{content: ".";display: block;height: 0;clear: both;visibility: hidden;}
      
          .clearfix{display: inline-block;} /* for IE/Mac */

      清除浮动的几种方法:

          1,额外标签法,<div style="clear:both;"></div>(缺点:不过这个办法会增加额外的标签使HTML结构看起来不够简洁。)
      
          2,使用after伪类
      
          #parent:after{
      
              content:".";
      
              height:0;
      
              visibility:hidden;
      
              display:block;
      
              clear:both;
      
              }
      
      
          3,浮动外部元素
      
          4,设置overflow为hidden或者auto

      DOM操作——怎样添加、移除、移动、复制、创建和查找节点。

      1)创建新节点

            createDocumentFragment()    //创建一个DOM片段
      
            createElement()   //创建一个具体的元素
      
            createTextNode()   //创建一个文本节点
      

      2)添加、移除、替换、插入

            appendChild()
      
            removeChild()
      
            replaceChild()
      
            insertBefore() //并没有insertAfter()
      

      3)查找

            getElementsByTagName()    //通过标签名称
      
            getElementsByName()    //通过元素的Name属性的值(IE容错能力较强,
            会得到一个数组,其中包括id等于name值的)
      
            getElementById()    //通过元素Id,唯一性
      

      html5有哪些新特性、移除了那些元素?如何处理HTML5新标签的浏览器兼容问题?如何区分 HTML 和 HTML5?

        HTML5 现在已经不是 SGML 的子集,主要是关于图像,位置,存储,多任务等功能的增加。
      
        拖拽释放(Drag and drop) API
      
        语义化更好的内容标签(header,nav,footer,aside,article,section)
      
        音频、视频API(audio,video)
      
        画布(Canvas) API
      
        地理(Geolocation) API
      
        本地离线存储 localStorage 长期存储数据,浏览器关闭后数据不丢失;
      
        sessionStorage 的数据在浏览器关闭后自动删除
      
      
        表单控件,calendar、date、time、email、url、search
      
        新的技术webworker, websocket, Geolocation
      

      移除的元素

      纯表现的元素:basefont,big,center,font, s,strike,tt,u;
      
      对可用性产生负面影响的元素:frame,frameset,noframes;
      

      支持HTML5新标签:

      
          IE8/IE7/IE6支持通过document.createElement方法产生的标签,
      
          可以利用这一特性让这些浏览器支持HTML5新标签,
      
          当然最好的方式是直接使用成熟的框架、使用最多的是html5shim框架
      
             <!--[if lt IE 9]>
      
             <script> src="http://html5shim.googlecode.com/svn/trunk/html5.js"</script>
      
             <![endif]-->
      
          如何区分: DOCTYPE声明\新增的结构元素\功能元素
      

      如何实现浏览器内多个标签页之间的通信?

          调用localstorge、cookies等本地存储方式

      什么是 FOUC(无样式内容闪烁)?你如何来避免 FOUC?

           FOUC - Flash Of Unstyled Content 文档样式闪烁
      
           <style type="text/css" media="all">@import "../fouc.css";</style>
      
          而引用CSS文件的@import就是造成这个问题的罪魁祸首。IE会先加载整个HTML文档的DOM,然后再去导入外部的CSS文件,因此,在页面DOM加载完成到CSS导入完成中间会有一段时间页面上的内容是没有样式的,这段时间的长短跟网速,电脑速度都有关系。
      
           解决方法简单的出奇,只要在<head>之间加入一个<link>或者<script>元素就可以了。

      null和undefined的区别?

      null是一个表示"无"的对象,转为数值时为0;undefined是一个表示"无"的原始值,转为数值时为NaN

      当声明的变量还未被初始化时,变量的默认值为undefined

      null用来表示尚未存在的对象,常用来表示函数企图返回一个不存在的对象。

      undefined表示"缺少值",就是此处应该有一个值,但是还没有定义。典型用法是:

      (1)变量被声明了,但没有赋值时,就等于undefined。
      
      
      (2) 调用函数时,应该提供的参数没有提供,该参数等于undefined。
      
      
      (3)对象没有赋值的属性,该属性的值为undefined。
      
      
      (4)函数没有返回值时,默认返回undefined。
      

      null表示"没有对象",即该处不应该有值。典型用法是:

      (1) 作为函数的参数,表示该函数的参数不是对象。
      
      (2) 作为对象原型链的终点。
      

      new操作符具体干了什么呢?

         1、创建一个空对象,并且 this 变量引用该对象,同时还继承了该函数的原型。
      
         2、属性和方法被加入到 this 引用的对象中。
      
         3、新创建的对象由 this 所引用,并且最后隐式的返回 this 。
      
      
      
      var obj  = {};
      
      obj.__proto__ = Base.prototype;
      
      Base.call(obj);
      

      js延迟加载的方式有哪些?

      defer和async、动态创建DOM方式(创建script,插入到DOM中,加载完毕后callBack)、按需异步载入js
      

      call() 和 apply() 的区别和作用?

      作用:动态改变某个类的某个方法的运行环境(执行上下文)。

      区别参见:JavaScript学习总结(四)function函数部分

      哪些操作会造成内存泄漏?

      内存泄漏指任何对象在您不再拥有或需要它之后仍然存在。
      
      垃圾回收器定期扫描对象,并计算引用了每个对象的其他对象的数量。如果一个对象的引用数量为 0(没有其他对象引用过该对象),或对该对象的惟一引用是循环的,那么该对象的内存即可回收。
      
      
      
      setTimeout 的第一个参数使用字符串而非函数的话,会引发内存泄漏。
      
      闭包、控制台日志、循环(在两个对象彼此引用且彼此保留时,就会产生一个循环)
      

      详见:详解js变量、作用域及内存

      列举IE 与其他浏览器不一样的特性?

      • IE支持currentStyle,FIrefox使用getComputStyle

      • IE 使用innerText,Firefox使用textContent

      • 滤镜方面:IE:filter:alpha(opacity= num);Firefox:-moz-opacity:num

      • 事件方面:IE:attachEvent:火狐是addEventListener

      • 鼠标位置:IE是event.clientX;火狐是event.pageX

      • IE使用event.srcElement;Firefox使用event.target

      • IE中消除list的原点仅需margin:0即可达到最终效果;FIrefox需要设置margin:0;padding:0以及list-style:none

      • CSS圆角:ie7以下不支持圆角

      WEB应用从服务器主动推送Data到客户端有那些方式?

      Javascript数据推送

      • Commet:基于HTTP长连接的服务器推送技术

      • 基于WebSocket的推送方案

      • SSE(Server-Send Event):服务器推送数据新方式

      对前端界面工程师这个职位是怎么样理解的?它的前景会怎么样?

      前端是最贴近用户的程序员,比后端、数据库、产品经理、运营、安全都近。
      
          1、实现界面交互
      
          2、提升用户体验
      
          3、有了Node.js,前端可以实现服务端的一些事情
      
      
      前端是最贴近用户的程序员,前端的能力就是能让产品从 90分进化到 100 分,甚至更好,
      
      
      
       参与项目,快速高质量完成实现效果图,精确到1px;
      
       与团队成员,UI设计,产品经理的沟通;
      
       做好的页面结构,页面重构和用户体验;
      
       处理hack,兼容、写出优美的代码格式;
      
       针对服务器的优化、拥抱最新前端技术。
      

      一个页面从输入 URL 到页面加载显示完成,这个过程中都发生了什么?

          分为4个步骤:
      
          (1),当发送一个URL请求时,不管这个URL是Web页面的URL还是Web页面上每个资源的URL,浏览器都会开启一个线程来处理这个请求,同时在远程DNS服务器上启动一个DNS查询。这能使浏览器获得请求对应的IP地址。
      
          (2), 浏览器与远程`Web`服务器通过`TCP`三次握手协商来建立一个`TCP/IP`连接。该握手包括一个同步报文,一个同步-应答报文和一个应答报文,这三个报文在 浏览器和服务器之间传递。该握手首先由客户端尝试建立起通信,而后服务器应答并接受客户端的请求,最后由客户端发出该请求已经被接受的报文。
      
          (3),一旦`TCP/IP`连接建立,浏览器会通过该连接向远程服务器发送`HTTP`的`GET`请求。远程服务器找到资源并使用HTTP响应返回该资源,值为200的HTTP响应状态表示一个正确的响应。
      
          (4),此时,`Web`服务器提供资源服务,客户端开始下载资源。
      
      
      
      请求返回后,便进入了我们关注的前端模块
      
      简单来说,浏览器会解析`HTML`生成`DOM Tree`,其次会根据CSS生成CSS Rule Tree,而`javascript`又可以根据`DOM API`操作`DOM`
      

      详情:从输入 URL 到浏览器接收的过程中发生了什么事情?

      javascript对象的几种创建方式

      1,工厂模式
      
      2,构造函数模式
      
      3,原型模式
      
      4,混合构造函数和原型模式
      
      5,动态原型模式
      
      6,寄生构造函数模式
      
      7,稳妥构造函数模式
      

      javascript继承的6种方法

      1,原型链继承
      
      2,借用构造函数继承
      
      3,组合继承(原型+借用构造)
      
      4,原型式继承
      
      5,寄生式继承
      
      6,寄生组合式继承
      

      详情:JavaScript继承方式详解

      创建ajax的过程

          (1)创建`XMLHttpRequest`对象,也就是创建一个异步调用对象.
      
          (2)创建一个新的`HTTP`请求,并指定该`HTTP`请求的方法、`URL`及验证信息.
      
          (3)设置响应`HTTP`请求状态变化的函数.
      
          (4)发送`HTTP`请求.
      
          (5)获取异步调用返回的数据.
      
          (6)使用JavaScript和DOM实现局部刷新.
      
      
          var xmlHttp = new XMLHttpRequest();
      
          xmlHttp.open('GET','demo.php','true');
      
          xmlHttp.send()
      
          xmlHttp.onreadystatechange = function(){
      
              if(xmlHttp.readyState === 4 & xmlHttp.status === 200){
      
              }
      
          }

      详情:JavaScript学习总结(七)Ajax和Http状态字

      异步加载和延迟加载

      1.异步加载的方案: 动态插入script标签
      
      2.通过ajax去获取js代码,然后通过eval执行
      
      3.script标签上添加defer或者async属性
      
      4.创建并插入iframe,让它异步执行js
      
      5.延迟加载:有些 js 代码并不是页面初始化的时候就立刻需要的,而稍后的某些情况才需要的。
      

      ie各版本和chrome可以并行下载多少个资源

      IE6 两个并发,iE7升级之后的6个并发,之后版本也是6个
      Firefox,chrome也是6个
      

      FlashAjax各自的优缺点,在使用中如何取舍?

      • Flash适合处理多媒体、矢量图形、访问机器;对CSS、处理文本上不足,不容易被搜索。

      -AjaxCSS、文本支持很好,支持搜索;多媒体、矢量图形、机器访问不足。

      • 共同点:与服务器的无刷新传递消息、用户离线和在线状态、操作DOM

      请解释一下 JavaScript 的同源策略。

      概念:同源策略是客户端脚本(尤其是Javascript)的重要的安全度量标准。它最早出自Netscape Navigator2.0,其目的是防止某个文档或脚本从多个不同源装载。

      这里的同源策略指的是:协议,域名,端口相同,同源策略是一种安全协议。

      指一段脚本只能读取来自同一来源的窗口和文档的属性。

      为什么要有同源限制?

      我们举例说明:比如一个黑客程序,他利用Iframe把真正的银行登录页面嵌到他的页面上,当你使用真实的用户名,密码登录时,他的页面就可以通过Javascript读取到你的表单中input中的内容,这样用户名,密码就轻松到手了。

      缺点:

      现在网站的JS 都会进行压缩,一些文件用了严格模式,而另一些没有。这时这些本来是严格模式的文件,被 merge 后,这个串就到了文件的中间,不仅没有指示严格模式,反而在压缩后浪费了字节。

      GET和POST的区别,何时使用POST?

          GET:一般用于信息获取,使用URL传递参数,对所发送信息的数量也有限制,一般在2000个字符
      
          POST:一般用于修改服务器上的资源,对所发送的信息没有限制。
      
      
          GET方式需要使用Request.QueryString来取得变量的值,而POST方式通过Request.Form来获取变量的值,
      
          也就是说Get是通过地址栏来传值,而Post是通过提交表单来传值。
      
      
      
      然而,在以下情况中,请使用 POST 请求:
      
      无法使用缓存文件(更新服务器上的文件或数据库)
      
      向服务器发送大量数据(POST 没有数据量限制)
      
      发送包含未知字符的用户输入时,POST 比 GET 更稳定也更可靠
      

      事件、IE与火狐的事件机制有什么区别? 如何阻止冒泡?

       1. 我们在网页中的某个操作(有的操作对应多个事件)。例如:当我们点击一个按钮就会产生一个事件。是可以被 JavaScript 侦测到的行为。
      
       2. 事件处理机制:IE是事件冒泡、firefox同时支持两种事件模型,也就是:捕获型事件和冒泡型事件。;
      
       3. `ev.stopPropagation()`;注意旧ie的方法 `ev.cancelBubble = true`;
      

      ajax的缺点和在IE下的问题?

      详情请见:JavaScript学习总结(七)Ajax和Http状态字

      ajax的缺点

        1、ajax不支持浏览器back按钮。
      
        2、安全问题 AJAX暴露了与服务器交互的细节。
      
        3、对搜索引擎的支持比较弱。
      
        4、破坏了程序的异常机制。
      
        5、不容易调试。
      

      IE缓存问题

      在IE浏览器下,如果请求的方法是GET,并且请求的URL不变,那么这个请求的结果就会被缓存。解决这个问题的办法可以通过实时改变请求的URL,只要URL改变,就不会被缓存,可以通过在URL末尾添加上随机的时间戳参数('t'= + new Date().getTime())

      或者:

      open('GET','demo.php?rand=+Math.random()',true);//
      

      Ajax请求的页面历史记录状态问题

      可以通过锚点来记录状态,location.hash。让浏览器记录Ajax请求时页面状态的变化。

      还可以通过HTML5history.pushState,来实现浏览器地址栏的无刷新改变

      谈谈你对重构的理解

      网站重构:在不改变外部行为的前提下,简化结构、添加可读性,而在网站前端保持一致的行为。也就是说是在不改变UI的情况下,对网站进行优化, 在扩展的同时保持一致的UI。

      对于传统的网站来说重构通常是:
      
      表格(table)布局改为DIV+CSS
      
      使网站前端兼容于现代浏览器(针对于不合规范的CSS、如对IE6有效的)
      
      对于移动平台的优化
      
      针对于SEO进行优化
      
      深层次的网站重构应该考虑的方面
      
      
      减少代码间的耦合
      
      让代码保持弹性
      
      严格按规范编写代码
      
      设计可扩展的API
      
      代替旧有的框架、语言(如VB)
      
      增强用户体验
      
      通常来说对于速度的优化也包含在重构中
      
      
      
      压缩JS、CSS、image等前端资源(通常是由服务器来解决)
      
      程序的性能优化(如数据读写)
      
      采用CDN来加速资源加载
      
      对于JS DOM的优化
      
      HTTP服务器的文件缓存
      

      HTTP状态码

          100  Continue  继续,一般在发送post请求时,已发送了http header之后服务端将返回此信息,表示确认,之后发送具体参数信息
      
          200  OK   正常返回信息
      
          201  Created  请求成功并且服务器创建了新的资源
      
          202  Accepted  服务器已接受请求,但尚未处理
      
          301  Moved Permanently  请求的网页已永久移动到新位置。
      
          302 Found  临时性重定向。
      
          303 See Other  临时性重定向,且总是使用 GET 请求新的 URI。
      
          304  Not Modified  自从上次请求后,请求的网页未修改过。
      
      
          400 Bad Request  服务器无法理解请求的格式,客户端不应当尝试再次使用相同的内容发起请求。
      
          401 Unauthorized  请求未授权。
      
          403 Forbidden  禁止访问。
      
          404 Not Found  找不到如何与 URI 相匹配的资源。
      
          500 Internal Server Error  最常见的服务器端错误。
      
          503 Service Unavailable 服务器端暂时无法处理请求(可能是过载或维护)。
      

      说说你对Promise的理解

      依照 Promise/A+ 的定义,Promise 有四种状态:

      pending: 初始状态, 非 fulfilled 或 rejected.
      
      fulfilled: 成功的操作.
      
      rejected: 失败的操作.
      
      settled: Promise已被fulfilled或rejected,且不是pending
      

      另外, fulfilled 与 rejected 一起合称 settled

      Promise 对象用来进行延迟(deferred) 和异步(asynchronous ) 计算。

      Promise 的构造函数

      构造一个 Promise,最基本的用法如下:

          var promise = new Promise(function(resolve, reject) {
      
              if (...) {  // succeed
      
                  resolve(result);
      
              } else {   // fails
      
                  reject(Error(errMessage));
      
              }
          });

      Promise 实例拥有 then 方法(具有 then 方法的对象,通常被称为 thenable)。它的使用方法如下:

      promise.then(onFulfilled, onRejected)

      接收两个函数作为参数,一个在 fulfilled 的时候被调用,一个在 rejected 的时候被调用,接收参数就是 future,onFulfilled 对应 resolveonRejected 对应 reject

      说说你对前端架构师的理解

      负责前端团队的管理及与其他团队的协调工作,提升团队成员能力和整体效率; 带领团队完成研发工具及平台前端部分的设计、研发和维护; 带领团队进行前端领域前沿技术研究及新技术调研,保证团队的技术领先 负责前端开发规范制定、功能模块化设计、公共组件搭建等工作,并组织培训。

      实现一个函数clone,可以对JavaScript中的5种主要的数据类型(包括Number、String、Object、Array、Boolean)进行值复制

          Object.prototype.clone = function(){
      
                  var o = this.constructor === Array ? [] : {};
      
                  for(var e in this){
      
                          o[e] = typeof this[e] === "object" ? this[e].clone() : this[e];
      
                  }
      
                  return o;
          }

      说说严格模式的限制

      严格模式主要有以下限制:

      变量必须声明后再使用
      
      函数的参数不能有同名属性,否则报错
      
      不能使用with语句
      
      不能对只读属性赋值,否则报错
      
      不能使用前缀0表示八进制数,否则报错
      
      不能删除不可删除的属性,否则报错
      
      不能删除变量delete prop,会报错,只能删除属性delete global[prop]
      
      eval不会在它的外层作用域引入变量
      
      eval和arguments不能被重新赋值
      
      arguments不会自动反映函数参数的变化
      
      不能使用arguments.callee
      
      不能使用arguments.caller
      
      禁止this指向全局对象
      
      不能使用fn.caller和fn.arguments获取函数调用的堆栈
      
      增加了保留字(比如protected、static和interface)
      

      设立"严格模式"的目的,主要有以下几个:

      • 消除Javascript语法的一些不合理、不严谨之处,减少一些怪异行为;

      • 消除代码运行的一些不安全之处,保证代码运行的安全;

      • 提高编译器效率,增加运行速度;

      • 为未来新版本的Javascript做好铺垫。

      注:经过测试IE6,7,8,9均不支持严格模式。

      如何删除一个cookie

      1.将时间设为当前时间往前一点。

      var date = new Date();
      
      date.setDate(date.getDate() - 1);//真正的删除

      setDate()方法用于设置一个月的某一天。

      2.expires的设置

          document.cookie = 'user='+ encodeURIComponent('name')  + ';expires = ' + new Date(0)

      <strong><em><b><i>标签

      <strong> 标签和 <em> 标签一样,用于强调文本,但它强调的程度更强一些。
      
      em 是 斜体强调标签,更强烈强调,表示内容的强调点。相当于html元素中的 <i>...</i>;
      
      < b > < i >是视觉要素,分别表示无意义的加粗,无意义的斜体。
      
      em 和 strong 是表达要素(phrase elements)。

      说说你对AMD和Commonjs的理解

      CommonJS是服务器端模块的规范,Node.js采用了这个规范。CommonJS规范加载模块是同步的,也就是说,只有加载完成,才能执行后面的操作。AMD规范则是非同步加载模块,允许指定回调函数。

      AMD推荐的风格通过返回一个对象做为模块对象,CommonJS的风格通过对module.exportsexports的属性赋值来达到暴露模块对象的目的。

      详情:也谈webpack及其开发模式

      document.write()的用法

      document.write()方法可以用在两个方面:页面载入过程中用实时脚本创建页面内容,以及用延时脚本创建本窗口或新窗口的内容。

      document.write只能重绘整个页面。innerHTML可以重绘页面的一部分

      编写一个方法 求一个字符串的字节长度

      假设:一个英文字符占用一个字节,一个中文字符占用两个字节

       function GetBytes(str){
      
              var len = str.length;
      
              var bytes = len;
      
              for(var i=0; i<len; i++){
      
                  if (str.charCodeAt(i) > 255) bytes++;
      
              }
      
              return bytes;
      
          }
      
      alert(GetBytes("你好,as"));

      git fetch和git pull的区别

      git pull:相当于是从远程获取最新版本并merge到本地
      
      git fetch:相当于是从远程获取最新版本到本地,不会自动merge

      说说你对MVC和MVVM的理解

      MVC

      View 传送指令到 Controller
      
      Controller 完成业务逻辑后,要求 Model 改变状态
      
      Model 将新的数据发送到 View,用户得到反馈
      

      所有通信都是单向的。

      Angular它采用双向绑定(data-binding):View的变动,自动反映在 ViewModel,反之亦然。

      组成部分Model、View、ViewModel
      
      View:UI界面
      
      ViewModel:它是View的抽象,负责View与Model之间信息转换,将View的Command传送到Model;
      
      Model:数据访问层
      

      请解释什么是事件代理

      事件代理(Event Delegation),又称之为事件委托。是 JavaScript 中常用绑定事件的常用技巧。顾名思义,“事件代理”即是把原本需要绑定的事件委托给父元素,让父元素担当事件监听的职务。事件代理的原理是DOM元素的事件冒泡。使用事件代理的好处是可以提高性能。

      attribute和property的区别是什么?

      attributedom元素在文档中作为html标签拥有的属性;

      property就是dom元素在js中作为对象拥有的属性。

      所以:

      对于html的标准属性来说,attributeproperty是同步的,是会自动更新的,

      但是对于自定义的属性来说,他们是不同步的,

      说说网络分层里七层模型是哪七层

      • 应用层:应用层、表示层、会话层(从上往下)(HTTP、FTP、SMTP、DNS

      • 传输层(TCPUDP

      • 网络层(IP

      • 物理和数据链路层(以太网)

      每一层的作用如下:

      物理层:通过媒介传输比特,确定机械及电气规范(比特Bit)
      数据链路层:将比特组装成帧和点到点的传递(帧Frame)
      网络层:负责数据包从源到宿的传递和网际互连(包PackeT)
      传输层:提供端到端的可靠报文传递和错误恢复(段Segment)
      会话层:建立、管理和终止会话(会话协议数据单元SPDU)
      表示层:对数据进行翻译、加密和压缩(表示协议数据单元PPDU)
      应用层:允许访问OSI环境的手段(应用协议数据单元APDU

      各种协议

      ICMP协议: 因特网控制报文协议。它是TCP/IP协议族的一个子协议,用于在IP主机、路由器之间传递控制消息。 TFTP协议: 是TCP/IP协议族中的一个用来在客户机与服务器之间进行简单文件传输的协议,提供不复杂、开销不大的文件传输服务。 HTTP协议: 超文本传输协议,是一个属于应用层的面向对象的协议,由于其简捷、快速的方式,适用于分布式超媒体信息系统。DHCP协议: 动态主机配置协议,是一种让系统得以连接到网络上,并获取所需要的配置参数手段。

      说说mongoDB和MySQL的区别

      MySQL是传统的关系型数据库,MongoDB则是非关系型数据库

      mongodbBSON结构(二进制)进行存储,对海量数据存储有着很明显的优势。

      对比传统关系型数据库,NoSQL有着非常显著的性能和扩展性优势,与关系型数据库相比,MongoDB的优点有: ①弱一致性(最终一致),更能保证用户的访问速度: ②文档结构的存储方式,能够更便捷的获取数据。

      讲讲304缓存的原理

      服务器首先产生ETag,服务器可在稍后使用它来判断页面是否已经被修改。本质上,客户端通过将该记号传回服务器要求服务器验证其(客户端)缓存。


      304是HTTP状态码,服务器用来标识这个文件没修改,不返回内容,浏览器在接收到个状态码后,会使用浏览器已缓存的文件


      客户端请求一个页面(A)。 服务器返回页面A,并在给A加上一个ETag。 客户端展现该页面,并将页面连同ETag一起缓存。 客户再次请求页面A,并将上次请求时服务器返回的ETag一起传递给服务器。 服务器检查该ETag,并判断出该页面自上次客户端请求之后还未被修改,直接返回响应304(未修改——Not Modified)和一个空的响应体。

      什么样的前端代码是好的

      高复用低耦合,这样文件小,好维护,而且好扩展。

      学习前端的同学注意了!!! 
      学习过程中遇到什么问题或者想获取学习资源的话,欢迎加入前端学习交流群,群号码:328058344

      展开全文
    • web前端 知识点总结

      2019-04-23 17:28:14
      基础知识点 1.水平垂直居中 子绝父相,子盒子设置绝对定位,设置top:50%;left:50%,margin-top:-50%;margin-left:-50%; 子绝父相,子盒子设置绝对定位,设置 left & top & right & bottom为0;margin: auto...

      基础知识点

      1.水平垂直居中

      1. 子绝父相,子盒子设置绝对定位,设置top:50%;left:50%,margin-top:-50%;margin-left:-50%;
      2. 子绝父相,子盒子设置绝对定位,设置 left & top & right & bottom为0;margin: auto;
      3. 伸缩盒子,父元素设置flex;justify-content: center;align-items: center;
      4. 利用transform属性,需要设置子绝父相,设置top:50%;left:50%;transform:translate(-50%, -50%);

      2.圣杯布局

      1. 中间盒子设置宽度100%,左右margin,留出左右盒子的位置
      2. 左右盒子在通过定位至左右

      3.兼容性问题

      1. 标签样式在不同的浏览器各自的margin 和padding差异较大, 解决方案:css里 *{margin:0;padding:0;}
      2. 当在a标签中嵌套img标签时,在某些浏览器中img会有蓝色边框;解决方案:给img添加border:0;或者是border:none;
      3. 图片默认有间;隙解决方案:1)给img标签添加左浮动float:left;2)给img标签添加display:block。

       

      4.清除浮动的方法?(重点)
            1.父级div定义height
            2.结尾处家空div标签clear:both
            3.父级div定义 伪类:after和zoom
           4.父级div定义 overflow:hidden

       

      5.前端优化技巧

      1. 压缩css,js,图片
        2.减少http请求次数,合并css,js 合并图片(雪碧图)
        3.使用CDN
        4.减少dom元素数量
        5.图片懒加载
        6.静态资源另外用无cookie得域名
        7.减少dom的访问(缓存dom)
        8.巧用事件委托
        9.样式表置顶,脚本置低

      6.this指向问题

        一般来说,谁调用,this就指向谁,特殊情况除外

        普通函数调用,此时 this 指向 window

        定时器函数, 此时 this 指向 window

        更改this指向的三个方法

        1.call( )方法调用一个函数,其具有一个指定的this值

          fn.call(改变其this指向, [指定的参数] ) 如果指定了null或者undefired,则内部this指向window

          应用场景:①借用构造函数

              ②借用其他对象的方法

        2.apply( )方法调用一个函数,其具有一个指定的this值,作为一个数组提供的参数

          fn.apply(var1, var2) 应用:把数组展开

          应用场景:把数组展开,传递给调用的方法

        3.bind 不会调用函数,会返回一个新的函数

          应用场景:①改变定时器内部的this,②改变事件处理函数的this

       

      7、json字符串转化方法

      JSON.parse(str); //由JSON字符串转换为JSON对象

      JSON.stringify(obj); //将JSON对象转化为JSON字符

      进阶知识点

      1、设置分页符

        function farmat(mun) {
        }
        var a =farmat(1000000)
        console.log(a);
      

      2、只能输入数字和小数点

       function clearNoNum(obj){ 
       }
      

      3、统计每一个字符串出现的次数

      高难度知识点

      1.怎样引入一个第三方的包?require与import的区别:

        遵循规范:
        require 是 AMD规范引入方式,
        import是es6的一个语法标准,如果要兼容浏览器的话必须转化成es5的语法.

        调用时间:
        require是运行时调用,所以require理论上可以运用在代码的任何地方,
        import是编译时调用,所以必须放在文件开头.

        本质:
        require是赋值过程,其实require的结果就是对象、数字、字符串、函数等,再把require的结果赋值给某个变量,
        import是解构过程,但是目前所有的引擎都还没有实现import,我们在node中使用babel支持ES6,也仅仅是将ES6转码为ES5再执行,import语法会被转码为require.

       2.在那调用第三方支付接口?为什么?前端调接口和后端调接口各有什么区别,优势与特点:

        一般支付接口都是由后端和支付单位联系调取的,前端调接口容易被劫持,不安全.

      展开全文
    • Web前端知识点总结

      千次阅读 2017-07-05 14:06:53
      有兴趣的小伙伴可以一起来讨论、分享、学习)最近想自学一下前端知识,其实前端的基础部分的话以前也搞过一段时间,但是后来长时间不用了,所以就一点一点淡忘了,而且也没做什么笔记,代码这东西就得多敲,多记。...

      (持续更新。。。。。。有兴趣的小伙伴可以一起来讨论、分享、学习)

      最近想自学一下前端的知识,其实前端的基础部分的话以前也搞过一段时间,但是后来长时间不用了,所以就一点一点淡忘了,而且也没做什么笔记,代码这东西就得多敲,多记。真正的工作经验其实就是你电脑某个文件夹中的word笔记,所以提醒大家学习的话一定要搞清楚,弄明白,然后记下来,这样才能学的有意义,这篇文章的话主要是一个目录的章,将所有的笔记博客全部综合下来,这样的话以后查询起来也比较方便。

      一、基础部分

      1.HTML

      2.CSS

      3.JavaScript

      4.工具

      展开全文
    • [Web]Web前端知识点总结

      千次阅读 2019-04-18 16:20:19
      web标准规定的内容:结构(xml(可扩展标记语言)),表现(css样式),行为(DOM) <head></head>:是html的头部标记,头部信息不显示在网页中,里边的显示在浏览器左上角的标题栏中 ...
    • 1.原型和原型链的理解 2.从零开始手写promise 3.算法题 最长公共前缀 首先第一层for循环(枚举首个字符串的所有字符),使用stringObject.charAt(index)方法获取数组第一个元素的第i个字符,赋值给c, ...
    • 下一篇:2020Web前端知识点总结-CSS篇(一) 1、HTML 基本文档 <html lang="en"> <head> 文档标题title> head> <body> 可见文本... body> html> 1.1、扩展 代码 参考扩展 lang属性的值:en表示为英文 zh中文简体...
    • 1.HTML:文档结构 2.CSS:文档样式,与HTML 交互 (选择器...a.选择器: 元素选择器:p div img table…..... id选择器:#idName 类选择器:.className 组合选择器:body,p,h1…… 后代选择器:p span(p下面的所有
    • 上一篇:2020Web前端知识点总结-HTML篇 下一篇:2020Web前端知识点总结-CSS篇(二) 1、CSS 引入&创建 1.1、创建css 任何 css 属性必须写在HTML的 代码块拿出开放到外部的.css文件中再通过 标签引入 1.1.2、CSS内联...
    • 1、CSS背景 1.1、背景样式 属性&属性值 ...指定要使用的背景颜色background-color:red; 具体颜色值1background-color:transparent;透明默认background-color:inherit;...指定要使用的一个或多个背景图像...

    空空如也

    空空如也

    1 2 3 4 5 ... 20
    收藏数 1,012
    精华内容 404
    关键字:

    web前端知识点总结