标签：关键字 基本概念 函数的参数 person 成绩 代码 array cto 事物
现实生活中 : 万物皆对象, 对象是一个具体的事物 , 一个具体的事物就会有 特征 和 行为 ;
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:"上网"
}对象的场景 : 京东
单纯的创建一个对象
字面量 : 直接量,,,通过看数值,,直接看出来类型的 ,或者不需要通过创建, 11, ‘234‘, true , [] , {}
var p = {};
var p = {
name : 'zs',
age:18,
sayHi:function(){
console.log(this.name)
}
}注意 :
? this使用在对象的属性的函数里,,其实地方使用没有意义
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. 如果没有这个属性，返回undefineddelete关键字可以删除对象的属性
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();优点：可以同时创建多个对象
缺点：创建出来的没有具体的类型，都是object类型的
typeof 只能判断基本数据类型的类型
instanceof 判断对象的具体类型
constructor.name 也可以获取到对象的具体类型关于typeof
typeof 函数的结果是function:因为函数是一等公民
```js
// 简单类型
var num1 = 12;
var num2 = ‘abc‘;
var num3 = true;
var num4 = undefined;
var num5 = null; //(object类型)
// 复杂类型 (引用类型)
function num6() {
}
var num7 = [];
var num8 = {};
```
方式2 : instanceof 判断
结构 : 对象 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在执行时会做四件事情
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..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)简单数据类型：number、string、boolean、undefined、null
复杂数据类型：Array、function, Object
简单数据类型也叫值类型，复杂数据类型也叫引用数据类型，这主要是根据内存存储方式来区分的。
变量存储数据的时候，存储的直接就是这个值本身。
练习 :
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);//结论：简单类型存储的是值本身，复杂类型存储的是地址，引入如果把第一个对象赋值给另一个变量，此时两个变量会指向同一个对象。
标签：关键字 基本概念 函数的参数 person 成绩 代码 array cto 事物
原文地址：https://www.cnblogs.com/f2ehe/p/11863327.html
