JavaScript 对象

JS对象
1.能够说出为什么需要对象
保存一个值时，可以使用变量，保存多个值（一组值）时，可以使用数组，如果要保存一个人的完整信息呢？
2.能够说出如何使用字面虽创建对象
3.能够使用构造函数创建对象
4.能够说出 new 的执行过程
能够遍历对象
对象万物皆对象
在现实生活中万物皆对象对象就是一个具体的事物看得见摸得到
在JS中对象是一组无序的相关属性和方法的集合 所有的事物都是对象 例如字符串 数值 数组函数等
对象是由属性和方法组成的
属性:事物的特征 在对象中用对象中的属性来表示(常用名词)
方法:事物的行为 在对象中用对象中的方法来表示(常用动词)

在JS中如何创建我们可以用三种方式创建对象(Object)
1.利用 字面量 创建对象
2.利用 new Object 创建对象
3.利用 构造函数 创建对象
1.利用 字面量 创建对象
对象字面量:就是花括号{} 里面包含了表达这个具体事务(对象)的属性和方法

（1）里面的属性或者方法我们采取键值对的形式， 键 属性名：值 属性值
（2）多个属性或者方法中间用逗号隔开
（3）方法冒号后面跟的是一个匿名函数
2.使用对象
（1）调用对象的属性，我们采取 对象名.属性名
console.log（obj.color);
（2）对象里面属性的另一 种方式 对象名[‘属性名’] 注意方括号里面的属性必须加引号
console.log(obj[‘age’]);
（3）调用对象的方法
sayHi 对象名.方法名() 千万别忘记添加小括号
obj.sayHi（）;
每一个属性和方法之间用 ; 隔开
console. log(obj. name);
console. log(obj[ 'name ']);
obj. sayHi()；

2.利用 new Object 创建对象

（1）我们是利用 等号 = 赋值的方法 添加对象的属性和方法
（2）每个属性和方法之间用 分号 结束
调用：
console.log(obj.age);
console.log(obj.[‘past’]);
obj.sayHi();

我们用构造函数创建
用这个的原因:是因为我们前面两种创建对象的方式一次只能创建一个
我们可以利用函数的方法 重复这些相同的代码 我们就把这个函数称为 构造函数
又因为这个函数不一样，里面封装的不是普通代码 而是 对象
构造函数 就是把我们对象里面一些相同的属性和方法抽象出来封装到函数里面

构造函数就是把我们对象里面的一些相同属性和方法拿出来封装到函数中
他是一种特殊的函数 主要用来初始化对象 即为对象成员变量赋初始值 他总与 new 运算符一起使用我们可以把对象中的一些公共的属性和方法抽取出来 然后封装到这个函数里面

构造函数的语法格式

我们需要创建五大金刚 对象相同的属性:姓名性别年龄 相同的方法:能歇善舞
练习：

1.构造函数名字首字母要大写
2.我们构造函数不需要 return 就可以返回结果
3.调用构造函数 必须使用 new
4.我们只要 new Star（）调用函数就创建一个对象 如 lcf {}
5.我们的属性和方法前面必须添加 this

2.4 构造函数和对象
构造函数 如 Stars(),抽象了对象的公共部分，封装到了函数里面，它泛指某一大类（class）
创建对象 如 new Stars(),特指某一个，通过 new 关键字创建对象的过程我们也称为对象实例化

new 关键字
1.在内存中创建一个新的空对象。
2.让 this 指向这个新的对象。
3.执行构造函数里面的代码。
4.返回这个新对象（所以构造函数里面不需要 return）。

4.遍历对象属性
for…in语句用于对数组或者对象的属性进行循环操作

        var obj = {
            name: '德玛西亚',
            age: 18,
            sex: '男'
        }
        for (var k in obj) {
            console.log(k); // k 变量 输出得到的是属性名  name  age  sex
            console.log(obj[k]); // obj[k] 得到的是属性值 德玛西亚 18 男
        }
        //使用 for in里面的变量 我们喜欢写 k 或者key 就像 i 一样

4.1 小结
1.对象可以让代码结构更加清晰
2.对象复杂数据类型 object
3.本质：对象就是一组无序的相关属性和方法的集合
4.构造函数泛指某一大类，比如苹果，不管是红色苹果还是绿色苹果，都统称为苹果
5.对象实例特指一个事物，比如这个苹果。
6.for…in 语句用于对对象的属性进行循环操作

JS 内置对象
JavaScript中的对象分为3种：自定义对象 内置对象 浏览器对象
自定义对象和内置对象是JS基础内容，属于ECMAScript; 第三个浏览器对象属于 JS 独有，后面JS API在学
内置对象就是指JS语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是最基本而必要的功能（属性和方法）
内置对象最大的优点就是帮助我们快速开发
JavaScript 提供了多个内置对象：Math（数学对象），Date（日期对象），Array（数组对象），String（字符串对象）等

查文档:MDN/W3C/CSDN

Math（数学对象）
Math 是一个内置对象，它具有数学常数和函数的属性和方法，不是一个函数对象
Math 不是一个构造器，所以我们不需要 new 来调用，而是直接使用里面的属性和方法即可

        console.log(Math.PI);  //一个属性  圆周率
        console.log(Math.max(1,99,66));  // 直接输出最大值 99

注意1：如果给定的一组数字中的最大值。至少有一个参数无法被转换成数字，则返回NaN

        console.log(Math.max(20,666,'wf放屁'));  // 输出 NaN 因为有非数字

注意2：如果没有参数，则结果为 -Infinity

        console.log(Math.max());  // 不赋值 得到结果 -Infinity

还有很多属性，参考 MDN 搜索 Math

练习：利用对象封装自己的数学对象，里面有 PI 最大值和最小值

        var myMath = {
            PI: 3.141592653,
            max: function() { // 方法必定是个函数 
                var max = arguments[0]; // 这里不确定有多少个参数 给个 arguments
                for (var i = 1; i < arguments.length; i++) { //依次和后面做比较
                    if (arguments[i] > max) { //如果你当前这个 arguments 里面的第 i 个 竟然比我的 max 还要大
                        max = arguments[i]; //那我 max 就等于 arguments 里面的第 i 个
                    }
                }
                return max; // 返回 return 里面的 max   最大值求完
            },
            min: function() { // 方法必定是个函数 
                var min = arguments[0]; // 这里不确定有多少个参数 给个 arguments
                for (var i = 1; i < arguments.length; i++) { //依次和后面做比较
                    if (arguments[i] < min) { //如果你当前这个 arguments 里面的第 i 个 竟然比我的 min 小
                        min = arguments[i]; //那我 min 就等于 arguments 里面的第 i 个
                    }
                }
                return min; // 返回 return 里面的 min 最小值求完
            }
        }
        console.log(myMath.PI);
        console.log(myMath.max(22, 33, 44, 77, )); // 出来的是 77
        console.log(myMath.min(22, 33, 44, 77, )); // 出来的是 22

3.1 其他常用 Math 属性

// 1.绝对值方法
console.log(Math.abs(1)); // 1
console.log(Math.abs(-1)); // 1
console.log(Math.abs('-1')); // 1 隐式转换 会把字符串型 -1 转换为数字型
console.log(Math.abs('red')); // NaN

// 2.三个取整方法
// (1) Math.floor() 向下取整 往最小了取值
console.log(Math.floor(1.1)); // 1
console.log(Math.floor(1.9)); // 1
// (2) Math.ceil()  向上取整 往最大了取值
console.log(Math.ceil(1.1)); // 2
console.log(Math.ceil(1.9)); // 2
// (2) Math.round() 四舍五入
console.log(Math.round(1.1)); // 1
console.log(Math.round(1.5)); // 2
console.log(Math.round(1.9)); // 2
console.log(Math.round(-1.1)); // -1
console.log(Math.round(-1.5)); // -1 不是 -2 往大了取 -1比-2大！

3.2 随机数方法 random（）
函数返回一个浮点，伪随机数在范围（0，1）也就是说 从 0 （包括0）往上，但是不包括1（排除1），然后您可以缩放到所需的范围，实现将初始种子选择到随机数生成算法，他不能被用户选择或重置

这个方法里面不跟参数
代码验证：

console.log(Math.random()); // 随机 0-1 的小数 包括 0 但是不包括 1

4.想要得到二个数之间的随机整数，并且包含这二个整数

function getRandom(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log(getRandom(1,20));

5.随机点名

function getRandom(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}
// console.log(getRandom(1,20));

var arr = ['张三','张三丰','张三疯子','李四','李思思'];
console.log(arr[getRandom(0, 4)]); // 写法一 缺点：不方便后期添加新数组元素
console.log(arr[getRandom(0, arr.length - 1)]); // 写法二 推荐！

案列：
程序随机生成一个 1-10 之间的数字，并让用户输入一个数字
1.如果大于该数，就提示，数字大了，继续猜
2.如果小于该数字，就提示数字小了，继续猜
3.如果等于该数字，就提示猜对了，结束程序。
思路：
1.随机生成一个 1-10 的整数 我们需要用到 Math.random（）方法
2.需要一直猜到正确为止，所以一直循环，
3.用while循环合适更简单
4.核心算法：使用 if else if 多分支语句来判断大于，小于，等于。
代码验证：

function getRandom(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}
var random = getRandom(1,10);
while (true) {  //死循环 后面别忘了加 break
    var num = prompt('输入一个1~10的数字');
    if (num > random) {
        alert('你猜大了');
    } else if (num < random) {
        alert('你猜小了');
    } else {
        alert('你好帅，猜对了');
        break;
    }
}

Date日期对象
用来处理日期和时间，Date 对象基于1970年1月1日（世界标准时间）起的毫秒数
Date（日期对象）是一个构造函数 必须使用 new 来调用创建我们的日期对象

// 1.使用 Date 如果没有参数 返回当前系统的当前时间
var date = new Date();
console.log(date);

也可以自己添加

// 2.参数常用的写法 数字型 2019, 10, 01 或者是 字符串型 '2019-10-1 8:8:8'
var date1 = new Date(2019, 10, 1);
console.log(date1); //返回的是 11月 不是 10月
var date2 = new Date('2019-10-1 8:8:8');
console.log(date2);

4.1 Date 概述
Date 对象和 Math 对象不一样，他是一个构造函数，所以我们需要实例化后才能使用，必须 new Date
Date 实例用来处理日期和时间
4.2 Date（）方法的使用
1.获取当前时间必须实例化

使用 Date 如果没有参数 返回当前系统的当前时间
2.Date（）构造函数的参数
如果括号里面有时间，就返回参数里面的时间。例如日期格式字符串为’2019-5-1’ 可以写成 new Date（‘2019-5-1’）

4.3 日期格式化
需要获取日期指定的部分，所以我们要手动的得到这种格式
格式化日期 年月日

        // 格式化日期 年月日
        var date = new Date();
        console.log(date.getFullYear()); //返回当前日期的年 今年2019
        console.log(date.getMonth() + 1); //月份 返回的月份小一个月 需要 + 1
        console.log(date.getDate()); //返回的是几号
        console.log(date.getDay()); //获取星期几（周日0到周六6）
        console.log(date.getHours()); // 获取当前小时
        console.log(date.getMinutes()); //获取当前分钟
        console.log(date.getSeconds()); //获取当前秒钟
        // 2019年 5月 1日 星期三 写一个好辨认， 人性化的写法
        var year = date.getFullYear(); //得到的是年份
        var month = date.getMonth() + 1; // 月份小一个月 记得+1
        var dates = date.getDate(); //得到的是 3日 但是格式没有中国化，我们可以用数组的方法去调用一个大写的 星期三
        var arr = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六']; // 必定是星期日开头，在老外眼里星期日是第一天，索引为0
        var day = date.getDay(); // 得到的是周几
        console.log('今天是：' + year + '年' + month + '月' + dates + '日 ' + arr[day]);

格式化日期 时分秒

        // 格式化日期 时分秒
        var date = new Date();
        console.log(date.getHours()); //出来的是 时
        console.log(date.getMinutes()); //出来的是 分
        console.log(date.getSeconds()); //出来的是 秒
        // 要求封装一个函数返回当前的时分秒 格式 08: 08: 08
        function getTime() {
            var time = new Date();
            var h = time.getHours();
            h = h < 10 ? '0' + h : h; // 三元表达式写法解释：如果这个 h 小时 他小于10 那就在前面补0 如果不小于10 那就原封不动的返回h
            var m = time.getMinutes();
            m = m < 10 ? '0' + m : m; //三元表达式写法解释：如果这个 m 小时 他小于10 那就在前面补0 如果不小于10 那就原封不动的返回m
            var s = time.getSeconds();
            s = s < 10 ? '0' + s : s; //三元表达式写法解释：如果这个 s 小时 他小于10 那就在前面补0 如果不小于10 那就原封不动的返回s
            return h + ':' + m + ':' + s; //return 返回输出
        }
        console.log(getTime());

获得 Date 的总的毫秒数 不是当前时间的毫秒数 而是距离1970年1月1日
1.通过 valueOf（） getTime（）

        var date = new Date()
        console.log(date.valueOf()); //就是 我们现在的时间距离 1970.1.1总的毫秒数（时间戳）
        console.log(date.getTime());
        // 简单点的写法（最常用的）
        var date0 = +new Date() //+new Date() 返回的也是总的毫秒数
        console.log(date0);
        // H5新增的 获得总毫秒的方法 IE678不兼容
        // console.log(Date.now());

倒计时案列

        // 输入的时间 减去 现在的时间就是剩余的时间 也就是倒计时，但是不能拿时分秒相减，会是负数
        // 用时间戳来做
        // 把剩余的总毫秒幻化为 天 时 秒
        d = parseInt(总秒数 / 60 / 60 / 24) //天数
        h = parseInt(总数 / 60 / 60 % 24) //小时
        m = parseInt(总数 / 60 % 60) //分
        s = parseInt(总数 % 60) // 秒
        
        function hmmSb(time) {
            var nowHmmSb = new Date() // 返回当前总的毫秒
            var inputHmmSb = +new Date(time) //返回的是当前用户上班的时间
            var sb = (inputHmmSb - nowHmmSb) / 1000 //返回的是剩余的总的秒数
            var d = parseInt(sb / 60 / 60 / 24) //天数
            d = d < 10 ? '0' + d : d;
            var h = parseInt(sb / 60 / 60 % 24) //小时
            h = h < 10 ? '0' + h : h;
            var m = parseInt(sb / 60 % 60) //分
            m = m < 10 ? '0' + m : m;
            var s = parseInt(sb % 60) // 秒
            s = s < 10 ? '0' + s : s;
            return d + '天' + h + '时' + m + '分' + s + '秒';
        }
        console.log(hmmSb('2020-7-31 24:00:00'));

数组对象 数组对象的创建

1. 字面量

        var arr = [1, 2, 3]
        console.log(arr[2]); //3

2. new Array()

        var arr = new Array(); //利用 Array 创建了一个空的数组
        var arr1 = new Array(2); //表示数组长度为2 里面有2个空的数组元素
        var arr2 = new Array(2,3);  //等价于[2,3] 这样写表示 里面有2个数组元素 是2和3
        console.log(arr2); //输出arr：一个空数组 输出arr1：empty x 2 输出arr2：[2,3]

翻转数组

        function reveres(arr) {
            var newArr = []
            for (var i = arr.length - 1; i >= 0; i--) {
                newArr[newArr.length] = arr[i]
            }
            return newArr;
        }
        console.log(reveres([1, 2, 3]));
        console.log(reveres(1, 2, 3)); //显示的是空的数组 上面的newArr原封不动的就返回回来了

所以我们要检测是否为数组
instanceof Array.isArray运算符 他们可以用来检测是否为数组

        var arr = []
        console.log(arr instanceof Array); //是数组返回 true 否则 flase
        
        Array.isArray(参数) //H5新增的 ie9以下都不支持
        console.log(Array.isArray(arr));

    添加删除数组的方法 面试题 说出N种常用数组方法 一般在10种左右
    
    1.push(参数1...) 在数组末尾添加一个或多个数组元素 注意！这个是会修改原数组的 返回一个新的长度

        var arr = [1,2,3];  
        arr.push(4,'pink'); //给上面的数组添加数组元素 push 是追加的 在屁股后面加
        console.log(arr);  //输出结果 [1,2,3,4,'pink']
        // (1) push 是可以给数组追加新的元素
        // (2) push() 参数直接写 数组元素就可以了
        // (3) push 完毕之后，返回的结果是 新数组的长度 (上面数组长度是5)
        // (4) 原数组也会发生变化

   2.unshift(参数...) 在数组开头添加一个或多个元素 注意这也会 修改原来的数组 返回的是他删除的

        var arr = [1,2,3];  
        arr.unshift('yellow', 'red'); //这二个新增数组元素会排在上面老数组的前面
        console.log(arr);  // 输出的是['yellow', 'red', 1, 2, 3]
        // (1) unshift 是可以给数组追加新的元素
        // (2) unshift() 参数直接写 数组元素就可以了
        // (3) unshift 完毕之后，返回的结果是 新数组的长度 (上面数组长度是5)
        // (4) 原数组也会发生变化

3.    pop()可以删除数组最后一个元素 把数组长度减1 注意！ 修改原数组 返回他删除的元素
   

        var arr = ['yellow', 'red', 1, 2, 3];  
        arr.pop(); //pop 不跟参数
        console.log(arr); //输出的是['yellow', 'red', 1, 2] 末尾的数组元素删掉
        console.log(arr.pop()); // 返回值是 3 你删除了哪个元素，就给你返回哪个元素
        // (1) pop 是可以删除数组的最后一个元素 一次删除一个
        // (2) pop() 没有参数
        // (3) pop 完毕之后，返回的结果是 删除的那个元素
        // (4) 原数组也会发生变化

4.    shift() 删除数组第一个元素 注意 修改原数组 返回第一个元素的值
   

        var arr = ['yellow', 'red', 1, 2, 3];  
        console.log(arr.shift()); //和 pop 一样 返回的是你删除的那个
        console.log(arr); // 输出结果['red', 1, 2, 3]
        // (1) shift 是可以删除数组的第一个元素 一次删除一个
        // (2) shift() 没有参数
        // (3) shift 完毕之后，返回的结果是 删除的那个元素
        // (4) 原数组也会发生变化

筛选数组
一个人有七个老婆 按照古代14岁成年 筛选出成年的

        var arr = [14, 15, 13, 16, 8, 14, 88]
        var newArr = []
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] >= 14) {
                newArr.push(arr[i])
            }
        }
        console.log(newArr);

数组的排序

        reverse() //翻转数组 改变方法会改变原来的数组 返回新的数组
        sort() //对数组的元素进行排序 该方法会改变原来的数组 返回新的数组
            // 数组索引的方法
        indexOf() //数组中查找给定的元素的第一个索引 如果存在返回索引号 如果不存在 返回 - 1
        lastIndexOf() //在数组中的最后一个索引

数组转化为字符串

        toString() //把数组转化为字符串 用逗号分隔 返回的是一个字符串
        join('分隔符') //方法用于把数组中元素转化为一个字符串 返回一个字符串
        var arr = [1, 2, 3]
        console.log(arr.toString()); //1,2,3
        console.log(arr.join('阿西吧')); // 1阿西吧2阿西吧3  括号里面什么都不写显示的是逗号
        
        concat() //连接二个或多个数组不影响原数组 返回的是一个新的数组
        var arr1 = [1, 2, 3]
        var arr2 = [4, 5, 6]
        var arr3 = [7, 8, 9]
        console.log(arr1.concat(arr2.concat(arr3))

        slice() //数组的截取slice(begin, end) 返回被截取的新数组
        var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
        console.log(arr.slice(0, 4));
        console.log();
        splice() //数组删除splice(从第几个开始， 要删除的个数) 返回被删除的项目的信数组 注意 这个会影响用来的数组
        console.log(arr.splice(2, 10));

    字符串对象
    基本包装类型 就是把简单的数据类型 包装成负责的数据类型
    为了方便操作基本数据类型 js 提供了三种特殊的引用类型 String Number Boolean
    基本包装类型就是把简单的数据类型 包装成复杂的数据类型 这样基本数据类型就有了属性和方法
    var hmmSb = 'admin'
    console.log(hmmSb.length);
    基本数据类型是没有属性和方法的 只有对象才有属性和方法 但是上面的这个代码可以执行 是因为 js 会把
    基本数据类型包装为复杂数据类型 然后进行解析
    解析过程
    1.生成一个临时变量 把简单的数据类型包装成复杂的数据类型
    var hmmSb1 = new String(admin)
    2.赋值给我们声明的字符变量
    hmmsb = hmmSb1
    3.销毁临时变量
    hmmsb = null

    字符串的不可变
    字符串不可变 指的是里面的值不可变的 虽然看上去可以改变内容 其实是地址改变了 在内存中新开辟了一个内存空间
    字符串对象 根据字符返回位置 str.indexOf('要查找的字符',[起始的位置])
    var hmmsb = '韩梅梅上班一路火花带闪电咔嚓咔嚓'
    console.log(hmmsb.indexOf('咔'));
    console.log(hmmsb.indexOf('咔',15)); //从索引号是15的位置开始查找

案列练习
查ahsfghasdgfjhasgdjifhk 中所有的a出现的位置以及次数
核心算法:先查找第一个a出现的位置
然后只要indexOf返回的结果不是-1 那么就继续真找
因为indexOf 只能查找到第一个 所以后面的查找一定是当前索引加1 从而继续查找

var hmmsb = 'ahsfghasdgfjhasgdjifhk'
var hmmdsb = hmmsb.indexOf('a')
var num = 0
while (hmmdsb !== -1) {
    console.log(hmmdsb);
    num++;
    hmmdsb = hmmsb.indexOf('a', hmmdsb + 1)
}
console.log('a出现的次数是：' + num);

根据位置返回字符(重点)
charAt(index)返回指定的字符(index是字符串的索引) 使用方法 str.charAt(0)

var str = 'admin'
console.log(str.charAt(2)); // m

charCodeAt(index) 获取指定位置字符的ASCLL码(index索引号) str.charCodeAt(0)
str[index]获取指定位置处 字符 H5 IE8 以上支持 和charAt()等效
遍历所有的字符

for (var i = 0; i < str.length ; i++) {
    console.log(str.charAt(i));
}
console.log(str.charCodeAt(0));

字符串操作方法

concat('字符串1','字符串2'....) 字符串拼接 连接多个字符串
var hmmsb = 'admin'
console.log(hmmsb.concat('是的 是DSB')); //admin是的 是DSB

substr(star,length) //从 start 开始 length 取的个数  重点！！！
var hmmsb = '韩梅梅到上班'
console.log(hmmsb.substr(3,3)); //到上班

slice(start,end) //从 start 开始 截取到的 end 的位置 end 取不到(他们俩个都是索引值)
substring(start,end) //从 start 开始 截取到 end 的位置 end 取不到 和上面的相同 但是不能接受负值

替换字符 replace(‘被替换的字符’,‘替换的字符’)

var hmmsb = 'admin'
console.log(hmmsb.replace('a','b'));

字符转换为数组 split(‘分隔符’)

var hmmsb = 'hmm, yx, sh'
console.log(hmmsb.split(','));
console.log(hmmsb.split('&'));

js数据类型
简单数据类型又叫基本数据类型 复杂数据类型又叫引用类型
值类型：简单数据类型/基本数据类型 在存储时 变量中存储的是值本身 因此叫值类型
string number boolean undefined null
简单数据类型 null 返回的是一个空对象 Object
var hmmsb = null
console.log( typeof hmmsb);
引用类型：复杂数据类型 在存储变量的时候 存储的仅仅是引用的地址 因此叫引用数据类型
通过 new 创建的对象 (系统对象 自定义对象) 如 Object Array Date等等

堆和栈
栈(操作系统)：有操作系统自动分配释放存储函数的参数值 局部变量的值等等 其操作方式类似于数据结构中的栈
简单数据类型存放到栈里面
堆(操作系统)：存储复杂数据类型(对象) 一般由程序猿分配释放 如果程序猿不释放 有垃圾回收机制回收
复杂数据类型存放到堆里面
注意js中没有堆栈的概念 通过堆栈的方式 可以让大家更容易理解代码的一些执行方式，便于将来学习其他的语言

如果有一个变量我们以后打算存储为对象 暂时没有想好放啥 那这个时候就给一个null
简单数据类型，是存放在栈里面 里面直接开辟一个空间存放的是值
复杂数据类型 首先在栈里面存放地址 十六进制来表示 然后这个地址指向堆里面的数据

简单的类型传参
函数的形参也可以看做是一个变量 当我们把一个值类型变量(简单数据类型)作为一个参数传给函数的形参时 其实就是把变量在栈空间的里的值复制了一份给形参，那么在方法内部堆形参做任何改变 都不会影响外部的变量

function fn(a) {
    a++;
    console.log(a); // 11
}
var x = 10;
fn(x);
console.log(x); //10

复杂数据类型的传参

function hmmsb(name) {
    this.name = name
}
function f1(x) {  // X = P
    console.log(x.name); //2.天线宝宝
    x.name = '韩梅梅';
    console.log(x.name); //3. 韩梅梅
}
var p = new hmmsb('天线宝宝')
console.log(p.name); //1.天线宝宝
f1(p) //调用函数到上面
console.log(p.name); //4.张学友

更详细视频：https://www.bilibili.com/video/BV1hT4y1u7qb?p=189