js知识点总结
程序员文章站
2022-07-09 20:49:01
组成 作用：（运营在用户端浏览器） 特征：面向对象 BOM： 浏览器对象模型 完成窗口与窗口之间的通信，window对象是其核心对象， history【前进，后退，刷新】 是一个对象 使用【window.history】 location【地址】 DOM【】 screen【屏幕】 frames[真窗 ......
ecmascript 基础语法
变量 数据类型 运算符 数组 函数 对象
bom 浏览器对象模型
window对象（获取浏览器宽高）
history对象
location对象
dom 文档对象模型 轮播图
元素获取 操作属性 操作样式 节点 事件 时间对象
作用：（运营在用户端浏览器）
1. 数据验证
2. 动态创建和删除元素
3. 操作元素的内容和样式
4. 模拟动画
5. 创建cookie
6. ajax 请求数据
。。。。。。
7. json格式的数据处理 *
特征：面向对象
1. 基于[对象]和[事件驱动]的松散型 解释型语言
2. 客户端脚本语言，实现用户交互
完成窗口与窗口之间的通信，window对象是其核心对象，
-
history【前进，后退，刷新】 是一个对象 使用【window.history】
-
location【地址】
-
dom【】
-
screen【屏幕】
-
frames[真窗口]
-
navigation
window对象：
属性
1-1：获取浏览器宽高
a.ie8及以上
window.innerwidth [获取浏览器宽度]
window.innerheight [获取浏览器高度]
b.ie8以下
document.documentelement.clientwidth [宽度]
document.documentelement.clientheight 【高度】
1-2： 重新获取浏览器宽高
window.onreset=function () {
neww=window.innerwidth;
newh=window.innerheight;
}
1-3：重新设置浏览器大小
window.onresize=function（）{
}
1-4：浏览器滚动事件
window.onscroll=function （）{
}
2.浏览器左上角距离屏幕左上角的偏移量
window.screentop [垂直偏移量]
window.screenleft [水平偏移量]
注意：
因为window是核心，可以省略window不写
方法
alert() 弹出框
prompt() 输入框
confirm() 提示框，返回true或flase
close() 关闭页面
open(“url”) 打开页面（“打开的页面的路径【根据本html位置的相对路径】”）
open("url","","width=300,height=200");
setinterval（fn，毫秒数）：隔毫秒数重复不断的执行一个函数fn
方法1
let t =setinterval(fn,3000)
function fn(){
}
方法2
setinterval(function(){
},1000)
clearinterval（t）：清除setinterval的时间函数
let t =setinterval(fn,3000)
function fn(){
}
clearinterval（t）
settimeout（fn，1000） 隔一定的时间只执行一次函数
cleantimeout（t） 清除时间函数 【用法同上】
获取表单的值
对象.value=
清空=“”
history对象
属性：
history.length 用来显示历史记录的长度
方法
history.forward() 前进
history.back()后退
history.go(0) 刷新 【1 前进，-1后退；不常用】
location对象
属性：设计获取当前页面的地址
location.href=“ ” 设置或获取页面地址 设置新值
location.host：主机名+端口号
location.hostname：主机名
location.port：端口号
location.protocol：协议
location.pathname： 路径
location.search： ？后面的查询【搜索】字段
方法
location.reload( ) 重新加载
location.replace（"网页.html"） 页面替换，不会增加历史记录
location.assign（“网页.html”） 页面替换， 能够增加历史记录
获取元素
获取body：document.body
获取html：document.documentelement
1. 获取id名的元素：
let 变量=document.getelementbyid("id名")
例子： let box=document.getelementbyid("id名")
2.获取class名的元素[得到的是集合，可以通过键名访问]
let 对象=document.getelementsbyclassname（“class名”）
通过遍历改变样式
集合通过单个下表改变，不能全部用class名同时改变
3. 获取标签名的元素[得到的是集合，可以通过键名访问]
let 对象=document.getelementsbytagname（“标签名”）
4.给对象加类
标签加1个类名
对象.classname=“类名”
div加多个类名
对象.classname=“类名1 类名2 ”
5.指定范围的多层级获取【集合】
<div class="box">
<div class="box1">
<div class="box2"></div>
</div>
</div>
多楼层获取
let box=document.getelementclassname("box");
let box1=box.getelementclassname("box1");
let box2=box1.getelementclassname("box2")
6.获取选择器选中的元素
let liss=document.queryselector("【选择器】"); 获取选择器选中的第一个元素
let lis=document.queryselectorall("【选择器】"); 获取选择器选中的全部元素【集合】【下标或者foreach遍历】
7.属性选择器
<textarea name="con" id="text" cols="30" rows="10"></textarea>
let con = document.queryselector("[name=con]")
操作样式
获取样式
获取行内样式
对象.style.样式名
获取通用的样式【css和行内】
getcomputedstyle(对象,null).样式名
设置行内样式
对象.style.样式名=“样式值”
对象.style=“background：red；border-radius：50%”
批量操作类名
对象.classname="class类名"
对象.classname=“ ”；
对象.classlist.add（“”） 添加类
对象.classlist.remove（“”） 删除类
对象.classlist.toggle（“”） 切换类
对象.id="id名"
外部定义一个样式，加到对象身上，参考第四点
操作属性
操作标准属性
已知的，系统自带
对象.属性
例子 ： img.src
自定义属性
获取
对象.getattrbutte("name")
设置
对象.setattrbutte("name","value")
操作内容
innertext：不能识别html的标签对
innerhtml: 可以识别html的标签对
对象.innertext=“内容”
对象.innerhtml=“内容”
添加事件
对象.对象事件=function（）{
}
元素的尺寸和位置
对象.offsetwidth:获取元素的真实宽度
对象.offsetheight:获取元素的真实高度
对象.offsettop：对象的上边框距离具有定位的父元素的内边框的垂直距离
对象.offsetleft：对象的左边框距离具有定位的父元素的内边框的水平距离
对象.scrolltop：有滚动条的元素，浏览器滚动时在垂直方向的拉动距离
body的兼容
document.body.scrolltop || document.documentelement.scrolltop
对象.scrollleft：有滚动条的元素，浏览器在滚动时在水平方向的拉动距离
动态创建标签
let div=document.createelement（“标签名”）
创建的元素放到也面中：
document.body.appendchild（div）
父元素.appendchild（子元素）
引入js
1. 外部引入方式
<head>
<script src='路径'></script>
</head>
2. 内部引入方式（在html页面中放入srcipt标签，和body同级）
<script>
</script>
3. 放在事件后
<div onclick="alert(1)">文字等或事件</div>
注意：
~js的几种引入方式是相互关联的，可以相互操作与访问
~外部js中不能添加srcipt标签对
~嵌入式的js中不能添加src属性
引入js的执行
1. 将srcipt标签对放最最后
2.在.js文档中加入
window.onload=function（）{
需要执行的js代码块
}
输出工具
弹出框：alter(' '); 数字可加可不加' ';
输出到控制台：console.log('输出到控制台');
输出到html页面中[可以识别html的标签对，即解释为html语言]：document.write('<h1>输出到html页面中 </h1>');
输入工具
弹出框输入：var num=prompt("提示文本",[默认值])；
提示工具
confirm("提示内容")；
confirm返回值为true和false
注释
单行注释： ctrl+？或者/ //
块注释： ctrl+shift+/或者？ /* 块 */
拼接
1. 用“+”拼接
2. 模板字符串（es6）：
`<td>${i}-${j}</td>`; 拼接部分用``括起来，变量用 ${变量}
识别空格，换行等
变量
一个容器，存储数据
变量的声明：
var:
let:
let命令，用来声明变量。它的用法类似于var，但是所声明的变量，只在
let命令所在的代码块内有效
1. 适用于for循环
2. 先声明，在使用
3. 不允许在相同作用域内重复声明同一个变量。
4. let可以识别块级作用域
5. 不存在变量提升（先访问后声明） 报错：没有定义
const
声明一个只读的常量。一旦声明，常量的值就不能改变。
声明常量的
同时进行赋值，不赋值就会报错可以识别块级作用域
不能重复声明
不存在变量提升【先访问在声明】
pi；
命名规范：
-
数字。字母。下划线组成
-
不能以数字开头
-
区分大小写
-
不能以关键字（js中已经用到的）命名
-
不能以保留字（js中将来会用到的）命名
-
有意义
-
遵循的规则：首字母大写 （array string obiect） ；驼峰命名法 （getelementbyld）
赋值
-
先声明再赋值
var num;
num=10; -
声明的同时赋值
var num=10; -
一次性声明多个变量，再赋值
var a,b,c;
a=1,b=2;
c=3; -
一次性声明多个变量同时复制
var a=1,b=2,c=3;
注意事项：
-
变量要先声明再访问，变量的默认值是undefined
-
新值可以覆盖旧值
-
变量可以用var关键字重新声明
-
不用var关键字声明时必须给变量赋值，并且为全局变量，先访问后声明变量，值为undefined：js执行时先预解析（即识别var 和function声明的变量，不赋值），在解析，一句一句执行。
数据类型
根据在内存中的存储位置划分。基本数据类型存放在栈中，引用数据类型存放在堆中（指针存放在栈中，内容存放在堆中 ）
基本数据类型
-
undefined
-
null 【空占位符】
-
string 【也是对象】
模板字符串 字符编码 ascii utf-8 unicode【万国码】 gb2312
转义字符： \ \n[换行] \r \t[制表符] \' \ ""
let 对象=new string（“ ”）；
编码
对象.charcodeat(2) 返回第2个位置的字符编码
string.fromcharcode（字符编码） 解码
查找元素
对象.charat(0) 字符串的第0个位置的元素【查找字符】
查找下标
对象.indexof（“ ”） 查找对应字符的下标，如果有返回下标，如果没有，返回-1【第一个字符开始的下标】
对象.lastindexof（“”） 倒着看查找，倒序看如果有返回下标，如果没有，返回-1【第一个字符开始的下标】
对象.search（“”） 正则：有返回0；没有返回-1；
对象.match（“”） 有的话，返回数组【返回值，下标，包含返回值的数组，】
没有 返回null
字符串的截取：【返回新值，不改变原内容】
对象.substr（开始下标，【截取的长度】）
对象.substring（开始下标，结束的下标），从开始下标开始到结束下标之前，不取到结束的下标
对象.slice（开始下标，结束的下标），从开始下标开始到结束下标之前，不取到结束的下标【数组的方法】
字符串大小写【转换】
let str="abcdef";
str.tolowercase() 转换为小写
str.touppercase() 转换为大写
替换：
str.replace（“山”，“闪”）；
转换【字符串转换数组】
let str=“1,2,3,4,5,6”；
arr2=str.split（“，”）； -
boolean
-
number 2e3=2*10^3
二进制： 0b开头
八进制：以0o{0+字母o}开头，后跟0-7的数
十六进制：以0x开头，后跟0-9或者a-f
nan:not a number 本来期望返回数值的操作，但并未返回数值的操作
引用数据类型
-
object（属性与方法的集合）数组，函数，对象
-
深拷贝
let arr=【1,2,3,4】
let arr1；
arr1=arr； ：传址
arr1 和 arr具有相同地址 -
浅拷贝：
let arr=【1,2,3,4】
let arr1=【】
arr.foreach(function（value）{
arr1.push（value）
})
判断变量的数据类型 ，其结果为字符串
typeof用法：
var num="5555";
typeof num;
| 数据类型 | 值 | 情况 | typeof 的结果【看返回0 1代码的前三位】 |
|---|---|---|---|
| undefined | undefined | undefined | |
| null | null（空占位符） | object | |
| boolean 布尔型 | true false | boolean | |
| string 字符串型 | 带" "或者' ' | string | |
| number 数值型 | 整数，小数，八进制，十六进制，十进制 | ||
| object |
运算符
表达式：能够求值的语句
算术运算符
+ - * / % ++var var++ --var var --
+的特殊性
计算：操作对象是数值型
拼接：操作对象含有字符串，字符串中进行运算时，用（）括起来
自增与自减
++var: ++在前，先算++，在执行本行的其他语句
var++：++在后，先执行本行的其他语句，在算++
关系运算符
返回值为布尔值 ，即true或者false
> < >= <= ==[等于] ===[全等于]--> 数值和数据类型相同 !=[不等于] !==[不全等]
如果比较的两个对象都是字符串[数字型，字符]，按照ascii表对应的ascii码比较，逐位相比
如果比较的两个对象都是数值，直接比大小
如果一个操作对象是字符串，另一个是操作对象是数值，先尝试将字符串转换为数字，如果转换成功，按照数字比较大小；如果转换不成，则返回false
1==true； 0==false ； ==数值相同
=== 数值和数据类型相同
undefined=null
赋值运算符
= +=[num+=10 等价于 num=num+10] -= *= /= %=
逻辑运算符[与或非]
测量值与变量之间的逻辑关系
假：0、false undefined null nan “ ”【空字符串】
真：其余为真
-
&&与
-
||或
-
！非【用来取反】
a b a && b a || b !a true true true true false true false false true false false true false true true false false false false true
返回值：
第一步：先看与或非两边的真假
第二步：在看返回的真假的内容
&& 同真为真，返回第一个假值 【遵循短路原则：看到假值，后边的不看了】；全为真，返回最后一个真值
|| 同假为假，返回第一个真值 【遵循短路原则：看到真值，后边的不看了】；全为假，返回最后一个假值
! 取反；返回值只有ture或false
运算符的优先级
算术>关系运算符>逻辑运算符
三元运算符：
表达式?为真的执行语句：为假的执行语句 【类似if else】
一元运算符： typeof + - new
特殊运算符： （） .
流程控制
代码按照指定条件的执行顺序
-
顺序结构
-
分支结构
-
循环结构
顺序结构
语句按照从上到下的顺序进行执行
循环结构
当满足条件时，重复不断的执行一段代码
for循环：明确知道次数
for(初始条件；终止条件；步进值){
}
swith循环
switch(表达式【能够求值的语句】){
case 值1【表达式能取到的值】：语句1；break；
case 值2【表达式能取到的值】：语句2；break；
...
default: 语句；
}
while循环
while(条件){
满足条件时，执行语句；
}
例子：
var j=0；
while(j<5){
console.log(1);
j++;
}
do while循环
执行顺序先执行循环体，在执行判断语句
do{
循环体；
}while(条件)
例子：
var i=0;
do{
console.log(1);
i++;
}(i<5)
循环结束
continue
满足条件终止本次循环
break
满足条件,终止整个循环
分支结构
当条件成立时执行相应的语句
-
单分支结构
if条件：
if（表达式）{
为真的执行语句【返回值为true执行的语句】
} -
双分支
if条件：
if（表达式）{
为真的执行语句
}
else{
为假的执行语句
} -
多分支
if条件：
if（表达式1）{
表达式1成立时执行语句
}
else if(表达式2){
表达式1不成立 但 表达式2成立时执行语句
}
else if(表达式3){
表达式1不成立且表达式2不成立【但】表达式3成立时执行语句
}
else{
以上表达式都不成立时执行的语句
} -
嵌套分支
if(){
if(){
}
else{
}
}
else{
}
数学方法
取随机数
math.random() ; (0-1)
取整
向下取整【向左取整】： rgb=math.floor(math.random());
向上取整【向右取整】： rgb=math.ceil(math.random());
次幂[x的y次幂]
math.pow(x,y)
一维数组
按照顺序排列的一组相关数据。
特点：每一个数组元素都有一个特定的键名（即俗称的下标）[字符串类型]
数组元素的默认值时undefined
数组的声明[初始化数组]
-
先声明后赋值
var arr=[];
arr[0]=89,arr[0]="adc",....; -
声明的同时赋值
var arr=[90,89,88,76,56];
数组下标的范围
访问数组元素，范围【0，n-1】
数组的长度
数组名.length; 例子： arr.length
注意：
数组的长度可变
arr=[90,89,88,76,56];
可以随时添加元素，可跳着添加。如：
arr[6]="aaa"；
数组元素可以时任意的数据类型
arr=[true,null,{name:},[1,2,3]]
遍历数组元素
访问数组的每一个元素
1. 用for循环遍历数组
for(var i=0;i<arr.length;i++){
arr.[i]; 即可访问arr的每个元素
}
2. 用for in循环遍历数组
for(var i in arr){
i; //代表arr的键名（下标）
arr[i]; //元素
}
3.for of遍历元素
for（item of arr1）{
arr2.push（item）
}
4.foreach遍历数组
用法：
arr.foreach(function (value，index){
}）
value[名字随便起]:数组中的当前元素【必须有】
index[名字随便起]:数组当前元素的下标【键名】【可选】
清空数组
arr.length=0
二维数组
声明：
var arr=[[1,2.3],["a","b"],[78,89];
访问：
arr[行][列]
遍历
for(var i=0;i<arr.length;i++){
for(var j=0;j<arr[i].length;j++){
arr[i][j]
}
}
数组身上的方法
向数组的后面插入一个或多个元素（.push）
arr.push(需要插入的内容)；
删除数组最后一位：.pop
arr.pop（）
在数组之前插入: .unshift
arr.unshift("")
在数组之前删除一位：.shift
arr.shift（）
万能的插入和删除：.splice（）
arr.splice(开始的位置,长度，“再删除的位置加入的元素1”，“再删除的位置加入的元素2”，...);
不想删除，让其长度为0；
可以返回删除的值：arr.splice（）
是否包含某个元素： .includes
arr.includes（“被包含的内容”）;
截取元素： .slice
arr.slice（2,5）：截取第2位开始的。第5位之前的
连接多个数组：.concat
arr.concat([数组1],[数组2])
数组的取反：.reverse
arr.reverse()
把数组转换为字符串: .join
arr.join（“连接符（-/，/；/..）”）
排序：.sort
arr.sort（（x，y）=> x-y）; 升序
arr.sort（（x，y）=> y-x）; 降序
arr.sort(function（x，y）{
return x-y
})
查找： .find（）
arr.find(item=>item>7) 找到第一个比7大的数
arr.find(item=>item%2==0) 找第一个偶数
arr.find（function(item){
return item%2==0;
}）
查找第一个符合条件的下标： .findindex（）
let index= arr.findindex(function(item){
return item > top //返回布尔值，为真时返回下标
})
返回符合条件的真假值：.some()
arr.some（item=>item>8）;
返回每一个符合条件的元素：.every()
arr.every（item=>item<10）;
筛选符合条件的：.filter()
arr.filter（item=>item%2==0）; 返回新数组
遍历数组（.foreach）
arr.foreach
用法：
arr.foreach(function (value，index){
}）
value[名字随便起]:数组中的当前元素【必须有】
index[名字随便起]:数组当前元素的下标【键名】【可选】
处理每个元素:.map
arr.map（item=>{return item*10}） //让数组中的每个元素都执行一个函数，返回一个新数组
全部方法
| 连接两个或更多的数组，并返回结果。 | |
|---|---|
| copywithin() | 从数组的指定位置拷贝元素到数组的另一个指定位置中。 |
| 检测数值元素的每个元素是否都符合条件。 | |
| 使用一个固定值来填充数组。 | |
| 检测数值元素，并返回符合条件所有元素的数组。 | |
| 返回符合传入测试（函数）条件的数组元素。 | |
| findindex() | 返回符合传入测试（函数）条件的数组元素索引。 |
| foreach() | 数组每个元素都执行一次回调函数。 |
| indexof() | 搜索数组中的元素，并返回它所在的位置。 |
| 把数组的所有元素放入一个字符串。 | |
| lastindexof() | 返回一个指定的字符串值最后出现的位置，在一个字符串中的指定位置从后向前搜索。 |
| 通过指定函数处理数组的每个元素，并返回处理后的数组。 | |
| 删除数组的最后一个元素并返回删除的元素。 | |
| 向数组的末尾添加一个或更多元素，并返回新的长度。 | |
| 将数组元素计算为一个值（从左到右）。 | |
| reduceright() | 将数组元素计算为一个值（从右到左）。 |
| 反转数组的元素顺序。 | |
| shift() | 删除并返回数组的第一个元素。 |
| 选取数组的的一部分，并返回一个新数组。 | |
| 检测数组元素中是否有元素符合指定条件。 | |
| 对数组的元素进行排序。 | |
| 从数组中添加或删除元素。 | |
| tostring() | 把数组转换为字符串，并返回结果。 |
| 向数组的开头添加一个或更多元素，并返回新的长度。 | |
| valueof() | 返回数组对象的原始值。 |
函数
把实现某一特定功能的代码块封装起来，并能够重复调用
定义函数
1. 基本语法（function关键字）【调用可以在声明前，也可以在声明后】
function 函数名（形参1，形参2,....）{
函数体；
return 返回值；【可有可无】 《并不向用户显示，仅是调用的数的值》
}
2. 字面量，自变量【必须先声明在调用】【预解析】
var 变量=function (参数){
函数体；
}
调用 变量（）
3. 对象的方式【实例化对象】
let aa=new function（“a”，“b”，“alter（a+b）”）
调用 aa（10,20）
匿名函数定义与调用
(function (){
})()
定义：(function (){
}
调用【一般在定义的时候就调用】：
(function (){
})()
箭头函数
定义：
let aa=()=>console.log(123);
let aa=(参数)=>{
多行函数体；
}
调用：
aa(实参)
函数的调用
1. 函数名（实参1，实参2，….）
2. 自变量（）
3.自变量（参数1，参数2）
参数
能够动态改变函数体的变量，使函数更加灵活
形参：
定义函数使写在括号里的量。其作用为接收实参
形参默认值的传递
1. if else分支结构
if(flag==undefined){
}
else{
}
2. 三元运算符【用的多】
flag=flag==underfined？"<":flag
3. 逻辑或||返回第一个真值【用的多】
flag=flag||"<"
4. 定义形参的时候直接赋值:当形参为undefined时给形参默认值
flag=25555;
实参：
函数调用时写在括号中的值。其作用为给形参传值
全部的实参由arguments接收
参数传递
-
参数可以是任意的数据类型
-
参数的传递按顺序传递：从左到右
-
形参=实参 ：一一对应的传递
-
形参>实参：多余的形参赋值为undefined
-
形参<实参：实参由
arguments对象来接收
剩余参数
声明： ...rest【为数组】
function 函数名(形参1,...rest){
函数体；
}
rest和arguments对象的区别
1. rest接收多余的参数，arguments接收全部的实参
2. rest是数组，能够使用数组的方法，键名从0开始；
arguments对象类似数组，不能使用数组的方法
函数的返回值：return
return 终止函数。遇到return，后面都不执行
返回值可以是任意的数据类型
一个函数内部可以有多条return分支语句，但最终只执行一条return语句
只能返回一个值
回调函数
把一个函数的指针（函数名）作为参数传递给另一个函数，当指针调用函数时，这个函数叫做回调函数【高阶函数】：形参高阶函数和 返回值高阶函数
指针类型
function math(num1,num2,callback) {
return callback(num1,num2);
}
function add(num1,num2) {
return num1+num2;
}
function sub(num1,num2) {
return num1-num2;
}
function mult(num1,num2) {
return num1*num2;
}
function div(num1,num2) {
return num1/num2;
}
document.write(math(1,2,div));
函数类型
foreach
arguments对象
用来接收参数的详细信息
每声明一个函数，在其内部自动生成arguments对象
arguments对象只在函数内部起作用
不是数组类似数组，可以用键名遍历数组（arguments[i]），其长度为arguments.length
不能用数组身上的方法
闭包函数
内部的函数调用外部的函数的【变量】;
function fn1(){
let a="456";
function fn2(){
console.log(a)
}
return fn2;
}
let fn2=fn1();
fn2()
// js中没有函数的重载：传的参数不同，执行不同的函数
作用域
变量起作用的范围
局部作用域优先于全局作用域[作用域链]
-
全局作用域
1. 在整个js中都能访问的变量，凡是进行修改，变量的值就会改变
2. 类型【情况】
在函数外部用var声明的变量，即拥有全局作用域
不用var声明，但是赋值的变量就是全局变量，即拥有全局作用域； -
局部作用域
类型【情况】
形参是局部变量，即拥有局部作用域
在函数内部用var关键字声明的变量，也是局部变量，即拥有局部的作用域。 -
块级作用域
{
括起来的就是块级作用域；
}
内置顶层函数
内置：ecmascript自带的函数，本身就有；只要求知道如何让使用，不用关心如何封装
顶层：在js代码中的任何位置都可以使用；
escape()：将传进来的字符串进行编码
escape("编码的内容"); 编码内容一般为中文
unescape（）：对编码的字符串进行解码
unescape("字符串的编码")
boolean（）：将其余数据类型转换为布尔型
string（）：将任意数据类型转换为字符串型
number（）：将其余数据类型转换为数值型
情况
1. null：0 “”：0 “ ”：0
2. false：0 true：1
3. undefined：nan
4. 进制数转换为十进制
5. 去掉没有意义的后导0和前导0
6. 字符串： 规范的浮点数，数值型字符串
parseint（）：将字符串转换为整数
第一个位置为字母 （+、-）号 空格
转换不成功，转换为nan
parsefloat（）：将字符串转换为小数
只能转换规范的浮点数
转换不成功，返回nan
isnan():值是否够转换为数值型
能转换为数值型返回false
不能转换为数值型返回true
作用：数据类型转换
强制类型转换
隐式数据类型转换：算数运算符，逻辑运算符，条件语句（if，while等）
对象 类
概念
类：一群具有相同特征的对象集合的描述
对象：具体存在的类个体
属性：对象基础信息的描述
方法：对象功能的描述
定义对象
构造函数（类）,实例化对象
1. 构造类
function 类名（color，price等其他形参）{
this.color=color；
this.price=price； //实例化时，this指向实例化的对象
this.play=function（）{
}
}
2. 实例化对象
let 对象=new 类名(实参);
3. 对象的属性【对象属性的添加】
对象.属性名=“属性值”； 访问：对象.属性名 /
上一篇： 老婆，你在干嘛呢
下一篇： 上一秒这是发生了什么