对象数据类型及其操作

对象数据类型----object

（1）是js中的一个数据类型，是一个复杂数据类型

（2）是一个”盒子“，承载的是数据

（3）是一个无序的数据集合，也是一个键(key)值(value)对的集合

一、对象数据类型的创建

1、字面量方式创建对象

（1）创建空间对象：var obj = {}

（2）创建有数据的对象： var obj = {键值对}

键值对：键–值 可以书写多个，之间用逗号相隔，最后一个键值对不需要书写逗号，可以写单不推荐。

空对象
    var obj = {}
    console.log(obj)
带有数据的对象
/*obj 对象内有一个成员, 键(key) 是 name, 值(value) 是 'Jack' */
 var obj = {
      name: 'Jack',
      age: 18,
      gender: '男'
    }
 console.log(obj)

2、内置构造函数(类)创建
创建空对象: var obj = new Object()

二、对象的基本操作

增: 相对内添加成员

删: 删除对象内某一个成员

改: 修改对象内某一个成员

查: 获取对象内某一个成员的值, 根据 key 获取 value

在 JS 内, 对于对象的操作提供了两套语法

1、点语法

（1）增加 ------ 对象名.键名 = 值 //obj.name = ‘jack’

（2） 删除------- delete 对象名.键名 // delete obj.name

（3）修改---------对象名.键名 = 值 //obj.name=‘rose’

​ 因为对象内 key 不允许重名，当设置的时候, 原先有就是修改, 原先没有就是增加

（4）查询 ---------对象名.键名

在访问的时候, 如果对象内有这个键, 那么直接给出值

如果对象内没有这个键, 那么给出 undefined(暂时)

2、数组关联语法

（1）增加 ------对象名[‘键名’] = 值 //obj[‘name’]=‘Jack’

（2）删除 -------delete 对象名[‘键名’] //delete obj[‘name’]

（3）修改 --------对象名[‘键名’] = 值 //obj[‘name’]=‘Rose’

（4） 查询 --------对象名[‘键名’] //obj[‘name’]

3、两种对象操作语法的区别

（1）操作符合变量命名规则和规范的, 使用两种语法无所谓

（2）操作纯数字的 key 或者操作带有特殊符号的 key, 只能使用数组关联语法

（3） 当你的 key 涉及变量的时候, 只能使用数组关联语法

---------对象的 key 可以写什么内容

（1）推荐使用符合变量命名规则和规范的名字作为 key

（2）可以使用纯数字当做对象的 key, 一旦使用纯数字, 会把纯数字的排列在所有成员的最前面

（3）可以使用任何符号当做对象的key, 如果包含特殊符号, 那么key 位置需要使用引号包裹

var obj = {
      name: 'Jack',
      n1: 100,
      abc$222: 'hello',
      1: 100,
      2: true,
      'a-c': '随便来',
      '^_^': 'O(∩_∩)O哈哈~'
    }
    console.log(obj)
    var s = 'name'
    console.log(obj.s)// 单纯访问 obj 内一个叫做 s 的 key 保存的值, 和 s 变量没有任何关系
    console.log(obj['s'])// 单纯的访问 obj 内一个叫做 s 的 key 保存的值, 和 s 变量没有任何关系
    console.log(obj[s])
// 中括号内没有书写 字符串, 而是书写的一个变量
// 相当于在 访问 s 变量, 把 s 变量的值拿过来放在 [] 内
// obj[s] === obj['name'] 访问的就是 obj 内一个叫做 name 的 key 保存的值

三、对象的遍历

使用for in循环进行遍历(不能使用for循环)

语法： for（var 变量 in 对象） {重复执行的代码}

​ （1）对象内有多少个成员，该循环就执行多少次

​ （2）随着循环，变量就分别是每一个key

 var obj = {
      name: 'Jack',
      age: 18,
      gender: '男',
      score: 100
    }
console.log(obj)
    // 开始遍历
for (var k in obj) {
      // 随着循环, k 分别是 obj 内的每一个 key
   console.log('我执行了', k)
      // 能拿到 对象名, 能随着循环拿到一个变量 k 表示每一个 key
   console.log(obj.k) // 都是在准确的访问对象内一个叫做 k 的成员, 和 k 变量没有任何关系
    }

数据类型

一、不同数据类型的存储

1、基本数据类型 复杂数据类型（地址/引用）

2、浏览器存储空间内存中, 分成两部分

（1）栈内存 （在 js 的代码中, 我们只能访问到栈内存的数据）

（2） 堆内存

3、存储数据

（1）基本数据类型就直接存储在栈内存中 数据+变量

（2） 复杂数据类型

​ 在堆内存中开辟空间存储数据

​ 把空间地址赋值给栈内存中的变量

二、数据类型的赋值

***变量的赋值：把当前变量内存储的内容一模一样的复制一份给另外一个变量

***函数的形参和实参的交互, 以及函数的返回值也是赋值的一种

1、基本数据类型

（1）因为变量中就是直接存储的准确的值

（2）赋值的过程中，就是把准确的值复制一份给另外一个变量

（3）赋值以后两个变量没有任何关系

var a = 100
var b = a
console.log(a)  //100
console.log(b)  //100
a = 200
console.log(a)  //200
console.log(b)  //100

2、复杂数据类型

（1）因为变量中存储的不是准确的数据结构，存储的是地址

（2）赋值的过程中，是把变量中存储的地址复制一份给到了另外一个变量

（3）赋值以后，两个变量操作同一个存储空间

var n = 100
function fn(a) {
  console.log('函数内的 a 修改前: ', a)   //100
  a = 200
  console.log('函数内的 a 修改后: ', a)    //200
 }
console.log('全局 fn 调用前 : ', n)    //100
    
// 把 n 变量保存的值赋值给了 fn 函数的形参 a
// 因为 n 保存的是基本数据类型, 所以赋值以后
// 全局变量 n 和 形参 a 没有任何关系了
fn(n)
console.log('全局 fn 调用后 : ', n)    //100
-----------------------------------------------
var obj = { name: 'Jack' }
function fn(o) {
  console.log('fn 内修改 o 以前 : ', o)
  o.name = 'Rose'
  console.log('fn 内修改 o 以后 : ', o)
}
console.log('全局 fn 调用前 : ', obj)
// 把 obj 存储的数据赋值给了 fn 函数的形参 o
// 因为 obj 存储的是某一个对象数据类型的地址
// 这里赋值给形参 o 的就是一个地址信息
// 赋值以后, 全局变量 obj 和 fn的形参o 操作的是一个 对象空间
fn(obj)
console.log('全局 fn 调用后 : ', obj)

/*控制台输出*/
全局 fn 调用前 :  {name: 'Jack'}
fn 内修改 o 以前 :  {name: 'Jack'}
fn 内修改 o 以后 :  {name: 'Rose'}
全局 fn 调用后 :  {name: 'Rose'}  
-----------------------------------------------
var obj = { name: 'Jack' }
function fn(o) {
  o.name = 'Rose'
  var o = new Object()
  o.name = 'Tom'

  console.log('形参 o : ', o.name) // Tom
}
fn(obj)
console.log('全局 obj : ', obj.name) // Rose  
-----------------------------------------------
var obj = { name: 'Jack' }
function fn() {
// 访问 obj 变量的值, 去到 obj 对象空间内, 添加或者修改 name 这个 key 的 value
// 因为 fn 函数内有私有变量 obj, 在这一行代码执行的时候, obj 还是 undefined
obj.name = 'Rose'      //往undefined 里加name(x)
var obj = new Object()   //预解析 变量提升 无赋值
obj.name = 'Tom'
console.log('函数内 obj : ', obj.name)   //若无var 则输出Tom
}
fn()
console.log('全局 obj : ', obj.name) //若无var 则输出Tom

3、函数的return也是赋值的一种

function fn(a) {
/* a 得到的内容是数值 10， a * 10 的结果就是 100，res 得到的数据就是 100 这个数字*/
var res = a * 10

/*return res, 就是把 res 保存的值返回到函数外, 因为 res 保存的是基本数据类型, 给出的就是准确的值*/
return res
}
/*result 接收到的就是 100 这个数字*/
var result = fn(10)
-----------------------------------------------function fn() {
  var obj = { name: 'Jack' }
  
/*因为 obj 内存储的内容是 某一个对象的地址,给出去的也是一个地址*/
  return obj
}
/* result 接受到的就是 fn 私有作用域内那个 对象的 地址*/
var result = fn()