对象的创建方法
var obj = {}
对象字面量/对象直接量- 构造函数
1) 系统自带的构造函数new Object()
- 自定义
- 链式调用 (模仿jQuery)
var obj = {
drink : function(){
console.log('drink!!!!')
return this;
},
smoking : function(){
console.log('smoking!!!!')
return this;
}
}
obj.drink().smoking();
- 获取属性值
obj.name
隐式转换为obj['name']
obj['name']
遍历属性时要用中括号语法
//1. for in
//2. hasOwnProperty //判断该属性是否是自己本身的属性,false 则为原型链上的属性
//3. in //判断该对象是否能调用该属性
//4. instanceof //A instanceof B 看A对象的原型链上有没有B的原型 (官方解释:A对象是不是B构造函数构造出来的----解释不全)
var obj = {
name : 'zhang',
age : 123,
sex : 'male',
height : 170,
weight : 60,
__proto__ : {
lastName : 'deng'
}
}
for(var prop in obj){
//console.log(obj.prop);//undefined ==> console.log(obj['prop'])
if(obj.hasOwnProperty(prop)){//hasOwnProperty 判断该属性是否是自己本身的属性,false 则为原型链上的属性
console.log(obj[prop])
}
}
console.log('name' in obj)//true
console.log('lastName' in obj)//true
- 判断一个数据到底是数组还是对象
var arr = [],
obj = {};
// 1. constructor
console.log(arr.constructor)//Array方法
console.log(obj.constructor)//Object方法
// 2. instanceof
console.log(arr instanceof Array)//true
console.log(obj instanceof Array)//false
// 3. Object.prototype.toString.call()
Object.prototype.toString.call(arr)//'[object Array]'
Object.prototype.toString.call(123)//'[object Number]'
Object.prototype.toString.call(obj)//'[object Object]'
深克隆
function deepClone(origin, target){
var target = target || {},
toStr = Object.prototype.toString,
arrStr = '[object Array]';
for(var prop in origin){
if(origin.hasOwnProperty(prop)){
if(origin[prop] !== 'null' && typeof(origin[prop]) == 'object'){
if(toStr.call(origin[prop]) == arrStr){
target[prop] = [];
}else{
target[prop] = {};
}
deepClone(origin[prop],target[prop]);
}else{
target[prop] = origin[prop];
}
}
}
return target;
}
构造函数的内部原理
function fn(){}
new fn()//先执行fn函数,返回this对象
- 在函数体最前面隐式的加上this = {};
- 执行 this.xxx = xxx;
- 隐式的返回this
function Person(){
//var this={} => Object.create(Person.prototype)隐式声明一个空对象
this.name = name;
this.height = height;
this.say = function () {
console.log(this.say)
}
return {};//当构造函数new Person()使用时,返回一个对象类型的数据可以破坏隐式的 return this;,return 一个原始值时不会破环默认的返回值,会被忽略
//return this; 隐式返回this对象
}
包装类
- Number()
- String()
- Boolean()
包装类new出来的值是一个对象,可以添加属性,当作原始值类型使用后回归原始值类型
var num = new Number(123);//生成一个数字类型对象
console.log(typeof(num));//object
num.len=3;
console.log(num.len)//3
var sum = num*3;
console.log(sum)//369
console.log(typeof sum)//number
给原始值添加属性
//原始值添加属性会调用包装类
//Number
var num = 4;
num.len = 3;
//new Number(4).len=3; 调用包装类,然后没保存直接delete
//new Number(4).len
console.log(num.len)//相当于console.log(new Number(4).len) ⇒ undefined
//String
var str = "abcd";
str.length = 2;
//new String("abcd").length = 2; delete
//new String("abcd").length
console.log(str.length)
原型
- 定义:原型是function对象的一个属性,它定义了构造函数制造出的对象的公共祖先。通过该构造函数产生的对象,它可以继承该原型的属性和方法。原型也是对象。
- 利用原型特点和概念,可以提取共有属性。
- 对象如何查看原型 ===> __proto__
- 对象如何查看对象的构造函数 ==> constructor
function Person(name,age){
this.name=name;
this.age=age;
this.num=100;
}
Person.prototype.grade="2017";
var person1 = new Person("zhangsan",18)
//原型链上面的增删改查
person1.size="big";//增加
delete person1.size;//删除 成功返回true,不包含该属性也返回true 无法删除原型中的属性
person1.num++;
//person1.num==101
//person1.__proto__.grade.num==100;
//绝大多数对象的最终都会继承自Object.prototype
var createObj = Object.create(null);//没有__proto__属性
var createObj.__proto__={name:'zhangsan'};
console.log(createObj.name)//undefined 手动添加的__proto__属性起不到链接作用
//Object.create(原型)
var obj = {name:"zhangsan"};
var obj1 = Object.create(obj);//obj作为obj1的__proto__原型创建一个空对象
||
\/
function Person () {}
Person.prototype.name = "zhangsan";
var person = new Person();
this
- 函数预编译过程
this
指向window
- 全局作用域里
this
指向window
call/apply
可以改变函数运行时this
指向obj.func();
func()
里面的this
指向obj
var name = '222';
var a = {
name : '111',
say : function () {
console.log(this.name);
}
}
var fun = a.say;
fun()
a.say()
var b = {
name : '333',
say : function (fun) {
fun()
}
}
b.say(a.say);
b.say = a.say;
b.say();
错题
var obj = {
n : 10,
m : obj.n * 10
};//Uncaught TypeError: Cannot read property 'n' of undefined
var obj1 = {
n : 10,
m : this.n * 10
};
console.log(obj1.m);//NaN
es6 对象方法
Object.assign(target, source_1, ···)
//用于将源对象的所有可枚举属性复制到目标对象中
let target = {a: 1};
let object2 = {b: 2};
let object3 = {c: 3};
Object.assign(target,object2,object3);
// 第一个参数是目标对象,后面的参数是源对象
target; // {a: 1, b: 2, c: 3}
//如果目标对象和源对象有同名属性,或者多个源对象有同名属性,则后面的属性会覆盖前面的属性。
//如果该函数只有一个参数,当参数为对象时,直接返回该对象;当参数不是对象时,会先将参数转为对象然后返回。
Object.assign(3); // Number {3}
typeof Object.assign(3); // "object"
//因为 null 和 undefined 不能转化为对象,所以会报错:
Object.assign(null); // TypeError: Cannot convert undefined or null to object
Object.assign(undefined); // TypeError: Cannot convert undefined or null to object
当参数不止一个时,null 和 undefined 不放第一个,即不为目标对象时,会跳过 null 和 undefined ,不报错
Object.assign(1,undefined); // Number {1}
Object.assign({a: 1},null); // {a: 1}
Object.assign(undefined,{a: 1}); // TypeError: Cannot convert undefined or null to object
//assign 的属性拷贝是浅拷贝:
let sourceObj = { a: { b: 1}};
let targetObj = {c: 3};
Object.assign(targetObj, sourceObj);
targetObj.a.b = 2;
sourceObj.a.b; // 2
//同名属性替换
targetObj = { a: { b: 1, c:2}};
sourceObj = { a: { b: "hh"}};
Object.assign(targetObj, sourceObj);
targetObj; // {a: {b: "hh"}}
//数组的处理
Object.assign([2,3], [5]); // [5,3]
//会将数组处理成对象,所以先将 [2,3] 转为 {0:2,1:3} ,然后再进行属性复制,所以源对象的 0 号属性覆盖了目标对象的 0。
Object.assign({a:10,0:11}, [5]); // {0: 5, a: 10}
Object.values(obj)
var obj = {a:1,b:2,c:3}
Object.values(obj)//[1, 2, 3]