前端知识学习笔记-三（JavaScript）

strugglegirl

已于 2024-04-10 09:36:42 修改

阅读量1k

点赞数 13

分类专栏：前端知识文章标签：前端学习笔记 javascript

于 2024-04-03 17:45:17 首次发布

本文链接：https://blog.csdn.net/strugglegirl/article/details/135273180

版权

前端知识专栏收录该内容

6 篇文章 0 订阅

订阅专栏

JavaScript简介

JavaScript介绍
JavaScript 是一种轻量级的脚本语言。所谓脚本语言指的是它不具备开发操作系统的能力，而是只用来编写控制其他大型应用程序的“脚本”。
JavaScript 是一种嵌入式 (embedded)语言。它本身提供的核心语法不算很多
JavaScript与ECMAScript的关系
ECMAScript和JavaScript的关系是，前者是后者的规格，后者是前者的一种实现。在日常场合，这两个词是可
以互换的。

JavaScript语句和标识符

语句
JavaScript 程序的单位是行 (line)，也就是一行一行地执行。一般情况下，每一行就是一个语句

var num = 10;

标识符
标识符 (identifier) 指的是用来识别各种值的合法名称。最常见的标识符就是变量名标识符是由:字母、美元符号($)、下划线(和数字组成，其中数字不能开头

中文是合法的标识符，可以用作变量名 (不推荐)

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.

变量

var 声明变量

var num=10;

变量的重新赋值

 var num = 10;
 num = 20;

变量提升
javaScript引擎的工作方式是，先解析代码，获取所有被声明的变量，然后再一行一行地运行。这造成的结果，就是所有的变量的声明语句，都会被提升到代码的头部，这就叫做变量提升 (hoisting)。

<scrip>
	console.1og(num);
	var num = 10; // 结果是什么呢?
</scrip>

javaScrip引用到html文件

嵌入到HTML文件中

<body>
	<script>
		var age = 20
	</script>
</body>

引入本地独立JS文件

<body>
	<script type="text/javascript" src="./itbaizhan.js"> </script>
</body>

引入网络来源文件

<body>
	<script src="http://code.jquery.com/jquery1.2.1.min.js"> </script>
</body>

javaScrip注释与常见输出方式

JavaScript注释
源码中注释是不被引擎所解释的，它的作用是对代码进行解释。
单行注释以 // 开头
多行注释以 /* 开始，以 */ 结尾

 // 这是单行注释
/* 
这是
多行
注释
 */

嵌入在HTML文件中的注释

 <!-- 注释 -->

温馨提示
注释的快捷键: ctrl +/

JavaScript输出方式
JavaScript有很多种输出方式，都可以让我们更直观的看到程序运行的结果

// 在浏览器中弹出一个对话框,然后把要输出的内容展示出来,alert都是把要输出的内容首先转换为字符串然后在输出的
alert("要输出的内容");
document.write("要输出的内容”);4
// 在控制台输出内容
console.1og("要输出的内容");

数据类型

数据类型分类
JavaScript 语言的每一个值，都属于某一种数据类型。JavaScript 的数据类型，共有六种。(ES6 又新增了第七种 Symbol 类型的值和第八种 Bigint类型，当前课程暂不涉及)
原始类型（基础类型）
数值、字符串、布尔值

//数值
var age=20
// 字符串类型: 被双引号或单引号包裹的值就是字符串类型
var name="viven"
// 布尔类型: 计算机是由 @ 和 1 组成 @:false 1: true
var flag=true

合成类型(复合类型)
对象
因为一个对象往往是多个原始类型的值的合成，可以看作是一个存放各种值的容器

var user{
	name:"西西",
	age:20,
	learn:true
	}

温馨提示
至于undefined和null，一般将它们看成两个特殊值。

typeof运算符

javaScript 有三种方法，可以确定一个值到底是什么类型。而我们现在需要接触到的就是typeof

<script>
	var age=20;
	var name="喜喜";
	var isStudent=true;
	var user{};
	console.log(typeof age);//number
	console.log(typeof name);//string
	console.log(typeof isStudent);//boolean
	console.log(typeof user);//object
	console.log(typeof []);//object
	console.log(typeof undefind)//undefind
	console.log(typeof null);//object
</script>

nulll和undefined的区别
nul与undefined都可以表示”没有”，含义非常相似。将一个变量赋值为undefined或null，语法效果几乎没区别。
null一般代表对象为“没有”undefined一般代表数值为“没有

算术运算符

加减乘除运算符

<script>
	var num1=10;
	var num2=2;
	console.log(num1+num2);//12 加法
	console.log(num1-num2);//8 减法
	console.log(num1*num2);//20 乘法
	console.log(num1/um2);//5 除法
	console.log(num1%num2);//0 取余
</script>

自增/自减运算符
自增和自减运算符，是一元运算符，只需要一个运算子。它们的作用是将运算子首先转为数值，然后加上1或者减去1

<body>
    <script>
        var a=1;
        var b=2;
        console.log(++a);//1
        console.log(--b);//0
    </script>
</body>

自增和自减运算符有一个需要注意的地方，就是放在变量之后，会先返回变量操作前的值，再进行自增/自减操作;放在变量之前，会先进行自增/自减操作，再返回变量操作后的值。

<body>
    <script>
        var a=1;
        var b=1;
        console.log(a++);//1
        console.log(++b);//2
    </script>
</body>

赋值运算符

赋值运算符 (Assignment Operators) 用于给变量赋值最常见的赋值运算符，当然就是等号 (=)

// 将 1 赋值给变量 X
var x = 1:
// 将变量 y 的值赋值给变量 X4
var x= y;

赋值运算符还可以与其他运算符结合，形成变体。下面是与算术运算符的结合

// 等同于 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

比较运算符

比较运算符用于比较两个值的大小，然后返回一个布尔值，表示是否满足指定的条件.

2 > 1 // true

JavaScript 一共提供了8个比较运算符。
在这里插入图片描述

双等（）比较值
三等（=）比较值和类型
不等（！=）比较值
不等（！==）比较值和类型

var num1=10
var num2="10"
console.log(num1==num2)//结果为true
console.log（num1===num2）//结果为false

布尔运算符

取反运算符（!）
布尔值取反

!true // false
!false /true

非布尔值取反
对于非布尔值，取反运算符会将其转为布尔值。可以这样记忆，以下六个值取反后为true，其他值都为false.

温馨提示：以下6个非布尔值取反为true，其他值取反为false
undefined
null
0
false
NaN
空字符串 (”)

且运算符 (&&)
多个条件都要满足

如果一个人一直做好事，突然有一天做了一件坏事，那么人们会认为这个人很虚伪，以前说不定都是装的!对这个人不再认可。

console.1og(10 < 20 && 10 >5); // true

或运算符 (II)
满足一个条件即可

如果一个人一直做坏事，突然有一天做了一件好事，那么人们会认为这个人其实还不错，以前也许是另有原因!对这个人突然就认可了

console.1og(10 < 20 || 10 <5); // true

条件语句-if语句

if结构先判断一个表达式的布尔值，然后根据布尔值的真伪，执行不同的语句。所谓布尔值，指的是avaScript 的两个特殊值，true表示真，false表示伪。
在这里插入图片描述

var num1=10
var num2=20
if(num1<num2){
console.log("num1小于num2")
}

条件语句-if…else语句
if…else基本结构
if代码块后面，还可以跟一个else代码块，表示不满足条件时，所要执行的代码。
在这里插入图片描述

   <script>
        var day=1;
        if(day==1){
            alert("星期一");
        }else if(day==2){
            alert("星期二");
        }else if(day==3){
            alert("星期三");
        }else if(day==4){
            alert("星期四");
        }else if(day==5){
            alert("星期五");
        }else if(day==6){
            alert("星期六");
        }else if(day==7){
        }else(alert("输入错误"))
    </script>

条件语句-switch语句

** switch(day){
            case 1:
                alert("星期一");
                break;
            case 2:
                alert("星期二");
                break;
            case 3:
                alert("星期三");
                break;
            case 4:
                alert("星期四");
                break;
            case 5:
                alert("星期五");
                break;
            case 6:
                alert("星期六");
                break;
            case 7:
                alert("星期日");
                break
            case 8:
                alert("输入错误");
                break;
        }**

需要注意的是每个case代码块内部的break语句不能少，否则会接下去执行下一个case代码块，而不是跳出switch结构。

三元运算符

lavaScript还有-个三元运算符 (即该运算符需要三个运算子) ?: ，也可以用于逻辑判断。
执行逻辑：如果条件为true,执行表达式1，条件为false执行表达式2

{条件?表达式1: 表达式2}

var num=5
        //三元运算符
        {num%2==0?console.log("偶数"):console.log("奇数")}//结果为基数

循环语句-for循环语句

循环语句用于重复执行某个操作
for语句就是循环命令，可以指定循环的起点、终点和终止条件。它的格式如下：

for(初始化表达式;条件;迭代因子){
语句
}

for语句后面的括号里面，有三个表达式
初始化表达式(initialize):确定循环变量的初始值，只在循环开始时执行一次。
布尔表达式(test):每轮循环开始时，都要执行这个条件表达式，只有值为真，才继续进行循环。
迭代因子(increment):每轮循环的最后一个操作，通常用来递增循环变量

 <script>
      for(var i=1;i<=10;i++){
          console.log(i);
      }
    </script>

温馨提示
for语句中三个表达式可以省略任意表达式
如果三个都省略，结果就导致了一个无限循环(死)

//for语句实现乘法表
 <script>
        var sum=0;
      for(b=1;b<=9;b++){
          document.write("<br>");
          for(c=1;c<=b;c++){
              sum=b*c;
              document.write(b+"*"+c+"="+sum+" ");
          }
      }
    </script>

循环语句-while循环语句

While语句包括一个循环条件和一段代码块，只要条件为真，就不断循环执行代码块。

while (条件){
语句;
}

//while语句实现乘法表
var i=1;
      while(i<=9){
          document.write("<br>");
          var j=1;
          while(j<=i){
              document.write(i+"*"+j+"="+i*j+" ");
              j++;
          }
           i++
        }

温馨提示：如果条件中全为true会造成死循环
while(true){
语句
}

break语句、continue语句

break语句和continue语句都具有跳转作用，可以让代码不按既有的顺序执行。
break
break语句用于跳出代码块或循环

for (var i = 0;i < 5; i++) {
if (i === 3){
break;
}
console.log(i);
}
//结果0、1、2

continue
continue语句跳出当前循环继续下一个循环

for (var i = 0;i < 5; i++) {
if (i === 3){
continue;
}
console.log(i);
}
//结果 0、1、2、4

字符串

字符串就是零个或多个排在一起的字符放在单引号或双引号之中

document.write("<br>"+"hello,word")
document.write('<br>'+'hello,word')

单引号字符串的内部，可以使用双引号。双引号字符串的内部，可以使用单引号

  document.write("<br>"+"key='hello,word'")
  document.write("<br>"+'key="hello,word"')

如果要在单引号字符串的内部，使用单引号，就必须在内部的单引号前面加上反斜杠，用来转义。双引号字符串内部使用双引号，也是如此

   document.write("<br>"+'say \'hello,word\'')
   document.write("<br>"+"say \"hello,word\"")

字符串方法-charAt()

charAt: 方法返回指定位置的字符，参数是从0开始编号的

 var s="hello,word"
 document.write("<br>"+s.charAt(0))//结果h
 document.write("<br>"+s.charAt(s.length-1))//结果为d

如果参数为负数，或大于等于字符串的长度，chrAt(): 返回空字符串

var s="hello,word"
document.write("<br>"+s.charAt(-1))
document.write("<br>"+s.charAt(10))

字符串方法-concat

concat 方法用于连接两个字符串，返回一个新字符串，不改变原字符串

var str1='hello'
var str2='world'
document.write("<br>"+str1.concat(str2))

concat 方法可接收多个参数

var str1='hello'
var str2='world'
var str3='!'
document.write("<br>"+str1.concat(str2,str3))

如果参数不是字符串，oonet 方法会将其先转为字符串，然后再连接

var str4="123"
var str5="456"
var num=789
document.write(str4.concat(str5,num))

一般字符串相连，除了concat外可以使用+连接（常用+连接方法）

var str1='hello'
var str2='world'
var str3='!'
document.write("<br>"+str1+str2+str3)

字符串方法substring()

substing 方法用于从原字符串取出子字符串并返回，不改变原字符串。它的第一个参数表示子字符串的开始位置，第二个位置表示结束位置 (返回结果不含该位置)

var str="hello,world!"
document.write(str.substring(1,5))//结果为ello

如果省略第二个参数，则表示子字符串一直到原字符串的结束

var str="hello,word!"
document.write(str.substring(1))//结果为ello，world!

如果第一个参数大于第二个参数，substing 方法会自动更换两个参数的位置

var str="hello,world!"
document.write(str.substring(3,1))//结果为el

如果参数是负数，substring 方法会自动将负数转为0

var str="hello,world!"
document.write(str.substring(-3,2))//结果为he

字符串方法-substr

subst 方法用于从原字符串取出子字符串并返回，不改变原字符串，跟substring 方法的作用相同subst 方法的第一个参数是子字符串的开始位置(从0开始计算)，第二个参数是子字符串的长度

var str="hello,world!"
document.write(str.substr(1,2))//结果为el
document.write(str.substr(1,5))//结果为ello,

如果省略第二个参数，则表示子字符串一直到原字符串的结束

var str="hello,world!"
document.write(str.substr(6))//结果为world!

如果第一个参数是负数，表示倒数计算的字符位置。如果第二个参数是负数，将被自动转为0，因此会返回空字符串

var str="hello,world!"
document.write(str.substr(-6))//结果为o,world
document.write(str.substr(1,-6))//结果为空

字符串方法-indexOf

indexof 方法用于确定一个字符串在另一个字符串中第一次出现的位置，返回结果是匹配开始的位置。如果返回 -1，就表示不匹配

var str="hello,world!"
document.write(str.indexOf("llo"))//结果2
document.write(str.substr("yt"))//结果为-1

indexOf 方法还可以接受第二个参数，表示从该位置开始向后匹配

var str="hello,world!"
document.write("<br>"+s.indexOf('o',5))//表示从第5位开始向后匹配“o”

字符串方法 -trim

trim 方法用于去除字符串两端的空格返回一个新字符串，不改变原字符串

"   hello,world    ".trim()//结果为"hello,word"

该方法去除的不仅是空格，还包括制表符 ( \t,\v )、换行符 (\n) 和回车符 (\r)

'\r\n hello,world \t'.trim() // 结果为'hello,word'

ES6扩展方法，trimEnd()和trimStart() 方法
trimEnd（）去除尾部空格
trimStart（）去除头部空格

字符串方法 split()

splt 方法按照给定规则分割字符串，返回一个由分割出来的子字符串组成的数组

"hello|world".split('|') // ["hello"，"world"]

如果分割规则为空字符串，则返回数组的成员是原字符串的每一个字符。

"hello|world".split('') // [h,e,l,l,o,|,w,o,r,l,d]

如果省略参数，则返回数组的唯一成员就是原字符串。

"hello|world".split() // [hello|world]

split 方法还可以接受第二个参数，限定返回数组的最大成员数。

"h|ello|wol|rd".split('|',0) // []
"h|ello|wol|rd".split('|',1) // [h]
"h|ello|wol|rd".split('|',2) // [h,ello]
"h|ello|wol|rd".split('|',3) // [h,ello,wol]
"h|ello|wol|rd".split('|',4) // [h,ello,wol,rd]

数组

数组(array) 是按次序排列的一组值。每个值的位置都有编号 (从0开始)，整个数组用方括号表示

var arr = ["hello", "word","!"];

两端的方括号是数组的标志。hello 是0号位置，word 是1号位置，!是2号位置。

除了在定义时赋值，数组也可以先定义后赋值。

var arr = [];
arr[0] = "hello";
arr[1] = "world";
arr[2] ="!";
console.log(arr1);//结果为["hello","world","!"]

任何类型的数据，都可以放入数组。

var arr = [ 100，[1，2，3],false ];

如果数组的元素还是数组，就形成了多维数组。

var a = [[1，2]，[3，4]];
a[O][1] // 2
a[1][1] // 4

length 属性
数组的length属性，返回数组的成员数量。

['sxt','baizhan',"it'].length // 3

数组的遍历

数组的遍历可以考虑使用for循环或while循环

var arr=[1,2,3,4,5]
for(i=0;i<arr.length;i++){
         document.write("<br>"+arr[i])
        }
 var j=0;
while(j<arr.length){
        document.write("<br>"+arr[j])
        j++
        }

for…in遍历数组

var arr=[1,2,3,4,5]
for(var k in arr){
          document.write("<br>"+arr[k])
        }

数组静态方法-Array.isArray()

Aray.isArray 方法返回一个布尔值，表示参数是否为数组。它可以弥补 typeof 运算符的不足。

var arr=[1,2,3,4,5]
document.write("<br>"+typeof arr)//结果为object
document.write("<br>"+Array.isArray(arr))//结果为true

数组方法push()/pop()

push 方法用于在数组的末端添加一个或多个元素，并返回添加新元素后的数组长度。注意：该方法会改变原数组。

var arr=[1,2,3,4,5];
document.write("<br>"+arr.push(6,7));//结果为7
console.log(arr);//结果为[1,2,3,4,5，6，7]

pop 方法用于删除数组的最后一个元素，并返回该元素。注意：该方法会改变原数组。

var arr=[1,2,3,4,5];
arr.pop();
console.log(arr);//结果为[1,2,3,4]

数组方法shift()/unshift()

shift方法用于删除数组的第一个元素，并返回该元素。注意:该方法会改变原数组

var arr=[1,2,3,4,5,6];
console.log(arr.shift());//结果为1
console.log(arr);//结果为：[2,3,4,5,6]

shift 方法可以遍历并清空一个数组

var arr=[1,2,3,4,5,6];
while(item=arr.shift()){
       document.write("<br>"+item)
        };
console.log(arr);//结果为[]

unshift方法用于在数组的第一个位置添加元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组。
unshit 方法可以接受多个参数，这些参数都会添加到目标数组头部。

var arr=[1,2,3,4,5,6];
arr.unshift(10);
console.log(arr);//结果为[10,1,2,3,4,5,6]
arr.unshift(11,12,13);
console.log(arr);//结果为[11,12,13,10,1,2,3,4,5,6]

数组方法-join()
join 方法以指定参数作为分隔符，将所有数组成员连接为一个字符串返回。如果不提供参数，默认用逗号分隔。

var a=[10,11,12,13,14];
console.log(arr.join(''));//结果为1011121314
console.log(arr.join(','));//结果为10,11,12,13,14
console.log(arr.join());//结果为10,11,12,13,14
console.log(arr.join("-"))//结果为10-11-12-13-14

如果数组成员是undefined 或null或空位，会被转成空字符串。
数组的 join 配合字符串的s 可以实现数组与字符串的互换。

var a=["a","b","c"];
var b=a.join('');
console.log(b);//结果为abc
console.log(b.split(''));//结果为["a","b","c"]

数组方法concat（）

concat 方法用于多个数组的合并。它将新数组的成员，添加到原数组成员的后部，然后返回一个新数组，原数组不变。

var a=["a","b","c"];
var arr=[1,2,3,4,5,6];
var b=["hello,world"];
console.log(a.concat(arr));//结果为["a","b","c",1,2,3,4,5,6]
console.log(a.concat(arr,b));//结果为["a","b","c",1,2,3,4,5,6,hello,world]

除了数组作为参数，concat 也接受其他类型的值作为参数，添加到目标数组尾部。

var a=["a","b","c"];
console.log(a.concat(3,4,5,6))//结果为["a","b","c",3,4,5,6]

数组方法 reverse()

reverse 方法用于颠倒排列数组元素，返回改变后的数组。注意:该方法将改变原数组

var a=["a","b","c","d","e"];
console.log(a.reverse());//结果为["e","d","c","b","a"]

实现一个字符串反转排列

var string="hello,world";
console.log(string.split('').reverse().join(''))//结果为：dlrow,olleh

数组方法indexOf()

indexor 方法返回给定元素在数组中第一次出现的位置，如果没有出现则返回-1。

var a=["hello","a","b","world"];
console.log(a.indexof("b"));//结果为2
console.log(a.indexof("2"));//结果为-1

indexor 方法还可以接受第二个参数，表示搜索的开始位置。

var a=["hello","a","b","c","b","world"];
console.log(a.indexof("b"，3));//结果为4

函数

函数是一段可以反复调用的代码块
函数的声明
function 命令: function命令今声明的代码区块，就是一个函数。function命令后面是函数名，函数名后面是一对圆括号，里面是传入函数的参数。函数体放在大括号里面。

<script>
        function test() {
            var a = 1;
            var b = 2;
            console.log(a + b);
        }
        test();
</script>

函数名的提升

javaScript 引擎将函数名视同变量名，所以采用function命令声明函数时，整个函数会像变量声明一样，被提升到代码头部。

test();
function test() {
      var a = 1;
      var b = 2;
      console.log(a + b);
        }

函数参数
函数运行的时候，有时需要提供外部数据，不同的外部数据会得到不同的结果，这种外部数据就叫参数。

//a,b为参数
<script>
     function add(a,b) {
         console.log(a + b);
     }
     add(10,20);
</script>

函数返回值
javaScript函数提供两个接口实现与外界的交互，其中参数作为入口，接收外界信息;返回值作为出口，把运算结果反馈给外界。

<script>
    function add(a,b) {
        return a+b;
    }
    c=add(10,20);
    console.log(c);
</script>

温馨提示
retumn 后面不能在添加任何代码，因为不会执行

对象概述

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

var user = {
name: '西西"
age: 13
}
console.log(user);//结果为{name: '张三', age: 18, sex: '男'}
console.log(user.name);//结果为：张三

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

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

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

<script>
    user={
       name:"张三",
       age:18,
       sex:"男",
       fancy:function(){
           console.log("我是个帅哥")
            },
      info:{
           phone:"13812345678",
           address:"北京"
      }
  }
   console.log(user.info.phone)
  </script>

Math对象

Math是JavaScript 的原生对象，提供各种数学功能。
Math.abs()
Math.abs 方法返回参数值的绝对值

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

Math.max()，Math.min()
Math.max 方法返回参数之中最大的那个值，Mathmin 返回最小的那个值。如果参数为空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.ceil()
Math.floor 方法返回小于参数值的最大整数(向下取整)

console.log(Math.floor(3.9))//3
console.log(Math.floor(3.1))//3

Matn.cei 方法返回大于参数值的最小整数（向上取整）

console.log(Math.ceil(3.5))//4
console.log(Math.ceil(3.1))//4

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

Math.random() // 0.28525367438365223

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

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

Data对象

Date 对象是JavaScript 原生的时间库。它以1970年1月1日00:00:00作为时间的零点，可以表示的时间范围是前后各一天(单位为毫秒)。
Date.now()
Date.now方法返回当前时间距离时间零点 (1970年1月1日 00:00:00 UTC)的毫秒数，相当于 Unix 时间截乘以。

Date.now()//1704865098283

时间戳
时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。
格林威治和北京时间就是时区的不同。
Date 对象提供了一系列 get” 方法，用来获取实例对象某个方面的值

实例方法get类
getTime(): 返回实例距离1970年1月1日00:00:00的毫秒数
getDate():返回实例对象对应每个月的几号 (从1开始)
getDay(): 返回星期几，星期日为0，星期一为1，以此类推
getYear():返回距离1900的年数
getFullYear(): 返回四位的年份
getMonth(): 返回月份 (0表示1月，11表示12月)
getHours0): 返回小时 (0-23)
getMilliseconds(): 返回毫秒 (0-999)
getMinutes(): 返回分钟 (0-59)getSeconds(): 返回秒 (0-59)

new Date()获取时间

new Date(1704865098283);//2024 13:38:18 GMT+0800 (中国标准时间)
new Date();//10 2024 13:48:41 GMT+0800 (中国标准时间)

var year=new Date().getFullYear()
var month=new Date().getMonth()+1
var day=new Date().getDate()
var hour=new Date().getHours()
var minute=new Date().getMinutes()
var second=new Date().getSeconds()
console.log(year+"-"+month+"-"+day+" "+hour+":"+minute+":"+second)

function leftDay(){
    var today=new Date()
    var enddate=new Date(today.getFullYear(),11,31,23,59,59,999)
    var msPerDay=24*60*60*1000
    var result=(enddate-today)/msPerDay
    return Math.floor(result)
    }
       //计算高考倒计时
function leftNEMTDay(){
    var today=new Date()
    var NEMTDay=new Date(today.getFullYear(),6,7,8,0,0,999)
    var msPerDay=24*60*60*1000
    return Math.floor((NEMTDay-today)/msPerDay)
    }
document.write(new Date().getFullYear()+"年，倒计时"+leftDay()+"天")
document.write("<br>"+new Date().getFullYear()+"年，高考倒计时"+leftNEMTDay()+"天")