JavaScript第六节

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

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

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

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

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

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

  //定义一个函数，用于创建学生对象
  //工厂函数：
  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();

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

// 简单类型

 var num1 = 12;

 var num2 = 'abc';

 var num3 = true;

 var num4 = undefined;

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

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

function num6() {

}

var num7  =  [];

var num8 = {};

结构 : 对象 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

// 原型的构造函数
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 一等公民

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

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

new会做4件事情
//1. new会创建一个新的空对象，类型是Teacher
//2. new 会让this指向这个新的对象
//3. 执行构造函数  目的：给这个新对象加属性和方法
//4. new会返回这个新对象

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

// 1. 学生对象
// name : 张三  age: 18岁 打招呼:大家好我是张三
// name : 李四  age: 19岁 打招呼:大家好我是李四

// 2. 老师对象
// name : 伟哥  爱好:篮球  打: 伟哥正在打篮球
// name : 马哥  爱好:台球  打: 马哥正在打台球

// 3. 英雄对象  (构造函数)
// name : 马哥  学习 : 马哥正在学前端 / 马哥正在学java

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

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

var obj = {
    name : 'zs'
} 

console.log ( obj.name ) //ok
console.log ( obj.'name' ) // X
obj.name = '小马哥'; //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 (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]);
}

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

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

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

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

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

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

// a -> x
function fn(a, b) {
  // 相当于
  //  var a = 10;
  //  var b = 20;
  // 函数的参数 其实就是函数内部的局部变量
  a = a + 1;
  b = b + 1;
  console.log(a);
  console.log(b);
}

var x = 10;
var y = 20;
fn(x, y);
console.log(x);
console.log(y);

//2.
var p = {
  name:"zs",
  age:18
}
function fn(person) {
  person.name = 'ls';
  console.log(person.name);
}
fn(p);
console.log(p.name);

//3.
function Person(name, age, salary) {
   this.name = name;
   this.age = age;
   this.salary = salary;
 }
 function f1(person) {
   person.name = "ls";
   console.log(person.name);
 }
 var p = new Person("zs", 18, 1000);//创建一个新对象
 console.log(p.name);//
 f1(p);
 console.log(p.name);//