JS内置对象的Math属性
概念：Math是一个内置对象，它拥有一些数学常数属性和数学函数方法，它不是一个函数对象，所以不需要 new来调用
1.Math.ramdom
作用：返回一个0-1之间的随机数
语法：consolo.log(Math.ramdom（）)
例如：生成一个1000到2000之间的随机数
consolo.log(Math.ramdom（）*1001+1000)
2.Math.PI
作用：返回圆周率
语法：consolo.log(Math.PI（）) 返回3.1415926
3.Math.max Math.min
作用：返回一组数据中的最大值和最小值
语法：consolo.log(Math.max（1,2,3）)返回3 consolo.log(Math.min（1,2,3）) 返回1
4. Math.abs
作用：返回绝对值
语法：consolo.log(Math.abs（-1）) 返回1
如果consolo.log(Math.abs（'-1'）) 字符串也会返回1
5.Math.floor Math.ceil
作用：向下取整 向上取整
语法： consolo.log(Math.floor（1.1）) consolo.log(Math.floor（1.9）) 都返回1
consolo.log(Math.floor（1.1）) consolo.log(Math.floor（1.9）) 都返回2
6.Math.round
作用：四舍五入
语法：consolo.log(Math.round(1.1)) 返回1 consolo.log(Math.round(1.9)) 返回2
7.Math.pow
作用：次幂
语法：consolo.log(Math.pow(2,2)) 返回2的2次方 4
8.Math.sqrt
作用：开平方根
语法：consolo.log(Math.sqrt(25)) 返回5
Js内置对象之Date属性
内置对象Date,是一个构造函数，必须用new 调用
例如：
1. let date = new Date();
console.log(date); //不写参数就是返回系统当前日期
2.let date = new Date('2021-11-15');
console.log(date);
属性：
一、getXXX() 方法 get方法用于获取当前时间
let date=new Date()
1. getFullYear
console.log (date.getFullYear( ) ) 返回当前年份
2. getMonth
console.log('月份：' + (date.getMonth ( ) + 1)); 返回当前月份 一定要+1 它是从0开始
3. getDate
console.log( date.getDate( ) );返回当前几号
4.getDay
console.log(date.getDay( ) );返回当前周几 0是周日 0-6
5.getHours
console.log(date.getHours( ) ); 返回当前小时
6.getMinutes
console.log(date.getMinutes( ) ); 返回当前分钟
7.getSeconds
console.log(date.getSeconds( ) );返回当前秒数
8.getMilliseconds
console.log(date.getMilliseconds( ) ); 返回当前毫秒数
二、setXXX()方法 用于修改日期， 语法格式与get一样
三、时间戳
获取的毫秒总数是距离 1970年1月1日开始算
1. 通过 valueOf() 和 getTime()获取毫秒数
let date = new Date();
console.log(date.valueOf( ) );
console.log(date.getTime( ) );
2.简单写法 +new Date()
let date = +new Date(); new Date前面加个 +号
console.log(date);
3.H5新增的 获得总的毫秒数 低版本不支持
console.log(Date.now());
四、时间运算
两个时间可以进行加减法运算
例如：
let d1 = new Date('1992/5/28') 注意：此处格式没有明确要求 ，用'-' '@' '#' '*' 皆可
let d2 = new Date()
let time = d2 - d1 可以直接进行减法运算
console.log(time); 获取到毫秒数，再进行转换即可
console.log('秒数：' + Math.floor(num / 1000)); 返回秒数
console.log('分钟：' + Math.floor(num / 1000 / 60)); 返回分钟
console.log('小时：' + Math.floor(num / 1000 / 60 / 60)); 返回小时
console.log('天数：' + Math.floor(num / 1000 / 60 / 60 / 24)); 返回天数
五、星期几汉化处理
用getDay获取到的周几是阿拉伯数字，一般我们写星期几都是大写，例如：星期三而不是星期3
解决办法：
如果要用汉字，加一个数组
let arr = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'];
let day = date.getDay(); 获取到周几就是数组的索引号
console.log(`今天是${year}年${month}月${dates}日,${arr[day]}`); 直接索引即可
箭头函数
ES6推出了定义函数的简写方式：箭头函数
1.在箭头函数中，如果方法体只有一条语句，可以省略大括号{}
2.在箭头函数中，如果方法只有一个参数，可以省略小括号()
3.在箭头函数中，如果方法体只有一条语句，并该语句是返回语句，那么在省略{}的同时，必须省略return关键字
例如：
let fn4 = (num1, num2) => num1 + num2
console.log(fn4(100, 200));
let fn5 = (num1, num2) => console.log(`${num1}+${num2}=${num1 + num2}`);
fn5(100, 200)
let fn6 = num => console.log(num * 3);
fn6(100)
let fn7 = () => console.log('我是箭头函数');
fn7(100)
例如：
1.判断是否是闰年的箭头函数:
let isLeapYear = (year) => (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
2.对个位数字补零的方法
let repair0 = (val) => (val < 10 ? "0" + val : val);
3.对字符串反转的方法
let reverseStr = (str) => str.split('').reverse().join('');
4. 返回一个日期的两种格式格式方法
let miniDate = (date, type) => {
let year = date.getFullYear(); //年
let month = date.getMonth() + 1; //月
let day = date.getDate(); //日
let hour = date.getHours(); //时
let minute = date.getMinutes(); //分
let second = date.getSeconds(); //秒
let week = date.getDay(); //周几
//定义一个返回值，默认拼接：年，月，日
let ret = [repair0(year), repair0(month), repair0(day)].join("-");
if (type == "1") {
ret += " " + [repair0(hour), repair0(minute), repair0(second)].join(":");
} else if (type == "2") {
ret +=
" " + [repair0(hour), repair0(minute), repair0(second)].join(":") +
" 星期" +
"日一二三四五六" [week];
}
return ret ; };
值类型
值类型：
简单（一般）数据类型：
字符串（String）、数字(Number)、布尔(Boolean)、对空（Null）、未定义（Undefined）、Symbol
引用（复杂）数据类型：
对象(Object)、数组(Array)、函数(Function)，
数据类型不同，那么浏览器对其内部操作也就不大相同，尤其是对于复杂数据类型而言，很有可能造成一些不必要的麻烦，变量的值如果是一般数据类型的话，浏览器会把这个值存放到【栈】中，如果是复杂数据类型将会在【堆】中开辟一个新的空间用于单独存放，其中的【栈】和【堆】是一种概念，相当于内存中某处存放数据的地方，对于【栈】，是有一定大小空间的，如果这个数据过于庞大，比如一些数位高的惊人的数据，在处理上也会造成延误或者滞留。
比如：
let a = 100, let b = a ,那么b的结果也将等于100
let a = { name : '王二麻子' } , let b = a ,由于此时两个变量都是指向一个值，而由于对象的值是存放在【堆】里面的，【堆】会将数据的位置生成一串内部地址存放在【栈】里，a和b都指向这个地址，则此时 b的结果也将会是 { name:'王二麻子'} ,但如果此时赋值 b = { name : '路人甲' },则由于更改的是同一内存地址内的值，则这个值也会影响a的取值，此时的a也会等于 { name : '路人甲' }
闭包函数和回调函数
回调函数概念： 函数的参数callback是另一个参数，这个参数在原始数据中执行
例如：
let arr = [11, 22, 33, 44, 55, 66, 77, 88, 99]
function liFor(arr, callback) {
for (let i = 0; i < arr.length; i++) {
if (callback(arr[i])) {
console.log(arr[i]);
}
}
}
console.log('---------遍历数组----------');
liFor(arr, val => true)
console.log('---------输出奇数----------');
liFor(arr, val => val % 2 !== 0)
console.log('---------输出被3整除----------');
liFor(arr, val => val % 3 === 0)
console.log('---------输出被3和6整除----------');
liFor(arr, val => val % 3 === 0 && val % 6 === 0)
闭包函数概念：定义一个a方法，在a方法中定义一个b方法，并且b方法里面用到了a方法里面定义的变量，那么此时就形成了闭包函数，由于内部方法里面，用到外部方法里面的变量，外部方法里面的那个变量会一直在内存中存保存着。两个方法嵌套定义，里面的方法，用到了外面方法里面定义的变量，此时这两个方法就形成了闭包。
例如：
function a() {
console.log('a函数被调用了...');
let num1 = 100
let num2 = 200
function b() {
console.log('b函数被调用了...');
console.log(num1 + num2);
}
//返回的返回值也是一个函数，那么a函数就是高阶函数。
return b
}
// 通常情况下，函数执行完成后，函数里面定义的变量，会被销毁。
// a函数，已经调用完毕了，但是a函数里面定义变量，始终在内存中，因为b函数中用到了a函数中定义的变量。
// 那么此时这两个函数，就称之为：闭包函数。
let c = a()
c()
console.log('------------------------------------------');
// 闭包函数的实际案例
function calc(num1, num2, type) {
switch (type) {
case '+':
console.log(`${num1}+${num2}=${num1 + num2}`);
break;
case '-':
console.log(`${num1}-${num2}=${num1 - num2}`);
break;
}
}
// 在实际开发中，我们在做num1和num2的计算之前，可能需要先做其他事情
let num1 = 100
let num2 = 50
// 在做其他事情的过程中，我们的数据很有可能会被篡改。
console.log('查看用户是否登录');
num1 = 555
num2 = 145
console.log('检查用户的权限');
calc(num1, num2, '+') //运行结果不对，因为变量的值被篡改了。
console.log('------------------------------------------');
// 定义一个闭包函数，实现计算器功能
function myCalc(num1, num2, type) {
switch (type) {
case '+':
return function() {
return num1 + num2
}
case '-':
return function() {
return num1 - num2
}
}
}
//先准备好你的数据
let n1 = 100
let n2 = 50
//将你的数据传给计算器方法，由计算器方法，返回一个计算方法。
let js = myCalc(n1, n2, '+')
//在做具体的计算之前，还先做些其他的事情
console.log('查看用户是否登录');
n1 = 555
n2 = 145
console.log('检查用户的权限');
//其他事件准备好了后，执行计算方法
简单来说就是：先将一段数据储存起来，等到需要用的是时候再调用即可。 目的就是为了其存储的的数据不会被篡改。 提高了安全性。
分页方法
let arr = [ ];
for (let i = 0; i < 100; i++) {
arr.push('数据' + (i + 1))
}
console.log(arr);
//定义一个分页方法，方法的三个参数分别是：原始数据，页码，每页数量
function pageDate(arr, pageIndex, pageSize) {
//思路就是对原始数据进行截取
let start = (pageIndex - 1) * pageSize //第三页下标就是pageIndex - 1，然后乘以后面要显示多少数据 算出开始截取的位置的下标，下标20就是数据21
// 定义截取的结束位置
let end = start + pageSize //结束位置就是 20+10=30,取不到下标30的数据31
return {
//定义返回的数据
date: arr.slice(start, end),
//总数量
count: arr.length,
//总页数 向上取整
totalPage: Math.ceil(arr.length / pageSize),
pageIndex: pageIndex,
pageSize: pageSize,
}
}
let arr2 = pageDate(arr, 3, 10)
console.log(arr2); //最后截取的就是数据21-30
对象
// 对象就是拥有一组属性和方法的集合
// 如果 a.b ，那么a就是对象，b是a的属性
// 如果 a.c()，那么a就是对象，c是a的方法
// 定义对象的第一种方式：采用字面量赋值方式直接定义
let stu1 = {
//属性名:属性值的方式，定义属性
no:1001,
name:'张三',
age:20,
sex:'男',
//定义学生的方法
study:function(){
console.log('每天学习8小时');
},
play:function(){
console.log('每天玩8小时');
}
}
console.log(stu1);
//调用对象身上的属性
console.log(stu1.name);
console.log(stu1.age);
//调用对象身上的方法
stu1.study()
stu1.play()