对象

对象的基本概念

什么是对象??

现实生活中 : 万物皆对象, 对象是一个具体的事物 , 一个具体的事物就会有特征和行为 ;

JavaScript中: js中的对象就是生活中对象的一个抽象,,,, 没有特征和行为,,取而代之的是有对应的属性和方法 ;

思考 :

1. 学生对象: 
   // 特征 : 名字,性别,身高,体重
   // 行为 : 吃饭、睡觉、敲代码
2.  js的对象 属性+方法
3. 对象初体验
var stu = {
      // 键  值 对
    // 属性名 : 属性值
    // 属性名 : 变量 => 不是字符型
    // 属性值 : 任意类型
    name : 'zs',
    gender: '男'
    height:170;
    weight:170;
    eat:function(){
      console.log('吃饭');
    }
}

对象 : 是一组无序的键值对的集合

特点 :

1. 声明的变量 = {}  []=> 数组
2. 键值对出现
3. 逗号隔开,, 记住 : 以后再 {} 内一行一行的都是用 , 隔开

为什么要学习对象?

思考1：如果要存储一个人的信息，应该怎么办？
var name = "张三";
var age = 18;
var sex = "男";
var hobby = "上网";
思考2：这么做的缺点是什么？
这些变量都是属于一个人的，应该跟数组一样，使用一个集合把所有的信息都存储起来。

数组：是有序的元素集合 ，数组用于存放一组有序的数据，比如一个班级所有人的名字，一个班级所有人的成绩。

对象：是一组无序的键值对的集合。 对象用于存放一组无序的数据，比如一个人的特征和行为。

//数组多个元素之间使用,隔开
//对象中多个键值对之间也用,隔开，，，键值对的格式： 键:值
var obj = {
  name:"张三",
  age:18,
  sex:"男",
  hobby:"上网"
}

创建对象-1 (2种方式单创)

单纯的创建一个对象

###对象字面量

字面量 : 直接量,,,通过看数值,,直接看出来类型的 ,或者不需要通过创建, 11, '234', true , [] , {}

var p = {};
var p = {
    name : 'zs',
    age:18,
    sayHi:function(){
        console.log(this.name)
    }
}

注意 :

this使用在对象的属性的函数里,,其实地方使用没有意义

通过Object构造函数创建

var p =  new Object(); // 创建一个空的对象
var p =  new Object({name :'xx'});

设置对象的属性

// 语法  对象名.属性 = 值
var obj = new Object();
obj.name = 'zs';
obj.age = 18;
obj.gender = '男';

// 添加方法
obj.sayHi = function () {
    console.log('大家好,我是' + obj.name);
}

// 补???
如果存在过的属性呢???
    
// 设置对象的属性的语法
    // 对象.属性 = 值
    // 1. 如果对象有这个属性，修改这个属性
    // 2. 如果对象没有这个属性，添加这个属性

获取对象的属性

// 语法  对象名.属性
console.log(obj.name);
console.log(obj.age);
console.log(obj.gender);

//如果是方法，可以调用
obj.sayHi();


// 获取对象属性的语法：
// 对象.属性：对象的属性
// 1. 如果有这个属性，直接返回属性值
// 2. 如果没有这个属性，返回undefined

删除对象属性

delete关键字可以删除对象的属性

var obj = {name:"zs", age:18}
delete obj.name;//删除obj的name属性

##创建对象-2 (2种方式批量)

批量创建对象

在实际开发中，经常需要创建多个相同类型的对象，比如班级的学生等。

使用工厂函数创建对象

  //定义一个函数，用于创建学生对象
  //工厂函数：
  function createStudent(name, age, sex) {
    var stu = {};
    stu.name = name;
    stu.age = age;
    stu.sex = sex;
    stu.sayHi = function() {
      console.log("大家好,我是"+this.name);
    }
    return stu;
  }

  var stu1 = createStudent("zs", 18, "男");
  stu1.sayHi();

优点：可以同时创建多个对象

缺点：创建出来的没有具体的类型，都是object类型的

查看一个对象的类型

typeof 只能判断基本数据类型的类型
instanceof 判断对象的具体类型
constructor.name 也可以获取到对象的具体类型

关于typeof

typeof用于查看基本的数据类型， number string boolean undefined
typeof如果查看复杂数据类型，返回的都是object类型。
typeof null比较特殊，结果是object
typeof 函数的结果是function:因为函数是一等公民

// 简单类型

var num1 = 12;

var num2 = 'abc';

var num3 = true;

var num4 = undefined;

var num5 = null;   //(object类型)

// 复杂类型 (引用类型)

function num6() {

}

var num7 = [];

var num8 = {};




**方式2 : instanceof 判断**

```js
结构 : 对象 instanceof 构造函数
var arr = [];
var obj = {}
var fn = function () {}
console.log( arr instanceof Array); // true
console.log( obj1 instanceof Object);// true
console.log( fn instanceof Function);// true

方式3 : constructor.name

// 原型的构造函数    
console.log(arr.constructor.name); //Array
console.log(obj1.constructor.name); //Object
console.log(fn.constructor.name); //Function

  // 方式1 : typeof
  console.log(typeof num1);
  console.log(typeof num2);
  console.log(typeof num3);
  console.log(typeof num4);
  console.log(typeof num5);
  console.log(typeof num6);
  console.log(typeof num7);
  console.log(typeof num8);


  // typeof 总结 :
  //1. 简单基本类型 : number string boolean undefined 
  //2.                null => object 
  //3. 复杂类型    : object
  //4.                 函数 => fuction 一等公民

自定义构造函数

工厂函数的缺点就是无法确定对象的具体类型

构造函数，是一种特殊的函数。主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。

  //所有创建出来的对象都有：
    //name
    //age
    //hobboy
  function Teacher(name, age) {
    //构造函数内部的this指向的是新创建的那个对象
    this.name = name;
    this.age = age;
  }

  var tea = new Teacher("zs", 18);
  console.log(tea);

构造函数首字母要大写，要和普通函数作区分（红宝书）。
构造函数要和new一起使用才有意义。
构造函数的作用是用于实例化一个对象，即给对象添加属性和方法。

在构造函数内部，this指的是一个新生成的空对象，所有针对this的操作，都会发生在这个空对象上。构造函数之所以叫“构造函数”，就是说这个函数的目的，就是操作一个空对象（即this对象），将其“构造”为需要的样子。如果构造函数内部有return语句，而且return后面跟着一个对象，new命令会返回return语句指定的对象；否则，就会不管return语句，返回this对象

new在执行时的原理 。


/**
*创建一个空对象，作为将要返回的对象实例
*将这个空对象的原型，指向构造函数的prototype属性
*将这个空对象赋值给函数内部的this关键字
*开始执行构造函数内部的代码
*/
//代码 演示new的过程
function _new(/* 构造函数 */ constructor, /* 构造函数参数 */ param1) {
  // 将 arguments 对象转为数组
  var args = [].slice.call(arguments);
  // 取出构造函数
  var constructor = args.shift();
  // 创建一个空对象，继承构造函数的 prototype 属性
  var context = Object.create(constructor.prototype);
  // 执行构造函数
  var result = constructor.apply(context, args);
  // 如果返回结果是对象，就直接返回，否则返回 context 对象
  return (typeof result === 'object' && result != null) ? result : context;
}

构造函数的作用(实例化对象)：给创建出来的对象增加属性和方法。

操作对象的属性

.语法 ----- 对象名.属性名 ( 看似变量,不是字符串 )

// 获取对象属性的语法：
	// 对象.属性：对象的属性
    // 1. 如果有这个属性，直接返回属性值
    // 2. 如果没有这个属性，返回undefined

// 设置对象的属性的语法
    // 对象.属性 = 值
    // 1. 如果对象有这个属性，修改这个属性
    // 2. 如果对象没有这个属性，添加这个属性

var obj = {
    name : 'zs'
} 

console.log ( obj.name ) //ok
console.log ( obj.'name' ) // X
obj.name = 'why'; //ok

var key = 'name';

console.log ( obj.key ) // X

[]语法 ---- 对象名 [ 属性字符串 ] (字符串)

var key = 'name';
console.log ( obj['name'] ) // ok
console.log ( obj[name] ) // X
console.log ( obj[key] ) //ok

二者的区别：当属性名是一个字符串存储在变量中的时候，只能使用关联数组的方式。

应用场景 : 遍历对象

遍历对象

通过for..in语法可以遍历一个对象

for (var key in obj) {
    // 键
    console.log(key);
    // 值
    console.log(obj[key]);
}

解析
var obj = {};
for (var i = 0; i < 10; i++) {
		obj[i] = i * 2;
}
for(var key in obj) {
	console.log(key + "==" + obj[key]);
}

###判断一个属性是否是对象的一个属性

结构 :
```
if (属性名  in  对象) { .. }
```
代码

var obj = {
	name: 'zs'
}
if ('name' in obj) {
	console.log('是');
}

获取对象里的所有属性

// 结构 :   Object.keys(对象)
Object.keys(obj)

值类型与引用类型

JS数据类型

简单数据类型：number、string、boolean、undefined、null

复杂数据类型：Array、function, Object

简单数据类型也叫值类型，复杂数据类型也叫引用数据类型，这主要是根据内存存储方式来区分的。

变量在存储简单类型的时候，存的是值本身（值类型）
变量在存储复杂数据类型的时候，存的是引用，也叫地址（类型）

值类型的存储

变量存储数据的时候，存储的直接就是这个值本身。

demo :
var num = 11;
var num1 = num;
num = 20;
console.log(num);
console.log(num1);

简单类型进行赋值的时候，赋值的是值本身。

引用类型的存储

复杂类型：变量不会存这个对象，对象随机存在内存中，会有一个地址，变量存储的仅仅是这个对象的地址。

demo:
var obj = {
  name:"zs",
  age:18
}

var obj1 = obj;
obj1.name = "ls";
console.log(obj.name);
console.log(obj1.name);

////把obj存的地址给了obj1  所以obj和obj1都存放了这个对象的地址，

结论：简单类型存储的是值本身，复杂类型存储的是地址，引入如果把第一个对象赋值给另一个变量，此时两个变量会指向同一个对象。

重学前端之（5）面向对象、new的执行原理

对象