js

对象,for in循环,值类型,引用类型

对象

对象的基本概念

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

函数：封装一段重复的代码，只要声明一次，就可以多次调用。

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

  • 事物的特征在对象中用属性来表示。
  • 事物的行为在对象中用方法来表示。

创建对象

对象字面量

1
2
3
4
5
6
7
8
9
var o = {};
var o = {
  name : "zs",
  age : 18,
  sex : true,
  sayHi : function() {
    console.log(this.name);
  }
};

通过Object构造函数创建

1
var hero = new Object();//创建一个空的对象

操作对象的属性

设置对象的属性

1
2
3
4
5
6
7
8
9
10
//语法  对象名.属性 = 值;
var obj = new Object();
obj.name = "zs";
obj.age = 18;
obj.gender = "男";

//给对象设置添加一个方法
obj.sayHi = function() {
  console.log("大家好，我是"+obj.name);
}

获取对象的属性

1
2
3
4
5
6
7
//语法：  对象名.属性
console.log(obj.name);
console.log(obj.age);
console.log(obj.gender);

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

操作对象的属性

.语法

获取对象属性的语法：对象.属性

  • 如果有这个属性，直接返回属性值
  • 如果没有这个属性，返回undefined

设置对象的属性的语法：对象.属性 = 值

  • 如果对象有这个属性，修改这个属性
  • 如果对象没有这个属性，添加这个属性

[]语法

也叫关联数组的方式，其实说白了就是把对象当成数组看待。在中括号中可以是一个变量或者是字符串。

获取对象属性：对象['下标']（把对象的属性当成下标）

设置对象的属性：对象['下标'] = "值";

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

遍历对象

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

1
2
3
for(var key in obj) {
	console.log(key + "==" + obj[key]);
}

批量创建对象

使用工厂函数创建对象

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

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

构造函数

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

  1. 构造函数首字母要大写（推荐做法）。
  2. 构造函数要和new一起使用才有意义。
  3. 构造函数的作用是用于实例化一个对象，即给对象添加属性和方法。

new在执行时会做四件事情

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

总结：创建对象的几种方式

1
2
3
4
1. new Object()
2. 对象字面量
3. 工厂函数
4. 自定义构造函数

值类型与引用类型

值类型：简单类型，变量在存储的时候，存储的是值本身。

引用类型：复杂类型，变量在存储的时候，存储的是复杂数据的地址。

值类型与引用类型赋值特征

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 值类型
var num1 = 10;
var num2 = num1;
num2 = 99;
console.log(num1);
console.log(num2);

// 引用类型
var obj1 = {
  name:"zs",
  age:18
}
var obj2 = obj1;
obj2.name = "ls";
console.log(obj1.name);
console.log(obj2.name);

值类型与引用类型参数传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var num = 10;
function fn(a) {
  a = 99;
  console.log(a);
}
fn(num);
console.log(num);

var obj = {
  name:"zs",
  age:18
}
function fn(a) {
  a.name = "ls";
  console.log(a.name);
}
fn(obj);
console.log(obj.name);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//测试1 : 
// 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);

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