/*P95-内置对象Number*/
//JS内置一些对象，方便对数据结构进行操作
//比如，数学，日期，集合等等
/*Number对象可以把字符串转换成数字，对数字精度进行操作
//使用时可以省掉Number，直接使用方法。Number.parseInt和parseInt()是一样的。
//老师说，JS的顶级对象包括这个parseInt()函数,所以，可以省掉Number.parseIne()中的'Number.'。
var strNum='15';
var num = Number.parseInt(strNum);
console.log(strNum);//15//控制台显示黑色
console.log(num);//15//控制台显示蓝色表示数字
console.log(typeof num);//number
//parFloat()把代表小数的字符串转换成float类型
var strNum='12.34';
var num = Number.parseFloat(strNum);
console.log(strNum);//12.34//控制台显示黑色
console.log(num);//12.34//控制台显示蓝色表示数字
console.log(typeof num);//number
//如果两个错用呢？
//15使用parseFloat(),结果和parseInt一样
var strNum='15';
var num = Number.parseFloat(strNum);
console.log(strNum);//15//控制台显示黑色
console.log(num);//15//控制台显示蓝色表示数字
console.log(typeof num);//number
//12.34使用parseInt(),结果变成12,丢失了小数部分
var strNum='12.34';
var num = Number.parseInt(strNum);
console.log(strNum);//12.34//控制台显示黑色
console.log(num);//12//控制台显示蓝色表示数字
console.log(typeof num);//number
/** */
/*NaN
//如果字符串不是数字样式的，返回NaN
//NaN本身是nubmer类型，通过typeof可知
//使用parseInt()和parseFloat()结果是一样的
var strNum='hello';
var num = Number.parseInt(strNum);
var num2=Number.parseFloat(strNum);
console.log(strNum);//hello//控制台显示黑色
console.log(num);//NaN//控制台显示蓝色表示数字
console.log(typeof num);//number
console.log(strNum);//hello//控制台显示黑色
console.log(num2);//NaN//控制台显示蓝色表示数字
console.log(typeof num2);//number
//判断变量是否为NaN,可以使用isNaN()函数
//Number.parseInt和parseInt()是一样的。
var strNum='abc';
var num = parseInt(strNum);
console.log(num);//NaN
console.log(isNaN(num));//true
console.log(typeof num);//number
console.log(isNaN(123));//false//数字不是NaN,可以理解为number=NaN+123
/** */
/*Number对象提供的转换精度的方法
//toFixed()可以设置一个小数保留几位小数
//Number.prototype提供的方法，所以需要一个数字对象来调用
//返回的是“字符串”，四舍五入的方式处理末位
var num = 12.33645;
var numStr=num.toFixed(2);
console.log(numStr);//12.34//因为小数第三位是6四舍五入到第二位3+1=4
console.log(typeof numStr);//string//toFixed()返回的是字符串不是数字！
/** */
/*Number的其他属性
//获取做大的不会溢出的整数
console.log(Number.MAX_SAFE_INTEGER);//9007199254740991
console.log(Number.POSITIVE_INFINITY);//Infinity
console.log(Number.NEGATIVE_INFINITY);//-Infinity
/** */
/*P96-内置对象-Math
//Math进行数学操作
//VH：调用时，需要'Math.'这样的样式，不能直接使用函数
//console.log(PI);//Uncaught ReferenceError: PI is not defined
//PI，就是圆周率
console.log(Math.PI);//3.141592653589793
//绝对值abs();
console.log(Math.abs(-6));//6
//sin()注意参数是PI代表180º
//https://blog.csdn.net/kkhk04/article/details/90447553
//PI就是圆周率π，PI是弧度制的π,也就是180°，Math.PI = 3.14 = 180°
//PI是一个浮小数
console.log(Math.sin(Math.PI/2));//1//代表sin90º
//floor()向下取整
console.log(Math.floor(3.98));//3
//ceil()向上取整
console.log(Math.ceil(3.1));//4
//pow()指数运算
console.log(Math.pow(10,3));//1000
//trunc()截短，保留整数部分
console.log(Math.trunc(2.645));//2
//random()返回随机数，生成0-1之间的随机数，次次不一样
console.log(Math.random());//0.6703508132506062
console.log(Math.random());//0.050737761906849865
console.log(Math.random());//0.14662200347888676
/** */
/*P97-内置对象-Date
//获取当前时间或设置新的时间
var date = new Date();
console.log(date);//Tue Feb 08 2022 17:35:17 GMT+0800 (中国标准时间)
console.log(date.getFullYear());//2022
console.log(date.getMonth());//1//表示2月，从0开始计算的
console.log(date.getDay());//2//表示周内的第几天，从周一开始算
console.log(date.getDate());//8//表示月内第几天，从1号开始
console.log(date.getHours());//17//表示当前几点
console.log(date.getMinutes());//35//表示当前几分
console.log(date.getSeconds());//17//表示当前几秒
console.log(date.getTime());//1644312917178//时间戳
//toLocaleDateString()本地的日期格式，
//更多参考网站根据本地时间把 Date 对象的日期部分转换为字符串【https://www.runoob.com/jsref/jsref-tolocaledatestring.html】
//老师的打印结果是2/22/2020,这应该是美国的格式
//老师的date值是Sat Feb 22 2020 15：43：10 GMT+0800(China Standard Time)
//说明date永远是所在时区，但是toLocaleDateString()是使用电脑系统中设置的地区的显示格式
console.log(date.toLocaleDateString());//2022/2/8
//设置时间，使用对应的set方法，如setFullYear()
date.setFullYear(2023);//可以设置date的值，这里只设置fullyear的值
console.log(date.toLocaleDateString());//2023/2/8//打印出来已经变更为2023年，其他部分未变
date.setTime(1044315917178);//变动过数字的时间戳（从上面例子复制过来的）
console.log(date.toLocaleDateString());//2003/2/4
//自己测试其他对应的设置函数
date.setMonth(3);
console.log(date.toLocaleDateString());//2003/4/8//打印出来已经变更为4月，其他部分未变
/** */
/*P98-内置对象-JOSN对象介绍*/
//特殊格式的字符串，用于服务间交换数据
//比如前台请求后台数据，后台返回的往往是JSON格式的数据
//JSON格式的数据和JS对象的结构类似，因为它本身就是JS对象标记， JavaScript Object Notation
//JSON支持的数据类型有：对象，数组，数字，字符串，Boolean，还有Null类型
//key必须使用双引号
//JSON.parse(),把JOSN格式变量转换成对象
/*以一篇文章为例
var postJSON=`{
"id":1,
"title":"标题",
"comments":[
{
"userId":1,
"comment":"评论1"
},
{
"userId":2,
"comment":"评论2"
}
],
"published":true,
"author":null
}`;
console.log(JSON.parse(postJSON));
/*
{id: 1, title: "标题", comments: Array(2), published: true, author: null}
author: null
comments: (2) [{…}, {…}]
id: 1
published: true
title: "标题"
__proto__: Object
*/
/** */
/*测试JSON的key使用单引号，似乎不可以,经测试value值也只能用双引号
var postJSON=`{
'id':1,
'title':'标题',
'comments':[
{
'userId':1,
'comment':'评论1'
},
{
'userId':2,
'comment':'评论2'
}
],
'published':true,
'author':null
}`;
console.log(JSON.parse(postJSON));//标号206
/*
VM3228:2
Uncaught SyntaxError: Unexpected token ' in JSON at position 6
at JSON.parse (<anonymous>)
at index.js:206
*/
/*测试value值使用单引号，JSON的value值也只能是双引号
var postJSON=`{
"id":1,
"title":'标题',
"comments":[
{
"userId":1,
"comment":'评论1'
},
{
"userId":2,
"comment":'评论2'
}
],
"published":true,
"author":null
}`;
console.log(JSON.parse(postJSON));//标号232
/*
VM3624:3 Uncaught SyntaxError: Unexpected token ' in JSON at position 26
at JSON.parse (<anonymous>)
at index.js:232
*/
/** */
/*使用JSON.stringify()，把对象转换成JSON
var person = {
id:1,
name:'峰华',
skills:['React','Java']
};
console.log(person);
/*以下是对象的格式：
{id: 1, name: "峰华", skills: Array(2)}
id: 1
name: "峰华"
skills: (2) ["React", "Java"]
__proto__: Object
*/
/** */
/*使用JSON.stringify()将对象转换成JSON字符串
console.log(JSON.stringify(person));
/*以下是JSON字符串的格式
{"id":1,"name":"峰华","skills":["React","Java"]}
*/
/** */
/*JSON.stringify()添加第三个参数格式化，缩进2个空格
//老师说这里第二个参数暂时用不到，用null代替
console.log(JSON.stringify(person,null,2));
/*以下是JSON字符串2个空格的格式化的样式
{
"id": 1,
"name": "峰华",
"skills": [
"React",
"Java"
]
}
*/
/** */
/*JSON的顶级定义也可以是数组
var comments=`[
{
"userId":1,
"comment":"评论1"
},
{
"userId":2,
"comment":"评论2"
}
]`;
console.log(JSON.parse(comments));
/*
(2) [{…}, {…}]
0: {userId: 1, comment: "评论1"}
1: {userId: 2, comment: "评论2"}
length: 2
__proto__: Array(0)
*/
/** */
/*VH补充：JS数组也可以变成JSON样式
//老师没有举例，只提了一下。
var fruits=['apple','banana','orange','pineapple'];
console.log(JSON.stringify(fruits));
console.log(fruits);
/*
["apple","banana","orange","pineapple"]
(4) ["apple", "banana", "orange", "pineapple"]
*/
/** */
/*P99-内置对象-set*/
//set是一种没有重复元素的集合
//可以对它进行添加，删除，清空，遍历元素等操作
/*使用add()方法添加元素
//？是不是没有字面值的方法呢？
var set = new Set();
set.add(1);
set.add(2);
set.add(3);
console.log(set);//Set(3) {1, 2, 3}
/** */
/*重复添加的话，添加不进去的。
var set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.add(3);
console.log(set);//Set(3) {1, 2, 3}//没有变
/** */
/*判断set中是否有某个特定的元素
var set = new Set();
set.add(1);
set.add(2);
set.add(3);
console.log(set.has(3));//true
console.log(set.has(4));//false
/** */
/*遍历元素
//forEach()方法
//和数组类似，第一个元素是value值
var set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.forEach(value=>{
console.log(value);
});
/*
1
2
3
*/
/** */
/*VH:测试是否和数组一样的提供3个参数呢【1元素2索引3本身】
var set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.forEach((value,second,third)=>{
console.log(value);
console.log(second);
console.log(third);
});
/*
1
1
Set(3) {1, 2, 3}
2
2
Set(3) {1, 2, 3}
3
3
Set(3) {1, 2, 3}
*/
/** */
/*删除delete元素
//VH：因为没有重复元素，直接把元素值作为参数
var set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.delete(3);
console.log(set);//Set(2) {1, 2}
/** */
/*清空元素
//没有返回值
//原set变成空
var set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.clear();
console.log(set);//Set(0) {}
/** */
/*对象作为set的元素
//相同内存地址的对象才是相同的set元素
//相同内容地址不同的对象，不是相同的set元素
var set = new Set();//必须先声明，不然报错是set is not defined
//定义体相同可以作为set的元素
var obj1={id:1};
var obj2={id:1};
set.add(obj1);
set.add(obj2);
console.log(set);//Set(2) {{…}, {…}}
//同一个地址的对象是无法再次添加到set中的
set.add(obj1);
console.log(set);//Set(2) {{…}, {…}}
/** */
/*P100-内置对象-Map*/
//map是一种键值对的数据结构
//与对象类似
//map的key和value可以是任意数据类型？是value吧，key不只能是名字么？
//可以使用单引号（对比JSON的key和value都必须是双引号）
//特殊注意：
//key为对象时不能直接作为delete()和get()的参数！
//key为对象和字符串时，不能直接作为has()的参数！
//感觉set，map，数组，对象各有侧重，各有特色！暂时还不能完全一一说清！
/*添加元素
var map = new Map();
map.set(1,'值1');//key是数字类型,value是字符串
map.set({key:2},'值2');//key是对象类型，value是字符串
map.set('key 3','值3');//key是字符串类型，value是字符串
console.log(map);//Map(3) {1 => "值1", {…} => "值2", "key 3" => "值3"}
/*
Map(3) {1 => "值1", {…} => "值2", "key 3" => "值3"}
[[Entries]]
0: {1 => "值1"}
1: {Object => "值2"}
2: {"key 3" => "值3"}
size: (...)
__proto__: Map
*/
/** */
/*访问
var map = new Map();
map.set(1,'值1');//key是数字类型,value是字符串
map.set({key:2},'值2');//key是对象类型，value是字符串
map.set('key 3','值3');//key是字符串类型，value是字符串
console.log(map.get(1));//值1
console.log(map.get({key:2}));//undefined//老师说这里其实是先创建了一个新对象（没有赋值给变量）
console.log(map.get('key 3'));//值3
/** */
/*对象作为map的key，需要先赋值给变量，才能访问到
//实现对象作为key的办法是，先把对象赋值给变量，map添加元素时变量作为key，遍历时参数是变量即可
var map = new Map();
var objKey ={key:2};
map.set(1,'值1');//key是数字类型,value是字符串
map.set(objKey,'值2');//key是对象类型，value是字符串
map.set('key 3','值3');//key是字符串类型，value是字符串
console.log(map.get(objKey));//值2
/** */
/*判断key是否存在
var map = new Map();
map.set(1,'值1');//key是数字类型,value是字符串
map.set({key:2},'值2');//key是对象类型，value是字符串
map.set('key 3','值3');//key是字符串类型，value是字符串
console.log(map.has(1));//true
//VH：对象和字符串作为key的时候，不能直接做has()的参数
console.log(map.has({key:2}));//false
console.log(map.has('key:3'));//false
//VH：对象作为key的时候，得使用赋值给变量的方式，has()用变量做参数
var objKey4 = {key:4};
map.set(objKey4,'值4');
console.log(map.has(objKey4));//true
//VH：字符串作为key的时候，得使用赋值给变量的方式，has()用变量做参数
var strKey5 ='key 5';
map.set(strKey5,'值5');
console.log(map.has(strKey5));//true
/** */
/*遍历map元素 */
/*forEach()方法遍历
//forEach()方法，提供2个参数：1值value2键key
var map = new Map();
map.set(1,'值1');//key是数字类型,value是字符串
map.set({key:2},'值2');//key是对象类型，value是字符串
map.set('key 3','值3');//key是字符串类型，value是字符串
map.forEach((value,key)=>{
console.log(key,value);
});
/*
1 "值1"//值1是红色
{key: 2} "值2"//值2是红色
key 3 值3////值3是黑色，且没有双引号
*/
/** */
/*迭代器访问Entries
//Entries就是单独一个键值对
var map = new Map();
map.set(1,'值1');//key是数字类型,value是字符串
map.set({key:2},'值2');//key是对象类型，value是字符串
map.set('key 3','值3');//key是字符串类型，value是字符串
var iterator = map.entries();
console.log(iterator);
//以下是打印结果，第一次尝试使用``符号来展示。
var notes=`
MapIterator {1 => "值1", {…} => "值2", "key 3" => "值3"}
[[Entries]]
0: {1 => "值1"}
1: {Object => "值2"}
2: {"key 3" => "值3"}
__proto__: Map Iterator
[[IteratorHasMore]]: true
[[IteratorIndex]]: 0
[[IteratorKind]]: "entries"`;
//展示单独一个entry，使用next()方法
//打印结果是按调用次数返回map的entries
//3对可以调用4次，最后一次的done:true,表示迭代器访问完毕。4次之后结果和4次一样
//继续可以查看entry的value,会以数组的形式返回
console.log(iterator.next());//{value: Array(2), done: false}
console.log(iterator.next().value);//{value: Array(2), done: false}
console.log(iterator.next());//{value: Array(2), done: false}
console.log(iterator.next());//{value: undefined, done: true}
console.log(iterator.next());//{value: undefined, done: true}
var notes=`
//使用next()按顺序查看entry
{value: Array(2), done: false}
done: false
value: (2) [1, "值1"]
__proto__: Object
//查看entry的value，以数组返回
(2) [{…}, "值2"]
0: {key: 2}
1: "值2"
length: 2
__proto__: Array(0)
//一共3个entries，第三个的done，依然false
{value: Array(2), done: false}
done: false
value: (2) ["key 3", "值3"]
__proto__: Object
//一共3个entries，第四个的done，才是true
{value: undefined, done: true}
done: true
value: undefined
__proto__: Object
`;
/** */
/*forof遍历map
//使用解构的方式
//老师说，因为map的entries的value也是数组的形式，可以解构
var map = new Map();
map.set(1,'值1');//key是数字类型,value是字符串
map.set({key:2},'值2');//key是对象类型，value是字符串
map.set('key 3','值3');//key是字符串类型，value是字符串
for (let[key,value] of map){
console.log(key,value);
}
var notes=`
1 "值1"
{key: 2} "值2"
key 3 值3
`;
/** */
/*删除元素
//delete()方法
//key为对象时不能直接作为delete()和get()的参数！
//key为对象和字符串时，不能直接作为has()的参数！
var map = new Map();
map.set(1,'值1');//key是数字类型,value是字符串
map.set({key:2},'值2');//key是对象类型，value是字符串
map.set('key 3','值3');//key是字符串类型，value是字符串
//key是数字时，数字可以直接作为delete()的参数
map.delete(1);
console.log(map);
var notes=`
Map(2) {{…} => "值2", "key 3" => "值3"}
[[Entries]]
0: {Object => "值2"}
1: {"key 3" => "值3"}
size: (...)
__proto__: Map`;
//key为对象时不能直接作为delete()和get()的参数！
//下例并没有删除entry【key是{key:2}】
//必须先把对象赋值给变量，用变量作为set()的参数添加后，再使用变量作为delete()的参数删除
map.delete({key:2});
console.log(map);
var notes=`
Map(2) {{…} => "值2", "key 3" => "值3"}
[[Entries]]
0: {Object => "值2"}
1: {"key 3" => "值3"}
size: (...)
__proto__: Map`;
//key是字符串时，字符串可以直接作为delete()的参数
map.delete('key 3');
console.log(map);
var notes=`
Map(1) {{…} => "值2"}
[[Entries]]
0: {Object => "值2"}
size: (...)
__proto__: Map`;
//key为对象时不能直接作为delete()和get()的参数！
//下例并没有删除entry【key是{key:2}】
//必须先把对象赋值给变量，用变量作为set()的参数添加后，再使用变量作为delete()的参数删除
var objKeyDel ={key:5};
map.set(objKeyDel,'值Del');
console.log(map);
var notes=`
Map(2) {{…} => "值2", {…} => "值Del"}
[[Entries]]
0: {Object => "值2"}
1: {Object => "值Del"}
size: (...)
__proto__: Map`;
map.delete(objKeyDel);
console.log(map);
var notes=`
Map(1) {{…} => "值2"}
[[Entries]]
0: {Object => "值2"}
size: (...)
__proto__: Map
`;
/** */
扫一扫 手机查看