1. 什么是数据
    *存储在内存中代表特定信息的东东,本质上是010101…
    *数据的特点: 可传递,可运算
    *一切皆数据
    *内存中所有操作的目标:数据
    **算术运算
    **逻辑运算
    **赋值
    **运行函数 fun()
  2. 什么是内存
    *内存条通电后产生的可存储数据的空间(临时的)
    *内存产生和死亡:内存条(电路板)>通电>产生内存空间==>存储数据==>处理数据==>断电==>内存空间和数据消失
    *一块小内存的2个数据:
    **内部存储的数据
    **地址值
    *内存分类
    **栈:全局变量/局部变量
    **堆:对象
    代码存到内存——>编译(编译成字节码也要内存存)——>解析执行
  3. 什么是变量
    *可变化的量,由变量名和变量值组成
    *每个变量都对应一块小内存,变量名用来查找对应的内存,变量值就是内存中保存的数据
  4. 内存,数据,变量三者之间的关系
    *内存是用来存储数据的空间
    *变量是内存的标识

实现代码:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        var age = 18
        console.log(age) //找内存,内存标识为age,读取内存中的值18

        var obj = {name: 'Tom'}
        console.log(obj.name) //读取obj的内存值,内存存的是一个地址值,找到地址所对应的内存,再读取内存中的值(name是内存标识,tom是内存中存的值)
    
        function fn () {
            var obj = {name: 'Tom'}  //obj存在栈中,{name: 'Tom'} 存在堆中
        }

        var a = 3
        var b = a //3 拷贝a内存中的值到b  数据的可传递性

        var c = 3
        var d = c + 3 //数据的可运算
    </script>
</body>
</html>

问题: var a = xxx,a内存中到底保存的是什么?
* xxx是基本数据,保存的就是这个数据
* xxx是对象,保存的是对象的地址值
* xxx是一个变量,保存的是xxx的内存内容(可能是基本数据,可能是地址值)

实现代码:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        var a = 3
        a = function () {

        }

        var b = 'abc'
        a = b  //存基本数据

        b = {}
        a = b  //存地址值
    </script>
</body>
</html>

关于引用变量赋值问题
*n个引用变量指向同一个对象,通过一个变量修改对象内部数据,其他所有变量看到的是修改后的数据
*2个引用变量指向同一个对象,让其中一个引用变量指向另一个对象,另一引用变量依然指向前一个对象

实现代码:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        // 2个引用变量指向同一个对象,通过一个变量修改对象内部数据,其他所有变量看到的是修改后的数据
        var obj1 = {name: 'kate'}
        var obj2 = obj1 //拷贝内存中的值给另一个变量,就实现两个引用变量指向同一个对象
        obj1.name = 'yueyue'
        console.log(obj2.name) //'yueyue'

        var obj3 = {name: 'yangyang'}
        var obj4 = obj3
        obj4.age = 12 
        console.log(obj3.age)  //12
        function fn (obj) {
            obj.name = 'A'  //这里是.  下面是=
        }
        fn(obj3)
        console.log(obj4.name) //A

        // 2个引用变量指向同一个对象,让其中一个引用变量指向另一个对象,另一引用变量依然指向前一个对象
        var a = {age: 12}
        var b = a
        a = {name: 'bob', age: 13}
        b.age = 14 
        console.log(b.age,a.name,a.age) //14 bob 13

        function fn2 (obj) {
            obj = {age: 15}//obj断开{name: 'bob', age: 13},指向{age: 15}
        }
        fn2(a)  // a 和 obj 同时指向一个对象,a = 13 ,obj指向{name: 'bob', age: 13}
        console.log(a.age) //13   //a 还是指向{name: 'bob', age: 13}
    </script>
</body>
</html>

问题:在js调用函数时传递变量参数时,是值传递还是引用传递
*理解一:都是值(基本/地址值)传递
*理解二:可能是值传递,也可能是引用传递(地址值)

实现代码:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        var a = 3
        function fn(a) {
            a = a + 1
            console.log(a)  //4
        }
        fn(a)
        console.log(a)  // 3

        function fn2 (obj) {
            console.log(obj.name) //Tom
        }
        var obj = {name: 'Tom'}
        fn2(obj)
    </script>
</body>
</html>

问题:就是引擎如何管理内存
1.内存的生命周期
*分配小内存空间,得到它的使用权
*存储数据,可以反复进行操作
*释放小内存空间
2.释放内存
*局部变量:函数执行完自动释放
*对象: 先成为垃圾对象==>垃圾回收器回收

实现代码:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        var a = 3
        var obj = {}
        obj = null//释放对象占的内存,让b指向的对象成为垃圾对象(被垃圾回收器回收)

        function fn () {
            var b = {}
        }
        fn()  //b是自动释放,b所指向的对象是在后面的某个时刻由垃圾回收器回收
    </script>
</body>
</html>