web前端学习笔记三

web前端学习笔记三
一、JavaScript语句、标识符和变量

1、语句

JavaScript 程序的单位是行（line），也就是一行一行地执行，一般情况下，每一行就是一个语句
```
var num = 10;
1
```
语句以分号结尾，一个分号就表示一个语句结束

2、标识符
标识符（identifier）指的是用来识别各种值的合法名称，最常见的标识符就是变量名
标识符是由：字母、美元符号($)、下划线(_)和数字组成，其中数字不能开头
注意：中文是合法的标识符，可以用作变量名 （不推荐）

3、JavaScript保留关键字（不用强行记忆）
JavaScript有一些保留字，不能用作标识符：arguments、break、case、catch、class、const、continue、debugger、default、delete、do、else、enum、eval、export、extends、false、finally、for、function、if、implements、import、in、instanceof、interface、let、new、null、package、private、protected、public、return、static、super、switch、this、throw、true、try、typeof、var、void、while、with、yield

4、变量
```
var num = 10;
1
```
变量的重新赋值
```
var num = 10;
num = 20;
1
2
```
变量提升
JavaScript 引擎的工作方式是，先解析代码，获取所有被声明的变量，然后再一行一行地运行。这造成的结果，就是所有的变量的声明语句，都会被提升到代码的头部，这就叫做变量提升（hoisting）
```
console.log(num);
var num = 10; // 结果是什么呢？
1
2
```
```
var num；
console.log(num);
var num = 10;
1
2
3
```
计算机运行的时候会将变量提升到输出代码前进行定义，而不会赋值，所以最后页面会输出undefined这个值

二、JavaScript引入到文件

1、嵌入到HTML文件中
```
<body>
	<script>
		var age = 20
	script>
body>
1
2
3
4
5
```
2、引入本地独立JS文件（推荐）
```
<body>
	<script type="text/javascript" src="./itbaizhan.js">   script>
body>
1
2
3
```
3、引入网络来源文件（推荐）
```
<body>
	<script>src="https://cdn.bootcdn.net/ajax/libs/jquery/3.6.0/jquery.min.js"> script>
body>
1
2
3
```
三、JavaScript常见的输出方式及数据类型

1、JavaScript输出方式
```
// 在浏览器中弹出一个对话框,然后把要输出的内容展示出来,alert都是把要输出的内容首先转换为字符串然后再输出的
alert("要输出的内容");
document.write("要输出的内容");
// 在控制台输出内容
console.log("要输出的内容");
1
2
3
4
5
```
2、数据类型
JavaScript 语言的每一个值，都属于某一种数据类型
JavaScript 的数据类型，共有六种 （ES6 又新增了第七种 Symbol 类型的值和第八种 BigInt类型）
原始类型（基础类型）
- 数值类型
- 字符串类型
- 布尔值类型
```
var age = 20;
var name = "尚学堂";
var learn = true;
1
2
3
```
合成类型（复合类型）
对象：因为一个对象往往是多个原始类型的值的合成，可以看作是一个存放各种值的容器，涵盖数值、字符串以及布尔值类型
```
var user = {
    name:"尚学堂",    
    age:20,    
    learn:true
}
1
2
3
4
5
```
至于undefined和null，一般将它们看成两个特殊值

四、运算符

1、typeof运算符
typeof运算符可以确定一个值到底是什么类型
```
console.log(typeof '123'); // "string"
console.log(typeof false); // "boolean"
console.log(typeof {}); // "object"
1
2
3
```
unll和undefined的区别
null与undefined都可以表示“没有”，含义非常相似。将一个变量赋值为undefined或null，语法效果几乎没区别。既然含义与用法都差不多，为什么要同时设置两个这样的值，这与历史原因有关
- null一般代表对象为“没有”
- undefined一般代表数值为“没有”
2、算术运算符
加减乘除运算符
```
10 + 10; // 20
100 - 10; // 90
10 * 2; //20
10 / 5; 2
1
2
3
4
```
余数运算符
```
13 % 5 // 3
1
```
自增和自减运算符
```
var x = 1;  
var y = 1; 
++x // 2
--y // 0
1
2
3
4
```
自增和自减运算符有一个需要注意的地方，就是放在变量之后，会先返回变量操作前的值，再进行自增/自减操作；放在变量之前，会先进行自增/自减操作，再返回变量操作后的值
```
var x = 1; 
var y = 1; 
x++ // 1
++y // 2
1
2
3
4
```
```
var x = 10; 
var y = 20; 
console.log(x++ + y);// 30
1
2
3
```
3、赋值运算符
```
// 将 1 赋值给变量 x
var x = 1; 
// 将变量 y 的值赋值给变量 x
var x = y;
1
2
3
4
```
赋值运算符还可以与其他运算符结合，形成变体
```
// 等同于 x = x + y
x += y 
// 等同于 x = x - y
x -= y 
// 等同于 x = x * y
x *= y 
// 等同于 x = x / y
x /= y
// 等同于 x = x % y
x %= y
1
2
3
4
5
6
7
8
9
10
```
4、比较运算符
JavaScript 一共提供了8个比较运算符

“==”和“===”的区别
```
var num1 = 10;
var num2 = "10";

console.log(num1 == num2); // true
// === 严格比较：数值本身是否相同，类型本身是否相同
console.log(num1 === num2); // false
1
2
3
4
5
6
```
5、布尔运算符
取反运算符（!）
- 布尔值取反
```
!true // false
!false // true
1
2
```
- 非布尔值取反
  对于非布尔值，取反运算符会将其转为布尔值，以下六个值取反后为true，其他值都为false
```
undefined、null、false、0、NaN、空字符串（''）
1
```
且运算符（&&）
```
console.log(10 < 20 && 10 >5); // true
1
```
或运算符（||）
```
console.log(10 < 20 || 10 < 5); // true
1
```
五、条件语句

1、 if语句
```
var m = 3;
if (m === 3) {
    m++; 
    }
console.log(m); // 4
1
2
3
4
5
```
2、 if…else
```
if (m === 3) {
  // 满足条件时，执行的语句
} else {
  // 不满足条件时，执行的语句
}
1
2
3
4
5
```
3、switch语句
```
switch (fruit) {
	case "banana": 
	// ...
	break; 
	case "apple":
	// ...
	break;
	default: 
	// ...
}
1
2
3
4
5
6
7
8
9
10
```
需要注意的是，每个case代码块内部的break语句不能少，否则会接下去执行下一个case代码块，而不是跳出switch结构
```
var x = 1; 
switch (x) {
	case 1:
	console.log('x 等于1');
	case 2:
	console.log('x 等于2');
	default:
	console.log('x 等于其他值');
}
// x等于1
// x等于2
// x等于其他值
1
2
3
4
5
6
7
8
9
10
11
12
```
六、三元运算符和循环语句

1、三元运算符语法
```
(条件) ? 表达式1 : 表达式2
1
```
判断一个整数是奇数与偶数
```
// if...else语句
var n = 100;
if (n % 2 === 0) {
  console.log("偶数");
} else {
  console.log("奇数");
}
1
2
3
4
5
6
7
```
```
// 三元运算符
var n = 100; 
n % 2 === 0 ? '偶数' : '奇数'
1
2
3
```
2、循环语句之for
语法
```
for (初始化表达式; 条件; 迭代因子) {
  语句
}
1
2
3
```
for语句后面的括号里面，有三个表达式：
1. 初始化表达式（initialize）：确定循环变量的初始值，只在循环开始时执行一次
2. 布尔表达式（test）：每轮循环开始时，都要执行这个条件表达式，只有值为真，才继续进行循环
3. 迭代因子（increment）：每轮循环的最后一个操作，通常用来递增循环变量
```
var x = 3;
for (var i = 0; i < x; i++) {
	console.log(i);
}
1
2
3
4
```
for语句的三个表达式，可以省略任何一个，也可以全部省略，如果三个都省略，结果就导致了一个无限循环（死循环）
```
for ( ; ; ){
	console.log('Hello World');
}
1
2
3
```
打印九九乘法表
```
for(var i = 1;i <= 9;i++){
    document.write("
");
    for(var j = 1;j <= i;j++){
        sum = i * j;
        document.write(i ,"*",j ,"=",sum," ");
   }
}
1
2
3
4
5
6
7
```
3、循环语句之while
While语句包括一个循环条件和一段代码块，只要条件为真，就不断循环执行代码块
```
while (条件) {
  语句; 
  }
1
2
3
```
所有for循环，都可以改写成while循环
```
// for
var x = 3;
for (var i = 0; i < x; i++) {
	console.log(i);
  }
// while
var x = 3;
var i = 0;
while (i < x) {
	console.log(i);
	i++;
  }
1
2
3
4
5
6
7
8
9
10
11
12
```
4、break 语句和 continue 语句
break语句和continue语句都具有跳转作用，可以让代码不按既有的顺序执行

break
break语句用于跳出代码块或循环
```
for (var i = 0; i < 5; i++) {
    if (i === 3){
        break;
   }
    console.log(i);
}
1
2
3
4
5
6
```
continue
continue语句用于立即终止本轮循环，返回循环结构的头部，开始下一轮循环
```
for (var i = 0; i < 5; i++) {
    if (i === 3){
        continue;
   }
    console.log(i);
}
1
2
3
4
5
6
```
七、字符串

字符串就是零个或多个排在一起的字符，放在单引号或双引号之中，单引号字符串的内部，可以使用双引号，双引号字符串的内部，也可以使用单引号
```
"hello word"
'key = "value"'
1
2
```
如果要在单引号字符串的内部，使用单引号，就必须在内部的单引号前面加上反斜杠，用来转义。双引号字符串内部使用双引号，也是如此
```
'Did she say \'Hello\'?'
// "Did she say 'Hello'?"
"Did she say \"Hello\"?"
// "Did she say "Hello"?"
1
2
3
4
```
字符串默认只能写在一行内，分成多行将会报错
如果长字符串必须分成多行，可以在每一行的尾部使用反斜杠
```
var longString = 'Long \
long \
string';
longString
// "Long long long string"
1
2
3
4
5
```
length 属性
length属性返回字符串的长度，该属性也是无法改变的
```
var s = 'itbaizhan'; 
s.length // 9
1
2
```
1、字符串方法_charAt()
charAt 方法返回指定位置的字符，参数是从 0 开始编号的
```
var s = new String('itbaizhan');
s.charAt(1) // "t"
s.charAt(s.length - 1) // "n"
1
2
3
```
如果参数为负数，或大于等于字符串的长度， charAt 返回空字符串
```
'itbaizhan'.charAt(-1) // ""
'itbaizhan'.charAt(9) // ""
1
2
```
2、字符串方法_concat()
concat 方法用于连接两个字符串，返回一个新字符串，不改变原字符串
```
var s1 = 'itbaizhan';
var s2 = 'sxt';

s1.concat(s2) // "itbaizhansxt"
s1 // "itbaizhan"
1
2
3
4
5
```
该方法可以接受多个参数
```
'sxt'.concat('itbaizhan', 'bjsxt') //"sxtitbaizhanbjsxt"
1
```
如果参数不是字符串， concat 方法会将其先转为字符串，然后再连接
```
var one = 1;
var two = 2;
var three = '3';

console.log(''.concat(one, two, three)) //123
console.log(one + two + three) //33
1
2
3
4
5
6
```
concat和加号还是有区别的：
- concat不管什么类型直接合并成字符串
- 加号是遇到数字类型直接做运算，遇到字符串和字符串相连接
3、字符串方法_substring()

substring 方法用于从原字符串取出子字符串并返回，不改变原字符串。它的第一个参数表示子字符串的开始位置，第二个位置表示结束位置（返回结果不含该位置）
```
'itbaizhan'.substring(0, 2) // "it"
1
```
如果省略第二个参数，则表示子字符串一直到原字符串的结束
```
'itbaizhan'.substring(2) // "baizhan"
1
```
如果第一个参数大于第二个参数， substring 方法会自动更换两个参数的位置
```
'itbaizhan'.substring(9, 2) // "baizhan"
// 等同于
'itbaizhan'.substring(2, 9) // "baizhan"
1
2
3
```
如果参数是负数， substring 方法会自动将负数转为0
```
'itbaizhan'.substring(-3) // "itbaizhan"
'itbaizhan'.substring(2, -3) // "it"
1
2
```
4、字符串方法_substr()
substr 方法用于从原字符串取出子字符串并返回，不改变原字符串，跟 substring 方法的作用相同
substr 方法的第一个参数是子字符串的开始位置（从0开始计算），第二个参数是子字符串的长度
```
'itbaizhan'.substr(2, 7); // baizhan
1
```
如果省略第二个参数，则表示子字符串一直到原字符串的结束
```
'itbaizhan'.substr(2) // "baizhan"
1
```
如果第一个参数是负数，表示倒数计算的字符位置。如果第二个参数是负数，将被自动转为0，因此会返回空字符串
```
'itbaizhan'.substr(-7) // "baizhan"
'itbaizhan'.substr(4, -1) // ""
1
2
```
5、字符串方法_indexOf()
indexOf 方法用于确定一个字符串在另一个字符串中第一次出现的位置，返回结果是匹配开始的位置。如果返回 -1 ，就表示不匹配
```
'hello world'.indexOf('o') // 4
'itbaizhan'.indexOf('sxt') // -1
1
2
```
indexOf 方法还可以接受第二个参数，表示从该位置开始向后匹配
```
'hello world'.indexOf('o', 6) // 7
1
```
6、字符串方法_trim()
trim 方法用于去除字符串两端的空格，返回一个新字符串，不改变原字符串
```
' hello world '.trim()
// "hello world"
1
2
```
该方法去除的不仅是空格，还包括制表符（ \t 、 \v ）、换行符（ \n ）和回车符（ \r ）
```
'\r\nitbaizhan \t'.trim() // 'itbaizhan'
1
```
ES6扩展方法， trimEnd() 和 trimStart() 方法
```
"   itbaizhan   ".trimEnd(); //   itbaizhan
"   itbaizhan   ".trimStart(); // itbaizhan
1
2
```
7、字符串方法_split()
split 方法按照给定规则分割字符串，返回一个由分割出来的子字符串组成的数组
```
'it|sxt|baizhan'.split('|') // ["it", "sxt","baizhan"]
1
```
如果分割规则为空字符串，则返回数组的成员是原字符串的每一个字符
```
'a|b|c'.split('') // ["a", "|", "b","|","c"]
1
```
如果省略参数，则返回数组的唯一成员就是原字符串
```
'it|sxt|bz'.split() // [it|sxt|bz]
1
```
split 方法还可以接受第二个参数，限定返回数组的最大成员数
```
'it|sxt|bz'.split('|', 0) // []
'it|sxt|bz'.split('|', 1) // ["it"]
'it|sxt|bz'.split('|', 2) // ["it", "sxt"]
'it|sxt|bz'.split('|', 3) // ["it", "sxt","bz"]
'it|sxt|bz'.split('|', 4) // ["it", "sxt","bz"]
1
2
3
4
5
```
八、数组

数组（array）是按次序排列的一组值。每个值的位置都有编号（从0开始），整个数组用方括号表示
```
var arr = ['sxt', 'baizhan', 'it'];
1
```
两端的方括号是数组的标志。 sxt 是0号位置， baizhan 是1号位置， it是2号位置（位置也被称为下标）
除了在定义时赋值，数组也可以先定义后赋值
```
var arr = [];

arr[0] = 'sxt';
arr[1] = 'baizhan';
arr[2] = 'it';
1
2
3
4
5
```
任何类型的数据，都可以放入数组
```
var arr = [ 100, [1, 2, 3],false ];
1
```
如果数组的元素还是数组，就形成了多维数组
```
var a = [[1, 2], [3, 4]];
a[0][1] // 2
a[1][1] // 4
1
2
3
```
length 属性
数组的length属性，返回数组的成员数量
```
['sxt', 'baizhan', 'it'].length // 3
1
```
1、数组的遍历
数组的遍历可以考虑使用for循环或while循环
```
var a = ['sxt', 'baizhan', 'it'];
// for循环
for(var i = 0; i < a.length; i++) {
  console.log(a[i]);
  }
// while循环
var i = 0;
while (i < a.length) {
  console.log(a[i]);
  i++; 
  }
1
2
3
4
5
6
7
8
9
10
11
```
for…in遍历数组
```
var a = ['sxt', 'baizhan', 'it'];
for (var i in a) {
	console.log(a[i]);
  }
1
2
3
4
```
2、数组静态方法_Array.isArray()
Array.isArray 方法返回一个布尔值，表示参数是否为数组，它可以弥补typeof 运算符的不足
```
var arr = ["尚学堂", 100, true];
console.log(typeof arr); // object
1
2
```
```
var arr = ['sxt', 'baizhan', 'it'];
Array.isArray(arr) // true
1
2
```
3、数组方法_push()/pop()
push 方法用于在数组的末端添加一个或多个元素，并返回添加新元素后的数组长度，该方法会改变原数组
```
var arr = [];
arr.push("尚学堂") // 1
arr.push('itbaizhan') // 2
arr.push(true, {}) // 4
arr // [尚学堂, 'itbaizhan', true, {}]
1
2
3
4
5
```
pop 方法用于删除数组的最后一个元素，并返回该元素，该方法会改变原数组
```
var arr = ['尚学堂', 'itbaizhan', 'WEB前端'];
arr.pop() // 'WEB前端'
arr // ['尚学堂', 'itbaizhan']
1
2
3
```
4、数组方法_shift()/unshift()
shift 方法用于删除数组的第一个元素，并返回该元素，该方法会改变原数组
```
var arr = ['尚学堂', 'itbaizhan', 'WEB前端'];
arr.shift() // '尚学堂'
arr // ['itbaizhan', 'WEB前端']
1
2
3
```
shift 方法可以遍历并清空一个数组
```
var list = [1, 2, 3, 4, 5, 6];
var item; 
while (item = list.shift()) {
	console.log(item);
  }

list // []
1
2
3
4
5
6
7
```
item = undefined值为false，所以跳出了while循环

unshift 方法用于在数组的第一个位置添加元素，并返回添加新元素后的数组长度，该方法会改变原数组
```
var arr = ['尚学堂', 'itbaizhan', 'WEB前端'];

arr.unshift('baizhan'); // 4
arr // ['baizhan', '尚学堂', 'itbaizhan', 'WEB前端']
1
2
3
4
```
unshift 方法可以接受多个参数，这些参数都会添加到目标数组头部
```
var arr = [ '尚学堂', 'itbaizhan' ];
arr.unshift('WEB前端', 'baizhan') // 4
arr // [ 'WEB前端', 'baizhan', '尚学堂','itbaizhan' ]
1
2
3
```
5、数组方法_join()
join 方法以指定参数作为分隔符，将所有数组成员连接为一个字符串返回，如果不提供参数，默认用逗号分隔
```
var a = [1, 2, 3, 4];

a.join(' ') // '1 2 3 4'
a.join(' | ') // "1 | 2 | 3 | 4"
a.join() // "1,2,3,4"
1
2
3
4
5
```
如果数组成员是 undefined 或 null 或空位，会被转成空字符串
```
[undefined, null].join('#')
// '#'

['a',, 'b'].join('-') 
// 'a--b'
1
2
3
4
5
```
数组的 join 配合字符串的 split 可以实现数组与字符串的互换
```
var arr = ["a","b","c"];
var myArr = arr.join("");
console.log(myArr);
console.log(myArr.split(""));
1
2
3
4
```
6、数组方法_concat()
concat 方法用于多个数组的合并，它将新数组的成员，添加到原数组成员的后部，然后返回一个新数组，原数组不变
```
['hello'].concat(['world'])
// ["hello", "world"]

['hello'].concat(['world'], ['!'])
// ["hello", "world", "!"]
1
2
3
4
5
```
除了数组作为参数， concat 也接受其他类型的值作为参数，添加到目标数组尾部
```
[1, 2, 3].concat(4, 5, 6)
// [1, 2, 3, 4, 5, 6]
1
2
```
应用场景：上拉加载，合并数据

7、数组方法_reverse()
reverse 方法用于颠倒排列数组元素，返回改变后的数组，该方法将改变原数组
```
var a = ['a', 'b', 'c'];

a.reverse() // ["c", "b", "a"]
a // ["c", "b", "a"]
1
2
3
4
```
实现一个字符串反转排列
```
var str = "hello"; 
str.split("").reverse().join("")
1
2
```
8、数组方法_indexOf()
indexOf 方法返回给定元素在数组中第一次出现的位置，如果没有出现则返回 -1
```
var arr = ['a', 'b', 'c'];

arr.indexOf('b') // 1
arr.indexOf('y') // -1
1
2
3
4
```
indexOf 方法还可以接受第二个参数，表示搜索的开始位置
```
['尚学堂', '百战程序员','itbaizhan'].indexOf('尚学堂', 1) // -1
1
```
九、函数
- 函数是一段可以反复调用的代码块；
- 函数的调用语句可以写在function 命令前；
- function命令声明的代码区块，就是一个函数；
- function命令后面是函数名，函数名后面是一对圆括号，里面是传入函数的参数，函数体放在大括号里面；
- 函数运行的时候，有时需要提供外部数据，不同的外部数据会得到不同的结果，这种外部数据就叫参数；
- JavaScript函数提供两个接口实现与外界的交互，其中参数作为入口，接收外界信息；返回值作为出口，把运算结果反馈给外界；
- return后面不能在添加任何代码，因为不会执行。
```
function square(x) {
 console.log(x * x);
}
square(2) // 4
square(3) // 9
1
2
3
4
5
```
十、对象

对象（object）是 JavaScript 语言的核心概念，也是最重要的数据类型。简单说，对象就是一组“键值对”（key-value）的集合，是一种无序的复合数据集合。
```
var user = {
 name: 'itbaizhan', 
 age: '13'
};
1
2
3
4
```
对象的每一个键名又称为“属性”（property），它的“键值”可以是任何数据类型。如果一个属性的值为函数，通常把这个属性称为“方法”，它可以像函数那样调用
```
var user = {
 getName: function (name) {
  return name;
 }
};
user.getName("itbaizhan") // itbaizhan
1
2
3
4
5
6
```
如果属性的值还是一个对象，就形成了链式引用
```
var user = {
    name:"itbaizhan",
    age:13,
    container:{
        frontEnd:["Web前端","Android","iOS"],
        backEnd:["Java","Python"]
   }
}
user.container.frontEnd // ["Web前 端","Android","iOS"]
1
2
3
4
5
6
7
8
9
```
十一、Math对象

Math是 JavaScript 的原生对象，提供各种数学功能

1、Math.abs()
Math.abs 方法返回参数值的绝对值
```
Math.abs(1) // 1
Math.abs(-1) // 1
1
2
```
2、Math.max()，Math.min()
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
1
2
3
4
```
3、Math.floor()，Math.ceil()
Math.floor 方法返回小于参数值的最大整数
```
Math.floor(3.2) // 3
Math.floor(-3.2) // -4
1
2
```
Math.ceil 方法返回大于参数值的最小整数
```
Math.ceil(3.2) // 4
Math.ceil(-3.2) // -3
1
2
```
4、Math.random()
Math.random() 返回0到1之间的一个伪随机数，可能等于0，但是一定小于1
```
Math.random() // 0.28525367438365223
1
```
任意范围的随机数生成函数如下
```
function getRandomArbitrary(min, max) {
  return Math.random() * (max - min) + min; 
}
getRandomArbitrary(5, 10)
1
2
3
4
```
十二、Date对象

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

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

时间戳是指格林威治时间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
1
2
3
4
5
```
编写函数获得本年度剩余天数
```
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);
}
1
2
3
4
5
6
```
相关阅读:
2024能源动力、机械自动化与航天航空技术国际学术会议(ICEPMAT2024)
SQL WHERE Clause（查询子句）
独立站必看攻略
 kubernetes1.24版本之后仍然使用docker作为运行时的部署方法
 【运维笔记】Docker 部署Kibana-7.4.0（在线Docker版）
centos7篇---安装anaconda
Java中的锁
 分布式配置中心Apollo
手写分布式配置中心（二）实现分布式配置中心的简单版本
 经纬度坐标转换为工程坐标
原文地址：https://blog.csdn.net/weixin_44064728/article/details/126164311

一、JavaScript语句、标识符和变量

二、JavaScript引入到文件

三、JavaScript常见的输出方式及数据类型

四、运算符

五、条件语句

六、三元运算符和循环语句

七、字符串

八、数组

九、函数

十、对象

十一、Math对象

十二、Date对象