第六天-内置对象；数组、字符串对象及方法；简单类型和复杂类型

javascript中的对象分为三种：自定义对象、内置对象、浏览器对象（前两种对象是JS基础内容，属于ECMAScript；第三个浏览器对象属于JS独有）

　　内置对象就是指JS语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是最基本而必要的功能(属性和方法)。内置对象最大的优点就是帮助我们快速开发，常见的内置对象有Math、Date、Array、String等

　　通过查文档(MDN)学习对象中的方法：1.查看该方法的功能；2.查看里面参数的意义和类型；3.查看返回值的意义和类型；4.通过demo进行测试

　　可以利用对象封装自己的内置对象

// 利用对象封装自己的内置对象
        var myMath = {
            PI: 3.1415926,
            max: function() {
                var max = arguments[0] 
                for(var i = 1; i < arguments.length; i++) {
                    if(arguments[i] > max) {
                        max = arguments[i]
                    }
                }
                return max
            }
        }

        // 调用内置对象
        console.log(myMath.PI);
        console.log(myMath.max(1, 5, 9));

　　常用Math：Math.floor()向下取整、ceil向上取整、round五舍六入、abs绝对值、random随机小数(大于等于0小于1)

// 得到两个数间的随机数，并包含这2个整数
        // Math.floor(Math.random() * (max - min + 1)) + min
        function getRandom(min, max) {
            return Math.floor(Math.random() * (max - min + 1)) + min
        }
        console.log(getRandom(1, 10));

        // 随机点名
        var arr = ['张三', '李四', '王五']
        console.log(arr[getRandom(0, arr.length-1)]);

 　　Date对象是构造函数，必须实例化之后使用，用来处理日期和时间

　　　　Date对象基于1970年1月1日(世界标准时间)起的毫秒数

var date = new Date()
        // 获取当年
        console.log(date.getFullYear());
        // 获取当月，从0开始
        console.log(date.getMonth()+1);
        // 当天日期
        console.log(date.getDate());
        // 星期几，周日0到周六6
        console.log(date.getDay());
        // 当前小时
        console.log(date.getHours());
        // 当前分钟
        console.log(date.getMinutes());
        // 当前秒钟
        console.log(date.getSeconds());

　　　　倒计时

// 倒计时
        function countDown(time) {
            // 返回的是当前时间的总毫秒数
            var nowTime = +new Date()
            // 返回的是用户输入时间的总毫秒数
            var inputTime = +new Date(time)
            // 剩余时间的总秒数
            var times = (nowTime - inputTime) / 1000
            // 天
            var d = parseInt(times / 60 / 60 / 24)
            d = d < 10 ? '0' + d : d
            // 时
            var h = parseInt(times / 60 / 60 % 24)
            h = h < 10 ? '0' + h : h
            // 分
            var m = parseInt(times / 60 % 60)
            m = m < 10 ? '0' + m : m
            // 秒
            var s = parseInt(times % 60)
            s = s < 10 ? '0' + s : s
            return d + '天' + h + '时' + m + '分' + s + '秒'
        }

        console.log(countDown('2019-5-1 18:00:00'));

　　数组对象

　　　　push末尾添加返回新的长度、

　　　　pop末尾弹出返回删除元素的值、

　　　　unshift开头添加返回新的长度、

　　　　shift开头删除返回第一个元素的值、

　　　　reverse翻转数组

　　　　sort排序数组(冒泡)

var arr = [564, 5644, 84, 564, 864]
        arr.sort(function(a, b) {
            // 升序
            // return a - b
            // 降序
            return b - a
        })
        console.log(arr);

　　　　indexOf查找给定元素的第一个索引，找不到返回-1；用来数组去重

　　　　lastIndexOf查找给定元素在数组中的最后一个索引，找不到返回-1；用来数组去重

　　　　toString把数组转为字符串，逗号分隔每一项

　　　　join('分隔符')把数组中所有元素转换为一个字符串，可单独设置分隔符

　　　　concat连接两个或多个数组，返回一个新数组，不影响原数组

　　　　slice截取slice(begin, end)，返回被截取的新数组

　　　　splice数组删除splice(第几个开始， 要删除个数)，返回被删除项目的新数组，这个方法会影响原数组

 

字符串对象

　　为了方便操作基本数据类型，javascript还提供了三个特殊的引用类型：String、Number和Boolean

　　基本包装类型：把简单数据类型包装成复杂数据类型，这样基本数据类型就有了属性和方法

　　基本数据类型是没有属性和方法的，而对象才有属性和方法，但是下面却可以执行，这是因为js会把基本数据类型包装为复杂数据类型

var str = 'andy'
        console.log(str.length);

　　基本数据类型包装为复杂数据类型，执行过程如下

// 1.生成临时变量，把简单数据类型包装为复杂数据类型
        var temp = new String('andy')
        // 2.赋值给声明的字符变量
        str = temp
        // 3.销毁临时变量
        temp = null

　　字符串的不可变指的是里面的值不可变，虽然看上去可以改变内容，但实际是地址变了，内存中新开辟了一个内存空间。因为字符串的不可变所以不要大量的拼接字符串

　　字符串的所有方法，都不会修改字符串本身(因为字符串本身是不可变的)，操作完成会返回一个新的字符串

　　　　indexOf('要查找的字符'，开始的位置)，返回指定内容在原字符串中的位置，找不到就返回-1

　　　　lastIndexOf()，从后往前找，只找第一个匹配的

　　　　charAt(index)，返回指定位置的字符

　　　　charCodeAt(index)，获取指定位置字符处的ASCII码

　　　　str[index]，获取指定位置处的字符

// 统计出现次数最多的字符和次数
        var str = 'adnbebcebvevberi'
        var o = {}
        for( var i = 0; i < str.length; i++) {
            var chars = str.charAt(i)
            if(o[chars]) {
                o[chars]++
                console.log(o[chars]);
            }else {
                o[chars] = 1
            }
        }
        console.log(o);

　　　　concat方法用于连接两个或多个字符串，+更常用

　　　　substr(start, length)从start开始，length取的个数

　　　　slice(start, end)从start开始截取到end位置，end取不到

　　　　substring(start, end)从start开始截取到end位置，end取不到，和slice基本相同，但是不接受负值

　　　　replace('被替换的字符', ’替换为的字符')

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

　　　　toUppercase转换大写

　　　　toLowercase转换小写

数据类型

　　简单类型和复杂类型

　　　　值类型：简单数据类型/基本数据类型，在存储时变量中存储的是值本身

　　　　　　string、number、boolean、undefined、null

　　　　引用类型：复杂数据类型，在存储时变量中存储的仅仅是地址(引用)

　　　　　　通过new关键字创建的对象(系统对象、自定义对象)，如Object、Array、Date等

　　　　栈：简单数据类型存放到栈里面，直接开辟一个空间存放值

　　　　堆：复杂数据类型存放到堆里面，首先在栈里面存放地址，十六进制表示，然后这个地址指向堆里面的数据

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

　　　　当把一个引用类型变量传给形参时，其实是把变量在栈空间里保存的堆地址复制给了形参，形参和实参其实保存的是同一个堆地址，所以操作的是同一个对象

 

function Person(name) {
            this.name = name
        }
        function f1(x) {
            console.log(x.name);
            x.name = "张学友"
            console.log(x.name);
        }

        var p = new Person("刘德华")
        console.log(p.name);
        f1(p)
        // 输出？
        console.log(p.name);