My Javascript DOM, BOM, storage etc notes

# Javascript DOM and BOM

[TOC]

# 1. Web API

# Web APIs 与 JS 基础关联性

# js 的组成

JS 基础阶段：

• 我们学习的是 ECMAscript 标准规定的基本语法
• 要求同学们掌握 Js 基础语法
• 只学习基本语法，做不了常用的网页交互效果
• 目的是为了 Js 后面的课程打基础、做铺垫

Web APIs 阶段：

• web APIs 是 w3c 组织的标准

• web APIs 我们主要学习 DoM 和 BOM

• web APIs 是我们 Js 所独有的部分

• 我们主要学习页面交互功能

• 需要使用 Js 基础的课程内容做基础

  Js 基础学习 ECMAscript 基础语法为后面作铺垫，web APIs 是 Js 的应用，大量使用 Js 基础语法做交互效果

---

# API 和 Web API

# API

• API (Application Programming Interface, 应用程序编程接口) 是一些预先定义的函数，目的是__提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节__。

• 简单理解︰API 是给程序员提供的一种工具，以便能更轻松的实现想要完成的功能。

  
  比如手机充电的接口∶我们要实现充电这个功能:
  ●我们不关心手机内部变压器，内部怎么存储电等
  ●我们不关心这个充电线怎么制作的
  ●我们只知道，我们拿着充电线插进充电接口就可以充电
  ●这个充电接口就是一个 API

# Web API

• Web API 是浏览器__提供的一套操作浏览器功能和页面元素的 API__(BOM 和 DOM).
• 现阶段我们主要针对于浏览器讲解常用的 API，主要针对浏览器做交互效果。
• 比如我们想要浏览器弹出一个警示框，直接使用 alert (“3 弹出’)
• MDN 详细 APl : https://developer.mozilla.org/zh-CN/docs/Web/API
• 因为 Web API 很多，所以我们将这个阶段称为 Web APIs

# API 和 Web API 总结

1. API 是为我们程序员提供的一个接口，帮助我们实现某种功能，我们会使用就可以了，不必纠结内部如何实现
2. Web API 主要是针对于浏览器提供的接口，主要针对于浏览器做交互效果。
3. Web API 一般都有输入和输出（函数的传参和返回值），WebAPI 很多都是方法（函数)
4. 学习 Web API 可以结合前面学习内置对象方法的思路学习

---

# 2. DOM

学习目标：

• 能够说出什么是 DOM
• 能够获取页面元素
• 能够给元素注册事件
• 能够操作 DOM 元素的属性
• 能够创建元素
• 能够操作 DOM 节点

# DOM 简介

• 文档对象模型（Document Object Model，简称 DOM），是 W3C 组织推荐的处理可扩展标记语言（HTML 或者 XML）的__标准编程接口__

• W3C 已经定义了一系列的 DOM 接口，通过这些 DOM 接口可以改变网页的内容、结构和样式。

  

• 文档：一个页面 (a website page) 就是一个文档，DOM 中使用 doucument 来表示

• 元素：页面中的所有__标签__都是元素，DOM 中使用 element 表示

• 节点：网页中的所有__内容__都是节点（标签，属性，文本，注释等都可以被看做是个节点，当前页面的所有内容都可以叫做节点），DOM 中使用__node__表示

• DOM 把以上内容都看做是对象

---

# 获取元素

1. 如何获取页面元素？ DOM 在我们实际开发中主要用来操作元素。
2. 我们如何来获取页面中的元素呢？获取页面中的元素可以使用以下几种方式：根据 ID 获取、根据标签名获取、通过 HTML5 新增的方法获取、特殊元素获取

# 1. 根据 ID 获取

使用 getElementByld() 方法可以获取带 ID 的__元素对象 (也就是那个标签): doucument.getElementByld('id名')
使用 console.dir() 可以__打印我们获取的元素对象，更好的查看对象里面的属性和方法。

<div id="time">2019-9-9</div>
<script>
    // 1.因为我们文档页面从上往下加载，所以得先有标签，所以script写在标签下面
    // 2.get 获得 element 元素 by 通过 驼峰命名法
    // 3.参数 id是大小写敏感的字符串
    // 4.返回的是一个元素对象
    var timer = document.getElementById('time');
    console.log(timer);
    // 5. console.dir 打印我们的元素对象，更好的查看里面的属性和方法
    console.dir(timer);
</script>

注意我们不再把 script 标签放到 body 部分而是按照想要放的位置，因为文档页面从上往下加载，我们需要先加载那个 div 标签，然后 script 再获取那个标签， 有了这个元素才可以获取它

注意是 document.getElementById('...');

这个 timer 变量通过 id 获取到了这个标签，也就是说现在你要是 console.log(timer);

显示的就是 <div id="time">2019-9-9</div> 这个一整个标签 (这一个整个标签也就是 DOM Element 对象 (元素对象，element object))

---

# 2. 根据标签名获取

根据标签名获取，使用 getElementByTagName() 方法可以返回带有指定标签名的对象的集合: doucument.getElementsByTagName('标签名');

• 因为得到的是一个__对象的集合，所以我们想要__操作里面的元素就需要遍历
• 得到元素对象是动态的，也就说获取到的标签里面内容变了 (比如说写的文字),js 也会获取到变化后的
• 返回的是获取过来元素对象的集合，以__伪数组__的形式存储
• 如果获取不到元素，则返回为空的伪数组 (因为获取不到对象)

<ul>
    <li>知否知否，应是等你好久</li>
    <li>知否知否，应是等你好久</li>
    <li>知否知否，应是等你好久</li>
    <li>知否知否，应是等你好久</li>
    <li>知否知否，应是等你好久</li>
</ul>
<script>
    // 1.返回的是获取过来元素对象的集合 以伪数组的形式存储
    var lis = document.getElementsByTagName('li');
    console.log(lis);
    console.log(lis[0]);
    // 2.依次打印,遍历
    for (var i = 0; i < lis.length; i++) {
    
        console.log(lis[i]);
    }
    // 3.如果页面中只有 1 个 li，返回的还是伪数组的形式
    // 4.如果页面中没有这个元素，返回的是空伪数组
</script>

记住返回的是伪数组，就算只有一个结果也是存在伪数组里.

如果没有该标签，返回的也是伪数组不过是空的伪数组

# 根据子标签名从父标签获取所有子元素

还可以根据标签名获取某个元素（父元素）内部所有指定标签名的子元素，获取的时候__不包括父元素自己__

element.getElementsByTagName('标签名')
ol.getElementsByTagName('li');

注意：父元素必须是单个对象 (必须指明是哪一个元素对象)，获取的时候不包括父元素自己

<script>
	//element.getElementsByTagName('标签名'); 父元素必须是指定的单个元素
    var ol = document.getElementById('ol');
    console.log(ol.getElementsByTagName('li'));
</script>

在上面，先是通过 id 获取到了父元素的元素对象，然后再从父元素的元素对象获取到这个父元素有的所有的 li 标签

这个跟 document.getElementsByTagName (‘标签名’) 很像，只不过如果用 document 指的就是当前的文档对象 (我们不用 new 出来本来就有的), 然后再按照标签名获取元素会返回当前文档 (页面)__所有__对应的标签对象.

---

# 3. 通过 H5 新增方法获取 (通过类名 (class) 等)

1. getElementsByClassName 根据类名返回__元素对象合集__ : document.getElementsByClassName('类名');
2. document.querySelector 根据指定选择器返回__第一个元素对象__

document.querySelector('选择器');
// 切记里面的选择器需要加符号 
// 类选择器.box 
// id选择器 #nav
var firstBox = document.querySelector('.box');

3. document.querySelectorAll 根据指定选择器返回所有元素对象: document.querySelectorAll('选择器');

注意：querySelector 和 querySelectorAll 里面的选择器需要加符号，比如: document.querySelector(’#nav’);

<script>
    // 1. getElementsByClassName 根据类名获得某些元素集合
    var boxs = document.getElementsByClassName('box');
    console.log(boxs);
    // 2. querySelector 返回指定选择器的第一个元素对象  切记 里面的选择器需要加符号 .box  #nav
    var firstBox = document.querySelector('.box');
    console.log(firstBox);
    var nav = document.querySelector('#nav');
    console.log(nav);
    var li = document.querySelector('li');
    console.log(li);
    // 3. querySelectorAll()返回指定选择器的所有元素对象集合
    var allBox = document.querySelectorAll('.box');
    console.log(allBox);
    var lis = document.querySelectorAll('li');
    console.log(lis);
</script>

选择器就跟 CSS 里面的一样写法，只不过 querySelector 只是返回第一个对应这个选择器的元素对象，而 querySelectorAll 返回的是所有对应这个选择器的元素的元素对象集合.

---

# 获取特殊元素

1. 获取 body 元素 返回 body 元素对象

var x = document.body;

1. 获取 html 元素 返回 html 元素对象

var y = document.documentElement;

---

# 3. 事件基础 (EVENT)

# 事件概述

• JavaScript 使我们有能力创建动态页面，而事件是可以被 JavaScript 侦测到的行为。
• 简单理解： 触发 — 响应机制。
• 网页中的每个元素都可以产生某些可以触发 JavaScript 的事件，例如，我们可以在用户点击某按钮时产生一个事件，然后去执行某些操作。

# 事件三要素

1. 事件源 (谁)-> 事件被触发的对象，e.g. a button, etc…
2. 事件类型 (什么事件)-> 如何触发的事件，e.g. hover, onclick, etc…
3. 事件处理程序 (做啥)-> 通过一个函数赋值的方式完成 (assigning a function as value)

<button id = "btn">BUTTON</button>
<script>
    // 点击一个按钮，弹出对话框
    // 事件是有三部分组成  事件源  事件类型  事件处理程序   我们也称为事件三要素
    //(1) 获取事件源
    var btn = document.getElementById('btn');
    //(2) 事件类型  如何触发 什么事件 比如鼠标点击(onclick) 还是鼠标经过 还是键盘按下
    //(3) 事件处理程序  通过一个函数赋值的方式 完成
    btn.onclick = function() {
        alert('点秋香');
    } //之前忘讲了,这里没有";"结尾
</script>

---

# 执行事件的步骤

1. 获取事件源
2. 注册事件 (绑定事件)
3. 添加事件处理程序 (采取函数赋值形式)

<script>
    // 执行事件步骤
    // 点击div 控制台输出 我被选中了
    // 1. 获取事件源
    var div = document.querySelector('div');
    // 2.绑定事件 注册事件
    // div.onclick 
    // 3.添加事件处理程序 
    div.onclick = function() {
    
        console.log('我被选中了');
    }
</script>

---

# 鼠标事件

鼠标事件	触发条件
onclick	鼠标点击左键触发
onmouseover	鼠标经过触发
onmouseout	鼠标离开触发
onfocus	获得鼠标焦点触发
onblur	失去鼠标焦点触发
onmousemove	鼠标移动触发
onmouseup	鼠标弹起触发
onmousedown	鼠标按下触发

---

# 操作元素

JavaScript 的 DOM 操作可以改变网页内容、结构和样式，我们可以利用 DOM 操作元素来改变元素里面的内容 、属性等。注意以下都是属性

# 1. 改变元素内容

innerText 从起始位置到终止位置的内容，但它去除 html 标签，同时空格和换行也会去掉. 也就是说我们在修改内容的时候要是加上了 HTML 标签等都不会起作用

element.innerText = ...

innerHTM 起始位置到终止位置的全部内容，包括 HTML 标签，同时保留空格和换行. 这个我们修改里面内容可以加 html 标签，都可以识别的

element.innerHTML = ...

<body>
    <div></div>
    <p>
        我是文字
        <span>123</span>
    </p>

    <script>
        // innerText 和 innerHTML的区别 
        // 1. innerText 不识别html标签,去除空格和换行
        var div = document.querySelector('div');
        div.innerText = '<strong>今天是：</strong> 2019';
        
        // 2. innerHTML 识别html标签,保留空格和换行的
        div.innerHTML = '<strong>今天是：</strong> 2019';
        
        // 这两个属性是可读写的  可以获取元素里面的内容
        var p = document.querySelector('p');
        console.log(p.innerText);
        console.log(p.innerHTML);
    </script>
</body>

innerText 在修改或者读取的时候都是不会考虑 html 标签的 (你修改的时候加 html 标签不会起作用，然后读取出来的也不会带有 html 标签)

去除空格和换行，读取来也是去除的

innerHTml 在修改或者读取的时候都会考虑 html 标签的 (你修改的时候加 html 标签会起作用，然后__读取出来的也会带有 html 标签__)

不去除空格和换行，读取来也是按照原样的

注意 innerHTML 和 innerText 无法对表单里面的标签使用，只能对普通盒子如 div 使用

表单里面的比如说 type="text" 的需要修改他的 value 而不是 innerText/innerHTML.

---

# 2. 改变元素属性

// img.属性
img.src = "xxx";

input.value = "xxx";
input.type = "xxx";
input.checked = "xxx";
input.selected = true / false;
input.disabled = true / false;

---

# 3. 改变样式属性

我们可以通过 JS 修改元素的大小、颜色、位置等样式。

• 行内样式操作

// element.style
div.style.backgroundColor = 'pink';
div.style.width = '250px';

这个其实在最后会变成在 html 标签那里的行内样式，所以权威比在 body 那写 css 更高 (参考 CSS 权威)

• 类名样式操作

// element.className

用这个就可以直接改这个标签 (元素对象) 的 class, 然后 CSS 先写好对应的类名然后里面等等的样式属性

这样就不用在 JS 里面写大量的 CSS 样式，而是直接改 class 的值就行了

注意：

1. JS 里面的样式采取驼峰命名法，比如 fontSize ，backgroundColor
2. JS 修改 style 样式操作 ，产生的是行内样式，CSS 权重比较高
3. 如果样式修改较多，可以采取操作类名方式更改元素样式
4. class 因为是个保留字，因此使用 className 来操作元素类名属性
5. className 会直接更改元素的类名，会覆盖原先的类名

<body>
    <div class="first">文本</div>
    <script>
        // 1. 使用 element.style 获得修改元素样式  如果样式比较少 或者 功能简单的情况下使用
        var test = document.querySelector('div');
        test.onclick = function() {
    
            // this.style.backgroundColor = 'purple';
            // this.style.color = '#fff';
            // this.style.fontSize = '25px';
            // this.style.marginTop = '100px';
            // 让我们当前元素的类名改为了 change
            // this.className = 'change';

            // 2. 我们可以通过 修改元素的className更改元素的样式 适合于样式较多或者功能复杂的情况
            // 3. 如果想要保留原先的类名，我们可以这么做 多类名选择器
            this.className = 'first change';
        }
    </script>
</body>

事件函数里面可以用 this, 这个事件函数里面的 this 代表的是这个事件函数的调用者

这里的 this 指的就是 test 这个存了元素对象的变量 (引用)

这里改类名其实就是重新赋值只不过把之前的类名也给写上了，其实就是把这个标签的 class 为之前的和现在的都是 (CSS 的多类名选择器) 注意会选择哪个，权重，覆盖等

---

# 总结

---

# 排他思想

如果有同一组元素，我们相要某一个元素实现某种样式，需要用到循环的排他思想算法：

• 所有元素全部清除样式（干掉其他人）
• 给当前元素设置样式 （留下我自己）
• 注意顺序不能颠倒，首先干掉其他人，再设置自己

<body>
    <button>按钮1</button>
    <button>按钮2</button>
    <button>按钮3</button>
    <button>按钮4</button>
    <button>按钮5</button>
    <script>
        // 1. 获取所有按钮元素
        var btns = document.getElementsByTagName('button');
        // btns得到的是伪数组  里面的每一个元素 btns[i]
        for (var i = 0; i < btns.length; i++) {
    
            btns[i].onclick = function() {
    
                // (1) 我们先把所有的按钮背景颜色去掉  干掉所有人
                for (var i = 0; i < btns.length; i++) {
    
                    btns[i].style.backgroundColor = '';
                }
                // (2) 然后才让当前的元素背景颜色为pink 留下我自己
                this.style.backgroundColor = 'pink';

            }
        }
        //2. 首先先排除其他人，然后才设置自己的样式 这种排除其他人的思想我们成为排他思想
    </script>
</body>

---

# 自定义属性

# 获取属性值

• 获取__内置属性值__(元素本身自带的属性)： element.属性;
• 获取__自定义的属性__： element.getAttribute('属性');

# 设置属性值

• 设置__内置属性值__: element.属性 = '值';
• 主要设置__自定义的属性__: element.setAttribute('属性', 值);

如果有我们设置的自定义属性 (可以这么干就跟内置属性的写法一样只不过不是内置属性), 我们__就必须要用 getAttribute 和 setAttribute 来获得该自定义属性的值，当然也可以用来修改我们内置属性__

# 移除属性

移除属性 removeAttribute('属性')

<body>
    <div id="demo" index="1" class="nav"></div>
    <script>
        var div = document.querySelector('div');
        // 1. 获取元素的属性值
        // (1) element.属性
        console.log(div.id);
        //(2) element.getAttribute('属性')  get得到获取 attribute 属性的意思 我们程序员自己添加的属性我们称为自定义属性 index
        console.log(div.getAttribute('id'));
        console.log(div.getAttribute('index'));
        // 2. 设置元素属性值
        // (1) element.属性= '值'
        div.id = 'test';
        div.className = 'navs';
        // (2) element.setAttribute('属性', '值');  主要针对于自定义属性
        div.setAttribute('index', 2);
        div.setAttribute('class', 'footer'); // class 特殊  这里面写的就是class 不是className
        // 3 移除属性 removeAttribute(属性)    
        div.removeAttribute('index');
    </script>
</body>

注意如果有个属性时 class (内置属性), 要修改是

div.className = … // 是 className

div.setAttribute (‘class’, ‘…’);// 是 class

# H5 自定义属性

• 自定义属性目的：

  • 保存并保存数据，有些数据可以保存到页面中而不用保存到数据库中

  • 有些自定义属性很容易引起歧义，不容易判断到底是内置属性还是自定义的，所以 H5 有了规定

    设置 H5 自定义属性：H5 规定自定义属性 data - 开头作为属性名并赋值

<div data-index = "1"></>
// 或者使用JavaScript设置
div.setAttribute('data-index',1); 

setAttribute 如果设置的属性没有那就会新建一个这个属性然后设上给的值，并不只是单纯改属性的值

• 获取 H5 自定义属性：

  • 兼容性获取 element.getAttribute (‘data-index’)
  • H5 新增的：element.dataset.index 或 element.dataset [‘index’] IE11 才开始支持 (注意这里不用写 data-index 而是直接 index)

  

  这个 dataset 返回的也是个属性所以可以 .属性 ，也可以 ['属性'] 来获取个属性的值

<body>
    <div getTime="20" data-index="2" data-list-name="andy"></div>
    <script>
        var div = document.querySelector('div');
        console.log(div.getAttribute('getTime'));
        div.setAttribute('data-time', 20);
        console.log(div.getAttribute('data-index'));
        console.log(div.getAttribute('data-list-name'));
        // h5新增的获取自定义属性的方法 它只能获取data-开头的
        // dataset 是一个集合里面存放了所有以data开头的自定义属性
        console.log(div.dataset);
        console.log(div.dataset.index);
        console.log(div.dataset['index']);
        // 如果自定义属性里面有多个-链接的单词，我们获取的时候采取 驼峰命名法
        console.log(div.dataset.listName);
        console.log(div.dataset['listName']);
    </script>
</body>

注意！！！

h5 新增的获取自定义属性的方法 它只能获取 data - 开头的

如果自定义属性里面有多个 - 链接的单词，我们获取的时候采取 驼峰命名法

---

# 4. 节点操作

获取元素通常使用两种方式：

1. 利用 DOM 提供的方法获取元素	2. 利用节点层级关系获取元素
document.getElementById()	利用父子兄节点关系获取元素
document.getElementsByTagName()	逻辑性强，但是兼容性较差
document.querySelector 等逻辑性不强，繁琐

这两种方式都可以获取元素节点，我们后面都会使用，但是节点操作更简单。一般的，节点至少拥有三个基本属性

# 节点概述

• 网页中的所有内容都是节点（标签、属性、文本、注释等），在 DOM 中，节点使用 node 来表示。

• HTML DOM 树中的所有节点均可通过 JavaScript 进行访问，所有 HTML 元素（节点）均可被修改，也可以创建或删除。

  
  一般的，节点至少拥有 nodeType（节点类型）、nodeName（节点名称）和 nodeValue（节点值) 这三个基本属性。

• 元素节点：nodeType 为 1

• 属性节点：nodeType 为 2

• 文本节点：nodeType 为 3 (文本节点包括文字、空格、换行等)

  我们在实际开发中，节点操作主要操作的是元素节点
  利用 DOM 树可以把节点划分为不同的层级关系，常见的是父子兄层级关系。

---

# 父级节点

• node.parentNode parentNode 属性可以返回__某节点 (所有的都是节点，包括你通过比如说 querySelector 得到的元素对象，它本身就是个节点然后可以访问他的属性得到父节点) 的父结点__，注意是__最近的一个父结点__
• 如果指定的节点没有父结点则返回 null

<body>
    <!-- 节点的优点 -->
    <div>我是div</div>
    <span>我是span</span>
    <ul>
        <li>我是li</li>
        <li>我是li</li>
        <li>我是li</li>
        <li>我是li</li>
    </ul>
    <div class="demo">
        <div class="box">
            <span class="erweima">×</span>
        </div>
    </div>

    <script>
        // 1. 父节点 parentNode
        var erweima = document.querySelector('.erweima');
        // var box = document.querySelector('.box');
        // 得到的是离元素最近的父级节点(亲爸爸) 如果找不到父节点就返回为 null
        console.log(erweima.parentNode);
    </script>
</body>

---

# 子节点

• parentNode.childNodes(标准) 返回包含__指定节点的子节点的集合__，该集合为即时更新的集合
• 返回值包含了所有的子结点，包括元素节点，文本节点等
• 如果只想要获得里面的元素节点，则需要专门处理。所以我们一般不提倡使用 childNodes
• parentNode.children(非标准) 是__一个只读 (不可写！) 属性，返回所有的子元素节点__
• 它只返回子元素节点，其余节点不返回 （这个是我们重点掌握的）
• 虽然 children 是一个非标准，但是得到了各个浏览器的支持，因此我们可以放心使用

<body>
    <ul>
        <li>我是li</li>
        <li>我是li</li>
        <li>我是li</li>
        <li>我是li</li>
    </ul>
    <ol>
        <li>我是li</li>
        <li>我是li</li>
        <li>我是li</li>
        <li>我是li</li>
    </ol>
    <script>
        // DOM 提供的方法（API）获取
        var ul = document.querySelector('ul');
        var lis = ul.querySelectorAll('li');
        // 1. 子节点  childNodes 所有的子节点 包含 元素节点 文本节点等等
        console.log(ul.childNodes);
        console.log(ul.childNodes[0].nodeType);
        console.log(ul.childNodes[1].nodeType);
        // 2. children 获取所有的子元素节点 也是我们实际开发常用的
        console.log(ul.children);
    </script>
</body>

父节点.childNodes 是所有的子节点，包括换行和空格！！(换行和空格是文本节点)\

所以这里 console.log(ul.childNodes); 会显示有 9 个节点而不是 4 个，其中是 ul 节点对象下面的四个小 li, 还有五个是小 li 之间 (之前) 的空格和换行的文本节点

一把我们用 父节点.children 这样就会获得父节点的所有子 == 元素 == 节点， 不包括父节点的 (子) 文本节点，也就是说不会带有空格和换行的那些文本节点.

# 第一个子节点

• parentNode.firstChild 返回第一个子节点，找不到则返回 null
• 同样，也是包含所有的节点

所有注意返回的是不是想要的子元素节点

兼容性：

• parentNode.firstElementChild 返回第一个子节点，找不到则返回 null
• 有兼容性问题，IE9 以上才支持

这个最常用！

# 最后一个子节点

• parentNode.lastChild 返回最后一个子节点，找不到则返回 null
• 同样，也是包含所有的节点

<body>
    <ol>
        <li>我是li1</li>
        <li>我是li2</li>
        <li>我是li3</li>
        <li>我是li4</li>
        <li>我是li5</li>
    </ol>
    <script>
        var ol = document.querySelector('ol');
        // 1. firstChild 第一个子节点 不管是文本节点还是元素节点
        console.log(ol.firstChild);
        console.log(ol.lastChild);
        // 2. firstElementChild 返回第一个子元素节点 ie9才支持
        console.log(ol.firstElementChild);
        console.log(ol.lastElementChild);
        // 3. 实际开发的写法  既没有兼容性问题又返回第一个子元素
        console.log(ol.children[0]);			//第一个子元素节点
        console.log(ol.children[ol.children.length - 1]);//最后一个子元素节点
    </script>
</body>

兼容性： parentNode.lastElementChild

• lastElementChild 返回最后一个子节点，找不到则返回 null
• 有兼容性问题，IE9 以上才支持

# 解决方案

实际开发中，firstChild 和 lastChild 包含其他节点，操作不方便，而 firstElementChild 和 lastElementChild 又有兼容性问题，那么我们如何获取第一个子元素节点或最后一个子元素节点呢？
解决方案：

• 如果想要第一个子元素节点，可以使用 parentNode.chilren [0]
• 如果想要最后一个子元素节点，可以使用

// 数组元素个数减1 就是最后一个元素的索引号
parentNode.chilren[parentNode.chilren.length - 1]

<body>
    <ol>
        <li>我是li1</li>
        <li>我是li2</li>
        <li>我是li3</li>
        <li>我是li4</li>
    </ol>
    <script>
        var ol = document.querySelector('ol');
        // 1.firstChild 获取第一个子结点的，包含文本结点和元素结点
        console.log(ol.firstChild);
        // 返回的是文本结点 #text(第一个换行结点)
        
        console.log(ol.lastChild);
        // 返回的是文本结点 #text(最后一个换行结点)
        // 2. firstElementChild 返回第一个子元素结点
        console.log(ol.firstElementChild);
        // <li>我是li1</li>
        
        // 第2个方法有兼容性问题，需要IE9以上才支持
        // 3.实际开发中，既没有兼容性问题，又返回第一个子元素
        console.log(ol.children[0]);
        // <li>我是li1</li>
        console.log(ol.children[3]);
        // <li>我是li4</li>
        // 当里面li个数不唯一时候，需要取到最后一个结点时这么写
        console.log(ol.children[ol.children.length - 1]);
    </script>
</body>

---

# 兄弟节点

# 下一个兄弟节点

• node.nextSibling 返回当前元素的下一个兄弟元素节点，找不到则返回 null
• 同样，也是包含所有的节点

兼容性： node.nextElementSibling (用这个)

• nextElementSibling 返回当前元素下一个兄弟元素节点，找不到则返回 null
• 有兼容性问题，IE9 才支持

# 上一个兄弟节点

• node.previousSibling 返回当前元素上一个兄弟元素节点，找不到则返回 null
• 同样，也是包含所有的节点

兼容性： node.previousElementSibling (用这个)

• previousElementSibling 返回当前元素上一个兄弟元素节点，找不到则返回 null
• 有兼容性问题，IE9 才支持

<body>
    <div>我是div</div>
    <span>我是span</span>
    <script>
        var div = document.querySelector('div');
        // 1.nextSibling 下一个兄弟节点 包含元素节点或者 文本节点等等
        console.log(div.nextSibling);		// #text
        console.log(div.previousSibling);	// #text
        // 2. nextElementSibling 得到下一个兄弟元素节点
        console.log(div.nextElementSibling);	//<span>我是span</span>
        console.log(div.previousElementSibling);//null
    </script>
</body>

如何解决兼容性问题？

答：自己封装一个兼容性的函数

function getNextElementSibling(element) {
    
    var el = element;
    while(el = el.nextSibling) {
    
        if(el.nodeType === 1){
    
            return el;
        }
    }
    return null;
}

---

# 节点操作

# 创建节点

• document.createElement() 方法创建由 tagName 指定的 HTML 元素 document.createElement('tagName(标签名)');
• 因为这些元素原先不存在，是根据我们的需求动态生成的，所以我们也称为动态创建元素节点

# 添加节点

• node(一般都是父元素节点).appendChild(child) 方法将一个节点添加到指定父节点的子节点列表末尾。类似于 CSS 里面的 after 伪元素。
• node(一般都是父元素节点).insertBefore(child,指定元素) 方法将一个节点添加到父节点的指定子节点前面。类似于 CSS 里面的 before 伪元素。

<body>
    <ul>
        <li>123</li>
    </ul>
    <script>
        // 1. 创建节点元素节点
        var li = document.createElement('li');
        // 2. 添加节点 node.appendChild(child)  node 父级  child 是子级 后面追加元素  类似于数组中的push
        // 先获取父亲ul
        var ul = document.querySelector('ul');
        ul.appendChild(li);
        // 3. 添加节点 node.insertBefore(child, 指定元素);
        var lili = document.createElement('li');
        ul.insertBefore(lili, ul.children[0]); //insert before the first element node of ul represented by ul.children[0].
    </script>
</body>

我们想要页面添加一个新的元素分两步: 1. 创建元素 2. 添加元素

一般 table 里面我们是先创建 tr 然后 append 到 tbody 然后在这个 tr 里面 append 每一个 td, 接下来在创建第二个 tr,so on…

# 删除节点

• node.removeChild(child) 方法从 DOM 中删除一个子节点，返回删除的节点

# 按 a 标签防止链接跳转

这样再按下这个 a 标签后就不会再地址栏上显示# (如果用的是 #)

# 复制节点（克隆节点）

• node.cloneNode() 方法返回调用该方法的节点的一个副本。 也称为克隆节点 / 拷贝节点
• 如果括号参数为空或者为 false ，则是浅拷贝，即只克隆复制节点本身，不克隆里面的子节点，所以里面要是有什么文本节点，元素节点等等是不会复制过来的
• 如果括号参数为 true ，则是深度拷贝，会复制节点本身以及里面所有的子节点

<body>
    <ul>
        <li>1111</li>
        <li>2</li>
        <li>3</li>
    </ul>
    <script>
        var ul = document.querySelector('ul');
        // 1. node.cloneNode(); 括号为空或者里面是false 浅拷贝 只复制标签不复制里面的内容
        // 2. node.cloneNode(true); 括号为true 深拷贝 复制标签复制里面的内容
        var lili = ul.children[0].cloneNode(true);
        ul.appendChild(lili);
    </script>
</body>

# 面试题

三种动态创建元素 doucument.write ()、element.innerHTML、document.createElement ()
区别：

• document.write() 是直接将内容写入页面的内容流，但是文档流 (就是当前页面的代码从上往下依次执行执行完毕) 执行完毕，则它会导致页面全部重绘
• innerHTML 是将内容写入某个 DOM 节点，不会导致页面全部重绘
• innerHTML 创建多个元素效率更高__（不要拼接字符串，采取数组形式拼接）__，结构稍微复杂

注意: innerHTML way is only faster than creating element and appending it when you have inserted all the needed elements to an array and add the array to innerHTML, instead of creating a bunch of String storing each element and appending the string which is way slower.

<body>
    <div class="innner"></div>
    <div class="create"></div>
    <script>
        // 2. innerHTML 创建元素
        var inner = document.querySelector('.inner');
        // 2.1 innerHTML 用拼接字符串方法   这种方式很慢!!!!!!!
        for (var i = 0; i <= 100; i++) {
    
            inner.innerHTML = '<a href="#">百度</a>';
        }
        // 2.2 innerHTML 用数组形式拼接   这种方式很块,最快的!!!!!!!
        var arr = [];
        for (var i = 0; i <= 100; i++) {
    
            arr.push('<a href="#">百度</a>');
        }
        inner.innerHTML = arr.join('');

        // 3.document.createElement() 创建元素 第二快的!
        var create = document.querySelector('.create');
        var a = document.createElement('a');
        create.appendChild(a);
    </script>
</body>

• createElement () 创建多个元素效率稍低一点点，但是结构更清晰
• 总结：不同浏览器下， innerHTML 效率要比 createElement 高

# DOM 核心，总结

对于 DOM 操作，我们主要针对子元素的操作，主要有

• 创建：document.write、innerHTML、createElement

• 增：appendChild、insertBefore

• 删：removeChild

• 改：主要修改 dom 的元素属性，dom 元素的内容、属性、表单的值等

  1. 修改元素属性：src、href、title 等
  2. 修改普通元素内容：innerHTML、innerText
  3. 修改表单元素：value、type、disabled
  4. 修改元素样式：style、className

• 查：主要获取查询 dom 的元素

  \1. DOM 提供的 API 方法：getElementById、getElementsByTagName (古老用法，不推荐)
  \2. H5 提供的新方法：querySelector、querySelectorAll (提倡)
  \3. 利用节点操作获取元素：父 (parentNode)、子 (children)、兄 (previousElementSibling、nextElementSibling) 提倡

• 属性操作：主要针对于自定义属性

  1. setAttribute：设置 dom 的属性值
  2. getAttribute：得到 dom 的属性值
  3. removeAttribute：移除属性

---

# 5. 事件高级

# 注册事件 (绑定事件)

• 给元素添加事件，称为注册事件或者绑定事件。
• 注册事件有两种方式：传统方式__和__方法监听注册方式

传统注册方式	方法监听注册方式
利用 on 开头的事件 onclick	w3c 标准推荐方式
<button onclick = “alert(“hi”)">	addEventListener () 它是一个方法
btn.onclick = function() {}	IE9 之前的 IE 不支持此方法，可使用 attachEvent () 代替
特点：注册事件的唯一性，就是比如说你要是同一个元素写了两个 onclick 只会执行之后的一个 (之后的把前面的给覆盖掉了)	特点：同一个元素同一个事件可以注册多个监听器
同一个元素同一个事件只能设置一个处理函数，最后注册的处理函数将会覆盖前面注册的处理函数	按注册顺序依次执行，就是比如说按了按钮，会把所有的监听器里的方法依次都执行，注意是都会执行.

# addEventListener 事件监听方式

• eventTarget.addEventListener () 方法将指定的监听器注册到 eventTarget（目标对象）上
• 当该对象触发指定的事件时，就会执行事件处理函数

eventTarget(节点对象).addEventListener(type,listener[,useCapture])

该方法接收三个参数：

• type: 事件类型字符串，比如 click,mouseover, 注意这里不要带 on
• listener：事件处理函数，事件发生时，会调用该监听函数
• useCapture：可选参数，是一个布尔值，默认是 false。学完 DOM 事件流后，我们再进一步学习

<body>
    <button>传统注册事件</button>
    <button>方法监听注册事件</button>
    <button>ie9 attachEvent</button>
    <script>
        var btns = document.querySelectorAll('button');
        // 1. 传统方式注册事件
        btns[0].onclick = function() {
    
            alert('hi');
        }
        btns[0].onclick = function() {
    
                alert('hao a u');
            }
            // 2. 事件监听注册事件 addEventListener 
            // (1) 里面的事件类型是字符串 所以加引号 而且不带on
            // (2) 同一个元素 同一个事件可以添加多个侦听器（事件处理程序）
        btns[1].addEventListener('click', function() {
    
            alert(22);
        })
        btns[1].addEventListener('click', function() {
    
                alert(33);
            })
            // 3. attachEvent ie9以前的版本支持
        btns[2].attachEvent('onclick', function() {
    
            alert(11);
        })
    </script>
</body>

# attachEvent 事件监听方式 (兼容)

• eventTarget.attachEvent () 方法将指定的监听器注册到 eventTarget（目标对象） 上
• 当该对象触发指定的事件时，指定的回调函数就会被执行

eventTarget.attachEvent(eventNameWithOn,callback)

该方法接收两个参数：

• eventNameWithOn：事件类型字符串，比如 onclick 、onmouseover ，这里要带 on
• callback： 事件处理函数，当目标触发事件时回调函数被调用
• ie9 以前的版本支持

# 注册事件兼容性解决方案

兼容性处理的原则：首先照顾大多数浏览器，再处理特殊浏览器

function addEventListener(element, eventName, fn) {
   
     // 判断当前浏览器是否支持 addEventListener 方法
     if (element.addEventListener) {
   
       element.addEventListener(eventName, fn);  // 第三个参数 默认是false
     } else if (element.attachEvent) {
   
       element.attachEvent('on' + eventName, fn);
     } else {
   
       // 相当于 element.onclick = fn;
       element['on' + eventName] = fn;
} 

---

# 删除事件 (解绑事件)

# removeEventListener 删除事件方式

eventTarget.removeEventListener(type,listener[,useCapture]);

该方法接收三个参数：

• type: 事件类型字符串，比如 click,mouseover, 注意这里不要带 on
• listener：事件处理函数，事件发生时，会调用该监听函数
• useCapture：可选参数，是一个布尔值，默认是 false。学完 DOM 事件流后，我们再进一步学习

# detachEvent 删除事件方式 (兼容)

eventTarget.detachEvent(eventNameWithOn,callback);

该方法接收两个参数：

• eventNameWithOn：事件类型字符串，比如 onclick 、onmouseover ，这里要带 on
• callback： 事件处理函数，当目标触发事件时回调函数被调用
• ie9 以前的版本支持

# 传统事件删除方式

eventTarget(节点对象).onclick = null;

<body>
    <div>1</div>
    <div>2</div>
    <div>3</div>
    <script>
        var divs = document.querySelectorAll('div');
        divs[0].onclick = function() {
    
            alert(11);
            // 1. 传统方式删除事件
            divs[0].onclick = null;
        }

        // 2.removeEventListener 删除事件
        divs[1].addEventListener('click',fn);   //里面的fn不需要调用加小括号
        function fn(){
            alert(22);
            divs[1].removeEventListener('click',fn);
        }

        // 3.IE9 中的删除事件方式
        divs[2].attachEvent('onclick',fn1);
        function fn1() {    
            alert(33);
            divs[2].detachEvent('onclick',fn1);
        }
    </script>

</body>

注意 removeEventListener 需要用到那个函数的名字，所以需要不能用匿名函数而是单独声明个函数 (正常方式), 然后再用那个函数名放进 addEventListener 和 removeEventListener , 注意在这里放函数名不需要加小括号。加上了小括号指的就是调用那个函数也就是会取回那个函数的返回值，这当然不是我们想要做的

# 删除事件兼容性解决方案

function removeEventListener(element, eventName, fn) {
   
     // 判断当前浏览器是否支持 removeEventListener 方法
     if (element.removeEventListener) {
   
       element.removeEventListener(eventName, fn);  // 第三个参数 默认是false
     } else if (element.detachEvent) {
   
       element.detachEvent('on' + eventName, fn);
     } else {
   
       element['on' + eventName] = null;
} 

---

# DOM 事件流

• 事件流描述的是从页面中接收事件的顺序

• 事件发生时会在元素节点之间按照特定的顺序传播，这个传播过程即 DOM 事件流

  比如我们给一个 div 注册了点击事件：DOM 事件流分为 3 个阶段：1. 捕获阶段 2. 当前目标阶段 3. 冒泡阶段
  

• 事件冒泡： IE 最早提出，事件开始时由最具体的元素接收，然后逐级向上传播到到 DOM 最顶层节点的过程。

• 事件捕获： 网景最早提出，由 DOM 最顶层节点开始，然后逐级向下传播到到最具体的元素接收的过程。

• 我们向水里面扔一块石头，首先它会有一个下降的过程，这个过程就可以理解为从最顶层向事件发生的最具体元素（目标点）的捕获过程；之后会产生泡泡，会在最低点（最具体元素）之后漂浮到水面上，这个过程相当于事件冒泡。

  

# 捕获阶段

• document -> html -> body -> father -> son
• 两个盒子嵌套，一个父盒子一个子盒子，我们的需求是当点击父盒子时弹出 father ，当点击子盒子时弹出 son

<body>
    <div class="father">
        <div class="son">son盒子</div>
    </div>
    <script>
        // dom 事件流 三个阶段
        // 1. JS 代码中只能执行捕获或者冒泡其中的一个阶段。
        // 2. onclick 和 attachEvent（ie） 只能得到冒泡阶段。
        // 3. 捕获阶段 如果addEventListener 第三个参数是 true 那么则处于捕获阶段  document -> html -> body -> father -> son
        var son = document.querySelector('.son');
        son.addEventListener('click', function() {
    
             alert('son');
        }, true);

        var father = document.querySelector('.father');
        father.addEventListener('click', function() {
    
            alert('father');
        }, true);

    </script>
</body>

但是因为 DOM 流的影响，我们设置捕获阶段，所以我们点击子盒子，会先弹出 father，之后再弹出 son

这是因为捕获阶段由 DOM 最顶层节点开始，然后逐级向下传播到到最具体的元素接收

• document -> html -> body -> father -> son
• 先看 document 的事件，没有；再看 html 的事件，没有；再看 body 的事件，没有；再看 father 的事件，有就先执行；再看 son 的事件，再执行。

# 冒泡阶段

• son -> father ->body -> html -> document

<body>
    <div class="father">
        <div class="son">son盒子</div>
    </div>
    <script>
		// 4. 冒泡阶段 如果addEventListener 第三个参数是 false 或者 省略 那么则处于冒泡阶段  son -> father ->body -> html -> document
        var son = document.querySelector('.son');
        son.addEventListener('click', function() {
    
            alert('son');
        }, false);
        var father = document.querySelector('.father');
        father.addEventListener('click', function() {
    
            alert('father');
        }, false);
        document.addEventListener('click', function() {
    
            alert('document');
        })
    </script>
</body>

• 我们点击子盒子，会弹出 son、father、document

• 这是因为冒泡阶段开始时由最具体的元素接收，然后逐级向上传播到到 DOM 最顶层节点：son -> father ->body -> html -> document

  

# 小结

• JS 代码中只能执行捕获或者冒泡其中的一个阶段
• onclick 和 attachEvent 只能得到冒泡阶段
• addEventListener (type,listener [,useCapture]) 第三个参数如果是 true，表示在事件捕获阶段调用事件处理程序；如果是 false (不写默认就是 false), 表示在事件冒泡阶段调用事件处理程序
• 实际开发中我们很少使用事件捕获，我们更关注事件冒泡。
• 有些事件是没有冒泡的，比如 onblur、onfocus、onmouseenter、onmouseleave

---

# 事件对象

eventTarget.onclick = function(event) {
    
   // 这个 event 就是事件对象，我们还喜欢的写成 e 或者 evt 
} 
eventTarget.addEventListener('click', function(event) {
    
   // 这个 event 就是事件对象，我们还喜欢的写成 e 或者 evt  
})

官方解释：event 对象代表事件的状态，比如键盘按键的状态、鼠标的位置、鼠标按钮的状态

简单理解：

• 事件发生后，跟事件相关的一系列信息数据的集合都放到这个对象里面
• 这个对象就是事件对象 event，它有很多属性和方法，比如 “
  • 谁绑定了这个事件
  • 鼠标触发事件的话，会得到鼠标的相关信息，如鼠标位置
  • 键盘触发事件的话，会得到键盘的相关信息，如按了哪个键
• 这个 event 是个形参，系统帮我们设定为事件对象，不需要传递实参过去
• 当我们注册事件时， event 对象就会被系统自动创建，并依次传递给事件监听器（事件处理函数）

<body>
    <div>123</div>
    <script>
        // 事件对象
        var div = document.querySelector('div');
        div.onclick = function(e) {
    
                // console.log(e);
                // console.log(window.event);
                // e = e || window.event;
                console.log(e);


            }
        // 1. event 就是一个事件对象 写到我们侦听函数的 小括号里面 当形参来看
        // 2. 事件对象只有有了事件才会存在，它是系统给我们自动创建的，不需要我们传递参数
        // 3. 事件对象 是 我们事件的一系列相关数据的集合 跟事件相关的 比如鼠标点击里面就包含了鼠标的相关信息，鼠标坐标啊，如果是键盘事件里面就包含的键盘事件的信息 比如 判断用户按下了那个键
        // 4. 这个事件对象我们可以自己命名 比如 event 、 evt、 e
        // 5. 事件对象也有兼容性问题 ie678 通过 window.event 兼容性的写法  e = e || window.event;
    </script>
</body>

# 事件对象的兼容性方案

事件对象本身的获取存在兼容问题：

1. 标准浏览器中是浏览器给方法传递的参数，只需要定义形参 e 就可以获取到。

2. 在 IE6~8 中，浏览器不会给方法传递参数，如果需要的话，需要到 window.event 中获取查找

   解决： e = e || window.event;

# 事件对象的常见属性和方法

事件对象属性方法	说明
e.target	返回触发事件的对象 标准
e.srcElement	返回触发事件的对象 非标准 ie6-8 使用
e.type	返回事件的类型 比如 click mouseover 不带 on
e.cancelBubble	该属性阻止冒泡，非标准，ie6-8 使用
e.returnValue	该属性阻止默认行为 非标准，ie6-8 使用
e.preventDefault()	该方法阻止默认行为 标准 比如不让链接跳转
e.stopPropagation()	阻止冒泡 标准

# 事件对象阻止默认行为

__取消掉__原本就有的默认改事件触发时会发生的事

e.preventDefault();

<body>
    <div>123</div>
    <a href="http://www.baidu.com">百度</a>
    <form action="http://www.baidu.com">
        <input type="submit" value="提交" name="sub">
    </form>
    <script>
        // 常见事件对象的属性和方法
        // 1. 返回事件类型
        var div = document.querySelector('div');
        div.addEventListener('click', fn);
        div.addEventListener('mouseover', fn);
        div.addEventListener('mouseout', fn);

        function fn(e) {
            console.log(e.type);
        }

        // 2. 阻止默认行为（事件） 让链接不跳转 或者让提交按钮不提交
        var a = document.querySelector('a');
        a.addEventListener('click', function(e) {
    
                e.preventDefault(); //  dom 标准写法
       })

       // 3. 传统的注册方式
        a.onclick = function(e) {
    
            // 普通浏览器 e.preventDefault();  方法
            // e.preventDefault();
            
            // 低版本浏览器 ie678  returnValue  属性
            // e.returnValue;
            
// 我们可以利用return false 也能阻止默认行为 没有兼容性问题 特点： return 后面的代码不执行了， 而且只限于传统的注册方式
            return false;
            alert(11);
        }
    </script>
</body>

# 阻止事件冒泡

• 事件冒泡：开始时由最具体的元素接收，然后逐级向上传播到到 DOM 最顶层节点

• 事件冒泡本身的特性，会带来的坏处，也会带来的好处，需要我们灵活掌握。

  标准写法： e.stopPropagation();
  非标准写法： IE6-8 利用对象事件 cancelBubble 属性： e.cancelBubble = true;

<body>
    <div class="father">
        <div class="son">son儿子</div>
    </div>
    <script>
        // 常见事件对象的属性和方法
        // 阻止冒泡  dom 推荐的标准 stopPropagation() 
        var son = document.querySelector('.son');
        son.addEventListener('click', function(e) {
    
            alert('son');
            e.stopPropagation(); // stop 停止  Propagation 传播
            e.cancelBubble = true; // 非标准 cancel 取消 bubble 泡泡
        }, false);

        var father = document.querySelector('.father');
        father.addEventListener('click', function() {
    
            alert('father');
        }, false);
        document.addEventListener('click', function() {
    
            alert('document');
        })
    </script>
</body>

在目标元素事件触发的函数里面设置 e.stopPropagation(); 就可取消事件冒泡，不会触发父元素的__对应事件__的函数.

阻止事件冒泡的兼容性解决方案：

if(e && e.stopPropagation){
      e.stopPropagation();
  }else{
      window.event.cancelBubble = true;
  }

# e.target 与 this

e.target 与 this 的区别：

• this 是事件绑定的元素，这个函数的调用者 (绑定这个事件的元素)
• e.target 是事件触发的元素

<body>
    <div>123</div>
    <ul>
        <li>abc</li>
        <li>abc</li>
        <li>abc</li>
    </ul>
    <script>
        // 常见事件对象的属性和方法
        // 1. e.target 返回的是触发事件的对象（元素）  this 返回的是绑定事件的对象（元素）
        // 区别 ： e.target 点击了那个元素，就返回那个元素 this 那个元素绑定了这个点击事件，那么就返回谁
        var div = document.querySelector('div');
        div.addEventListener('click', function(e) {
    
            console.log(e.target);
            console.log(this);
        })
        var ul = document.querySelector('ul');
        ul.addEventListener('click', function(e) {
    
                // 我们给ul 绑定了事件  那么this 就指向ul  
                console.log(this);
                console.log(e.currentTarget);

                // e.target 指向我们点击的那个对象 谁触发了这个事件 我们点击的是li e.target 指向的就是li
                console.log(e.target);

            })
            // 了解兼容性
            // div.onclick = function(e) {
    
            //     e = e || window.event;
            //     var target = e.target || e.srcElement;
            //     console.log(target);

        // }
        // 2. 了解 跟 this 有个非常相似的属性 currentTarget  ie678不认识
    </script>
</body>

e.target 和 this 的区别：

• this 是事件绑定的元素，这个函数的调用者（绑定这个事件的元素）
• e.target 是事件触发的元素。

⭐️this 指向的是当前事件绑定的元素 (这个函数的调用者), 比如说上面如果 click ul 就会触发事件，这里的 ul 就是 this.

⭐️e.target 是真正让这个事件发生的那个元素，因为 li 在 ul 里面，虽然没给 li 绑定事件但是点 li 也会触发 ul (不管是冒泡还是捉),li 被点击了，但是没有绑定事件，所以冒泡到 ul， 而 ul 有绑定，就触发了

所以让这个事件真正触发的那个元素其实是 li 而不是 ul.

# 事件对象的兼容性

事件对象本身的获取存在兼容问题：

• 标准浏览器中浏览器是给方法传递的参数，只需定义形参 e 就可以获取到
• 在 IE6 -> 8 中，浏览器不会给方法传递参数，如果需要的话，需要到 window.event 中获取查找
• 解决方案： e = e || window.event

<body>
    <div>123</div>
    <script>
        // 事件对象
        var div = document.querySelector('div');
        div.onclick = function(e) {
    
                // e = e || window.event;
                console.log(e);
	// 事件对象也有兼容性问题 ie678 通过 window.event 兼容性的写法  e = e || window.event;

            }
</body>

---

# 事件委托

• 事件委托也称为事件代理，在 jQuery 里面称为事件委派
• 事件委托的原理：不是每个子节点单独设置事件监听器，而是事件监听器设置在其父节点上，然后利用冒泡原理影响设置每个子节点

<body>
    <ul>
        <li>知否知否，点我应有弹框在手！</li>
        <li>知否知否，点我应有弹框在手！</li>
        <li>知否知否，点我应有弹框在手！</li>
        <li>知否知否，点我应有弹框在手！</li>
        <li>知否知否，点我应有弹框在手！</li>
    </ul>
    <script>
        // 事件委托的核心原理：给父节点添加侦听器， 利用事件冒泡影响每一个子节点
        var ul = document.querySelector('ul');
        ul.addEventListener('click', function(e) {
    
            // alert('知否知否，点我应有弹框在手！');
            // e.target 这个可以得到我们点击的对象
            e.target.style.backgroundColor = 'pink';
            // 点了谁，就让谁的style里面的backgroundColor颜色变为pink
        })
    </script>
</body>

以上案例：给 ul 注册点击事件，然后利用事件对象的 target 来找到当前点击的 li，因为点击 li，事件会冒泡到 ul 上， ul 有注册事件，就会触发事件监听器。

---

# 常见的鼠标事件

鼠标事件	触发条件
onclick	鼠标点击左键触发
onmouseover	鼠标经过触发
onmouseout	鼠标离开触发
onfocus	获得鼠标焦点触发
onblur	失去鼠标焦点触发
onmousemove	鼠标移动触发
onmouseup	鼠标弹起触发
onmousedown	鼠标按下触发

# 禁止鼠标右键与鼠标选中

• contextmenu 主要控制应该何时显示上下文菜单，主要用于程序员取消默认的上下文菜单 (比如说右键然后赋值)
• selectstart 禁止鼠标选中

<body>
    <h1>我是一段不愿意分享的文字</h1>
    <script>
        // 1. contextmenu 我们可以禁用右键菜单
        document.addEventListener('contextmenu', function(e) {
    
                e.preventDefault(); // 阻止默认行为
        })
        
		// 2. 禁止选中文字 selectstart
        document.addEventListener('selectstart', function(e) {
    
            e.preventDefault();

        })
    </script>
</body>

# 鼠标事件对象

• event 对象代表事件的状态，跟事件相关的一系列信息的集合 (就是这个事件对象可能是个鼠标事件对象，也可能是个键盘事件对象，或许其他… 然后 onclick 这些只是这个事件对象的一个键叫做 type 的值)
• 现阶段我们主要是用鼠标事件对象 MouseEvent 和键盘事件对象 KeyboardEvent 。

鼠标事件对象	说明
e.clientX	返回鼠标相对于浏览器窗口__可视区 (代表往页面下面滑鼠标还是按照当前可视窗口而不是真正的最顶上开始的)__的 X 坐标
e.clientY	返回鼠标相对于浏览器窗口__可视区__的 Y 坐标
e.pageX（重点）	返回鼠标相对于__文档页面 (跟可视区不一样，是从真正最上面开始)__的 X 坐标 IE9+ 支持
e.pageY（重点）	返回鼠标相对于__文档页面__的 Y 坐标 IE9+ 支持
e.screenX	返回鼠标相对于电脑屏幕的 X 坐标
e.screenY	返回鼠标相对于电脑屏幕的 Y 坐标

<body>
    <script>
        // 鼠标事件对象 MouseEvent
        document.addEventListener('click', function(e) {
    
            // 1. client 鼠标在可视区的x和y坐标
            console.log(e.clientX);
            console.log(e.clientY);
            console.log('---------------------');

            // 2. page 鼠标在页面文档的x和y坐标
            console.log(e.pageX);
            console.log(e.pageY);
            console.log('---------------------');

            // 3. screen 鼠标在电脑屏幕的x和y坐标
            console.log(e.screenX);
            console.log(e.screenY);

        })
    </script>
</body>

图片跟随鼠标案例

<style>
      img {
          /*绝对定位!这样不会影响其他的盒子的位置*/
        position: absolute;
        width: 300px;
      }
</style>
...
<img src="..." alt="" />

<script>
      var img = document.querySelector("img");

      document.addEventListener("mousemove", function (e) {
        var x = e.clientX;
        var y = e.clientY;
        img.style.top = y + "px";
        img.style.left = x + "px";
      });
</script>

注意别忘了后面的 px!!!

---

# 常用的键盘事件

键盘事件	触发条件
onkeyup	某个键盘按键被松开时触发
onkeydown	某个键盘按键被按下时触发 (一直按着一直触发)
onkeypress	某个键盘按键被按下时触发，(一直按着一直触发). 但是它不识别功能键，比如 ctrl shift 箭头等

• 如果使用 addEventListener 不需要加 on
• onkeypress 和前面 2 个的区别是，它不识别功能键，比如左右箭头，shift 等
• 三个事件的执行顺序是： keydown (先) –> keypress (然后) —> keyup (最后松开执行)

<body>
    <script>
        // 常用的键盘事件
        //1. keyup 按键弹起的时候触发 
        // document.onkeyup = function() {
    
        //         console.log('我弹起了');

        //     }
        document.addEventListener('keyup', function() {
    
            console.log('我弹起了');
        })

        //3. keypress 按键按下的时候触发  不能识别功能键 比如 ctrl shift 左右箭头啊
        document.addEventListener('keypress', function() {
    
                console.log('我按下了press');
            })
            //2. keydown 按键按下的时候触发  能识别功能键 比如 ctrl shift 左右箭头啊
        document.addEventListener('keydown', function() {
    
                console.log('我按下了down');
            })
            // 4. 三个事件的执行顺序  keydown -- keypress -- keyup
    </script>
</body>

# 键盘对象属性

键盘事件对象 属性	说明
keyCode	返回该键值的 ASCII 值

• onkeydown 和 onkeyup 不区分字母大小写 (所以要是看 keyCode, 'a’和’A’一样都会是 65)，onkeypress 区分字母大小写。
• 在我们实际开发中，我们更多的使用 keydown 和 keyup， 它能识别所有的键（包括功能键）
• Keypress 不识别功能键，但是 keyCode 属性能区分大小写，返回不同的 ASCII 值

<body>
    <script>
        // 键盘事件对象中的keyCode属性可以得到相应键的ASCII码值
        // 1. 我们的keyup 和keydown事件不区分字母大小写  a 和 A 得到的都是65
        // 2. 我们的keypress 事件 区分字母大小写  a 得到的是97 , A 得到的是65
        document.addEventListener('keyup', function(e) {
    
            console.log('up:' + e.keyCode);
            // 我们可以利用keycode返回的ASCII码值来判断用户按下了那个键
            if (e.keyCode === 65) {
    
                alert('您按下的a键');
            } else {
    
                alert('您没有按下a键')
            }

        })
        document.addEventListener('keypress', function(e) {
    
            console.log('press:' + e.keyCode);
        })
    </script>
</body>

某些时候比如说我们直接键盘打 s 键，会自动让搜索框 onfocus, 这时候我们可以把事件的触发条件设置为 keyup 而不是 keydown 因为要是设置了 keydown, 你在按的时候会一直触发，所以你一按，搜索框 onfocus 了，然后因为你一直按着会一直在搜索框里输入内容 (检测的很快地，就算你就是轻轻按了一下)

所以你一按键会先触发事件执行对应的代码然后才把你按下的放到那个文本框里，这样不好用

一般都是用 keyup

---

思维导图：

# 1. BOM 概述

• BOM = Browser Object Model 浏览器对象模型
• 它提供了独立于内容而与浏览器窗口进行交互的对象，其核心对象是 window
• BOM 由一系列相关的对象构成，并且每个对象都提供了很多方法与属性
• BOM 缺乏标准，JavaScript 语法的标准化组织是 ECMA, DOM 的标准化组织是 W3C, BOM 最初是 Netscape 浏览器标准的一部分

DOM	BOM
文档对象模型	浏览器对象模型
DOM 就是把文档当作一个对象来看待	把 浏览器当作一个对象来看待
DOM 的顶级对象是 document	BOM 的顶级对象是 window
DOM 主要学习的是操作页面元素	BOM 学习的是浏览器窗口交互的一些对象
DOM 是 W3C 标准规范	BOM 是浏览器厂商在各自浏览器上定义的，兼容性较差

# BOM 的构成

• BOM 比 DOM 更大。它包含 DOM。
• window 对象是浏览器的顶级对象，它具有双重角色
• 它是 JS 访问浏览器窗口的一个接口
• 它是一个全局对象。定义在全局作用域中的变量、函数都会变成 window 对象的属性和方法
• 在调用的时候可以省略 window，前面学习的对话框都属于 window 对象方法，如 alert ()、prompt () 等。
• 注意：window 下的一个特殊属性 window.name

// 定义在全局作用域中的变量会变成window对象的属性
var num = 10;
console.log(window.num);
// 10

// 定义在全局作用域中的函数会变成window对象的方法
function fn() {
    console.log(11);
}
console.fn();
// 11

var name = 10;  //不要用这个name变量,window下已经有一个特殊属性window.name

# window 对象的常见事件

# 窗口加载事件

window.onload 是窗口（页面）加载事件，当文档内容完全加载完成会触发该事件（包括图像，脚本文件，CSS 文件等），就调用的处理函数。

window.onload = function(){
    // 然后正常的写代码
    var btn = document.querySelector('button');
    btn.addEventListener('click',function(){
        alert('haha');
    })
};
// 或者
window.addEventListener("load",function(){
    // 然后正常的写代码
    var btn = document.querySelector('button');
    btn.addEventListener('click',function(){
    alert('haha');
    })
});

注意：

• 有了 window.onload 就可以把 JS 代码写到页面元素的上方
• 因为 onload 是等页面内容全部加载完毕，再去执行处理函数
• window.onload 就像 onclick 等一样是传统注册事件方式，只能写一次
• 如果有多个，会以最后一个 window.onload 为准，就是最后的覆盖了前面的
• 如果使用 addEventListener 则没有限制，就跟我们上面学的一样

另一种方式 (DOMContentLoaded):

document.addEventListener('DOMContentLoaded',function(){
});

接收两个参数：

• DOMCountentLoaded 事件触发时，仅当 DOM 加载完成，不包括样式表，图片，flash 等等
• 如果页面的图片很多的话，从用户访问到 onload 触发可能需要较长的时间
• 交互效果就不能实现，必然影响用户的体验，此时用 DOMContentLoaded 事件比较合适。

区别：

• load 等页面内容全部加载完毕，包括页面 dom 元素，图片，flash，css 等
• DOMContentLoaded 是 DOM 加载完毕，不包含图片 flash css 等就可以执行，加载速度比 load 更快一些

<script>
    // window.onload = function() {
    
    //     var btn = document.querySelector('button');
    //     btn.addEventListener('click', function() {
    
    //         alert('点击我');
    //     })
    // }
    // window.onload = function() {
    
    //     alert(22);
    // }
    
    window.addEventListener('load', function() {    
        var btn = document.querySelector('button');
        btn.addEventListener('click', function() {
         alert('点击我');
        })
    })

    window.addEventListener('load', function() {  
        alert(22);
    })
    
	document.addEventListener('DOMContentLoaded', function() {
            alert(33);
	})
// load 等页面内容全部加载完毕，包含页面dom元素 图片 flash  css 等等
// DOMContentLoaded 是DOM 加载完毕，不包含图片 falsh css 等就可以执行 加载速度比 load更快一些
</script>

# 调整窗口大小事件

window.onresize 是调整窗口大小加载事件，当触发时就调用的处理函数

window.onresize = function() {
    }
// 或者
window.addEventListener('resize',function(){
});

• 只要窗口大小发生像素变化，就会触发这个事件
• 我们经常利用这个事件完成响应式布局。 window.innerWidth 当前屏幕的宽度

<body>
    <script>
        window.addEventListener('load', function() {
    
            var div = document.querySelector('div');
            window.addEventListener('resize', function() {
    
                console.log(window.innerWidth);

                console.log('变化了');
                if (window.innerWidth <= 800) {
    
                    div.style.display = 'none';
                } else {
    
                    div.style.display = 'block';
                }

            })
        })
    </script>
    <div></div>
</body>

---

# 2. 定时器

window 对象给我们提供了两个定时器：setTimeout ()、setInterval ()

# setTimeout() 定时器

setTimeout () 方法用于设置一个定时器，该定时器在定时器到期后执行调用函数。

window.setTimeout(调用函数,[延迟的毫秒数]);

注意：

1. window 可以省略
2. 这个调用函数：可以直接写函数 或者 写函数名 或者 采取字符串 ‘函数名 ()’（不推荐）
3. 延迟的毫秒数省略默认是 0，如果写，必须是毫秒
4. 因为一个页面中定时器可能有很多，所以我们经常给定时器赋值一个标识符 (名字)

<body>
    <script>
        // 1. setTimeout 
        // 语法规范：  window.setTimeout(调用函数, 延时时间);
        // 1. 这个window在调用的时候可以省略
        // 2. 这个延时时间单位是毫秒 但是可以省略，如果省略默认的是0
        // 3. 这个调用函数可以直接写函数 还可以写 函数名 还有一个写法 '函数名()'
        // 4. 页面中可能有很多的定时器，我们经常给定时器加标识符 （名字)
        // setTimeout(function() {
    
        //     console.log('时间到了');

        // }, 2000);
        function callback() {
    
            console.log('爆炸了');

        }
        var timer1 = setTimeout(callback, 3000);
        var timer2 = setTimeout(callback, 5000);
        // setTimeout('callback()', 3000); // 我们不提倡这个写法
    </script>
</body>

1. setTimeout () 这个调用函数我们也称为回调函数 callback
2. 普通函数是按照代码顺序直接调用，而这个函数，需要等待事件，事件到了才会去调用这个函数，因此称为回调函数。

所以这个 setTimeout () 里面的函数和 setTimeout () 本身不需要我们去调用，就算我们赋值给一个变量那只是给这个定时器一个标识符而已，不需要特意去写调用，时间一到就会检测到事件然后去自动就会调用那个函数.

# clearTimeout() 停止定时器

• clearTimeout () 方法取消了先前通过调用 setTimeout () 建立的定时器

window.clearTimeout(timeoutID)

注意：window 可以省略；里面的参数就是定时器的标识符

<body>
    <button>点击停止定时器</button>
    <script>
        var btn = document.querySelector('button');
        var timer = setTimeout(function() {
    
            console.log('爆炸了');
        }, 5000);
        btn.addEventListener('click', function() {
    
            clearTimeout(timer);
        })
    </script>
</body>

注意这里需要把 setTimeout 回调函数赋值给一个变量，这样也就是为了这个定时器起了个标识符

这个样子之后想清掉这个计时器就可以用 clearTimeout (标识符)

# setInterval() 定时器

• setInterval () 方法重复调用一个函数，每隔这个时间，就去调用一次回调函数

window.setInterval(回调函数,[间隔的毫秒数]);

• window 可以省略
• 这个回调函数：可以直接写函数或者写函数名或者采取字符 ‘函数名 ()’(不推荐)
• 第一次执行也是间隔毫秒数之后执行，之后每隔毫秒数就执行一次

<body>
    <script>
        // 1. setInterval 
        // 语法规范：  window.setInterval(调用函数, 延时时间);
        setInterval(function() {
    
            console.log('继续输出');

        }, 1000);
        // 2. setTimeout  延时时间到了，就去调用这个回调函数，只调用一次 就结束了这个定时器
        // 3. setInterval  每隔这个延时时间，就去调用这个回调函数，会调用很多次，重复调用这个函数
    </script>
</body>

# clearInterval() 停止定时器

• clearInterval () 方法取消了先前通过调用 setInterval () 建立的定时器
• 注意：window 可以省略；里面的参数就是定时器的标识符

<body>
    <button class="begin">开启定时器</button>
    <button class="stop">停止定时器</button>
    <script>
        var begin = document.querySelector('.begin');
        var stop = document.querySelector('.stop');
        var timer = null; // 全局变量  null是一个空对象
        begin.addEventListener('click', function() {
    
            timer = setInterval(function() {
    
                console.log('ni hao ma');

            }, 1000);
        })
        stop.addEventListener('click', function() {
    
            clearInterval(timer);
        })
    </script>
</body>

这里 timer 先全局声明然后赋值为空对象 null, 而不是什么都不赋值因为什么都不赋值会是 undefined, 可能会出错.(timer 要存的是对象)

全局声明这样都可以 clearInterval 和 setInterval 在自己各自的 (匿名) 函数作用域里面都可以 access 到

# this 指向

• this 的指向在函数定义的时候是确定不了的，只有函数执行的时候才能确定 this 到底指向谁
• 现阶段，我们先了解一下几个 this 指向：
  • 全局作用域或者普通函数中 this 指向全局对象
  • window (注意定时器里面的 this 指向 window)
  • 方法调用中谁调用 this 指向谁
  • 构造函数中 this 指向构造函数实例

<body>
    <button>点击</button>
    <script>
        // this 指向问题 一般情况下this的最终指向的是那个调用它的对象

        // 1. 全局作用域或者普通函数中this指向全局对象window（ 注意定时器里面的this指向window）
        console.log(this);
        function fn() {
            console.log(this);
        }
        window.fn();
        window.setTimeout(function() { //定时器里面的this也指向的是window,一般调用定时器方法都是window对象调用只不过我们之前都省略掉了   
            console.log(this);
        }, 1000);

        // 2. 方法调用中谁调用this指向谁
        var o = {
            sayHi: function() {
                console.log(this); 
            }
        }
        o.sayHi(); // this指向的是 o 这个对象 
        var btn = document.querySelector('button');
        btn.onclick = function() {  
             console.log(this); // this指向的是btn这个按钮对象
        }
        btn.addEventListener('click', function() {
                console.log(this); // this指向的是btn这个按钮对象
        }) //方法谁调用,this就指向谁
        
	    // 3. 构造函数中this指向构造函数的实例
        function Fun() {
            console.log(this); // this 指向的是fun 实例对象
        }
        var fun = new Fun(); 
//在遇到new的那一刻就是创造一个新对象然后把这个赋值给fun让fun这个变量指向这个新对象,所以构造函数里面的this其实就是这个变量(因为这个变量指向的就是这个new创建的新对象),也可以称作为实例.跟java里一样.
    </script>
</body>

---

# 3. JS 执行机制

# JS 是单线程

• JavaScript 语言的一大特点就是单线程，也就是说，同一个时间只能做一件事。这是因为 Javascript 这门脚本语言诞生的使命所致 ——JavaScript 是为处理页面中用户的交互，以及操作 DOM 而诞生的。比如我们对某个 DOM 元素进行添加和删除操作，不能同时进行。 应该先进行添加，之后再删除。
• 单线程就意味着，所有任务需要排队，前一个任务结束，才会执行后一个任务。这样所导致的问题是： 如果 JS 执行的时间过长，这样就会造成页面的渲染不连贯，导致页面渲染加载阻塞的感觉。
• 一个问题：以下代码执行的结果是什么？

console.log(1);
setTimeout(function() {
    
    console.log(3);
},1000);
console.log(2);

按照单线程的话，需要把定时器上面的代码执行完了才可以进行计时器的倒计时然后进行运行的代码，然后等定时器完全计时完了执行完了等等才可以执行定时器下面的代码. 按照排列的顺序依次执行

那么以下代码执行的结果又是什么？

console.log(1);
setTimeout(function() {    
    console.log(3);
},0);
console.log(2);

# 同步和异步

为了解决这个问题，利用多核 CPU 的计算能力，HTML5 提出 Web Worker 标准，允许 JavaScript 脚本创建多个线程。于是，JS 中出现了同步和异步。

• 同步：前一个任务结束后再执行后一个任务

• 异步：在做这件事的同时，你还可以去处理其他事情

• 同步任务：同步任务都在主线程上执行，形成一个 执行栈

• 异步任务：JS 中的异步是通过回调函数实现的

  • 异步任务有以下三种类型：

    • 普通事件，如 click,resize 等；

    • 资源加载，如 load,error 等；

    • 定时器，包括 setInterval__里面的回调函数__,setTimeout__里面的回调函数__等。

      (setInterval,setTimeout 本身自己是同步任务！)

  • 异步任务相关回调函数添加到任务队列中
    

1. 先执行执行栈中的同步任务

2. 再执行执行栈中的同步任务时遇到属于异步任务 (回调函数) 的就会把这个异步任务放入任务队列中， 但先不执行！

3. 一旦执行栈中的所有同步任务执行完毕，系统就会按次序读取任务队列中的异步任务，于是被读取的异步任务结束等待状态，进入执行栈，开始执行

   
   此时再来看我们刚才的问题：

console.log(1);
setTimeout(function() {
    console.log(3);
},1000);
console.log(2);
// 执行的结果和顺序为 1、2、3
console.log(1);
setTimeout(function() {
    
    console.log(3);
},0);
console.log(2);
// 执行的结果和顺序为 1、2、3

这个顺序是因为多线程，异步概念，都是执行多个任务，这样一个耗时长的一直阻塞一个线程其他的线程可以继续执行下面的代码

// 3. 第三个问题
console.log(1);
document.onclick = function() { 
    console.log('click');
}
console.log(2);
setTimeout(function() {    
    console.log(3)
}, 3000)

同步任务放在执行栈中执行，异步任务由__异步进程处理__放到任务队列中 (注意比如 onclick 这类的只会在鼠标点击了才会从由异步进程处理放到 (异步) 任务队列，再执行栈结束会看异步任务列表会看有没有异步任务要执行，如果有的话就从任务队列把这个任务拿出来 (所以任务列表里面会清空) 放到执行栈进行执行). 所以比如说事件触发调用的回调函数也只是触发了之后先安排去排队，然后在等待主线程执行栈执行现有的然后来这里看到这个要执行的

执行栈中的任务执行完毕会去任务队列中查看是否有异步任务执行，如果有会拿回运行栈执行，执行完再去看，so on…，由于主线程不断的重复获得任务、执行任务、再获取任务、再执行，所以这种机制被称为事件循环（event loop)。

JavaScript 是单线程执行的，无法同时执行多段代码。当某一段代码正在执行的时候，所有后续的任务都必须等待，形成一个队列。一旦当前任务执行完毕，再从队列中取出下一个任务，这也常被称为 “阻塞式执行”。所以一次鼠标点击，或是计时器到达时间点，或是 Ajax 请求完成触发了回调函数，这些事件处理程序或回调函数__都不会立即运行，而是立即排队__，一旦线程有空闲就执行。假如当前 JavaScript 线程正在执行一段很耗时的代码，此时发生了一次鼠标点击，那么事件处理程序就被阻塞，用户也无法立即看到反馈，事件处理程序会被放入任务队列，直到前面的代码结束以后才会开始执行。如果代码中设定了一个 setTimeout，那么浏览器便会在合适的时间，将代码插入任务队列，如果这个时间设为 0，就代表立即插入队列，但不是立即执行，仍然要等待前面代码执行完毕。所以 setTimeout 并不能保证执行的时间，是否及时执行取决于 JavaScript 线程是拥挤还是空闲。

---

# 4. location 对象

window 对象给我们提供了一个 location 属性用于获取或者设置窗体的 url，并且可以解析 url。因为这个属性返回的是一个对象，所以我们将这个属性也称为 location 对象。

# url

统一资源定位符（uniform resouce locator）是互联网上标准资源的地址。互联网上的每个文件都有一个唯一的 URL，它包含的信息指出文件的位置以及浏览器应该怎么处理它。
url 的一般语法格式为：

protocol://host[:port]/path/[?query]#fragment

http://www.itcast.cn/index.html?name=andy&age=18#link

组成	说明
protocol	信协议 常用的 http,ftp,maito 等
host	主机 (域名) www.itheima.com
port	端口号，可选
path	路径 由零或多个’/' 符号隔开的字符串
query	参数 以键值对的形式，通过 & 符号分隔开来
fragment	片段 #后面内容 常见于链接 锚点

# location 对象属性

location 对象属性	返回值
location.href	获取或者设置整个 URL
location.host	返回主机（域名）www.baidu.com
location.port	返回端口号，如果未写返回空字符串
location.pathname	返回路径
location.search	返回参数
location.hash	返回片段 #后面内容常见于链接 锚点

重点记住： href 和 search

• 需求：5s 之后跳转页面

<body>
    <button>点击</button>
    <div></div>
    <script>
        var btn = document.querySelector('button');
        var div = document.querySelector('div');
        var timer = 5;
        setInterval(function() {
    
            if (timer == 0) {
    
                location.href = 'http://www.itcast.cn';
            } else {
    
                div.innerHTML = '您将在' + timer + '秒钟之后跳转到首页';
                timer--;
            }

        }, 1000);
    </script>
</body>

# location 对象方法

location 对象方法	返回值
location.assign()	跟 href 一样，可以跳转页面 (也称为重定向页面), 记录浏览历史，可以后退页面
location.replace()	替换当前页面，因为不记录历史，所以不能后退页面
location.reload()	重新加载页面，相当于刷新按钮或者 f5 ，如果参数为 true 强制刷新 ctrl+f5 (就不使用之前本地缓存的内容)

<body>
    <button>点击</button>
    <script>
        var btn = document.querySelector('button');
        btn.addEventListener('click', function() {
    
            // 记录浏览历史，所以可以实现后退功能
            // location.assign('http://www.itcast.cn');
            // 不记录浏览历史，所以不可以实现后退功能
            // location.replace('http://www.itcast.cn');
            location.reload(true);
        })
    </script>
</body>

# 获取 URL 参数

我们简单写一个登录框，点击登录跳转到 index.html

<body>
    <form action="index.html">
        用户名： <input type="text" name="uname">
        <input type="submit" value="登录">
    </form>
</body>

接下来我们写 index.html

<body>
    <div></div>
    <script>
        console.log(location.search); // ?uname=andy
        // 1.先去掉？  substr('起始的位置'，截取几个字符);
        var params = location.search.substr(1); // uname=andy
        console.log(params);
        // 2. 利用=把字符串分割为数组 split('=');
        var arr = params.split('=');
        console.log(arr); // ["uname", "ANDY"]
        var div = document.querySelector('div');
        // 3.把数据写入div中
        div.innerHTML = arr[1] + '欢迎您';
        // 这样我们就能获取到路径上的URL参数
    </script>
</body>

---

# 5. navigator 对象

• navigator 对象包含有关浏览器的信息，它有很多属性
• 我们常用的是 userAgent, 该属性可以返回由客户机发送服务器的 user-agent 头部的值
• 下面前端代码可以判断用户是用哪个终端打开页面的，如果是用 PC 打开的，我们就跳转到 PC 端的页面，如果是用手机打开的，就跳转到手机端页面

if((navigator.userAgent.match(/(phone|pad|pod|iPhone|iPod|ios|iPad|Android|Mobile|BlackBerry|IEMobile|MQQBrowser|JUC|Fennec|wOSBrowser|BrowserNG|WebOS|Symbian|Windows Phone)/i))) {
    
    window.location.href = "";     //手机
 } else {
    
    window.location.href = "";     //电脑
 }

---

# 6. history 对象

• window 对象给我们提供了一个 history 对象，与浏览器历史记录进行交互
• 该对象包含用户（在浏览器窗口中）访问过的 URL。

history 对象方法	作用
back()	可以后退功能
forward()	前进功能
go (参数)	前进后退功能，参数如果是 1 前进 1 个页面 如果是 -1 后退 1 个页面

<body>
    <a href="list.html">点击我去往列表页</a>
    <button>前进</button>
    <script>
        var btn = document.querySelector('button');
        btn.addEventListener('click', function() {
    
            // history.forward();
            history.go(1);
        })
    </script>
</body>

history.go(几步) , 如果是正数就往前走几个网页，负数就是倒退几个网页.

---

# PC 端网页特效

# 1. offset

# offset 概述

offset 翻译过来就是偏移量， 我们使用 offset 系列相关属性可以__动态的__得到该元素的位置（偏移）、大小等。

• 获得元素距离__带有定位父元素 (父元素需要有定位！)__的位置

• 获得元素自身的大小（宽度高度）

注意：返回的数值都不带单位

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <style>
        * {
    
            margin: 0;
            padding: 0;
        }
        
        .father {
    
            /* position: relative; */
            width: 200px;
            height: 200px;
            background-color: pink;
            margin: 150px;
        }
        
        .son {
    
            width: 100px;
            height: 100px;
            background-color: purple;
            margin-left: 45px;
        }
        
        .w {
    
            height: 200px;
            background-color: skyblue;
            margin: 0 auto 200px;
            padding: 10px;
            border: 15px solid red;
        }
    </style>
</head>

<body>
    <div class="father">
        <div class="son"></div>
    </div>
    <div class="w"></div>
    <script>
        // offset 系列
        var father = document.querySelector('.father');
        var son = document.querySelector('.son');
        // 1.可以得到元素的偏移 位置 返回的不带单位的数值  
        console.log(father.offsetTop);
        console.log(father.offsetLeft);
        // 它以带有定位的父亲为准  如果么有父亲或者父亲没有定位 则以 body 为准
        console.log(son.offsetLeft);
        // 2.可以得到元素的大小 宽度和高度 是包含 padding + border + width 
        var w = document.querySelector('.w');
        console.log(w.offsetWidth);
        console.log(w.offsetHeight);
        // 3. 返回带有定位的父亲 否则返回的是body
        console.log(son.offsetParent); // 返回带有定位的父亲 否则返回的是body
        console.log(son.parentNode); // 返回父亲 是最近一级的父亲 亲爸爸 不管父亲有没有定位
    </script>
</body>

</html>

offsetWidth 和 offsetHeight 是盒子 (padding 加内容加 border 一起的)

console.log (son.offsetParent); // 返回带有定位的父亲 否则返回的是 body
console.log (son.parentNode); // 返回父亲 是__最近一级的父亲 亲爸爸 不管父亲有没有定位__

# offset 与 style 区别

offset	style
offset 可以得到__任意样式表中的样式值__	style 只能得到__行内样式 (就是 html 代码那里 inline 的 style, 权重高)__表中的样式值
offset 系列获得的数值 (是 Number 类型不是字符串类型) 是没有单位的	style.width 获得的是带有__单位的字符串__
offsetWidth 包含 padding+border+width	style.width 获得不包含 padding 和 border 的值
offsetWidth 等属性是只读属性，只能获取不能赋值	style.width 是可读写属性，可以获取也可以赋
所以，我们想要__获取元素大小位置，用 offset 更合适__	所以，我们想要给元素__更改值，则需要用 style 改变__

# 案例：获取鼠标在盒子内的坐标

我们在盒子内点击，想要得到鼠标距离盒子左右的距离。

• 首先得到鼠标在页面中的坐标（e.pageX, e.pageY）
• 其次得到盒子在页面中的距离 (box.offsetLeft, box.offsetTop)
• 用鼠标距离页面的坐标减去盒子在页面中的距离，得到 鼠标在盒子内的坐标
• 如果想要移动一下鼠标，就要获取最新的坐标，使用鼠标移动事件 mousemove

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <style>
        .box {
    
            width: 300px;
            height: 300px;
            background-color: pink;
            margin: 200px;
        }
    </style>
</head>

<body>
    <div class="box"></div>
    <script>
        // 我们在盒子内点击， 想要得到鼠标距离盒子左右的距离。
        // 首先得到鼠标在页面中的坐标（ e.pageX, e.pageY）
        // 其次得到盒子在页面中的距离(box.offsetLeft, box.offsetTop)
        // 用鼠标距离页面的坐标减去盒子在页面中的距离， 得到 鼠标在盒子内的坐标
        var box = document.querySelector('.box');
        box.addEventListener('mousemove', function(e) {
    
            // console.log(e.pageX);
            // console.log(e.pageY);
            // console.log(box.offsetLeft);
            var x = e.pageX - this.offsetLeft;
            var y = e.pageY - this.offsetTop;
            this.innerHTML = 'x坐标是' + x + ' y坐标是' + y;
        })
    </script>
</body>

</html>

# 案例：模态框拖拽（重点）

任务需求：

弹出框，我们也称为模态框。

点击弹出层，会弹出模态框，并且显示灰色半透明的遮挡层。
点击关闭按钮，可以关闭模态框，并且同时关闭灰色半透明遮挡层。
鼠标放到模态框最上面一行，可以按住鼠标拖拽模态框在页面中移动。
鼠标松开，可以停止拖动模态框移动。

案例分析:

①点击弹出层，模态框和遮挡层就会显示出来 display:block;
②点击关闭按钮，模态框和遮挡层就会隐藏起来 display:none;
③鼠标按下触发的事件源是最上面一行，就是 id 为 title，触发事件是鼠标按下 mousedown, 之后鼠标移动 mousemove，最后松开鼠标 mouseup
④在页面中拖拽的原理：鼠标移动过程中，获得最新的值赋值给模态框的 left 和 top 值，这样模态框可以跟着鼠标走了
⑤对于模态框的更新坐标的计算：首先鼠标按下，我们可以得到鼠标在页面中的坐标，根据偏移量可以求出按下鼠标时模态框的坐标，两者相减得到鼠标在盒子中的坐标 (x, y)，由于在移动过程中，鼠标在盒子中的坐标不变，因此鼠标在页面中的坐标减去鼠标在盒子内的坐标，就是模态框真正的位置（注意移动事件写到按下事件里面。）
⑥鼠标松开，就停止拖拽，就是可以让鼠标移动事件解除

<!DOCTYPE html>
<html>

<head lang="en">
    <meta charset="UTF-8">
    <title></title>
    <style>
        .login-header {
    
            width: 100%;
            text-align: center;
            height: 30px;
            font-size: 24px;
            line-height: 30px;
        }
        
        ul,
        li,
        ol,
        dl,
        dt,
        dd,
        div,
        p,
        span,
        h1,
        h2,
        h3,
        h4,
        h5,
        h6,
        a {
    
            padding: 0px;
            margin: 0px;
        }
        
        .login {
    
            display: none;
            width: 512px;
            height: 280px;
            position: fixed;
            border: #ebebeb solid 1px;
            left: 50%;
            top: 50%;
            background: #ffffff;
            box-shadow: 0px 0px 20px #ddd;
            z-index: 9999;
            transform: translate(-50%, -50%);
        }
        
        .login-title {
    
            width: 100%;
            margin: 10px 0px 0px 0px;
            text-align: center;
            line-height: 40px;
            height: 40px;
            font-size: 18px;
            position: relative;
            cursor: move;
        }
        
        .login-input-content {
    
            margin-top: 20px;
        }
        
        .login-button {
    
            width: 50%;
            margin: 30px auto 0px auto;
            line-height: 40px;
            font-size: 14px;
            border: #ebebeb 1px solid;
            text-align: center;
        }
        
        .login-bg {
    
            display: none;
            width: 100%;
            height: 100%;
            position: fixed;
            top: 0px;
            left: 0px;
            background: rgba(0, 0, 0, .3);
        }
        
        a {
    
            text-decoration: none;
            color: #000000;
        }
        
        .login-button a {
    
            display: block;
        }
        
        .login-input input.list-input {
    
            float: left;
            line-height: 35px;
            height: 35px;
            width: 350px;
            border: #ebebeb 1px solid;
            text-indent: 5px;
        }
        
        .login-input {
    
            overflow: hidden;
            margin: 0px 0px 20px 0px;
        }
        
        .login-input label {
    
            float: left;
            width: 90px;
            padding-right: 10px;
            text-align: right;
            line-height: 35px;
            height: 35px;
            font-size: 14px;
        }
        
        .login-title span {
    
            position: absolute;
            font-size: 12px;
            right: -20px;
            top: -30px;
            background: #ffffff;
            border: #ebebeb solid 1px;
            width: 40px;
            height: 40px;
            border-radius: 20px;
        }
    </style>
</head>

<body>
    <div class="login-header"><a id="link" href="javascript:;">点击，弹出登录框</a></div>
    <div id="login" class="login">
        <div id="title" class="login-title">登录会员
            <span><a id="closeBtn" href="javascript:void(0);" class="close-login">关闭</a></span>
        </div>
        <div class="login-input-content">
            <div class="login-input">
                <label>用户名：</label>
                <input type="text" placeholder="请输入用户名" name="info[username]" id="username" class="list-input">
            </div>
            <div class="login-input">
                <label>登录密码：</label>
                <input type="password" placeholder="请输入登录密码" name="info[password]" id="password" class="list-input">
            </div>
        </div>
        <div id="loginBtn" class="login-button"><a href="javascript:void(0);" id="login-button-submit">登录会员</a></div>
    </div>
    <!-- 遮盖层 -->
    <div id="bg" class="login-bg"></div>
    <script>
        // 1. 获取元素
        var login = document.querySelector('.login');
        var mask = document.querySelector('.login-bg');
        var link = document.querySelector('#link');
        var closeBtn = document.querySelector('#closeBtn');
        var title = document.querySelector('#title');
        // 2. 点击弹出层这个链接 link  让mask 和login 显示出来
        link.addEventListener('click', function() {
    
                mask.style.display = 'block';
                login.style.display = 'block';
            })
            // 3. 点击 closeBtn 就隐藏 mask 和 login 
        closeBtn.addEventListener('click', function() {
    
                mask.style.display = 'none';
                login.style.display = 'none';
            })
            // 4. 开始拖拽
            // (1) 当我们鼠标按下， 就获得鼠标在盒子内的坐标
        title.addEventListener('mousedown', function(e) {
    
            var x = e.pageX - login.offsetLeft;
            var y = e.pageY - login.offsetTop;
            // (2) 鼠标移动的时候，把鼠标在页面中的坐标，减去 鼠标在盒子内的坐标就是模态框的left和top值
            document.addEventListener('mousemove', move) //注意这里只是回调函数的名字而不是调用,所以不要传e什么的,会自动传的

            function move(e) {
    
                login.style.left = e.pageX - x + 'px';
                login.style.top = e.pageY - y + 'px';
            }
            // (3) 鼠标弹起，就让鼠标移动事件移除
            document.addEventListener('mouseup', function() {
    
                document.removeEventListener('mousemove', move);
            })
        })
    </script>
</body>

</html>

注意这里的 mousemove 事件是写在 mousedown 事件里面，这样就是只有鼠标按下然后移动才可以触发的事件.

还有这里的 mousemove 是用 document 调用的这样 (冒泡会冒到 document 那里因为 document 都包含了), 而且这个 mousemove 想的是在整个页面移动所以 good. 这个样子只有按那个盒子才可以触发 mousedown 然后才可以 mousemove 触发里面的事件，而不是拽任何地方都可以.

# 案例：仿京东放大镜

整个案例可以分为三个功能模块

1. 鼠标经过小图片盒子， 黄色的遮挡层 和 大图片盒子显示，离开隐藏 2 个盒子功能
2. 黄色的遮挡层跟随鼠标功能
3. 移动黄色遮挡层，大图片跟随移动功能

• 鼠标经过小图片盒子， 黄色的遮挡层 和 大图片盒子显示，离开隐藏 2 个盒子功能

  就是显示与隐藏

• 黄色的遮挡层跟随鼠标功能。

• 把鼠标坐标给遮挡层不合适。因为遮挡层坐标以父盒子为准。

• 首先是获得鼠标在盒子的坐标。

• 之后把数值给遮挡层做为 left 和 top 值。

• 此时用到鼠标移动事件，但是还是在小图片盒子内移动。

• 发现，遮挡层位置不对，需要再减去盒子自身高度和宽度的一半。

• 遮挡层不能超出小图片盒子范围。

• 如果小于零，就把坐标设置为 0

• 如果大于遮挡层最大的移动距离，就把坐标设置为最大的移动距离

• 遮挡层的最大移动距离： 小图片盒子宽度 减去 遮挡层盒子宽度

window.addEventListener('load', function() {
    
    var preview_img = document.querySelector('.preview_img');
    var mask = document.querySelector('.mask');
    var big = document.querySelector('.big');
    // 1. 当我们鼠标经过 preview_img 就显示和隐藏 mask 遮挡层 和 big 大盒子
    preview_img.addEventListener('mouseover', function() {
    
        mask.style.display = 'block';
        big.style.display = 'block';
    })
    preview_img.addEventListener('mouseout', function() {
    
            mask.style.display = 'none';
            big.style.display = 'none';
        })
        // 2. 鼠标移动的时候，让黄色的盒子跟着鼠标来走
    preview_img.addEventListener('mousemove', function(e) {
    
        // (1). 先计算出鼠标在盒子内的坐标
        var x = e.pageX - this.offsetLeft;
        var y = e.pageY - this.offsetTop;
        // console.log(x, y);
        // (2) 减去盒子高度 300的一半 是 150 就是我们mask 的最终 left 和top值了
        // (3) 我们mask 移动的距离
        var maskX = x - mask.offsetWidth / 2;
        var maskY = y - mask.offsetHeight / 2;
        // (4) 如果x 坐标小于了0 就让他停在0 的位置
        // 遮挡层的最大移动距离
        var maskMax = preview_img.offsetWidth - mask.offsetWidth;
        if (maskX <= 0) {
    
            maskX = 0;
        } else if (maskX >= maskMax) {
    
            maskX = maskMax;
        }
        if (maskY <= 0) {
    
            maskY = 0;
        } else if (maskY >= maskMax) {
    
            maskY = maskMax;
        }
        mask.style.left = maskX + 'px';
        mask.style.top = maskY + 'px';
        // 3. 大图片的移动距离 = 遮挡层移动距离 * 大图片最大移动距离 / 遮挡层的最大移动距离
        // 大图
        var bigIMg = document.querySelector('.bigImg');
        // 大图片最大移动距离
        var bigMax = bigIMg.offsetWidth - big.offsetWidth;
        // 大图片的移动距离 X Y
        var bigX = maskX * bigMax / maskMax;
        var bigY = maskY * bigMax / maskMax;
        bigIMg.style.left = -bigX + 'px';
        bigIMg.style.top = -bigY + 'px';

    })

})

由于代码过多，部分没有显示.

---

# 2. client

# 元素可视区 client 系列

client 翻译过来就是客户端，我们使用 client 系列的相关属性来获取元素可视区的相关信息。通过 client 系列的相关属性可以动态的得到该元素的边框大小、元素大小等。

如果想要元素带着内容，边框和 padding 的大小用 offset.

想要元素带着内容和 padding (没有边框) 的大小用 client.

# 案例： 淘宝 flexible.js 源码分析⭐️重要！！！⭐️

立即执行函数 (function () {})() 或者 (function(){}()), 都很像，跟我们之前说的一样，也都可以传参数等.

第二种方式 (function (…,…){}(…,…)) 可以是匿名也可以加名字 ->(function XXX (参数 1, 参数 2,…){}(实参 1, 实参 2,…))

主要作用： 创建一个独立的作用域，里面变量都是局部变量。 避免了命名冲突问题，而且立即执行，执行完就把空间释放了

把这个 js 文件中所有的都放进这个立即执行函数里面， 这么做之后要是引入多个 js 文件，不会因为有可能会有全局变量而让一些变量混起来，每个 js 文件里面的变量都是对于他自己的 (局部变量)

注意，把整个 js 文件放进一个立即执行函数需要传 window 和 document 这样子函数里面就可以用了

<script>
     // 1.立即执行函数: 不需要调用，立马能够自己执行的函数
     function fn() {   
         console.log(1);
     }
     fn();
     // 2. 写法 也可以传递参数进来
     // 1.(function() {})()    或者  2. (function(){}());
     (function(a, b) {
 
         console.log(a + b);
         var num = 10;
     })(1, 2); // 第二个小括号可以看做是调用函数
     (function sum(a, b) {
 
         console.log(a + b);
         var num = 10; // 局部变量
     }(2, 3));
     // 3. 立即执行函数最大的作用就是 独立创建了一个作用域, 里面所有的变量都是局部变量 不会有命名冲突的情况
 </script>

下面三种情况都会刷新页面都会触发 (window.) load 事件。

1. a 标签的超链接
2. F5 或者刷新按钮（强制刷新）
3. 前进后退按钮

但是 火狐中，有个特点，有个 “往返缓存”，这个缓存中不仅保存着页面数据，还保存了 DOM 和 JavaScript 的状态；实际上是将整个页面都保存在了内存里。 所以此时后退按钮不能刷新页面。

此时可以使用 pageshow 事件来触发。这个事件在页面显示时触发，无论页面是否来自缓存。

在重新加载页面中，pageshow 会在 load 事件触发后触发；根据事件对象中的 persisted 来判断是否是缓存中的页面触发的 pageshow 事件，注意这个事件给 window 添加。

flexible.js 源码分析:

(function flexible(window, document) {
    
    // 获取的html 的根元素
    var docEl = document.documentElement
        // dpr 物理像素比
    var dpr = window.devicePixelRatio || 1 //拿的到就会是那个,拿不到就会是1

    // adjust body font size  设置我们body 的字体大小
    function setBodyFontSize() {
    
        // 如果页面中有body 这个元素 就设置body的字体大小
        if (document.body) {
    
            document.body.style.fontSize = (12 * dpr) + 'px'
        } else {
    
            // 如果页面中没有body 这个元素，则等着 我们页面主要的DOM元素加载完毕再去设置body
            // 的字体大小
            document.addEventListener('DOMContentLoaded', setBodyFontSize)
        }
    }
    setBodyFontSize();

    // set 1rem = viewWidth / 10    设置我们html 元素的文字大小
    function setRemUnit() {
    
        var rem = docEl.clientWidth / 10
        docEl.style.fontSize = rem + 'px'
    }

    setRemUnit()

    // reset rem unit on page resize  当我们页面尺寸大小发生变化的时候，要重新设置下rem 的大小
    window.addEventListener('resize', setRemUnit)
        // pageshow 是我们重新加载页面触发的事件
    window.addEventListener('pageshow', function(e) {
    
        // e.persisted 返回的是true 就是说如果这个页面是从缓存取过来的页面，也需要从新计算一下rem 的大小
        if (e.persisted) {
    
            setRemUnit()
        }
    })

    // detect 0.5px supports  有些移动端的浏览器不支持0.5像素的写法
    if (dpr >= 2) {
    
        var fakeBody = document.createElement('body')
        var testElement = document.createElement('div')
        testElement.style.border = '.5px solid transparent'
        fakeBody.appendChild(testElement)
        docEl.appendChild(fakeBody)
        if (testElement.offsetHeight === 1) {
    
            docEl.classList.add('hairlines')
        }
        docEl.removeChild(fakeBody)
    }
}(window, document))

---

# 3. scroll

# 元素 scroll 系列属性

scroll 翻译过来就是滚动的，我们使用 scroll 系列的相关属性可以动态的得到该元素的大小、滚动距离等。

scroll 是真正内容的大小，包括超出的内容.(注意 scrollTop 是如果你有卷动条往下卷动，上面超出盒子的距离)

client 就是之前内容的大小，不包括超出得内容.

# 页面被卷去的头部

如果浏览器的高（或宽）度不足以显示整个页面时，会自动出现滚动条。当滚动条向下滚动时，页面上面被隐藏掉的高度，我们就称为页面被卷去的头部。滚动条在滚动时会触发 onscroll 事件。

# 案例：仿淘宝固定右侧侧边栏

1. 原先侧边栏是绝对定位

2. 当页面滚动到一定位置，侧边栏改为固定定位

3. 页面继续滚动，会让 返回顶部显示出来

注意，元素被卷去的头部是 element.scrollTop , 如果是页面被卷去的头部 则是 window.pageYOffset
其实这个值 可以通过盒子的 offsetTop 可以得到，如果大于等于这个值，就可以让盒子固定定位了

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <style>
        .slider-bar {
    
            position: absolute;
            left: 50%;
            top: 300px;
            margin-left: 600px;
            width: 45px;
            height: 130px;
            background-color: pink;
        }
        
        .w {
    
            width: 1200px;
            margin: 10px auto;
        }
        
        .header {
    
            height: 150px;
            background-color: purple;
        }
        
        .banner {
    
            height: 250px;
            background-color: skyblue;
        }
        
        .main {
    
            height: 1000px;
            background-color: yellowgreen;
        }
        
        span {
    
            display: none;
            position: absolute;
            bottom: 0;
        }
    </style>
</head>

<body>
    <div class="slider-bar">
        <span class="goBack">返回顶部</span>
    </div>
    <div class="header w">头部区域</div>
    <div class="banner w">banner区域</div>
    <div class="main w">主体部分</div>
    <script>
        //1. 获取元素
        var sliderbar = document.querySelector('.slider-bar');
        var banner = document.querySelector('.banner');
        // banner.offestTop 就是被卷去头部的大小 一定要写到滚动的外面
        var bannerTop = banner.offsetTop;
            // 当我们侧边栏固定定位之后应该变化的数值
        var sliderbarTop = sliderbar.offsetTop - bannerTop;
        // 获取main 主体元素
        var main = document.querySelector('.main');
        var goBack = document.querySelector('.goBack');
        var mainTop = main.offsetTop;
        // 2. 页面滚动事件 scroll
        document.addEventListener('scroll', function() {
    
            // console.log(11);
            // window.pageYOffset 页面被卷去的头部
            // console.log(window.pageYOffset);
            // 3 .当我们页面被卷去的头部大于等于了 172 此时 侧边栏就要改为固定定位
            if (window.pageYOffset >= bannerTop) {
    
                sliderbar.style.position = 'fixed';
                sliderbar.style.top = sliderbarTop + 'px';
            } else {
    
                sliderbar.style.position = 'absolute';
                sliderbar.style.top = '300px';
            }
            // 4. 当我们页面滚动到main盒子，就显示 goback模块
            if (window.pageYOffset >= mainTop) {
    
                goBack.style.display = 'block';
            } else {
    
                goBack.style.display = 'none';
            }

        })
    </script>
</body>

</html>

---

# offset, client, scroll 总结

他们主要用法：
offset 系列 经常用于获得元素位置 offsetLeft offsetTop
client 经常用于获取元素大小 clientWidth clientHeight
scroll 经常用于获取滚动距离 scrollTop scrollLeft
注意页面滚动的距离通过 window.pageX (Y) Offset 获得

---

# mouseenter 和 mouseover 的区别（面试经常问）

当鼠标移动到元素上时就会触发 mouseenter 事件
类似 mouseover，它们两者之间的差别是

mouseover 鼠标经过自身盒子会触发，经过子盒子还会触发。

mouseenter 只会经过自身盒子触发，经过子盒子不会触发。__
之所以这样，就是因为 mouseenter 不会冒泡，所以经过子盒子不会冒泡把事件冒到父盒子上

跟 mouseenter 搭配 鼠标离开 mouseleave 同样不会冒泡

---

# 4. 动画

# 动画实现原理

核心原理：通过定时器 setInterval () 不断移动盒子位置。

实现步骤：

1. 获得盒子当前位置
2. 让盒子在当前位置加上 1 个移动距离
3. 利用定时器不断重复这个操作
4. 加一个结束定时器的条件
5. 注意此元素需要添加定位，才能使用 element.style.left, 动画的话必须要给那个盒子定位才可以让那个盒子动起来，因用的是 element.style.left 和 element.style.top

# 动画函数简单封装

注意函数需要传递 2 个参数，动画对象和移动到的距离。

// 简单动画函数封装obj目标对象 target 目标位置
function animate(obj, target) {
    var timer = setInterval(function() {
        if (obj.offsetLeft >= target) {
            // 停止动画 本质是停止定时器
            clearInterval(timer);
        }
        //每次均匀向右移动1px
        obj.style.left = obj.offsetLeft + 1 + 'px';

    }, 30);
}
animate(aaa,xxx);
animate(bbb,yyy);

# 动画函数给不同元素记录不同定时器

如果多个元素都使用这个动画函数 (然后把这个元素作为参数传进来了)，每次都要 var 声明定时器。我们可以给不同的元素使用不同的定时器（自己专门用自己的定时器）。

核心原理：利用 JS 是一门动态语言，可以很方便的给当前对象添加属性。

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <style>
        div {
    
            position: absolute;
            left: 0;
            width: 100px;
            height: 100px;
            background-color: pink;
        }
        
        span {
    
            position: absolute;
            left: 0;
            top: 200px;
            display: block;
            width: 150px;
            height: 150px;
            background-color: purple;
        }
    </style>
</head>

<body>
    <button>点击夏雨荷才走</button>
    <div></div>
    <span>夏雨荷</span>
    <script>
        // var obj = {};
        // obj.name = 'andy';
        // 简单动画函数封装obj目标对象 target 目标位置
        // 给不同的元素指定了不同的定时器
        function animate(obj, target) {
    
            // 当我们不断的点击按钮，这个元素的速度会越来越快，因为开启了太多的定时器
            // 解决方案就是 让我们元素只有一个定时器执行
            // 先清除以前的定时器，只保留当前的一个定时器执行
            clearInterval(obj.timer);
            obj.timer = setInterval(function() { //这里是obj.timer添加属性而不是var timer->又不知道是哪一个的计时器还会开辟新的空间,空间一多就浪费
    
                if (obj.offsetLeft >= target) {
    
                    // 停止动画 本质是停止定时器
                    clearInterval(obj.timer);
                }else{
                obj.style.left = obj.offsetLeft + 1 + 'px';
                }
            }, 30);
        }

        var div = document.querySelector('div');
        var span = document.querySelector('span');
        var btn = document.querySelector('button');
        // 调用函数
        animate(div, 300);
        btn.addEventListener('click', function() {
    
            animate(span, 200);
        })
    </script>
</body>

</html>

注意如果要是不停触发一个事件调用一个动画函数，因为一般都是定时器实现的，所以要是多个一样的定时器他们会叠加在一起，让所有的效果都叠加在一起，比如说定时器让盒子往右每秒走 1px, 要是触发了事件调用了三个一样的定时器那么盒子会每秒往右走 3px, 是叠加，不会覆盖的.

要解决就是在动画函数一开始先清除这个 obj.timer (要是之前运行过这个动画函数就会给__这个传进来的__对象加的定时器属性) 然后再设新的定时器实现动画效果

可以看到这里就必须是 obj.timer 而不是 var timer 声明新的定时器，不然根本找不到你想清除的那个定时器

# 缓动效果原理

缓动动画就是让元素运动速度有所变化，最常见的是让速度慢慢停下来

思路：

1. 让盒子每次移动的距离慢慢变小，速度就会慢慢落下来。
2. 核心算法：(目标值 - 现在的位置) / 10 做为每次移动的距离步长
3. 停止的条件是：让当前盒子位置等于目标位置就停止定时器
4. 注意步长值需要取整

还是在之前的代码基础上进行修改：

function animate(obj, target) {
    // 先清除以前的定时器，只保留当前的一个定时器执行
    clearInterval(obj.timer);
    obj.timer = setInterval(function() {
        // 步长值写到定时器的里面
        var step = (target - obj.offsetLeft) / 10;
        if (obj.offsetLeft == target) {
            // 停止动画 本质是停止定时器
            clearInterval(obj.timer);
        } else{
        // 把每次加1 这个步长值改为一个慢慢变小的值  步长公式：(目标值 - 现在的位置) / 10
        obj.style.left = obj.offsetLeft + step + 'px';
        }
    }, 15);
}
			var span = document.querySelector('span');
			var btn = document.querySelector('button');
			btn.addEventListener('click', function() {
     
				// 调用函数
				animate(span, 500);
			})
			// 匀速动画 就是 盒子是当前的位置 +  固定的值 10 
			// 缓动动画就是  盒子当前的位置 + 变化的值(目标值 - 现在的位置) / 10）

# 动画函数多个目标值之间移动

可以让动画函数从 800 移动到 500。当我们点击按钮的时候，判断步长是正值还是负值

1. 如果是正值，则步长往大了取整（ceil）
2. 如果是负值，则步长向小了取整（floor）

<script>
        function animate(obj, target) {
            clearInterval(obj.timer);
            obj.timer = setInterval(function() {
     
                // 步长值写到定时器的里面
                // 把我们步长值改为整数 不要出现小数的问题
                // var step = Math.ceil((target - obj.offsetLeft) / 10);
                var step = (target - obj.offsetLeft) / 10;
                step = step > 0 ? Math.ceil(step) : Math.floor(step);
                if (obj.offsetLeft == target) {
     
                    // 停止动画 本质是停止定时器
                    clearInterval(obj.timer);
                } else{
                // 把每次加1 这个步长值改为一个慢慢变小的值  步长公式：(目标值 - 现在的位置) / 10
                obj.style.left = obj.offsetLeft + step + 'px';
                }
            }, 15);
        }
        var span = document.querySelector('span');
        var btn500 = document.querySelector('.btn500');
        var btn800 = document.querySelector('.btn800');

        btn500.addEventListener('click', function() {
     
            animate(span, 500);
        })
        btn800.addEventListener('click', function() {
     
                animate(span, 800);
        })

    </script>

# 动画函数添加回调函数 (最后动画的写法)

回调函数原理：函数可以作为一个参数。将这个函数作为参数传到另一个函数里面，当那个函数执行完之后，再执行传进去的这个函数，这个过程就叫做回调。

回调函数写的位置：定时器结束的位置。

<!DOCTYPE html>
<html lang="en">

	<head>
		<meta charset="UTF-8">
		<meta name="viewport" content="width=device-width, initial-scale=1.0">
		<meta http-equiv="X-UA-Compatible" content="ie=edge">
		<title>Document</title>
		<style>
			div {
     
				position: absolute;
				left: 0;
				width: 100px;
				height: 100px;
				background-color: red;
			}

			span {
     
				position: absolute;
				left: 0;
				top: 200px;
				display: block;
				width: 150px;
				height: 150px;
				background-color: greenyellow;
			}
		</style>
	</head>

	<body>
		<button class="btn500">点击胡图图到500</button>
		<button class="btn800">点击胡图图到800</button>
		<span>胡图图</span>
		<script>
			// 缓动动画函数封装obj目标对象 target 目标位置
			// 思路：
			// 1. 让盒子每次移动的距离慢慢变小， 速度就会慢慢落下来。
			// 2. 核心算法：(目标值 - 现在的位置) / 10 做为每次移动的距离 步长
			// 3. 停止的条件是： 让当前盒子位置等于目标位置就停止定时器
			function animate(obj, target, callback) {
     
				// console.log(callback);  callback = function() {}  调用的时候 callback()
				
				// 先清除以前的定时器，只保留当前的一个定时器执行
				clearInterval(obj.timer);
				obj.timer = setInterval(function() {
     
					// 步长值写到定时器的里面
					// 把我们步长值改为整数 不要出现小数的问题
					var step = (target - obj.offsetLeft) / 10;
					step = step > 0 ? Math.ceil(step) : Math.floor(step);
					if (obj.offsetLeft == target) {
     
						// 停止动画 本质是停止定时器
						clearInterval(obj.timer);
						
                        // 回调函数写到定时器结束里面
						if (callback) { //判定看有没有这个函数传进来(可能没传,看之前说的关于函数的参数),如果没传进来就不会调用
						    // 调用函数
						    callback();
						}
					} else{
					// 把每次加1 这个步长值改为一个慢慢变小的值  步长公式：(目标值 - 现在的位置) / 10
					obj.style.left = obj.offsetLeft + step + 'px';
                    }
				}, 15);
			}
			var span = document.querySelector('span');
			var btn500 = document.querySelector('.btn500');
			var btn800 = document.querySelector('.btn800');

			btn500.addEventListener('click', function() {
     
				// 调用函数
				animate(span, 500);
			})
			btn800.addEventListener('click', function() {
     
				// 调用函数
				animate(span, 800, function() {
     
				    // alert('你好吗');
				    span.style.backgroundColor = 'red';
				});
			})
			// 匀速动画 就是 盒子是当前的位置 +  固定的值 10 
			// 缓动动画就是  盒子当前的位置 + 变化的值(目标值 - 现在的位置) / 10）
		</script>
	</body>

</html>

把传进动画函数的函数参数放到定时器结束时启动，这样就会在动画完结的时候运行你穿的函数参数里面的代码

这里的回调函数 callback 其实可以不用 if 来判断存不存在

直接 callback&&callback(); 就可以因为如果 1 为 true (存在) 就返回 (执行) 2,1 为 false 返回 1

这么干这里的 callback__参数__就是要是用一个函数传进来，就会执行那个传进来的函数，当然这还在动画的停止条件到了，所以在关闭定时器之后执行这个传进来的参数存的函数.

# 动画函数封装到单独 JS 文件里面

因为以后经常使用这个动画函数，可以单独封装到一个 JS 文件里面，使用的时候引用这个 JS 文件即可。

1. 单独新建一个 JS 文件。
2. HTML 文件引入 JS 文件

<script src="animate.js"></script>

然后就可以在别处直接调用这个 animate.js 里面的 animate 函数.

引用 animate.js 案例制作：

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <style>
        .sliderbar {
     
            position: fixed;
            right: 0;
            bottom: 100px;
            width: 40px;
            height: 40px;
            text-align: center;
            line-height: 40px;
            cursor: pointer;
            color: #fff;
        }
        
        .con {
     
            position: absolute;
            left: 0;
            top: 0;
            width: 200px;
            height: 40px;
            background-color: purple;
            z-index: -1;
        }
    </style>
</head>

<body>
    <div class="sliderbar">
        <span>←</span>
        <div class="con">问题反馈</div>
    </div>
    <script src="animate.js"></script>
    <script>
        // 1. 获取元素
        var sliderbar = document.querySelector('.sliderbar');
        var con = document.querySelector('.con');
        // 当我们鼠标经过 sliderbar 就会让 con这个盒子滑动到左侧
        // 当我们鼠标离开 sliderbar 就会让 con这个盒子滑动到右侧
        sliderbar.addEventListener('mouseenter', function() {
     
            // animate(obj, target, callback);
            animate(con, -160, function() {
     
                // 当我们动画执行完毕，就把 ← 改为 →
                sliderbar.children[0].innerHTML = '→';
            });
        })
        sliderbar.addEventListener('mouseleave', function() {
     
            // animate(obj, target, callback);
            animate(con, 0, function() {
     
                sliderbar.children[0].innerHTML = '←';
            });

        })
    </script>
	
</body>

</html>

# 5、常见网页特效案例

# 1. 网页轮播图 (重点)

carousel.html 代码如下：

<!DOCTYPE html>
<html lang="zh-CN">

	<head>
		<meta charset="UTF-8">
		<title>轮播图</title>
		<!-- 引入css 初始化的css 文件 -->
		<link rel="stylesheet" href="css/base.css">
		<!-- 引入 轮播图的css文件 -->
		<link rel="stylesheet" href="css/carousel.css">
		<!-- 这个animate.js 必须写到 index.js的上面引入 -->
		<script src="js/animate.js"></script>
		<!-- 引入我们首页的js文件 -->
		<script src="js/carousel.js"></script>
	</head>

	<body>
		<div class="w">
			<div class="main">
				<div class="focus fl">
					<!-- 左侧按钮 -->
					<a href="javascript:;" class="arrow-l">
						&lt;
					</a>
					<!-- 右侧按钮 -->
					<a href="javascript:;" class="arrow-r">
						&gt;
					</a>
					<!-- 核心的滚动区域 -->
					<ul>
						<li>
							<a href="#"><img src="upload/focus.jpg" alt=""></a>
						</li>
						<li>
							<a href="#"><img src="upload/focus1.jpg" alt=""></a>
						</li>
						<li>
							<a href="#"><img src="upload/focus2.jpg" alt=""></a>
						</li>
						<li>
							<a href="#"><img src="upload/focus3.jpg" alt=""></a>
						</li>
					</ul>
					<!-- 小圆圈 -->
					<ol class="circle">
					</ol>
				</div>
			</div>
		</div>
	</body>

</html>

base.css 代码如下：

/*清除元素默认的内外边距  */
* {
    
    margin: 0;
    padding: 0
}
/*让所有斜体 不倾斜*/
em,
i {
    
    font-style: normal;
}
/*去掉列表前面的小点*/
li {
    
    list-style: none;
}
/*图片没有边框   去掉图片底侧的空白缝隙*/
img {
    
    border: 0;  /*ie6*/
    vertical-align: middle;
}
/*让button 按钮 变成小手*/
button {
    
    cursor: pointer;
}
/*取消链接的下划线*/
a {
    
    color: #666;
    text-decoration: none;
}

a:hover {
    
    color: #e33333;
}

button,
input {
    
    font-family: 'Microsoft YaHei', 'Heiti SC', tahoma, arial, 'Hiragino Sans GB', \\5B8B\4F53, sans-serif;
    /*取消轮廓线 蓝色的*/
    outline: none;
}

body {
    
    background-color: #fff;
    font: 12px/1.5 'Microsoft YaHei', 'Heiti SC', tahoma, arial, 'Hiragino Sans GB', \\5B8B\4F53, sans-serif;
    color: #666
}

.hide,
.none {
    
    display: none;
}
/*清除浮动*/
.clearfix:after {
    
    visibility: hidden;
    clear: both;
    display: block;
    content: ".";
    height: 0
}

.clearfix {
    
    *zoom: 1
}

carousel.css 代码如下：

/* 公共样式 */
.fl {
    
	float: left;
}
.fr {
    
	float: right;
}
/*版心*/
.w {
    
	width: 1200px;
	margin: 0 auto;
}

/*carousel样式*/

.main {
    
    width: 980px;
    height: 455px;
    margin-left: 219px;
    margin-top: 10px;
}

.focus {
    
    position: relative;
    width: 721px;
    height: 455px;
    background-color: purple;
    overflow: hidden;
}

.focus ul {
    
    position: absolute;
    top: 0;
    left: 0;
    width: 600%;
}

.focus ul li {
    
    float: left;
}

.arrow-l,
.arrow-r {
    
    display: none;
    position: absolute;
    top: 50%;
    margin-top: -20px;
    width: 24px;
    height: 40px;
    background: rgba(0, 0, 0, .3);
    text-align: center;
    line-height: 40px;
    color: #fff;
    font-family: 'icomoon';
    font-size: 18px;
    z-index: 2;
}

.arrow-r {
    
    right: 0;
}

.circle {
    
    position: absolute;
    bottom: 10px;
    left: 50px;
}

.circle li {
    
    float: left;
    width: 8px;
    height: 8px;
    /*background-color: #fff;*/
    border: 2px solid rgba(255, 255, 255, 0.5);
    margin: 0 3px;
    border-radius: 50%;
    /*鼠标经过显示小手*/
    cursor: pointer;
}

.current {
    
    background-color: #fff;
}

carousel.js 代码如下：

window.addEventListener('load', function() {
    
    // 1. 获取元素
    var arrow_l = document.querySelector('.arrow-l');
    var arrow_r = document.querySelector('.arrow-r');
    var focus = document.querySelector('.focus');
    var focusWidth = focus.offsetWidth;
    // 2. 鼠标经过focus 就显示隐藏左右按钮
    focus.addEventListener('mouseenter', function() {
    
        arrow_l.style.display = 'block';
        arrow_r.style.display = 'block';
        clearInterval(timer);
        timer = null; // 清除定时器变量
    });
    focus.addEventListener('mouseleave', function() {
    
        arrow_l.style.display = 'none';
        arrow_r.style.display = 'none';
        timer = setInterval(function() {
    
            //手动调用点击事件
            arrow_r.click();
        }, 2000);
    });
    // 3. 动态生成小圆圈  有几张图片，我就生成几个小圆圈
    var ul = focus.querySelector('ul');
    var ol = focus.querySelector('.circle');
    // console.log(ul.children.length);
    for (var i = 0; i < ul.children.length; i++) {
    
        // 创建一个小li 
        var li = document.createElement('li');
        // 记录当前小圆圈的索引号 通过自定义属性来做 
        li.setAttribute('index', i);
        // 把小li插入到ol 里面
        ol.appendChild(li);
        // 4. 小圆圈的排他思想 我们可以直接在生成小圆圈的同时直接绑定点击事件
        li.addEventListener('click', function() {
    
            // 干掉所有人 把所有的小li 清除 current 类名
            for (var i = 0; i < ol.children.length; i++) {
    
                ol.children[i].className = '';
            }
            // 留下我自己  当前的小li 设置current 类名
            this.className = 'current';
            // 5. 点击小圆圈，移动图片 当然移动的是 ul 
            // ul 的移动距离 小圆圈的索引号 乘以 图片的宽度 注意是负值
            // 当我们点击了某个小li 就拿到当前小li 的索引号
            var index = this.getAttribute('index');
            // 当我们点击了某个小li 就要把这个li 的索引号给 num  
            num = index;
            // 当我们点击了某个小li 就要把这个li 的索引号给 circle  
            circle = index;
            // num = circle = index;
            animate(ul, -index * focusWidth);
        })
    }
    // 把ol里面的第一个小li设置类名为 current
    ol.children[0].className = 'current';
    // 6. 克隆第一张图片(li)放到ul 最后面
    var first = ul.children[0].cloneNode(true);
    ul.appendChild(first);
    // 7. 点击右侧按钮， 图片滚动一张
    var num = 0;
    // circle 控制小圆圈的播放
    var circle = 0;
    // flag 节流阀
    var flag = true;
    arrow_r.addEventListener('click', function() {
    
        if (flag) {
    
            flag = false; // 关闭节流阀
            // 如果走到了最后复制的一张图片，此时 我们的ul 要快速复原 left 改为 0
            if (num == ul.children.length - 1) {
    
                ul.style.left = 0;
                num = 0;
            }
            num++;
            animate(ul, -num * focusWidth, function() {
    
                flag = true; // 打开节流阀
            });
            // 8. 点击右侧按钮，小圆圈跟随一起变化 可以再声明一个变量控制小圆圈的播放
            circle++;
            // 如果circle == 4 说明走到最后我们克隆的这张图片了 我们就复原
            if (circle == ol.children.length) {
    
                circle = 0;
            }
            // 调用函数
            circleChange();
        }
    });

    // 9. 左侧按钮做法
    arrow_l.addEventListener('click', function() {
    
        if (flag) {
    
            flag = false;
            if (num == 0) {
    
                num = ul.children.length - 1;
                ul.style.left = -num * focusWidth + 'px';

            }
            num--;
            animate(ul, -num * focusWidth, function() {
    
                flag = true;
            });
            // 点击左侧按钮，小圆圈跟随一起变化 可以再声明一个变量控制小圆圈的播放
            circle--;
            // 如果circle < 0  说明第一张图片，则小圆圈要改为第4个小圆圈（3）
            // if (circle < 0) {
    
            //     circle = ol.children.length - 1;
            // }
            circle = circle < 0 ? ol.children.length - 1 : circle;
            // 调用函数
            circleChange();
        }
    });
    function circleChange() {
    
        // 先清除其余小圆圈的current类名
        for (var i = 0; i < ol.children.length; i++) {
    
            ol.children[i].className = '';
        }
        // 留下当前的小圆圈的current类名
        ol.children[circle].className = 'current';
    }
    // 10. 自动播放轮播图
    var timer = setInterval(function() {
    
        //手动调用点击事件
        arrow_r.click();
    }, 2000);

})

效果图

# 2. 返回顶部

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <style>
        .slider-bar {
     
            position: absolute;
            left: 50%;
            top: 300px;
            margin-left: 600px;
            width: 45px;
            height: 130px;
            background-color: pink;
        }
        
        .w {
     
            width: 1200px;
            margin: 10px auto;
        }
        
        .header {
     
            height: 150px;
            background-color: purple;
        }
        
        .banner {
     
            height: 250px;
            background-color: skyblue;
        }
        
        .main {
     
            height: 1000px;
            background-color: yellowgreen;
        }
        
        span {
     
            display: none;
            position: absolute;
            bottom: 0;
        }
    </style>
</head>

<body>
    <div class="slider-bar">
        <span class="goBack">返回顶部</span>
    </div>
    <div class="header w">头部区域</div>
    <div class="banner w">banner区域</div>
    <div class="main w">主体部分</div>
    <script>
        //1. 获取元素
        var sliderbar = document.querySelector('.slider-bar');
        var banner = document.querySelector('.banner');
        // banner.offestTop 就是被卷去头部的大小 一定要写到滚动的外面
        var bannerTop = banner.offsetTop;
            // 当我们侧边栏固定定位之后应该变化的数值
        var sliderbarTop = sliderbar.offsetTop - bannerTop;
        // 获取main 主体元素
        var main = document.querySelector('.main');
        var goBack = document.querySelector('.goBack');
        var mainTop = main.offsetTop;
        // 2. 页面滚动事件 scroll
        document.addEventListener('scroll', function() {
     
                // console.log(11);
                // window.pageYOffset 页面被卷去的头部
                // console.log(window.pageYOffset);
                // 3 .当我们页面被卷去的头部大于等于了 172 此时 侧边栏就要改为固定定位
                if (window.pageYOffset >= bannerTop) {
     
                    sliderbar.style.position = 'fixed';
                    sliderbar.style.top = sliderbarTop + 'px';
                } else {
     
                    sliderbar.style.position = 'absolute';
                    sliderbar.style.top = '300px';
                }
                // 4. 当我们页面滚动到main盒子，就显示 goback模块
                if (window.pageYOffset >= mainTop) {
     
                    goBack.style.display = 'block';
                } else {
     
                    goBack.style.display = 'none';
                }

            })
            // 3. 当我们点击了返回顶部模块，就让窗口滚动的页面的最上方
        goBack.addEventListener('click', function() {
     
            // 里面的x和y 不跟单位的 直接写数字即可
            // window.scroll(0, 0);
            // 因为是窗口滚动 所以对象是window
            animate(window, 0);
        });
        // 动画函数
        function animate(obj, target, callback) {
     
            // console.log(callback);  callback = function() {}  调用的时候 callback()

            // 先清除以前的定时器，只保留当前的一个定时器执行
            clearInterval(obj.timer);
            obj.timer = setInterval(function() {
     
                // 步长值写到定时器的里面
                // 把我们步长值改为整数 不要出现小数的问题
                // var step = Math.ceil((target - obj.offsetLeft) / 10);
                var step = (target - window.pageYOffset) / 10;
                step = step > 0 ? Math.ceil(step) : Math.floor(step);
                if (window.pageYOffset == target) {
     
                    // 停止动画 本质是停止定时器
                    clearInterval(obj.timer);
                    // 回调函数写到定时器结束里面
                    callback && callback();
                }
                // 把每次加1 这个步长值改为一个慢慢变小的值  步长公式：(目标值 - 现在的位置) / 10
                // obj.style.left = window.pageYOffset + step + 'px';
                window.scroll(0, window.pageYOffset + step);
            }, 15);
        }
    </script>
</body>

</html>

# 3. 筋斗云案例

<!DOCTYPE html>
<html>

<head lang="en">
    <meta charset="UTF-8">
    <title></title>
    <style>
        * {
     
            margin: 0;
            padding: 0
        }
        
        ul {
     
            list-style: none;
        }
        
        body {
     
            background-color: black;
        }
        
        .c-nav {
     
            width: 900px;
            height: 42px;
            background: #fff url(images/rss.png) no-repeat right center;
            margin: 100px auto;
            border-radius: 5px;
            position: relative;
        }
        
        .c-nav ul {
     
            position: absolute;
        }
        
        .c-nav li {
     
            float: left;
            width: 83px;
            text-align: center;
            line-height: 42px;
        }
        
        .c-nav li a {
     
            color: #333;
            text-decoration: none;
            display: inline-block;
            height: 42px;
        }
        
        .c-nav li a:hover {
     
            color: white;
        }
        
        .c-nav li.current a {
     
            color: #0dff1d;
        }
        
        .cloud {
     
            position: absolute;
            left: 0;
            top: 0;
            width: 83px;
            height: 42px;
            background: url(images/cloud.gif) no-repeat;
        }
    </style>
    <script src="animate.js"></script>
    <script>
        window.addEventListener('load', function() {
     
            // 1. 获取元素
            var cloud = document.querySelector('.cloud');
            var c_nav = document.querySelector('.c-nav');
            var lis = c_nav.querySelectorAll('li');
            // 2. 给所有的小li绑定事件 
            // 这个current 做为筋斗云的起始位置
            var current = 0;
            for (var i = 0; i < lis.length; i++) {
     
                // (1) 鼠标经过把当前小li 的位置做为目标值
                lis[i].addEventListener('mouseenter', function() {
     
                    animate(cloud, this.offsetLeft);
                });
                // (2) 鼠标离开就回到起始的位置 
                lis[i].addEventListener('mouseleave', function() {
     
                    animate(cloud, current);
                });
                // (3) 当我们鼠标点击，就把当前位置做为目标值
                lis[i].addEventListener('click', function() {
     
                    current = this.offsetLeft;
                });
            }
        })
    </script>
</head>

<body>
    <div id="c_nav" class="c-nav">
        <span class="cloud"></span>
        <ul>
            <li class="current"><a href="#">首页新闻</a></li>
            <li><a href="#">师资力量</a></li>
            <li><a href="#">活动策划</a></li>
            <li><a href="#">企业文化</a></li>
            <li><a href="#">招聘信息</a></li>
            <li><a href="#">公司简介</a></li>
            <li><a href="#">详情内容</a></li>
            <li><a href="#">运营方向</a></li>
        </ul>
    </div>
</body>

</html>

效果图

---

# javaScript 之本地存储

随着互联网的快速发展，基于网页的应用越来越普遍，同时也变的越来越复杂，为了满足各种各样的需求，会经常性__在本地存储__大量的数据，HTML5 规范提出了相关解决方案。

# 本地存储特性

1. 数据存储在用户浏览器中
2. 设置、读取方便、甚至页面刷新不丢失数据
3. 容量较大，sessionStorage 约 5M、localStorage 约 20M
4. 只能存储字符串，可以将对象 JSON.stringify () 编码后存储

# window.sessionStorage

1. __生命周期 (就是数据还存在的时候) 为关闭浏览器窗口，也就是说__sessionStorage 在你关闭窗口时本地存储的数据就没有了，其他操作比如说刷新页面是不会结束存储的数据的生命周期的
2. 在同一个窗口 (页面) 下数据可以共享
3. 以键值对的形式存储使用

sessionStorage.setItem(key, value)   //存储数据,这些都省略掉了前面的"window."

sessionStorage.getItem(key)         //获取数据

sessionStorage.removeItem(key)     //删除数据

sessionStorage.clear()            //删除所有数据

注意 key 和 value 要么是变量，要么是字符串 (用引号包起来)

如果想改数据就是重新给同一个 key 赋值就会覆盖掉之前的

# window.localStorage

1. 生命周期永久生效，除非手动删除 否则关闭页面也会存在
2. 可以多窗口（页面）共享（同一浏览器可以共享）
3. 以键值对的形式存储使用

localStorage.setItem(key, value)//存储数据

localStorage.getItem(key)       //获取数据

localStorage.removeItem(key)    //删除数据

localStorage.clear()           //删除所有数据

localStorage 类似于 sessionStorage，区别在于 localStorage 可以永久存储，且支持跨浏览器访问，而 sessionStorage 在页面被关闭时，存储在里面的数据就会被清除，localStorage 则不会。

localStorage 存入的数据只能是字符串的形式。

当想存储对象类型数据时，要使用 JSON.stringify() 进行转换成字符串类型数据

# localStorage 的使用方式

# 增加 localStorage

// localStorage.setItem('标识符', 'JSON字符串数据');
localStorage.setItem('order', '{"goods_id":449,"count":1}');

# 读取 localStorage

// localStorage.getItem('标识符');
let res = localStorage.getItem('order');
console.log(res)

# 删除 localStorage

// localStorage.removeItem('标识符');
localStorage.removeItem('order');

# 删除所有的 localStorage

// localStorage.clear();
localStorage.clear();

# JSON 对象与字符串的转化

# JSON 字符串转成 JSON 对象

let str = [{"id": 1, "name": "seabert"}]
str = JSON.parse(str)

console.log(str)

# JSON 对象转成 JSON 字符串

let obj = {"id": 1, "name": "seabert"}
obj = JSON.stringify(obj)

console.log(obj)

需要转换为 JSON 字符串因为 localStorage 和 sessionStorage 只能存字符串数据类型.

要是直接存对象会是之后取出来会是像这种:[object Object]

# Chrome 浏览器中查看 localStorage

使用例子:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script src="js/jquery.min.js"></script>
</head>
<body>

    <script>
        var todolist = [{
            title: '我今天吃八个馒头',
            done: false
        }, {
            title: '我今天学习jq',
            done: false
        }, ];
        // localStorage.setItem("todo", todolist);
        // 1. 本地存储里面只能存储字符串的数据格式 把我们的数组对象转换为字符串格式 JSON.stringify()
        localStorage.setItem("todo", JSON.stringify(todolist));
        var data = localStorage.getItem("todo");
        // console.log(typeof data);
        // console.log(data[0].title);
        // 2. 获取本地存储的数据 我们需要把里面的字符串数据转换为 对象格式 JSON.parse()
        data = JSON.parse(data);
        console.log(data);
        console.log(data[0].title);
    </script>

</body>

</html>

---

# 记住用户名案例

<!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<meta http-equiv="X-UA-Compatible" content="ie=edge">
	<title>Document</title>
</head>
 
<body>
	<input type="text" id="username"> <input type="checkbox" name="" id="remember"> 记住用户名
	<script>
		var username = document.querySelector('#username');
		var remember = document.querySelector('#remember');
		remember.addEventListener('change', function() {
			if (this.checked) {
				localStorage.setItem('uname', username.value);
			} else {
				localStorage.removeItem('uname');
			}
		});
		if (localStorage.getItem('uname')) {
			username.value = localStorage.getItem('uname');
			remember.checked = true;
		}
	</script>
</body>

---

# cookie

简介

• Cookie 是一些数据，存储于你电脑上的文本文件中，用于存储 web 页面的用户信息
• Cookie 数据是以键值对的形式存在的，每个键值对都有过期时间。如果不设置时间，浏览器关闭，cookie 就会消失，当然
• 用户也可以手动清除 cookie
• Cookie 每次都会携带在 HTTP 头中，如果使用 cookie 保存过多数据会带来性能问题
• Cookie 内存大小受限，一般每个域名下是 4K 左右，每个域名大概能存储 50 个键值对

基本操作

• 通过访问 document.cookie 可以对 cookie 进行创建，修改与获取。
• 默认情况下，cookie 在浏览器关闭时删除，你还可以为 cookie 的某个键值对添加一个过期时间
• 如果设置新的 cookie 时，某个 key 已经存在，则会更新这个 key 对应的值，否则他们会同时存在 cookie 中

//设置cookie 
document.cookie = "username=orochiz";
document.cookie = "age=20";
//读取cookie 
var msg = document.cookie
console.log(msg) //username=orochiz;age=20 

//添加过期时间（单位：天） 
var date = new Date();
//当前时间2019-9-25 
var days = 3 //3天
date.setDate(d.getDate() + days)
document.cookie = "username=orochiz;" + "expires=" + date;
//删除cookie（给某个键值对设置过期的时间） 
date.setDate(date.getDate() - 1)
console.log(document.cookie)

<script>
			/*
			  设置 cookie 
			  直接写 document.cookie = "key=value"设置一条cookie
			  一次只能设置一条 cookie 
			  默认的过期时间 是 session 
			  如果需要设置过期时间，直接在本条 cookie 后面添加一个 expires 
			  过期时间的值 是一个时间对象
			  如果传递当前时间，就是会话级别 
			  如果传递的是未来时间，会在将来的某一个时间过期
			*/
		   // document.cookie = "a=100";
		   // console.log(document.cookie)
		   // 时间对象
		   var time = new Date();
		   console.log(time,'000')
		   // 设置 过期时间
		   //document.cookie = "a=100;expires="+time;
		   console.log(time.getTime(),'70年到现在的时间戳')
		   // 匹配 cookie 的时间
		   console.log(time.getTime()-1000*60*60*8);
		   time.setTime(time.getTime()-1000*60*60*8+1000*5);
		   console.log(time,'设置后的时间')
		   document.cookie = "a=100;expires="+time;
		</script>

---

# 总结以及 sessionStorage,localStorage,cookie 区别

** 相同点：** 都保存在浏览器端，可以下图位置查看储存的信息

不同点：

①传递方式不同

cookie 数据始终在同源的 http 请求中携带（即使不需要），即 cookie 在浏览器和服务器间来回传递。

sessionStorage 和 localStorage 不会自动把数据发给服务器，仅在本地保存。

②数据大小不同

cookie 数据还有路径（path）的概念，可以限制 cookie 只属于某个路径下。
存储大小限制也不同，cookie 数据不能超过 4k，同时因为每次 http 请求都会携带 cookie，所以 cookie 只适合保存很小的数据，如会话标识。

sessionStorage 和 localStorage 虽然也有存储大小的限制，但比 cookie 大得多，可以达到 5M 或更大。

③数据有效期不同

sessionStorage：仅在当前浏览器窗口关闭前有效，自然也就不可能持久保持；

localStorage：始终有效，窗口或浏览器关闭也一直保存，因此用作持久数据；

cookie 只在设置的 cookie 过期时间之前一直有效，即使窗口或浏览器关闭。

④作用域不同

sessionStorage 不在不同的浏览器窗口中共享，即使是同一个页面；

localStorage 在所有同源窗口中都是共享的；

cookie 也是在所有同源窗口中都是共享的。

WebStorage 支持事件通知机制，可以将数据更新的通知发送给监听者。

WebStorage 的 api 接口使用更方便。

---

# JSON

JSON 指 JavaScript 对象表示法（JavaScript Object Notation），是一种轻量级的数据交换格式，用于存储和交换文本信息。JSON 采用了类似 C 语言家族的习惯，易于人阅读和编写，同时也易于机器解析和生成。

JSON 在用途上类似 XML，但比 XML 更小、更快，更易解析。

# 简介

# 什么是 JSON

• JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation）。
• JSON 是轻量级的文本数据交换格式。
• JSON 独立于语言。
• JSON 具有自我描述性，更易理解。

JSON 使用 JavaScript 语法来描述数据对象，但是 JSON 仍然独立于语言和平台。JSON 解析器和 JSON 库支持许多不同的编程语言。目前很多动态编程语言（如 PHP、JSP、.NET）都支持 JSON。

# JSON 转换为 JavaScript 对象

JSON 文本格式在语法上与创建 JavaScript 对象的代码相同。

由于这种相似性，无需解析器，JavaScript 程序能够使用内置的 eval() 函数，用 JSON 数据来生成原生的 JavaScript 对象。

JSON 是一种轻量级的基于文本的开放标准，被设计用于可读的数据交换。约定使用 JSON 的程序包括 C、C++、Java、Python、Perl 等等。

• 用于可读的数据交换。
• 从 JavaScript 脚本语言中演变而来。
• 文件扩展名是 .json。
• JSON 的互联网媒体类型是 application/json。

# JSON 的适用范围

• 用于编写基于 JavaScript 的应用程序，包括浏览器扩展和网站。
• JSON 格式可以用于通过网络连接序列化和传输结构化数据。
• 主要用于在服务器和 Web 应用程序之间传输数据。
• Web 服务和 APIs 可以使用 JSON 格式提供公用数据。
• 还可以用于现代编程语言中。

# JSON 的特点

• JSON 容易阅读和编写。
• 它是一种轻量级的基于文本的交换格式。
• 与语言无关。

# 简单示例

鉴于书籍数据有语言和版本信息，下面的例子展示了使用 JSON 存储书籍信息：

{
    "book": [
        {
            "id": "01",
            "language": "Java",
            "edition": "third",
            "author": "Herbert Schildt"
        },
        {
            "id": "07",
            "language": "C++",
            "edition": "second",
            "author": "E.Balagurusamy"
        }
    ]
}

# 与 XML 相似之处

• JSON 是纯文本。
• JSON 具有 “自我描述性”（人类可读）。
• JSON 具有层级结构（值中存在值）。
• JSON 可通过 JavaScript 进行解析。
• JSON 数据可使用 AJAX 进行传输。

# 与 XML 不同之处

• 没有结束标签。
• 更短。
• 读写的速度更快。
• 能够使用内建的 JavaScript eval() 方法进行解析。
• 使用数组。
• 不使用保留字。

# 为什么使用 JSON

对于 AJAX 应用程序来说，JSON 比 XML 更快更易使用：

# 使用 XML

1. 读取 XML 文档；
2. 使用 XML DOM 来循环遍历文档；
3. 读取值并存储在变量中。

# 使用 JSON

1. 读取 JSON 字符串；
2. 用 eval() 处理 JSON 字符串。

# 语法

JSON 使用 JavaScript 语法来描述数据对象，但是 JSON 仍然独立于语言和平台。

JSON 的语法基本上可以视为 JavaScript 语法的一个子集，包括以下内容：

• 数据使用名称－值对表示。
• 使用大括号保存对象，每个键后面跟着一个冒号 : ，名称－值对之间使用逗号 , 分隔。
• 使用方括号保存数组，数组之间使用逗号 , 分隔。
• 注意: JSON 对象需要 键 被双引号包括住，然后值可以是…(看下面)

下面是一个简单的示例：

{
    "book": [
        {
            "id": "01",
            "language": "Java",
            "edition": "third",
            "author": "Herbert Schildt"
        },
        {
            "id": "07",
            "language": "C++",
            "edition": "second",
            "author": "E.Balagurusamy"
        }
    ]
}

JSON 支持以下两种数据结构：

• 名称－值对集合：这一数据结构由不同的编程语言支持。
• 有序的值列表：包括数组、列表、向量或序列等等。

# JSON 语法规则

JSON 语法是 JavaScript 对象表示法语法的子集。

JSON 语法规则不复杂，它参考了 C 语言家族的一些习惯，学习起来并不会感到陌生。

• 数据在名称－值对中；
• 数据由逗号分隔；
• 花括号保存对象；
• 方括号保存数组。

# JSON 名称－值对

JSON 数据的书写格式是：名称－值对。

名称－值对包括字段名称（在双引号中），后面跟一个冒号，然后是值：

"firstName" : "John"

这很容易理解，等价于这条 JavaScript 语句：

firstName = "John"

# JSON 值

JSON 值可以是：

• 数字（整数或浮点数）
• 字符串（在双引号中）
• 布尔值（true 或 false）
• 数组（在方括号中）
• 对象（在花括号中）
• null

# JSON 对象

JSON 对象在花括号中书写。对象可以包含多个名称－值对：

{
    "firstName": "John",
    "lastName": "Doe"
}

这一点也容易理解，与这条 JavaScript 语句等价：

firstName = "John";
lastName = "Doe";

# JSON 数组

JSON 数组在方括号中书写。数组可包含多个对象：

{
    "employees": [ //键一定是双引号,这个键本身是个复杂数据类型,存的对象里面的键也需要双引号
        {
            "firstName": "John",
            "lastName": "Doe"
        },
        {
            "firstName": "Anna",
            "lastName": "Smith"
        },
        {
            "firstName": "Peter",
            "lastName": "Jones"
        }
    ]
}

在上面的例子中，对象 “employees” 是包含三个对象的数组。每个对象代表一条关于某人（有姓和名）的记录。

# JSON 文件

• JSON 文件的文件类型是 “.json”。
• JSON 文本的 MIME 类型是 “application/json”。

# JavaScript 对象转换为 JSON 文本

或者执行如下命令即可：

String myObjectInJSON = myObject.toJSONString();

# 数据类型

JSON 格式支持以下数据类型：

类型	描述
数字型（Number）	JavaScript 中的双精度浮点型格式
字符串型（String）	双引号包裹的 Unicode 字符和反斜杠转义字符
布尔型（Boolean）	true 或 false
数组（Array）	有序的值序列
值（Value）	可以是字符串、数字、true 或 false、null 等等
对象（Object）	无序的名称－值对集合
空格（Whitespace）	可用于任意符号对之间
null	空

# 数字型

• JavaScript 中的双精度浮点型格式，取决于实现。
• 不能使用八进制和十六进制格式。
• 在数字中不能使用 NaN 和 Infinity。

下表展示了数字类型：

类型	描述
整型（Integer）	数字 1～9，0 和正负数
分数（Fraction）	分数，比如 .3、.9
指数（Exponent）	指数，比如 e，e+，e-，E，E+，E-

# 语法

var json-object-name = { string : number_value, … }

# 示例

下面的示例展示了数字类型，其值不应该使用引号包裹：

var obj = {marks: 97}

# 字符串型

• 零个或多个双引号包裹的 Unicode 字符以及反斜杠转义序列。
• 字符就是只有一个字符的字符串，长度为 1。

下表展示了字符串类型：

类型	描述
"	双引号
\	反斜杠
/	斜杠
\b	退格符
\f	换页符
\n	换行符
\r	回车符
\t	水平制表符
\u	四位十六进制数字

# 语法

var json-object-name = { string : "string value", … }

# 示例

下面的示例展示了字符串数据类型：

var obj = {name: 'Amit'}

# 布尔型

它包含 true 和 false 两个值。

# 语法

var json-object-name = { string : true/false, … }

# 示例

var obj = { name: 'Amit', marks: 97, distinction: true }

# 数组

• 是一个有序的值集合。
• 使用方括号闭合，这意味着数组以 [ 开始，以 ] 结尾。
• 值使用逗号 , 分割。
• 数组索引可以从 0 或 1 开始。
• 当键名是连续的整数时应该使用数组。

# 语法

[ value, … ]

# 示例

下面的示例展示了一个包含多个对象的数组：

{
    "books": [
        {
            "language": "Java",
            "edition": "second"
        },
        {
            "language": "C++",
            "lastName": "fifth"
        },
        {
            "language": "C",
            "lastName": "third"
        }
    ]
}

# 对象

• 是一个__无序的名称－值对集合__。
• 对象使用大括号闭合，以 { 开始，以 } 结尾。
• 每个名称后面都跟随一个冒号 : ，名称－值对使用逗号 , 分隔。
• 键名必须是字符串，并且不能同名。
• 当键名是任意字符串时应该使用对象。

# 语法

{ string : value, … }

# 示例

下面的例子展示了对象：

{
    "id": "011A",
    "language": "JAVA",
    "price": 500,
}

# 空格

可以在任意一对符号之间插入。可以添加用来让代码更可读。下面的例子展示了使用空格和不使用空格的声明：

# 语法

{ string : "   ", … }

# 示例

var i = "   sachin";
var j = "  saurav";

# null

意味着空类型。

# 语法

null

# 示例

var i = null;

if (i == 1) {
    document.write("<h1>value is 1</h1>");
} else {
    document.write("<h1>value is null</h1>");
}

# JSON 基础结构

JSON 包含两种基础结构：

1. 无序的对象结构

   无序的对象结构在不同语言中称法不同，比如在 Python 中称为字典，在 JSON 中称为 JSON 对象……

   总之就是键－值对组合形式。

2. 有序的数组结构

   将数组作为有序数组进行转换 JSON，就可以得到有序的 JSON 数组结构。

# 模式

JSON 模式（Schema）是一种基于 JSON 格式定义 JSON 数据结构的规范。JSON 模式：

• 描述现有数据格式。
• 干净的、人类和机器可读的文档。
• 完整的结构验证，有利于自动化测试。
• 完整的结构验证，可用于验证客户端提交的数据。

# JSON 模式示例

下面是一个基本的 JSON 模式，其中涵盖了一个经典的产品目录说明：

{
    "$schema": "https://json-schema.org/draft-04/schema#",
    "title": "Product",
    "description": "A product from Acme's catalog",
    "type": "object",
    "properties": {
        "id": {
            "description": "The unique identifier for a product",
            "type": "integer"
        },
        "name": {
            "description": "Name of the product",
            "type": "string"
        },
        "price": {
            "type": "number",
            "minimum": 0,
            "exclusiveMinimum": true
        }
    },
    "required": ["id", "name", "price"]
}

我们来看一下可以用于这一模式中的各种重要关键字：

关键字	描述
$schema	$schema 关键字状态，表示这个模式与 v4 规范草案书写一致。
title	用它给我们的模式提供了标题。
description	关于模式的描述。
type	type 关键字在我们的 JSON 数据上定义了第一个约束：必须是一个 JSON 对象。
properties	定义各种键和它们的值类型，以及用于 JSON 文件中的最小值和最大值。
required	存放必要属性列表。
minimum	给值设置的约束条件，表示可以接受的最小值。
exclusiveMinimum	如果存在 exclusiveMinimum 并且具有布尔值 true，如果它严格意义上大于 minimum 的值则实例有效。
maximum	给值设置的约束条件，表示可以接受的最大值。
exclusiveMaximum	如果存在 exclusiveMinimum 并且具有布尔值 true，且它严格意义上小于 maximum 的值则实例有效。
multipleOf	如果通过这个关键字的值分割实例的结果是一个数字则表示紧靠 multipleOf 的数字实例是有效的。
maxLength	字符串实例字符的最大长度数值。
minLength	字符串实例字符的最小长度数值。
pattern	如果正则表达式匹配实例成功则字符串实例被认为是有效的。

可以在 JSON Schema 上检出可用于定义 JSON 模式的完整关键字列表。上面的模式可用于测试下面给出的 JSON 代码的有效性：

[
    {
        "id": 2,
        "name": "An ice sculpture",
        "price": 12.50,
    },
    {
        "id": 3,
        "name": "A blue mouse",
        "price": 25.50,
    }
]

# 使用

JSON 常见的应用场景是：在后台应用程序中将响应数据封装成 JSON 格式，传到前台页面之后，需要将 JSON 格式转换为 JavaScript 对象，然后在网页中使用该数据。

# 把 JSON 文本转换为 JavaScript 对象

JSON 最常见的用法之一，是从 Web 服务器上读取 JSON 数据（作为文件或 HttpRequest），将 JSON 数据转换为 JavaScript 对象，然后在网页中使用该数据。

下面使用字符串作为输入进行演示（而不是文件）。

# 实例：来自字符串的对象

创建包含 JSON 语法的 JavaScript 字符串：

var txt = '{"employees": [' +
    '{"firstName" : "John", "lastName" : "Doe"}, ' +
    '{"firstName" : "Anna", "lastName" : "Smith"}, ' +
    '{"firstName" : "Peter", "lastName" : "Jones"} ]}';

由于 JSON 语法是 JavaScript 语法的子集，JavaScript 函数 eval() 可用于将 JSON 文本转换为 JavaScript 对象。

eval() 函数使用的是 JavaScript 解释器，可解析 JSON 文本，然后生成 JavaScript 对象。必须把文本包围在括号中，这样才能避免语法错误：

var obj = eval ("(" + txt + ")");

# JSON 解析器

eval() 函数可解释执行任何 JavaScript 代码。这隐藏了一个潜在的安全问题。

使用 JSON 解析器将 JSON 转换为 JavaScript 对象是更安全的做法。JSON 解析器只能识别 JSON 文本，而不会解释脚本。

浏览器提供了原生的 JSON 支持，而且 JSON 解析器的速度更快。

# JSONP

JSONP（JSON with Padding）是 JSON 的一种 “使用模式”，可以让网页从别的域名（网站）获取资料，即跨域读取数据。

为什么我们从不同的域（网站）访问数据需要一个特殊的技术（JSONP）呢？这是因为同源策略。

同源策略是由网景提出的一个著名的安全策略，现在所有支持 JavaScript 的浏览器都会使用这个策略。

JSONP 的实现原理是利用 <script> 标签可以获取不同源资源的特点，来达到跨域访问某个资源的目的。

# JSONP 应用

# 服务端 JSONP 格式数据

如客户想访问 : /try/ajax/jsonp.php?jsonp=callbackFunction。

假设客户期望返回 JSON 数据：[“customername1”, “customername2”]。

真正返回到客户端的数据显示为：callbackFunction ([“customername1”, “customername2”])。

服务端文件 jsonp.php 代码为：

<?php header('Content-type: application/json'); 
// 获取回调函数名 
$jsoncallback = htmlspecialchars($_REQUEST ['jsoncallback']); 
// JSON 数据 
$json_data = '["customername1", "customername2"]'; 
// 输出 JSONP 格式的数据 
echo $jsoncallback . "(" . $json_data . ")"; ?>

# 客户端实现 callbackFunction () 函数

<script type="text/javascript">
function onCustomerLoaded(result, methodName) {
    var html = '<ul>';
    for (var i = 0; i < result.length; i++) {
        html += '<li>' + result[i] + '</li>';
    }
    html += '</ul>';
    document.getElementById('divCustomers').innerHTML = html;
}
</script>

# 页面展示

<div id="divCustomers"></div>

# 客户端页面完整代码

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="https://www.w3.org/1999/xhtml/" >
<head>
    <title>JSONP 实例</title>
</head>
<body>
    <div id="divCustomers"></div>
    <script type="text/javascript">
        function onCustomerLoaded(result, methodName)         {
            var html = '<ul>';
            for (var i = 0; i < result.length; i++) {
                html += '<li>' + result[i] + '</li>';
            }
            html += '</ul>';
            document.getElementById('divCustomers').innerHTML = html;
        }
    </script>
<script type="text/javascript" src="/try/ajax/jsonp.php?jsoncallback=callbackFunction"></script>
</body>
</html>

# jQuery 使用 JSONP

以上代码可以使用 jQuery 代码实例：

<!DOCTYPE html>
<html>
<head>
   <title>JSONP 实例</title>
   <script src="https://apps.bdimg.com/libs/jquery/1.8.3/jquery.js"></script> 
</head>
<body>
<div id="divCustomers"></div>
<script>
$.getJSON("/try/ajax/jsonp.php?jsoncallback=?", function(data) {
    var html = '<ul>';
    for(var i = 0; i < data.length; i++) {
        html += '<li>' + data[i] + '</li>';
    }
    html += '</ul>';
    $('#divCustomers').html(html); 
});
</script>
</body>
</html>

# 在 Python 中使用 JSON

先准备环境以便针对 JSON 进行 Python 编程。

# 环境

在我们使用 Python 编码和解码 JSON 之前，我们需要安装一个可用 JSON 模块。我们采用 Demjson：

$tar xvfz demjson-1.6.tar.gz
$cd demjson-1.6
$python setup.py install

# JSON 函数

函数	程序库
encode()	将 Python 对象编码为 JSON 字符串表示。
decode()	将 JSON 编码的字符串解码为 Python 对象。

# 使用 Python 编码 JSON（encode）

Python 的 encode() 函数用于将 Python 对象编码为 JSON 字符串表示。

# 语法

demjson.encode(self, obj, nest_level = 0)

# 示例

下面的例子展示了使用 Python 将数组转换为 JSON：

#!/usr/bin/python
import demjson

data = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]

json = demjson.encode(data)
print json

执行时会生成如下结果：

[{"a":1,"b":2,"c":3,"d":4,"e":5}]

# 使用 Python 解码 JSON（decode）

Python 可以使用 demjson.decode() 函数处理 JSON 解码。这个函数返回从 JSON 解码到适当 Python 类型的值。

# 语法

demjson.decode(self, txt)

# 示例

下面的例子展示了如何使用 Python 解码 JSON 对象。

#!/usr/bin/python
import demjson

json = '{"a":1,"b":2,"c":3,"d":4,"e":5}'

text = demjson.decode(json)
print text

执行时生成如下结果：

{u'a': 1, u'c': 3, u'b': 2, u'e': 5, u'd': 4}

# 在 Java 中使用 JSON

先准备环境以便针对 JSON 进行 Java 编程。

# 环境

在我们使用 Java 编码和解码 JSON 之前，我们需要安装一个可用的 JSON 模块。我们采用 JSON.simple，然后导入 jsonsimple-1.1.1.jar 。

# JSON 和 Java 实体映射

JSON.simple 实体映射从左侧到右侧为解码或解析，实体映射从右侧到左侧为编码。

JSON	Java
字符串	java.lang.String
数字	java.lang.Number
bool	java.lang.Boolean
null	null
数组	java.util.List
对象	java.util.Map

解码时， java.util.List 的默认具体类是 org.json.simple.JSONArray ， java.util.Map 的默认具体类是 org.simple.JSONObject 。

# 在 Java 中编码 JSON

下面这个简单的示例展示了使用 java.util.HashMap 的子类 JSONObject 编码一个 JSON 对象。这里并没有提供顺序。如果需要严格的元素顺序，请使用 JSONValue.toJSONString(map) 方法的有序映射实现，比如 java.util.LinkedHashMap 。

import org.json.simple.JSONObject;

class JsonEncodeDemo 
{
    public static void main(String[] args)
    {
        JSONObject obj = new JSONObject();

        obj.put("name", "foo");
        obj.put("num", new Integer(100));
        obj.put("balance", new Double(1000.21));
        obj.put("is_vip", new Boolean(true));

        System.out.print(obj);
    }
}

生成如下结果：

{"balance": 1000.21, "num":100, "is_vip":true, "name":"foo"}

下面是另一个示例，使用 Java JSONObject 展示了 JSON 对象流：

import org.json.simple.JSONObject;
class JsonEncodeDemo
{
    public static void main(String[] args)
    {
        JSONObject obj = new JSONObject();

        obj.put("name", "foo");
        obj.put("num", new Integer(100));
        obj.put("balance", new Double(1000.21));
        obj.put("is_vip", new Boolean(true));

        StringWriter out = new StringWriter();
        obj.writeJSONString(out);
        String jsonText = out.toString();
        System.out.print(jsonText);
    }
}

生成如下结果：

{"balance": 1000.21, "num":100, "is_vip":true, "name":"foo"}

# 在 Java 中解码 JSON

下面的例子使用了 JSONObject 和 JSONArray ，其中 JSONObject 就是 java.util.Map ， JSONArray 就是 java.util.List ，因此我们可以使用 Map 或 List 的标准操作访问它们。

import org.json.simple.JSONObject;
import org.json.simple.JSONArray;
import org.json.simple.parser.ParseException;
import org.json.simple.parser.JSONParser;

class JsonDecodeDemo
{
    public static void main(String[] args)
    {
        JSONParser parser=new JSONParser();
        String s = "[0,{\"1\":{\"2\":{\"3\":{\"4\":[5,{\"6\":7}]}}}}]";
        try {
            Object obj = parser.parse(s);
            JSONArray array = (JSONArray)obj;
            System.out.println("The 2nd element of array");
            System.out.println(array.get(1));
            System.out.println();
            JSONObject obj2 = (JSONObject)array.get(1);
            System.out.println("Field \"1\"");
            System.out.println(obj2.get("1"));

            s = "{}";
            obj = parser.parse(s);
            System.out.println(obj);

            s= "[5,]";
            obj = parser.parse(s);
            System.out.println(obj);

            s= "[5,,2]";
            obj = parser.parse(s);
            System.out.println(obj);
        } catch(ParseException pe) {
            System.out.println("position: " + pe.getPosition());
            System.out.println(pe);
        }
    }
}

生成如下结果：

The 2nd element of array
{"1":{"2":{"3":{"4":[5,{"6":7}]}}}}

Field "1"
{"2":{"3":{"4":[5,{"6":7}]}}}
{}
[5]
[5,2]

---

# eval()

这么干只能 JSON 文本对象 (也就是那个字符串) 转换为 JS 对象，而不能从 JS 转为 JSON.

__== 而且还患有安全隐患，不要使用！！！==__

而不是使用 eval 来兼容 ie7 或更低的版本

**eval()** 函数会将传入的字符串当做 JavaScript 代码进行执行。

# 语法

eval(string)

# 参数

• string

  一个表示 JavaScript 表达式、语句或一系列语句的字符串。表达式可以包含变量与已存在对象的属性。

# 返回值

返回字符串中代码的返回值。如果返回值为空，则返回 undefined 。

# 描述

eval() 是全局对象的一个函数属性。

eval() 的参数是一个字符串。如果字符串表示的是表达式， eval() 会对表达式进行求值。如果参数表示一个或多个 JavaScript 语句，那么 eval() 就会执行这些语句。不需要用 eval() 来执行一个算术表达式：因为 JavaScript 可以自动为算术表达式求值。

如果你以字符串的形式构造了算术表达式，那么可以在后面用 eval() 对它求值。例如，假设你有一个变量 x ，您可以通过将表达式的字符串值（例如 3 * x + 2 ）赋值给一个变量，然后在你的代码后面的其他地方调用 eval() ，来推迟涉及 x 的表达式的求值。

如果 eval() 的参数不是字符串， eval() 会将参数原封不动地返回。在下面的例子中， String 构造器被指定，而 eval() 返回了 String 对象而不是执行字符串。

eval(new String("2 + 2")); // 返回了包含"2 + 2"的字符串对象
eval("2 + 2");             // returns 4

你可以使用一些通用的方法来绕过这个限制，例如使用 toString() 。

var expression = new String("2 + 2");
eval(expression.toString());

如果你间接的使用 eval() ，比如通过一个引用来调用它，而不是直接的调用 eval 。 从 ECMAScript 5 起，它工作在全局作用域下，而不是局部作用域中。这就意味着，例如，下面的代码的作用声明创建一个全局函数，并且 eval 中的这些代码在执行期间不能在被调用的作用域中访问局部变量。

function test() {
  var x = 2, y = 4;
  console.log(eval('x + y'));  // 直接调用，使用本地作用域，结果是 6
  var geval = eval; // 等价于在全局作用域调用
  console.log(geval('x + y')); // 间接调用，使用全局作用域，throws ReferenceError 因为`x`未定义
  (0, eval)('x + y'); // 另一个间接调用的例子
}

# 永远不要使用 eval ！

eval() 是一个危险的函数， 它使用与调用者相同的权限执行代码。如果你用 eval() 运行的字符串代码被恶意方（不怀好意的人）修改，您最终可能会在您的网页 / 扩展程序的权限下，在用户计算机上运行恶意代码。更重要的是，第三方代码可以看到某一个 eval() 被调用时的作用域，这也有可能导致一些不同方式的攻击。相似的 Function 就不容易被攻击。

eval() 通常比其他替代方法更慢，因为它必须调用 JS 解释器，而许多其他结构则可被现代 JS 引擎进行优化。

此外，现代 JavaScript 解释器将 javascript 转换为机器代码。 这意味着任何变量命名的概念都会被删除。 因此，任意一个 eval 的使用都会强制浏览器进行冗长的变量名称查找，以确定变量在机器代码中的位置并设置其值。 另外，新内容将会通过 eval() 引进给变量， 比如更改该变量的类型，因此会强制浏览器重新执行所有已经生成的机器代码以进行补偿。 但是，（谢天谢地）存在一个非常好的 eval 替代方法：只需使用 window.Function。 这有个例子方便你了解如何将 eval() 的使用转变为 Function() 。

使用 eval 的糟糕代码:

function looseJsonParse(obj){
    return eval("(" + obj + ")");
}
console.log(looseJsonParse(
   "{a:(4-1), b:function(){}, c:new Date()}"
))

不用 eval 的更好的代码:

function looseJsonParse(obj){
    return Function('"use strict";return (' + obj + ')')();
}
console.log(looseJsonParse(
   "{a:(4-1), b:function(){}, c:new Date()}"
))

比较上面的两个代码片段，两个代码片段似乎是以相同的方式工作，但再想一想：eval 的这个代码的速度要慢得多。 注意 c: new Date() 在执行体中。 在没有 eval 的函数中，对象在全局范围内被用来进行计算，因此浏览器可以放心的假设 Date 是来自 window.Date 的而不是一个名为 Date 的局部变量。 然而，在使用 eval() 的代码中，浏览器不能假设这一点，因为如果您的代码是下面这个：

function Date(n){
    return ["Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"][n%7 || 0];
}
function looseJsonParse(obj){
    return eval("(" + obj + ")");
}
console.log(looseJsonParse(
   "{a:(4-1), b:function(){}, c:new Date()}"
))

因此，在 eval() 版本的代码中，浏览器被迫进行高代价的查找调用以检查是否存在名为 Date () 的任何局部变量。 与 Function() 相比，这是非常低效的。

在类似的情况下，如果您确实希望能够从 Function() 内部的代码调用 Date 函数，该怎么办？ 你应该躲避并退回到 eval() 吗？ 绝对不是，永远不要这么做。 而是尝试下面的方法。

function Date(n){
    return ["Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"][n%7 || 0];
}
function runCodeWithDateFunction(obj){
    return Function('"use strict";return (' + obj + ')')()(
        Date
    );
}
console.log(runCodeWithDateFunction(
   "function(Date){ return Date(5) }"
))

由于三重嵌套函数，上面的代码似乎效率低下，但让我们分析一下上述有效方法的好处：

1. 它使得传递给 runCodeWithDateFunction 的字符串中的代码更少。

2. 函数调用开销很小，使得代码尺寸小得多，值得获益

\3. Function() 更容易让你的代码利用特性修饰 "use strict" ;

4. 代码不使用 eval（），使其比其他方式快几个数量级。

最后，我们来看看简化版。 使用如上所示的 Function() ，您可以更有效地缩小传递给 runCodeWithDateFunction 的代码字符串，因为函数参数名称也可以缩小，如下面的缩小代码所示。

console.log(Function('"use strict";return(function(a){return a(5)})')()(function(a){
return"Monday Tuesday Wednesday Thursday Friday Saturday Sunday".split(" ")[a%7||0]}));

对于常见用例， eval() 或 Function() 还有更安全 (而且更快！) 的替代方案。

# 访问成员属性

你不应该去使用 eval() 来将属性名字转化为属性。考虑下面的这个例子，被访问对象的属性在它被执行之前都会未知的。这里可以用 eval 处理：

var obj = { a: 20, b: 30 };
var propName = getPropName(); // 返回 "a" 或 "b"

eval( 'var result = obj.' + propsName )

但是，这里并不是必须得使用 eval() 。事实上，这里并不建议这样使用。可以使用 属性访问器 进行代替，它更快、更安全：

var obj = { a: 20, b: 30 }
var propName = getPropName(); // 返回 "a" 或 "b"
var result = obj[ propName ]; // obj[ "a" ] 与 obj.a 等价

你还可以使用这个方法去访问子代的属性。如下：

var obj = {a: {b: {c: 0}}};
var propPath = getPropPath(); // 例如返回 "a.b.c"

eval( 'var result = obj.' + propPath )

这里，可以通过分割属性路径、循环遍历不同的属性，来避免 eval() ：

function getDescendantProp(obj, desc) {
  var arr = desc.split('.');
  while (arr.length) {
    obj = obj[arr.shift()];
  }
  return obj;
}

var obj = {a: {b: {c: 0}}};
var propPath = getPropPath(); // 例如返回 "a.b.c"
var result = getDescendantProp(obj, propPath);

同样的方法也可实现设置子代的属性值：

function setDescendantProp(obj, desc, value) {
  var arr = desc.split('.');
  while (arr.length > 1) {
    obj = obj[arr.shift()];
  }
  return obj[arr[0]] = value;
}

var obj = {a: {b: {c: 0}}};
var propPath = getPropPath();  // 例如，返回 "a.b.c"
var result = setDescendantProp(obj, propPath, 1);  // a.b.c 值为 1

# 使用函数而非代码段

JavaScript 拥有 first-class functions，这意味着你可以将函数直接作为参数传递给其他接口，将他们保存在变量中或者对象的属性中，等等。很多 DOM 的 API 都用这种思路进行设计，你也可以（或者应该）这样子设计你的代码：

// 代替 setTimeout(" ... ", 1000) 写法:
setTimeout(function() { ... }, 1000);

// 代替 elt.setAttribute("onclick", "...") 写法:
elt.addEventListener('click', function() { ... } , false);

闭包 也有助于创建参数化函数而不用连接字符串。

# 解析 JSON（将字符串转化为 JavaScript 对象）

如果你在调用 eval() 传入的字符串参数中包含数据（如：一个数组 “[1,2,3]”）而不是代码，你应该考虑将其转换为 JSON 对象，这允许你用 JavaScript 语法的子集来表示数据。在扩展中下载 JSON 和 JavaScript

提示：因为 JSON 语法子集相对于 JavaScript 语法子集比较有局限性，很多在 JavaScript 中可用的特性在 JSON 中就不起作用了。比如，后缀逗号在 JSON 中不支持，并且对象中的属性名在 JSON 中必须用引号括起来。请务必使用 JSON 序列化方法来生成稍后将被解析为 JSON 的字符串。

# 尽量传递数据而非代码

例如，设计为抓取网页内容的扩展，可能会在 XPath 中定义抓取规则，而不是在 JavaScript 代码中。

# 以有限权限运行代码

如果你必须执行这段代码，应考虑以更低的权限运行。此建议主要适用于扩展和 XUL 应用程序，可以使用 Components.utils.evalInSandbox 做到降低权限。

# 例子

# 使用 eval

在下面的代码中，两种包含了 eval() 的声明都返回了 42。第一种是对字符串 “ x + y + 1 ” 求值；第二种是对字符串 “ 42 ” 求值。

var x = 2;
var y = 39;
var z = "42";
eval("x + y + 1"); // returns 42
eval(z);           // returns 42

# 使用 eval 执行一串 JavaScript 语句

下面的例子使用 eval() 来执行 str 字符串。这个字符串包含了如果 x 等于 5，就打开一个 Alert 对话框并对 z 赋值 42，否则就对 z 赋值 0 的 JavaScript 语句。 当第二个声明被执行， eval() 将会令字符串被执行，并最终返回赋值给 z 的 42。

var x = 5;
var str = "if (x == 5) {console.log('z is 42'); z = 42;} else z = 0;";

console.log('z is ', eval(str));

如果您定义了多个值，则会返回最后一个值。

var x = 5;
var str = "if (x == 5) {console.log('z is 42'); z = 42; x = 420; } else z = 0;";

console.log('x is ', eval(str)); // z is 42  x is 420

# 返回值

eval 返回最后一个表达式的值。

var str = 'if ( a ) { 1 + 1; } else { 1 + 2; }';
var a = true;
var b = eval(str);  // returns 2

console.log('b is : ' + b);

a = false;
b = eval(str);  // returns 3

console.log('b is : ' + b);

# eval 中函数作为字符串被定义需要 “（” 和 “）” 作为前缀和后缀

var fctStr1 = 'function a() {}'
var fctStr2 = '(function a() {})'
var fct1 = eval(fctStr1)  // 返回undefined
var fct2 = eval(fctStr2)  // 返回一个函数