6.对象
object：是一组属性和方法的集合
1.创建
1》对象字面量
var o={
name:'lisi',
age:20,
gender:'men'
}
var a={}
console.log(o);
2〉构造函数
var o=new Object();
o.name='lisi';
o.age=20;
2.访问属性
1》点操作符
console.log(o.name);
2〉[""]
o["name"]
当访问变量/标识符比较复杂的
o["name-first"]
3.删除属性
delete o.name
4.检测属性
in:
对于继承属性或者私有属性返回true
"name" in obj
hasOwnProperty()：
对私有属性返回true，堆继承属性返回false
obj.hasOwnProperty('name')
5.对象序列化
json字符串
JSON.parse():
将字符串转换为对象
JSON.stringify()
将对象转换为字符串
stu->str->obj:
stu==obj:false
6.构造函数和原型对象
每一个函数都有一个原型对象
prototype：原型对象
每一个对象都有一个构造者
constructor：构造者
静态方法/属性：
声明在构造函数内部，只能构造函数本身访问
Object.assign(a,b):
将对象进行合并(将b的属性给了a)
Object.keys():
返回当前对象的所有属性名组成的数组
Object.values():
获取当前对象的所有属性值所组成的数组
Object.defineProperty():
定义属性
非静态方法/属性：
声明在构造函数的原型对象中，所有实例对象均可以调用
constructor:
Object.prototype.constructor
obj.constructor
toString()
valueOf()
hasOwnProperty()
7.Object.defineProperty(obj,"key",{})
定义属性
{}:
属性描述符：
value:'':设置属性值
writable:是否可写，false
enumerable：是否可以遍历，默认false
configurable:是否可配置/删除，默认false
存取描述符(监听过程)
不能和value同时使用
set:function
get:function
7.函数
function say(){}
say()
funciton run(){}
Number()
new Object()
js中，所有函数的内部结构都是一样的
普通函数：
function say(){}
Number()
构造函数
new Object()
函数就是一个对象
1.创建
1.函数字面量
var say=function(){}
2.函数声明
function say(){}
3.匿名函数
(function(){})()
优先解析函数的声明，然后解析使用var操作符声明的变量
2.函数的参数
形式参数（形参）
实际参数（实参）
function say(a,b){
console.log(a+b);
}
say(1);
js中只要函数名相同，即为重写
function say(){}
function say(a,b){}
say();
js中实际参数个数可以和形式参数个数不一致
3>函数的调用
普通函数：
函数名()
构造函数：
new 函数名()
4>函数的内部属性
arguments:类数组对象
用来保存实际参数列表
length:实际参数的个数
callee:用来从函数内部指向函数本身
this:
函数赖以执行的环境对象
1.什么时候确定？
当拥有当前this的函数被调用的时候确定
2.指向
谁调用当前拥有this的函数，this指向谁
5.作为值的函数和作为返回值的函数
作为值：
function say(){//1001
console.log("hello");
}
function sayHello(fn){
//var fn;
//say->arguments[0]:1001->
//arguments[0]->fn
//fn:1001
fn();
}
sayHello(say);
6.函数的属性
say.length:形式参数个数
函数的调用：
this->指定函数内部this值
call(this,实参列表)
apply(this,[实参列表])
prototype:原型对象
3.数组
1.特点
数组的长度可以动态修改
数组中的元素可以使用任意数据类型
length可以返回当前数组长度，也可以设置数组长度
2.创建数组
1.数组字面量
var arr=[null,undefined,true,0,function(){},{}];
2.构造函数
1.var arr=new Array();
2.var arr=new Array(10);
创建一个数组，并且数组长度为10
3.var arr=new Array("hello",20,true);
创建一个以参数为数组项的数组
new Array("hello");
function Array(){
if(arguemnts.length==0){
//
}else if(arguments.length==1 && typeof(arguments[0])=="number"){
}else{
}
}
new Array()
2.访问数组元素
数组下标：从0开始
[1,2,3,4]{0:1,1:2,2:3}
arr[3]:
访问arr数组中的第4个数据
arr.length=10;
将数组长度设置为10，如果原数组长度小于10，相当于将原数组的长度扩展到10的长度；如果原数组的数组长度大于10，相当于删除数组元素，直到数组长度为10
arr[10]='hello';
将原数组的长度扩展到11
3.检测数组
Array.isArray():
返回当前参数是否为array类型
es6:
Array.from():
将类数组转换为数组
创建类数组对象：
1.包含length属性
2.属性名必须为number类型或者字符串number
0:
"0"
Array.of(10,"hello"):
创建数组
4.将数组转换为字符串
toString():
arr->Array.prototype:
toString(){}
var arr=[];
arr.toString();
join("-"):
将数组元素使用分隔符进行连接之后转换为字符串
5.队栈方法
删除或者添加数组元素
栈方法：
pop():
参数：无
返回值：删除的元素
push()：
参数：想要添加的元素
返回值：新数组的长度
队列方法：
shift():
参数：无
返回值:删除的元素
unshift()：
参数：添加的数组元素
返回值：新数组长度
6.排序方法
reverse():
反转
参数：无
返回值：反转之后的数组
在原数组的基础上进行反转
sort():
排序
参数：
1.无
默认调用每一个数组元素的tostring()进行比较
2.回调函数
function(a,b){
if(a>b){
return 1;//a排在b之后
}else if(a<b){
return -1;//a排在b前面
}else{
return 0;//不排序
}
}
1.review 0824
1.函数
1.创建函数
1.函数字面量
var say=function(){}
2.函数的声明
function say(){}
优先解析函数的声明，然后解析使用var操作符声明的变量
2.调用函数
函数名()
new 函数名()
函数名.call()
函数名.apply()
3.参数
形式参数：
在声明函数时，写在function后的（）中
实际参数：
在调用函数时，写在函数名后（）中
js中没有重载概念，所有函数名相同的函数，均为重写
实际参数可以和形式参数的个数不一致
4.函数的内部属性
arguments:类数组对象
保存实际参数
实参-》arguments->形式参数
length:
callee:
this:
函数赖以生存的环境对象
1.何时确定this?
当拥有当前this的函数被调用时确定
2.this指向谁？
谁调用当前函数，this指向谁
html:兜底对象：window
vi:兜底对象：global
function say(){
console.log(this);
}
say();
5.作为值和返回值的函数
function say(){}
return say;
6.函数的属性
length:
say.length
prototype:原型对象
call(this,实参列表)
apply(this,[实参列表])
2.数组
1》特点：
长度可以动态修改（length）
每一个数组元素的数据类型可以任意设置
2〉创建数组实例
a.数组字面量
var arr=[1,2,true];
b.构造函数
var arr=new Array();
var arr=new Array(5);
var arr=new Array(2,true);
3>访问数组元素
arr[index]:
数组下标：从0开始
console.log(arr[0]);
arr[10]=10;
arr.length=10;
4>检查数组
Array.isArray();
es6:
Array.from():
将类数组对象转换为数组
Array.of(10):
创建数组
[10]
5>将数组将转换为字符串
toString()
join("-")
6>队栈方法
栈：
push
pop
队列：
unshift
shift
7>排序
reverse():
反转
sort():
数组排序
修改原数组
参数：
无：默认调用每一个数组元素的tostring()进行排序
1 11 2
回调函数：
function(a,b){
if(a>b){
return -1
}else{
return 1
}
}
2.操作方法（非静态方法）
concat():
数组拼接
任意想要拼接的内容当作参数给concat
拼接结果为新数组
slice():
数组切割
不改变原数组
参数：
0: 返回值为一个没有切割的新数组
1: index
从当前位置开始切割，到数组末尾结束
2:begin end
从begin开始切割，到end结束，不包含结束位置
-1代表数组中的最后一个元素
splice：
返回值？
原数组：？
数组切割
修改原数组
参数：
0：返回一个空数组
1:index
从当前位置切割到数组末尾
2:begin num
从begin开始切割，切割num个
3:begin num 插入的元素
num=0: 插入
num!=0: 替换
indexOf(key,index):
查找数组元素
使用全等操作符进行比较
返回值：
找到了返回下标(从前向后查找一个)
找不到返回-1
lastIndexOf():
查找数组元素
从后向前查找
3.迭代方法(非静态方法)
every():
当数组中的每一个数组项满足条件时，返回true
some():
只要有一个数组项满足条件，返回true
map():
对每一个数组元素进行操作
filter()：
过滤
将满足条件的数组元素组成了一个新数组返回
forEach()：
for(){}升级版
没有返回值
作业：
myEvery/mySome/myFilter/myForeach
参数：
回调函数 this
回调函数参数：
item index arr
数组项 当前数组项下标 当前数组
reduce():
回调函数 this
回调函数参数：
pre item index arr
当this不存在时，pre第一次为第一个item，从第二次开始为undefined
当this值存在时，第一次pre为this，从第二次开始，为上一次回调函数的返回值
review----------
数组：（非静态方法：公有方法）
1.操作方法：
concat():数组拼接
slice():数组切割
0/1/2
-1:数组中最后一个数组项
splice()：数组切割
修改原数组
0/1/2/3
indexOf(key,index):查找数组元素
===
找到返回数组下标，找不到返回-1
lastIndexOf()
2.迭代方法：
every(function(item,index,arr){
console.log(this);
return item>5
},{})
some(function(){
return item>5
},this)
map(function(){
return item+1
},this);
filter(function(){
return item>5
},this);
forEach(function(){
//没有返回值
//循环体
},this);
reduce(function(pre,item,index,arr){
pre:第一次执行时，pre为this或者第一个数组元素
},this)
包装器函数：
Number():
Number.prototype.xxx
Boolean():
Boolean.prototype.xxx
String():
String.prototype.xxx
var str="hello";//string
console.log(str.length//number);
console.log(typeof str);//string
//1.new String(str)->object:String
自动装箱
//2.new String(str).length
//3.str：自动拆箱
var num=10;//number
console.log(num.toString());
//1.自动装箱
new Number(num)
//2.调用方法
new Number(num).toString()
//3.自动拆箱
num//number
function Number(){}
Number(a);//返回值为number类型
new Number(a);//object: Number
String.prototype.xx:
length:返回字符串的长度
charAt(index):
返回某个位置的字符
charCodeAt(index);
返回某个位置的字符对应的ascll码
concat():字符串拼接
+""
slice():字符串切割
0:返回原字符串的复制字符串
1:index从当前位置截取，截取到字符串末尾结束
2:
begin end
从begin开始，到end结束，不包含end
substr():字符串切割
0:返回原字符串的复制字符串
1:index从当前位置截取，截取到字符串末尾结束
2:begin num
从begin开始截取，截取num个
substring()字符串切割
0:返回原字符串的复制字符串
1:index从当前位置截取，截取到字符串末尾结束
2:begin end
从begin开始，到end结束，不包含end
如果end为负数，改变切割方向
trim():
去除字符串的前后空格
没有参数
toUpperCase():
将字符串转换为大写字母
toLowerCase()：
将字符串转换为小写字母
search():查找字符串
参数为想要查找的字符串/正则表达式
找到返回字符串下标，找不到返回-1
match():匹配字符串
参数为想要匹配的字符串/正则表达式
返回值为匹配结果组成的数组
匹配失败返回null
split():
将字符串进行切割，然后将切割后的字符存放到数组项中：
将字符串转换为数组
replace():替换字符
参数可以为字符串/正则表达式
正则表达式：
匹配字符串的对象
Math:
普通对象
Math.min():
查找一组数中的最小值
Math.max()：
查找一组数中的最大值
取整操作：
Math.ceil()：向上取整
Math.floor()：向下取整
Math.round()：四舍五入
review----0826-
1.包装器函数
new Number():object
Number():number
new String()
String():string
new Boolean()
Boolean:boolean
1.手动包装
var str="hello";
var strobj=new String(str);-->obect String
2.自动包装
var str="hello";
str.length;
//1.自动装箱
//2.调用属性/方法
//3.自动拆箱
String.peorotype.xxx:
length:
charAt(index)
charCodeAt(index)
concat()
slice()
substr()
substring()
trim()
toUpperCase
toLowerCase
search(""/正则)
match(""/正则)
replace(""/正则,替换的字符)
split(""/正则)
2.正则表达式
str-正则
1.创建
/表达式/
new RegExp(表达式，)
2.修饰符
3.书写表达式
4.属性和方法
test()
exec():match()
3.Math对象
普通对象
比较：
Math.min()
Math.max()
取整：
Math.ceil():
Math.floor():
Math.round():
随机数：
Math.random():
返回一个0-1之间的随机数，不包含1
没有参数
Math.abs()
Math.log()
Math.sin()
Math.cos()
....
4.Date:日期
new Date()：
月份：0-11月
参数：
0:返回当前日期
1:
new Date(2020,8,7,8,9,0);
new Date("2020-8-10");
new Date("2020/8/10");
使用字符串类型设置月份时，不受影响
new Date(毫秒数);
5.面向对象
var stu1={
name:'lisi',
age:20,
gender:',men',
say:function(){}
...
}
var stu2={
name:'wangwu',
age:20,
gender:'women',
say:function(){}
...
}
1.工厂模式
function setStudent(name,age,gender){
var obj=new Object();
obj.name=name;
obj.age=age;
obj.gender=gender;
return obj
}
var stu1=setStudent(name,age,gender);
var stu2=setStudent('lisi',20,"men");
优点：
代码进行简化
缺点：
对象不能细分
公有属性或方法的存放位置过于混乱
2.构造函数模式
function Student(name,age,gender){
//new Object
//this->new
this.name=name;
this.age=age;
this.gender=gender;
//return this
}
var stu1=new Student("lisi",20,"men");
优点：
解决了对象细分问题
缺点：
公有属性或方法的存放位置过于混乱
3.原型对象模式
基于构造函数模式，将公有属性或者方法存放在构造函数的原型对象中
function Stduent(name,age){
this.name=name;
this.age=age;
}
Student.prototype.say=function(){
}
var stu1=new Student();
var stu2=new Student();
4.继承
子类的原型指向父类的实例对象
Poor.prototype=new Rich();
Poor.prototype.constructor=Poor;
function Rich(name,age){
this.name=name;
this.age=age;
}
Rich.prototype.money=["crad1","card2","card3"];
Rich.prototype.enjoy=function(){}
var r1=new Rich("lisi",20);
function Poor(name,age){
this.name=name;
this.age=age;
}
Poor.prototype.work=function(){
alert();
}
var p1=new Poor("tom",20);
借用构造函数：
Rich.call(this,name,age,gender);
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
