Javascript基础

JS总结

1.JS概述

(1)历史

1995年，JS最早出现在Netscape的浏览器中

1996年，IE3中也可以出现了JS，称作JScript

1997年，JS被提交给了ECMA组织，制定了JS的标准规范ECMAScript

2009年，JS遵循CommonJS规范，开始向服务器端发展

(2)现状

JS就可以运行在客户端浏览器，也可以运行在服务器端

(3)特点

解释型语言，编译一行执行一行

弱类型语言

基于对象

跨平台

(4)应用场景

开发浏览器端的交互效果，进行服务器端开发，例如：创建WEB服务器、访问数据库、调用其它的服务器...

2.开发环境

(1)浏览器端

每个浏览器都有自带的一套JS解释器执行JS代码

世界上5大浏览器：谷歌、火狐、edge、Safari、欧朋

内核

(2)服务器端

Node.js

下载地址：https://nodejs.org

在命令行cmd下输入 node -v 查看到版本号

(3)运行JS

浏览器端

创建01.html和01.js，将js文件嵌入到html

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

Node.js

node 拖拽要运行的文件 回车

3.JS的语法规范

区分大小写

每行代码结束的分号可以省略

分为单行注释(//)和多行注释(/* */)

4.变量

存储数据的容器

(1)声明变量

 var x=1; 

 var a=1,b=2;

使用关键字var来声明变量，也可以一次声明多个变量

(2)变量的命名规则

可以由字母、数字、下划线、美元符号组成，不能以数字开头，不能使用关键字

语义化(可读性)

用户名 user_name userName yongHuMing

密码 password

(3)变量的赋值

变量声明后未赋值则为undefined（未定义）

变量声明后可以被重新赋值，并且赋不同类型的值，这是弱类型语言的特点

练习：声明多组变量分别保存商品的单价和数量，声明变量暂时为空，用于保存总价，计算总价并打印结果。

5.常量

和变量一样用于存储数据的容器，声明后必须赋值，不允许重新赋值

const pi=3.14;

6.数据类型

分为原始类型和引用类型

原始类型分为数值型、字符串型、布尔型、未定义型、空

(1)数值型

整型

10进制

1 2 3 .... 7 8 9 10 11 ... 15 16

8进制

1 2 3 ... 7 10 11 12

16进制

1 2 3 ... 7 8 9 a ... f 10

8进制以0开头的数字，例如012

16进制以0x开头的数字，a_f代表1015，不区分大小写

浮点型

3141.5E-1

314.15

31.415E+1

3.1415E+2

typeof 检测数据类型

(2)字符串型

被引号包含的数据，不区分单双引号

查看任意一个字符的Unicode码

'a'.charCodeAt()

(3)布尔型

只有两个值，分别是true和false，代表真和假

通常用于保存只有两个状态的数据，例如是否登录、是否在线... 一些运算符的结果也是布尔型

(4)未定义型

只有一个值是undefined，代表一个空值，例如声明了变量未赋值为undefined

(5)空

只有一个值是null，类型是object，常结合对象一起使用

7.数据类型转换

分为隐式转换和强制转换

1)隐式转换

在运算过程中自动产生的数据转换

(1)数字+字符串 数字转换为字符串

1 + '2' // '12'

(2)数字+布尔型 布尔型转换数值 true -> 1 false -> 0

  var a = 2 + true //3

  var b = 2 + false //2

(3)布尔型+字符串 布尔型转为字符串

  var c = true + '5' //'true5'

加号(+)的作用 执行数字之间的加法运算 执行字符串之间的拼接

NaN：Not a Number(不是一个数字) 在将一个数据转换为数值型时候，没有成功得到一个数字就会返回NaN NaN和任意数字执行运算，结果还是NaN

所有的隐式转换为数字都是会自动调用函数Number完成的

2)强制转换

(1)强制转换为数值型

Number()

Number('1') //1 Number(true) //1 Number(false) //0 Number(undefined) //NaN Number(null) //0 Number('1a') //NaN

(2)强制转换为整型

parseInt()

强制将字符串和小数转为整型

parseInt('3.94') //3   
parseInt('6.18a') //6  
parseInt('a6.18')  //NaN  
parseInt(5.9) //5  

undefined null true false都是返回NaN

(3)强制转换为浮点型

parseFloat()

强制将字符串转换为浮点型

parseFloat('3.14') //3.14 parseFloat('6.18a') //6.18 parseFloat('6a') //6 parseFloat('a6.18') //NaN

(4)数值和布尔型强制转字符串

toString()

  var  num = 5;  num.toString() //'5'  

8.运算符

表达式：由数据本身或者由运算符连接的操作数据组成的形式称作表达式

运算符分为算术运算符、比较运算符、逻辑运算符、位运算符、赋值运算符、三目运算符

(1)算术运算符

+ - * / % ++ --

% 取余

++ 自增，在原来的基础之上加1

-- 自减，在原来的基础之上减1

(2)比较运算符

> < >= <= ==(等于) !=(不等于) =(全等于) !(不全等于)

等于：只是比较两者的值是否相同，可能会发生隐式转换

全等于：同时比较类型和值，都相同结果才是true，否则false

不等于：比较值是否不相同

不全等于：同时比较类型和值，有一个不等为true，否则false

3>'10' 数字和字符串比较，字符串转为数值

'3'>'10' 字符串比较，比较的是首个字符的Unicode码

'3' -> 51 '1' -> 49

var a = 3>'10a' //false

var b = 3<'10a' //false

var c = 3=='10a' //false

NaN和任何值比较（> < >= <= == ===）结果都是false NaN == NaN //false

(3)逻辑运算符

&& || !

&& 逻辑与，关联的两个条件都为true，结果是true，否则false

|| 逻辑或，关联的两个有一个为true，结果是true，否则false

! 逻辑非，取反

短路逻辑

逻辑与，如果第一个条件是false，就不再执行第二个条件

逻辑或，如果第一个条件是true，就不再执行第二个条件

练习：以下程序运行是否会报错

  var  a = 3;  a  > 1 && console.log(num);  a  < 5 || console.log(num);  

短路逻辑关注点在于是否会执行第二个表达式。

练习：声明变量保存一个人的年龄，使用短路逻辑，如果满18岁打印‘成年人’

(4)位运算符

模拟计算机底层的运算，先把数据转为2进制，然后进行运算；当运算完以后再把结果转回成10进制。

& 按位与，上下两位都是1结果是1，否则是0

| 按位或，上下两位含有1结果是1，否则是0

^ 按位异或，上下两位不同是1，相同是0

>> 按位右移，删除最后的位数，在原来基础之上除以2再取整，例如7>>1 执行 parseInt(7/2)

<< 按位左移，在末尾补0，在原来的基础之上乘以2，例如3<<1 执行3*2

(5)赋值运算符

= += -= *= /= %= ... 运算赋值：先执行运算，再执行赋值

(6)三目运算符

一目运算符：由一个运算符连接的一个操作数据或者表达式 ! ++ --

二目运算符：由一个运算符连接的两个操作数据或者表达式

三目运算符：由两个运算符连接的三个操作数据或者表达式

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

如果条件表达式为true，执行表达式1

如果条件表达式为false，执行表达式2

9.浏览器端函数

alert() 弹出警示框

prompt() 弹出提示框(输入框)，需要使用变量保存用户输入的值，类型是字符串型，如果点击取消返回null

10.流程控制

1.判断

(1)if语句

if(age >= 18){
    console.log('成年人')
}

以下5种情况隐式转换为布尔型为false：0 NaN '' undefined null

(2)if-else语句

var age = 19;
if(age >= 18){
    console.log('成年人')
}else{
    console.log('未成年');
}

(3)if-else嵌套

var n = 1;
if(n === 1){
    console.log('非洲');
}else if(n === 2){
    console.log('印度');
}else if(n === 3){
    console.log('日本');
}else{
    console.log('??');
}

(4)switch-case

var n = 2;
switch(n){
    case 0:
        console.log('星期日');
        break;
    case 1:
        console.log('星期一');
        break;
    case 2:
        console.log('星期二');
        break;
    case 3:
        console.log('星期三');
        break;
    case 4:
        console.log('星期四');
        break;
    case 5:
        console.log('星期五');
        break;
    case 6:
        console.log('星期六');
        break;
    default:
        console.log('错误的星期');    
}

表达式在和case后的值比较的时候，用的是全等于(===)

对比if-else和switch-case

if-else可以进行各种条件的比较，switch-case只能进行全等于的比较

switch-case的代码结构更为清晰，执行效率更高

2.循环

(1)while循环

while (true) {
    console.log(i);
    if(i === 10){
        break; //break: 在循环体中使用，用于跳出循环，不再执行任何循环中的代码
    }
    i++;
}

(2)do-while循环

var a = 1;
do {
    console.log(a);
    a++;
} while (a <= 10);

(3)for循环

for (let k = 1; k <= 100; k++) {
    if (k % 3 ===0 || k % 4 === 0) {
        continue; //continue：跳过后续循环体代码，还会往后继续执行  break：跳出循环，结束循环的执行
    }
    console.log(k);
}

(4)循环嵌套

var x = 0;
while (x < 5) {
    for (var index = 0,star = ''; index < 5; index++) {
        star += '*';
    }
    console.log(star); 
    x++;
}
//循环嵌套
//在一个循环体的内部出现了另一个循环
//任意两个循环之间都可以相互嵌套

11.函数

函数分为系统函数和自定义函数

Number()/parseInt()/parseFloat()/alert()/prompt()

1.函数

函数：是一个功能体，需要提供若干个数据，返回处理的结果 —— 用于封装重复执行的代码、**

(1).创建函数

function laba() {
    console.log('1');
    console.log('2');
}

laba();//调用

(2)创建带有参数的函数

function getSum(a,b) {
    console.log(a+b);
}
getSum(1,2);//调用

创建函数时的参数称作形参，调用函数时的参数称作实参，实参会赋值给形参，实参的数量可以和形参的数量不匹配，如果形参未被赋值则为undefined

(3)创建带有返回值的函数

function getSum(a,b) {
    return a+b;
}
var n = getSum(1,2);
console.log(n);//调用

如果函数中没有写return或者return后没有任何值，则返回undefined 一旦执行return，就会跳出函数的执行

对比return和break

return用于函数中，跳出函数的执行

break用于循环和switch-case，跳出循环或者switch-case语句

2.变量的作用域

(1)全局变量：

在全局作用域(函数以外)声明的变量就是全局变量，可以在任意的作用域下访问到

(2)局部变量：

在函数作用域下声明的变量就是局部变量，只能在当前的作用域下访问到

在函数内不加var声明的变量是全局变量，后期在严格模式下报错，不推荐

//全局作用域
//全局变量
var a = '北京城管';
function shi(params) {
    //函数作用域
    //局部变量
    var b = '石景山城管';
    console.log(a);
}
shi();
//console.log(b);

var n1 = 6;
function fn() {
    //函数内不用var声明的变量 是全局变量
    n = 2;
    //访问到全局变量 可以重新赋值
    n1 = 8;
}
fn();

(3)变量提升：

程序执行前，会将var声明的变量提升到所在作用域的最前边，只是提升声明，赋值不提升

//变量提升 程序执行前 会将var 声明的变量提升到所在作用于的最前面，只提升声明 赋值不提升。
var a
console.log(a);
var a = 1;

function fn() {
    console.log(b);
    var b = 2;
}
fn();
//console.log(b); // b is not defined

3.函数的作用域

(1)全局函数：

在全局作用域下创建的函数，可以在任意的作用域访问

(2)局部函数：

在函数作用域下创建的函数，只能在当前的作用域访问

(3)函数提升：

程序执行前，会将函数整体提升到所在作用域的最前边

//全局函数
function fun1() {
    //局部函数
    function fun2() {
        console.log(1);
    }
    fun2();
}
fun1();
//fun2(); //fun2 is not defined

//函数提升 程序执行前 会将函数整体提升到所在作用域的最前面
foo();
function foo() {
    console.log(4);
}

4.递归

是一个函数的内部调用自身这个函数，本身是一个死循环

递归一直运行会产生内存泄漏，造成系统崩溃

如何使用：

要有边界条件，结合着return使用

JS属于单线程运行逻辑，无法充分利用CPU内核，递归对CPU消耗比较大，JS不适合深层次的递归嵌套。

//打印第三次 结束
var count = 0;
function say() {
    console.log('从前有座山');
    count++;
    if (count === 3) {
        return 3;
    }
    //递归
    //把返回的结果 传给上一次调用
    return say();
}
console.log(say());

//斐波那契数列
function fib(x) {
    if(x === 1 || x === 2){
        return 1;
    }
    
    return fib(x-1) + fib(x-2);
}
console.log(fib(3));


//1-n 整数和
function sum(n) {
    if(n === 1){
        return 1;
    }
    return n+sum(n-1);
}
console.log(sum(100));

5.匿名函数

(1)创建函数

//匿名函数
//变量名称就是函数名称
var fun = function(){
    console.log('ok');
}

fun();

对比函数名称和函数名称()

函数名称()：调用函数，得到函数的返回值

函数名称：本质上就是一个变量，保存了一个函数

对比函数声明和函数表达式创建函数的区别

函数声明存在函数提升，可以先写调用再写创建；

函数表达式只是变量声明提升，必须先写创建再写调用

(2)匿名函数自调用

目的是为了防止全局污染

(function(a){
  var num = 4;
  console.log(num,a);
})(20);//传参

(3)回调函数

将函数作为参数来传递到另一个函数

function a(x){
  console.log('1');
  console.log('2');
  //x=b
  //x=function(){}
  //传递的函数需要通过形参来接收，通过形参来调用
  x();//相当于dong() // (function(){})()
}
function b(){
  console.log('3');
  console.log('4');
}
//把函数dong作为实参传递，dong就是回调函数
a(b);
//把匿名函数作为实参传递
a(function(){
  console.log('5');
});

6.系统函数

(1)isNaN()

判断一个值是否为NaN，会隐式转换为数值型，是NaN -> true 不是NaN -> false

var a = '2';
console.log( isNaN(a) );

(2)isFinite()

判断一个值是否为有限值，只有Infinity是无限值，其它都是有限值 2/0 -> Infinity

console.log(-2/0);//Infinity 无限值
console.log(2/3);
//是否为有限值
console.log( isFinite(2/0) );//false
console.log( isFinite(2/3) );//true

(3)eval()

执行字符串表达式

var str = 'parseInt(5.5)';
console.log(str);//parseInt(5.5)
console.log( eval(str) );//5

12.对象

是一组属性和方法的集合 万物皆对象

一部手机，属性有颜色、品牌、CPU、内存... 方法有打电话、发短信、玩游戏、看视频、办公...

1.JS中的对象

• 自定义对象：用户自己创建的对象
• 内置对象：JS提供的对象
• 宿主对象：根据不同的执行环境划分

2.自定义对象创建方式

• 对象字面量
• 内置构造函数
• 自定义构造函数

3.对象字面量

{ 属性名1: 属性值1, 属性名2: 属性值2.... }

属性名的引号可以省略，如果含有特殊字符必须添加

//对象字面量
var phone = {
  brand: '华为',
  color: '黑色',
  'size': 6.18,
  'made-in': '中国'
};

4.访问属性

• 对象.属性名

• 对象['属性名']

• 如果访问没有的属性，则返回undefined

  //访问属性
  console.log(laptop.lid);
  console.log(laptop['is-onsale']);
  console.log(laptop['price']);
  console.log(laptop.memory);
  

5.内置构造函数

new Object() 创建一个空对象，需要单独的添加每个属性

//内置构造函数
var emp = new Object();
//需要单独添加属性
emp.eid = 1;
emp.ename = '涛哥';
emp['sex'] = '男';

6.遍历属性

var student = {
  sid: 1,
  name: 'dong',
  sex: '男',
  score: 82
};
//遍历   键值对
for(var k in student){
    //k代表属性名
  console.log(k,student[k]);
}

7.检测属性是否存在

• 对象.属性名 === undefined 存在 -> false 不存在 -> true

• 对象.hasOwnProperty('属性名') 存在 -> true 不存在 -> false

• '属性名' in 对象 存在 -> true 不存在 -> false

  //检测属性是否存在 对象.属性名 === undefined 存在 false 
  var person = {
      name : 'x',
      sex : '1'
  };
  
  console.log(person.age === undefined);
  //检测属性是否存在 对象.hasOwnProperty('属性名') 存在 true 
  console.log(person.hasOwnProperty('age'));
  
  //检测属性是否存在 '属性名' in 对象 存在 true 
  console.log('age' in person);
  

8.对象中的方法

方法对应的是一个函数

var person = {
    name : 'hui',
    //成员方法
    play : function(){
        //this 指代调用方法的对象
        console.log(this.name + 'tai');
    },
    play2 : function(a,b){
        return a + b;
    }
};
console.log(person);
person.play();
console.log(person.play2(1,2));

13.数据的存储

• 原始类型，将数据直接存储在栈内存；

• 引用类型，将数据存储在堆内存中，然后自动生成一个16进制地址，然后将地址保存在栈内存

//原始类型
var a = 1;
//把a的值拷贝一份，再赋给b
//a和b都是独立的
var b = a;
a = 2;
//console.log(a,b);

var ming = {
  color: '绿色',
  size: 'XL'
};
var hong = ming;
hong.color = '红色';
ming.size = 'XXL';
console.log(ming);
console.log(hong);
//两个对象比较的是地址
console.log(ming === hong);

var p1 = {price: 5000};
var p2 = {price: 5000};
console.log(p1 === p2);

//var fn1=function(){}
function fn1(){
  console.log(1);
}
//两者指向同一个函数
var fn2=fn1;
//fn1 = 2;
console.log(fn2);
console.log(fn1);
//引用类型的数据，如果没有被任何地址所指向就会自动销毁
//null 空地址，没有指向任何堆内存的数据
//如果赋值为null，用来销毁一个引用类型的数据
fn1=null;
fn2=null;

14.数组

就是一组数据的集合

1.字面量创建数组

[ 元素1, 元素2 ... ]

//创建数组
//字面量
var arr = ['a','b',20,true,null,{}];
//console.log(arr);

2.访问数组元素

数组[下标]

下标：自动为每个元素添加的编号，从开始的整数

如果访问不存在的元素，则结果为undefined

var title = [
  '华为',
  '小米Air',
  '戴尔燃'
];
//下标：自动为每个元素添加的编号，从0开始的整数
console.log( title[3] );//undefined
title[0] = '荣耀';
title[3] = '联想';
title[6] = '苹果';

3.数组的长度

数组.length 获取数组元素的数量

在数组末尾添加元素 数组[ 数组.length ] = 值

var country = ['瓦坎达','日本','印度','土耳其'];
//用长度作为下标
country[ country.length ] = '美国';
country[ country.length ] = '英国';
country[ country.length ] = '德国';
//获取数组长度
console.log( country.length );
console.log(country);

4.内置构造函数创建数组

new Array(元素1,元素2,...)

new Array(4) 创建数组，初始化长度为4，可以添加更多个元素

//构造函数
var arr = new Array('阿里巴巴','腾讯','京东');
var arr2 = new Array(4);

5.数组的分类

索引数组：以0及以上的整数作为下标

关联数组：以字符串作为下标，只能单独的添加元素

关联数组不能使用length属性获取数组的长度

//索引数组
//关联数组：以字符串作为下标
var arr = [];
arr['id'] = 9;
arr['title'] = '标题1';
arr.ctime = '2021-6-15';
console.log(arr);

6.遍历数组元素

依次访问数组中的每个元素

for-in for(var k in 数组)

循环 —— 推荐用法 for(var i=0;i < 数组的长度;i++)

var arr = ['a','b','c','d'];
//遍历
for(var k in arr){
  //k 下标
  //arr[k] 元素
  console.log(k,arr[k]);
}

//练习：使用for循环遍历数组，0~3循环
var arr = ['a','b','c','d','e','f','g'];
for(var i = 0;i < arr.length;i++){
  //i 下标
  //arr[i]  元素
  console.log(i, arr[i]);
}

7.API

应用程序编程接口：JS中预定义的函数或者对象下的方法

toString() 将数组转为字符串

var arr = ['a','b','c'];
//数组转为字符串
console.log( arr.toString() );//'a,b,c'

join('-') 将数组转为字符串，默认用逗号分割元素，可以指定分割符号

var arr = ['a','b','c'];
console.log( arr.join('-') );

concat(arr2,arr3...) 拼接多个数组，arr2，arr3代表要拼接的数组

var arr1 = ['a','b','c'];
var arr2 = ['d','e','f'];
var arr3 = ['g','h','i'];
//拼接多个数组
console.log( arr1.concat(arr2,arr3) );

API:https://www.w3school.com.cn/jsref/jsref_obj_array.asp

8.二维数组

对数据进行二次分类

//二维数组
var arr3 = [
    ['a','b','c'],
    ['d','e','f'],
    ['g','h','i']
];
console.log(arr3[2][1]);

15.字符串对象

1.包装对象：

目的是为了让原始类型的数据像引用类型的数据一样，具有属性和方法，一共三种包装对象，字符串对象，数值对象，布尔对象

new String() 将数据强制转换为字符串，返回对象

String() 将数据强制转换为字符串，返回字符串

var str1 = '1';//自面量
//构造函数
var str2 = new String(1);
var str3 = String(1);
console.log(str1);
console.log(typeof str2,str2);
console.log(typeof str3,str3);

var arr = null;
//将特定的数据转
console.log(arr.toString());
//不限数据类型
console.log(String(arr));

2.转义字符

转换字符本身的意义

' 将具有特殊意义单引号转为普通引号

\n 将普通的字符n转义为换行符

\t 将普通的字符t转义为制表符(tab键效果)

//转义字符\
console.log('It\'s a dog');
//换行符
console.log('a\nd');

//tab
console.log('a\td');
console.log('C:\\Users\\web');

3.API

https://www.w3school.com.cn/jsref/jsref_obj_string.asp

var str = 'javascript';
//获取字符串长度
console.log(str.length);
//通过下标找字符
console.log(str.charAt(8));
console.log(str.charAt(4),str[4]);
//遍历字符串 查a出现次数
var count = 0;
for (let i = 0; i < str.length; i++) {
    if (str[i] === 'a') {
        count++
    }
    
}
console.log(count);
//查找满足条件的第一个
console.log(str.indexOf('s'));
//查找满足条件的最后一个
console.log(str.lastIndexOf('a'));

//邮箱 没有@ 打印非法邮箱  或合法邮箱
var email = 'liu0320@163.com';
var flg = email.indexOf('@')
if (flg === -1) {
    console.log('非法邮箱');
} else {
    console.log('合法邮箱');
}

//英文字母大小写转化
var str2 = 'JavaScript';
console.log(str2.toUpperCase());
console.log(str2.toLowerCase());

//截取字符串
console.log(str2.slice(4));
console.log(str2.slice(4,7));
console.log(str2.slice(-3,-1));

//分别截取出 邮箱的用户名  域名
var index = email.indexOf('@')
console.log(email.slice(0,index));

console.log(email.slice(index+1));

//substr
console.log(str2.substr(0,2));
console.log(str2.substr(-3,2));
//身份证号码 出生年月  性别（倒数第二） 奇数男 偶数女 
// xxxx年 xx月 xx日 性别x
var id = '210682199511230029' 
var birthday = id.substr(6,4) + '年' + id.substr(10,2) + '月' + id.substr(12,2) + '日';
var sex = id.substr(-2,1);
 if (sex % 2 === 0) {
     sex = '女';
 } else {
     sex = '男';
 }
sex = sex % 2 ? '男' : '女'
console.log(birthday + '性别：' + sex);

//数组转字符串
var arr = ['a','b','c']; 
console.log(arr.join('-'));

//字符串转数组
var str3 = 'a-b-c';
console.log(str.split('-'));

//获取后缀名
var img = 'abx.123.tt.jpeg';
var arr = img.split('.');
console.log(arr[arr.length-1])

//反转字符串
var arr2 = str.split('');
console.log(arr2.reverse().join(''));

16.Math对象

不需要创建，可以直接使用API

https://www.w3school.com.cn/jsref/jsref_obj_math.asp

console.log(Math.PI);
//绝对值
console.log(Math.abs(-1));
//向上取整
console.log(Math.ceil(5.1));
console.log(Math.ceil(-5.1));
//向下取整
console.log(Math.floor(5.9));
console.log(Math.floor(-5.9));
//四舍五入取整
console.log(Math.round(3.5));
//获取一组数字的最大值
console.log(Math.max(23,9,78,6,45));
//获取一组数字的最小值
console.log(Math.min(23,9,78,6,45));
//计算x的y次方
console.log(Math.pow(5,3));
//随机
console.log(Math.random());

var arr3 = ['a','b','c','d','e','f','g','h'];
//0 - 9之间的随机整数
var n = Math.floor(Math.random()*8);
console.log(arr3[n]);

17.Date对象

用于对日期时间的存储和计算

1.创建

• new Date('2021/6/17 10:20:30')
• new Date(2021,5,17,10,20,30) 月份范围0~11 代表1~12月
• new Date(1683036000000) 存储距离计算机元年的毫秒数对应的日期时间
• new Date() 存储当前操作系统的时间

//创建时间对象
var d1 = new Date('2021/6/17 10:20:45');
console.log(d1);
//月份 0-11  对应 1- 12
var d2 = new Date(2021,5,17,10,20,30);
console.log(d2);
//距离计算机元年的毫秒数对应的日期时间
var d3 = new Date(1608336000000);
console.log(d3);
//获取当前系统时间
var d4 = new Date();
console.log(d4);

2.获取

• getFullYear/getMonth/getDate
• 月份范围0~11 对应1~12月
• getHours/getMinutes/getSeconds/getMilliseconds(毫秒)
• getTime 获取距离计算机元年毫秒数
• getDay 获取星期 范围0~6 对应星期日~星期六

//获取
console.log(d1.getFullYear());
console.log(d1.getMonth()+1);
console.log(d1.getDate());
console.log(d1.getHours());
console.log(d1.getMinutes());
//获取距离计算纪元年毫秒数
console.log(d1.getTime());

//星期 0-6 星期日-星期六
console.log(d1.getDay());

3.转为本地字符串格式

存在兼容性问题，用于测试

• toLocaleString() 获取完整的
• toLocaleDateString() 获取日期部分
• toLocaleTimeString() 获取时间部分

//转为本地字符串格式
var d = new Date();
console.log(d.toLocaleString());
console.log(d.toLocaleDateString());
console.log(d.toLocaleTimeString());

4.修改

• setFullYear()/setMonth()/setDate()
• setHours()/setMinutes()/setSeconds()/setMilliseconds()
• setTime() 设置距离计算机元年毫秒会，产生具体的日期时间

//修改
var d2 = new Date('2021/6/17 14:35:40');
//修改年份
d2.setFullYear(2024);
//修改月 0 - 11
d2.setMonth(12);
//日期
d2.setDate(27);
//星期不许修改
d2.setHours(17);
d2.setTime(1932878450000);

18.Number对象

• new Number() 将数据转为数值型，返回对象
• Number() 将数据转为数值型，返回数值
• toFixed(n) 强制保留小数点后n位
• toString(n) 强制转为字符串，可以通过n设置进制

//字面量
var n1 = 1;
//number 对象
var n2 = new Number(n1);

var n3 = Number(true);
console.log(n1,typeof n1)
console.log(n2,typeof n2)

console.log(n1+2,n2+2)

console.log(n3);

//保留小数点后n位
var n = 2*3.14*5;
console.log(n.toFixed(2));
//强转字符串 可以设置进制
var num = 12;
console.log(num.toString(2));

19.Boolean对象

• new Boolean() 将数据转为布尔型，返回对象
• Boolean() 将数据转为布尔型，返回布尔型数据

var b1 = true;
//false : 0 NaN '' undefined null
var b2 = new Boolean(0); //返回对象

var b3 = Boolean(5);//返回boolean

var b4 = new Boolean([]);
var b5 = new Boolean({});

console.log(b1);
console.log(b2);
console.log(b3);
console.log(b4);
console.log(b5);
//隐式转换为boolean
console.log(!!{});

20.错误处理

1.常见的错误

• 语法错误(SyntaxError)：出现了中文符号，缺少括号等
• 引用错误(ReferenceError)：使用了未声明的变量
• 类型错误(TypeError)：函数或者对象下的方法找不到
• 自定义错误：程序员自己指定的错误 throw 错误内容

2.错误处理

//错误处理 出现错误不影响后面代码的执行
var age = 75;
try {
    if(age > 60 || age < 18){
        //自定义错误
        throw '非法年龄';
    }
} catch (error) {
    //捕获错误 try出错才会执行
    //error会保存错误信息
    console.log(error);
    age = 20;
}

console.log(age)