【Web前端】JavaScript入门与基础(二)

Javascript对象

什么是对象？对象（object）是 JavaScript 语言的核心概念，也是最重要的数据类型。简单说，对象就是一组“键值对”（key-value）的集合，是一种无序的复合数据集合。

var user = {
 name: 'Javascript',
 age: '13'
};

对象的每一个键名又称为“属性”（property），它的“键值”可以是任何数据类型。如果一个属性的值为函数，通常把这个属性称为“方法”，它可以像函数那样调用。

var user = {
 getName: function (name) {
  return name;
  }
};
user.getName("Javascript") // Javascript

如果属性的值还是一个对象，就形成了链式引用。

var user = {
  name:"Javascript",
  age:13,
  container:{
    frontEnd:["Web前端","Android","iOS"],
    backEnd:["Java","Python"]
   }
}
user.container.frontEnd // ["Web前端","Android","iOS"]

Math对象

Math.abs方法返回参数值的绝对值。

Math.abs(1) // 1
Math.abs(-1) // 1

Math.max方法返回参数之中最大的那个值，Math.min返回最小的那个值。如果参数为空, Math.min返回Infinity, Math.max返回-Infinity。

Math.max(2, -1, 5) // 5
Math.min(2, -1, 5) // -1
Math.min() // Infinity
Math.max() // -Infinity

Math.floor方法返回小于参数值的最大整数

Math.floor(3.2) // 3
Math.floor(-3.2) // -4

Math.ceil方法返回大于参数值的最小整数

Math.ceil(3.2) // 4
Math.ceil(-3.2) // -3

Math.random()返回0到1之间的一个伪随机数，可能等于0，但是一定小于1

Math.random() // 0.28525367438365223

任意范围的随机数生成函数如下：

function getRandomArbitrary(min, max) {
 return Math.random() * (max - min) + min;
}
getRandomArbitrary(5, 10)

Date对象

Date对象是 JavaScript 原生的时间库。它以1970年1月1日00:00:00作为时间的零点，可以表示的时间范围是前后各1亿天（单位为毫秒）

Date.now方法返回当前时间距离时间零点（1970年1月1日 00:00:00 UTC）的毫秒数，相当于 Unix 时间戳乘以1000

Date.now();  // 1635216733395

时间戳

时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。

格林威治和北京时间就是时区的不同

Unix是20世纪70年代初出现的一个操作系统，Unix认为1970年1月1日0点是时间纪元。JavaScript也就遵循了这一约束

Date对象提供了一系列get*方法，用来获取实例对象某个方面的值

实例方法get类

getTime()：返回实例距离1970年1月1日00:00:00的毫秒数

getDate()：返回实例对象对应每个月的几号（从1开始）

getDay()：返回星期几，星期日为0，星期一为1，以此类推

getYear()：返回距离1900的年数

getFullYear()：返回四位的年份

getMonth()：返回月份（0表示1月，11表示12月）

getHours()：返回小时（0-23）

getMilliseconds()：返回毫秒（0-999）

getMinutes()：返回分钟（0-59）

getSeconds()：返回秒（0-59）

var d = new Date('January 6, 2022');
d.getDate() // 6
d.getMonth() // 0
d.getYear() // 122
d.getFullYear() // 2022

编写函数获得本年度剩余天数：

function leftDays() {
 var today = new Date();
 var endYear = new Date(today.getFullYear(), 11, 31, 23, 59, 59, 999);
 var msPerDay = 24 * 60 * 60 * 1000;
 return Math.round((endYear.getTime() - today.getTime()) / msPerDay);
}

DOM概述

DOM 是 JavaScript 操作网页的接口，全称为“文档对象模型”（Document Object Model）。它的作用是将网页转为一个 JavaScript 对象，从而可以用脚本进行各种操作（比如对元素增删内容）

浏览器会根据 DOM 模型，将结构化文档HTML解析成一系列的节点，再由这些节点组成一个树状结构（DOM Tree）。所有的节点和最终的树状结构，都有规范的对外接口

DOM 只是一个接口规范，可以用各种语言实现。所以严格地说，DOM 不是 JavaScript 语法的一部分，但是 DOM 操作是 JavaScript 最常见的任务，离开了 DOM，JavaScript 就无法控制网页。另一方面，JavaScript 也是最常用于 DOM 操作的语言

节点： DOM 的最小组成单位叫做节点（node）。文档的树形结构（DOM 树），就是由各种不同类型的节点组成。每个节点可以看作是文档树的一片叶子。

节点的类型有七种：

Document：整个文档树的顶层节点

DocumentType：doctype标签

Element：网页的各种HTML标签

Attribute：网页元素的属性（比如class="right"）

Text：标签之间或标签包含的文本

Comment：注释

DocumentFragment：文档的片段

节点树：一个文档的所有节点，按照所在的层级，可以抽象成一种树状结构。这种树状结构就是 DOM 树。它有一个顶层节点，下一层都是顶层节点的子节点，然后子节点又有自己的子节点，就这样层层衍生出一个金字塔结构，倒过来就像一棵树。

浏览器原生提供document节点，代表整个文档：

document
// 整个文档树

除了根节点，其他节点都有三种层级关系：

父节点关系（parentNode）：直接的那个上级节点

子节点关系（childNodes）：直接的下级节点

同级节点关系（sibling）：拥有同一个父节点的节点

Node.nodeType属性：不同节点的nodeType属性值和对应的常量如下：

文档节点（document）：

1. 对应常量Node.DOCUMENT_NODE 元素节点（element）：

2, 对应常量Node.ELEMENT_NODE 属性节点（attr）：

3，对应常量Node.ATTRIBUTE_NODE 文本节点（text）：

4，对应常量Node.TEXT_NODE 文档片断节点（DocumentFragment）：

5，对应常量Node.DOCUMENT_FRAGMENT_NODE

document.nodeType // 9
document.nodeType === Node.DOCUMENT_NODE // true

document对象_方法/获取元素

document.getElementsByTagName方法搜索 HTML 标签名，返回符合条件的元素。它的返回值是一个类似数组对象（HTMLCollection实例），可以实时反映 HTML 文档的变化。如果没有任何匹配的元素，就返回一个空集

var paras = document.getElementsByTagName('p');

如果传入*，就可以返回文档中所有 HTML 元素：

var allElements = document.getElementsByTagName('*');

document.getElementsByClassName方法返回一个类似数组的对象（HTMLCollection实例），包括了所有class名字符合指定条件的元素，元素的变化实时反映在返回结果中。

var elements = document.getElementsByClassName(names);

由于class是保留字，所以 JavaScript 一律使用className表示 CSS 的class。参数可以是多个class，它们之间使用空格分隔。

var elements = document.getElementsByClassName('foo bar');

document.getElementsByName方法用于选择拥有name属性的 HTML 元素（比如<form>、<radio>、<img>等），返回一个类似数组的的对象（NodeList实例），因为name属性相同的元素可能不止一个

// 表单为 <form name="Javascript"></form>
var forms = document.getElementsByName('Javascript');

document.getElementById方法返回匹配指定id属性的元素节点。如果没有发现匹配的节点，则返回null 。

var elem = document.getElementById('para1');

注意：该方法的参数是大小写敏感的。比如，如果某个节点的id属性是main，那么document.getElementById('Main')将返回null

document.querySelector方法接受一个 CSS 选择器作为参数，返回匹配该选择器的元素节点。如果有多个节点满足匹配条件，则返回第一个匹配的节点。如果没有发现匹配的节点，则返回null

var el1 = document.querySelector('.myclass');

document.querySelectorAll方法与querySelector用法类似，区别是返回一个NodeList对象，包含所有匹配给定选择器的节点。

var elementList = document.querySelectorAll('.myclass');

document对象_方法_创建元素

document.createElement方法用来生成元素节点，并返回该节点。

var newDiv = document.createElement('div');

document.createTextNode方法用来生成文本节点（Text实例），并返回该节点。它的参数是文本节点的内容。

var newDiv = document.createElement('div');
var newContent = document.createTextNode('Hello');
newDiv.appendChild(newContent);

document.createAttribute方法生成一个新的属性节点（Attr实例），并返回它。

var attribute = document.createAttribute(name);
var root = document.getElementById('root');
var it = document.createAttribute('Javascript');
it.value = 'it';
root.setAttributeNode(it);

Element

Element对象对应网页的 HTML 元素。每一个 HTML 元素，在 DOM 树上都会转化成一个Element节点对象（以下简称元素节点）

Element.id属性返回指定元素的id属性，该属性可读写。

// HTML 代码为 <p id="foo">
var p = document.querySelector('p');
p.id // "foo"

className属性用来读写当前元素节点的class属性。它的值是一个字符串，每个class之间用空格分割。

// HTML 代码 <div class="one two three" id="myDiv"></div>
var div = document.getElementById('myDiv');
div.className

classList对象有下列方法

add()：增加一个 class。
remove()：移除一个 class。
contains()：检查当前元素是否包含某个 class。
toggle()：将某个 class 移入或移出当前元素。

var div = document.getElementById('myDiv');
div.classList.add('myCssClass');
div.classList.add('foo', 'bar');
div.classList.remove('myCssClass');
div.classList.toggle('myCssClass'); // 如果 myCssClass 不存在就加入，否则移除
div.classList.contains('myCssClass'); // 返回 true 或者 false

Element.innerHTML属性返回一个字符串，等同于该元素包含的所有 HTML 代码。该属性可读写，常用来设置某个节点的内容。它能改写所有元素节点的内容，包括<HTML>和<body>元素。

el.innerHTML = '';

innerText和innerHTML类似，不同的是innerText无法识别元素，会直接渲染成字符串

Element获取元素位置

属性	描述
clientHeight	获取元素高度包括`padding`部分，但是不包括`border`、`margin`
clientWidth	获取元素宽度包括`padding`部分，但是不包括`border`、`margin`
scrollHeight	元素总高度，它包括`padding`，但是不包括`border`、`margin`包括溢出的不可见内容
scrollWidth	元素总宽度，它包括`padding`，但是不包括`border`、`margin`包括溢出的不可见内容
scrollLeft	元素的水平滚动条向右滚动的像素数量
scrollTop	元素的垂直滚动条向下滚动的像素数量
offsetHeight	元素的 CSS 垂直高度（单位像素），包括元素本身的高度、padding 和 border
offsetWidth	元素的 CSS 水平宽度（单位像素），包括元素本身的高度、padding 和 border
offsetLeft	到定位父级左边界的间距
offsetTop	到定位父级上边界的间距

Element.clientHeight属性返回一个整数值，表示元素节点的 CSS 高度（单位像素），只对块级元素生效，对于行内元素返回0。如果块级元素没有设置 CSS 高度，则返回实际高度.

除了元素本身的高度，它还包括padding部分，但是不包括border、margin。如果有水平滚动条，还要减去水平滚动条的高度。注意，这个值始终是整数，如果是小数会被四舍五入。

Element.clientWidth属性返回元素节点的 CSS 宽度，同样只对块级元素有效，也是只包括元素本身的宽度和padding，如果有垂直滚动条，还要减去垂直滚动条的宽度。

document.documentElement的clientHeight属性，返回当前视口的高度（即浏览器窗口的高度）。document.body的高度则是网页的实际高度。

// 视口高度
document.documentElement.clientHeight
// 网页总高度
document.body.clientHeight

Element.scrollHeight属性返回一个整数值（小数会四舍五入），表示当前元素的总高度（单位像素），它包括padding，但是不包括border、margin以及水平滚动条的高度（如果有水平滚动条的话）

Element.scrollWidth属性表示当前元素的总宽度（单位像素），其他地方都与scrollHeight属性类似。这两个属性只读

整张网页的总高度可以从document.documentElement或document.body上读取。

// 返回网页的总高度
document.documentElement.scrollHeight
document.body.scrollHeight

Element.scrollLeft属性表示当前元素的水平滚动条向右侧滚动的像素数量，Element.scrollTop属性表示当前元素的垂直滚动条向下滚动的像素数量。对于那些没有滚动条的网页元素，这两个属性总是等于0

如果要查看整张网页的水平的和垂直的滚动距离，要从document.documentElement元素上读取

document.documentElement.scrollLeft
document.documentElement.scrollTop

Element.offsetHeight属性返回一个整数，表示元素的 CSS 垂直高度（单位像素），包括元素本身的高度、padding 和 border，以及水平滚动条的高度（如果存在滚动条）。

Element.offsetWidth属性表示元素的 CSS 水平宽度（单位像素），其他都与Element.offsetHeight一致。

这两个属性都是只读属性，只比Element.clientHeight和Element.clientWidth多了边框的高度或宽度。如果元素的 CSS 设为不可见（比如display: none;），则返回0

Element.offsetLeft返回当前元素左上角相对于Element.offsetParent节点的水平位移，Element.offsetTop返回垂直位移，单位为像素。通常，这两个值是指相对于父节点的位移。

// html文件
<div class="parent">
  <div class="box" id="box"></div>
</div>

// css文件
.parent{
  width: 200px;
  height: 200px;
  background: red;
  position: relative;
  left: 50px;
  top: 50px;
}
.box{
  width: 100px;
  height: 100px;
  background: yellow;
  position: relative;
  left: 50px;
  top: 50px;
}

// js文件
var box = document.getElementById("box");
console.log(box.offsetLeft);
console.log(box.offsetTop);

CSS操作

操作 CSS 样式最简单的方法，就是使用网页元素节点的setAttribute方法直接操作网页元素的style属性。

div.setAttribute(
 'style',
 'background-color:red;' + 'border:1px solid black;'
);

// 元素节点的style属性
var divStyle = document.querySelector('div').style;
divStyle.backgroundColor = 'red';
divStyle.border = '1px solid black';
divStyle.width = '100px';
divStyle.height = '100px';
divStyle.fontSize = '10em';

// cssText属性
var divStyle = document.querySelector('div').style;
divStyle.cssText = 'background-color: red;'
 + 'border: 1px solid black;'
 + 'height: 100px;'
 + 'width: 100px;';

事件处理程序

HTML事件

<!DOCTYPE html>
<html>
  <head lang="en">
    <meta charset="UTF-8">
    <title>Js事件详解--事件处理</title>
  </head>
  <body>
    <div id="div">
      <button id="btn1" onclick="demo()">按钮</button>
    </div>
    <script>
      function demo(){
        alert("hello html事件处理");
       }
    </script>
  </body>
</html>

DOM0级事件处理

<body>
  <div id="div">
    <button id="btn1">按钮</button>
  </div>
  <script>
    var btn1=document.getElementById("btn1");
    btn1.onclick=function(){alert("Hello DOM0级事件处理程序1");}//被覆盖掉
    btn1.onclick=function(){alert("Hello DOM0级事件处理程序2");}
  </script>
</body>

DOM2级事件处理

<body>
  <div id="div">
    <button id="btn1">按钮</button>
  </div>
  <script>
    var btn1=document.getElementById("btn1");
    btn1.addEventListener("click",demo1);
    btn1.addEventListener("click",demo2);
    btn1.addEventListener("click",demo3);
    function demo1(){
      alert("DOM2级事件处理程序1")
     }
    function demo2(){
      alert("DOM2级事件处理程序2")
     }
    function demo3(){
      alert("DOM2级事件处理程序3")
     }
    btn1.removeEventListener("click",demo2);
  </script>
</body>

事件类型之鼠标事件

鼠标事件指与鼠标相关的事件，具体的事件主要有以下一些

click：按下鼠标时触发
dblclick：在同一个元素上双击鼠标时触发
mousedown：按下鼠标键时触发
mouseup：释放按下的鼠标键时触发
mousemove：当鼠标在节点内部移动时触发。当鼠标持续移动时，该事件会连触发。
mouseenter：鼠标进入一个节点时触发，进入子节点不会触发这个事件
mouseleave：鼠标离开一个节点时触发，离开父节点不会触发这个事件
mouseover：鼠标进入一个节点时触发，进入子节点会再一次触发这个事件
mouseout：鼠标离开一个节点时触发，离开父节点也会触发这个事件
wheel：滚动鼠标的滚轮时触发
这些方法在使用的时候，除了DOM2级事件，都需要添加前缀on

var btn1 = document.getElementById("btn1");
btn1.onclick = function(){
  console.log("click事件");
}

Event事件对象

Event对象属性有target和type两种。

Event.target属性返回事件当前所在的节点。

// HTML代码为
// <p id="para">Hello</p>
function setColor(e) {
 console.log(this === e.target);
 e.target.style.color = 'red';
}


para.addEventListener('click', setColor);

Event.type属性返回一个字符串，表示事件类型。事件的类型是在生成事件的时候。该属性只读

Event对象方法：有Evnet.preventDefault()和Event.stopPropagation()

Event.preventDefault方法取消浏览器对当前事件的默认行为。比如点击链接后，浏览器默认会跳转到另一个页面，使用这个方法以后，就不会跳转了.

btn.onclick = function(e){
  e.preventDefault(); // 阻止默认事件
  console.log("点击A标签");
}

stopPropagation方法阻止事件在 DOM 中继续传播，防止再触发定义在别的节点上的监听函数，但是不包括在当前节点上其他的事件监听函数.

btn.onclick = function(e){
  e.stopPropagation(); // 阻止事件冒泡
  console.log("btn");
}

事件类型之键盘事件

键盘事件由用户击打键盘触发，主要有keydown、keypress、keyup三个事件

keydown：按下键盘时触发。
keypress：按下有值的键时触发，即按下 Ctrl、Alt、Shift、Meta 这样无值的键，这个事件不会触发。对于有值的键，按下时先触发keydown事件，再触发这个事件。
keyup：松开键盘时触发该事件

username.onkeypress = function(e){
  console.log("keypress事件");
}

// event对象
// keyCode:唯一标识
var username = document.getElementById("username");
username.onkeydown = function(e){
  if(e.keyCode === 13){
    console.log("回车");
   }
}

事件类型之表单事件

input事件当<input>、<select>、<textarea>的值发生变化时触发。对于复选框（<input type=checkbox>）或单选框（<input type=radio>），用户改变选项时，也会触发这个事件

input事件的一个特点，就是会连续触发，比如用户每按下一次按键，就会触发一次input事件。

var username = document.getElementById("username");
username.oninput = function(e){
  console.log(e.target.value);
}

select事件当在<input>、<textarea>里面选中文本时触发.

// HTML 代码如下
// <input id="test" type="text" value="Select me!" />


var elem = document.getElementById('test');
elem.addEventListener('select', function (e) {
 console.log(e.type); // "select"
}, false);

Change事件当<input>、<select>、<textarea>的值发生变化时触发。它与input事件的最大不同，就是不会连续触发，只有当全部修改完成时才会触发

var email = document.getElementById("email");
email.onchange = function(e){
  console.log(e.target.value);
}

reset事件当表单重置（所有表单成员变回默认值）时触发。

submit事件当表单数据向服务器提交时触发。注意，submit事件的发生对象是<form>元素，而不是<button>元素，因为提交的是表单，而不是按钮.

// html文件
<form id="myForm" onsubmit="submitHandle">
  <button onclick="resetHandle">重置数据</button>
  <button>提交</button>
</form>
// js文件
var myForm = document.getElementById("myForm")
function resetHandle(){
  myForm.reset();
}
function submitHandle(){
  console.log("提交");
}

事件代理(事件委托)

由于事件会在冒泡阶段向上传播到父节点，因此可以把子节点的监听函数定义在父节点上，由父节点的监听函数统一处理多个子元素的事件。这种方法叫做事件的代理（delegation）

var ul = document.querySelector('ul');


ul.addEventListener('click', function (event) {
 if (event.target.tagName.toLowerCase() === 'li') {
  // some code
  }
});

定时器之`setTimeout()`

JavaScript 提供定时执行代码的功能，叫做定时器（timer），主要由setTimeout()和setInterval()这两个函数来完成。它们向任务队列添加定时任务

setTimeout函数用来指定某个函数或某段代码，在多少毫秒之后执行。它返回一个整数，表示定时器的编号，以后可以用来取消这个定时器。

var timerId = setTimeout(func|code, delay);

setTimeout函数接受两个参数，第一个参数func|code是将要推迟执行的函数名或者一段代码，第二个参数delay是推迟执行的毫秒数

setTimeout(function(){
  console.log("定时器")
},1000)

注意:还有一个需要注意的地方，如果回调函数是对象的方法，那么setTimeout使得方法内部的this关键字指向全局环境，而不是定义时所在的那个对象

var name = "Javascript";
var user = {
  name: "HTML",
  getName: function () {
    setTimeout(function(){
      console.log(this.name);
     },1000)
   }
};
user.getName();

// 解决方案
var name = "Javascript";
var user = {
  name: "HTML",
  getName: function () {
    var that = this;
    setTimeout(function(){
      console.log(that.name);
     },1000)
   }
};
user.getName();

定时器可以进行取消

var id = setTimeout(f, 1000);
clearTimeout(id);

定时器之`setInterval()`

setInterval函数的用法与setTimeout完全一致，区别仅仅在于setInterval指定某个任务每隔一段时间就执行一次，也就是无限次的定时执行.

var timer = setInterval(function() {
 console.log(2);
}, 1000)

例子:通过setInterval方法实现网页动画

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <style>
        #someDiv{
            width: 100px;
            height: 100px;
            background: red;
        }
    </style>
</head>
<body>
    <div id="someDiv"></div>
    <script>
        var div = document.getElementById('someDiv');
        var opacity = 1;
        var fader = setInterval(function() {
         opacity -= 0.05;
         if (opacity > 0) {
          div.style.opacity = opacity;
          } else {
          clearInterval(fader);
          }
        }, 30);
    </script>
</body>
</html>