JavaScript函数封装，js对象

1、函数：是封装了一段可以被重复执行调用的
一次声明，多次调用，封装就是打包

一：声明函数
 (1)function 声明函数的关键字，全部小写
（2）函数是做某件事情，函数名一般是动词 getSum
（3）函数不调用自己不执行
二：调用函数
 (1)getSum(num1,num2);


  function getSum(num1,num2) {
            var sum=0;
            for (var i=num1;i<=num2;i++){	·       
                sum+=i;
            }
            console.log(sum);
        }
        getSum(1,100);
        getSum(1,10);
        getSum(1,5);

2、利用函数参数（形参，实参）实现不同的代码

 形参是接受实参的
        function cook(aru) {  声明函数里的参数放**形参**
            console.log(aru);
        }
        cook('ABC');   调用显示的是**实参**
        cook('DEF');

3、函数形参实参个数匹配（建议相匹配）

  function getSum(num1,num2) {
            console.log(num1+num2);
        }
       参数匹配时,正常
        getSum(1.2);
       参数不匹配时.多余不参与运算,取决与形式参数
        getSum(1,2,3);
       实参小于形式参数,可看作不可申明的变量num2是一个变量但是没有接收值,结果就是undefined
        getSum(1);//NaN

4、函数的返回值（函数的结果返回给调用者）return

 返回值格式
        function 函数名() {
            return 需要返回的结果;
        }
        函数名();
        (1)函数只是实现某种功能,最终的结果需要返回给函数的调用者() 通过return实现
        (2)只要函数遇到return 就把后面的结果返回给函数的调用者 函数名()=return后面的结果
        (3)代码验证
        function cook(aru) {
           return aru;
       }
        console.log(cook('ABC'));
**最大值验证**
  function getMax(num1,num2) {
            if(num1>num2){
        法一     return num1;
            }else{
                return num2;
                          }
            return  num1>num2?num1:num2;      法二
        }
        console.log(getMax(100,200));

列题：数组最大值验证

     function getMax(arr) {
            var max=arr[0];
            for (var i=1;i<arr.length;i++){
                if (max<arr[i]){
                    max=arr[i];
                }
            }
            return max;
        }       实际开发里面用一个变量来接收
        var re=getMax([1,5,6,89,2,5,63]);
        console.log(re);

return终止函数的注意事项（return语句之后的代码不被执行）

   function getSum(num1,num2) {
            return num1+num2;
       //return  只能返回一个值，以返回最后一个num2值为准
       // return num1,num2;
            alert('我是不会被执行的');
        }
        console.log(getSum(3,4));

我们求任意两个数的加减乘除结果是，我们可以在return中使用数组

  function getResult(num1,num2) {
            return [num1+num2,num1-num2,num1*num2,parseFloat(num1/num2)];
        }
        var re=getResult(1,2);
        console.log(re);

我们的函数如果有return，则返回值是return后面的值，如果函数没有return则返回underfined``

     function fin1() {
              return  6666;
          }
          console.log(fin1());//6666



     function fun2() {

        }
        console.log(fun2());//underfined

break:结束当前的循环（如for,while）
continue:跳出本次循环，继续执行下次循环（如for,while）
return:不可以退出循环，还能够返回return语句中的值，同时还可以结束当前函数体的代码

函数三步骤：（榨汁机）
  function fn(参数1，参数2) {    输入参数
            函数体；             内部处理
            return 返回值        返回结果 
       }

---

arguments(只有函数才有，内置好的)

对象中存储了传递的所有实参

        function fn() {            
            console.log(arguments);
            console.log(arguments.length);
            console.log(arguments[2]);  
            我们用数组的方式遍历arguements
        }
        fn(1,2,3);里面存储了所有传递过来的实参

arguments展示形式是一个伪数组，因此可以进行遍历，并具有以下特点
（1）具有length属性
（2)按索引方式存储
（3）不具有数组的push（）.pop（）方法

    在遇见***实参***个数不知时，可考虑求大小
     function gtemax() {
            var max=arguments[0];
            for (var i=0;i<=arguments.length;i++){
                if (max<arguments[i]){
                    max=arguments[i];
                }
            }
            return max;
        }
        console.log(gtemax(1,2,3));
        console.log(gtemax(1,2,3,4,5,6))
        console.log(gtemax(11,56,12,44,3))

利用函数翻转任意数组

利用函数封装方式，对数组排序—冒泡排序

  function sort(arr) {
            for (var i=0;i<arr.length-1;i++){
                for (var j=0;j<arr.length-1-i;j++){
                    if (arr[j]>arr[j+1]){
                       var  temp=arr[j];
                       arr[j]=arr[j+1];
                       arr[j+1]=temp;
                    }
                }
            }
            return arr;
        }
         var arr1=sort([1,5,6,2,4,8]);
        console.log(arr1);

函数封装

        判断闰年
        function isRunYear(year) {
            //如果是闰年我们返回 true，否则返回false
            var flag=false;
            if(year%4==0 && year%100!=0 || year%400==0){
                flag=true;
            }
            return flag;
        }
        console.log(isRunYear(2000));
        console.log(isRunYear(1999));

// 函数调用函数

 
        function fun1() {
            console.log(11)
            fun2()
        }
        fun1();
        function fun2() {
            console.log(22)
        }

案列明细
   function backDay() {
            var year=prompt('请输入你的年份');
            if(isRunYear(year)){
                alert('当前的年份是闰年2月份有29天');
                  }else{
                alert('当前的年份是平年2月份有28天');
            }
        }
        backDay()

        function isRunYear(year) {
            //如果是闰年我们返回 true，否则返回false
            var flag=false;
            if(year%4==0 && year%100!=0 || year%400==0){
                flag=true;
            }
            return flag;
        }

函数的两种声明方式

 1、 利用函数关键字自定义函数
        function fn() {
            
        }
 2、 函数表达式(匿名函数)
        var 变量名=function(){}
        
        
        列题
        var fun=function (aru){
           console.log('我是函数表达式');
           console.log(aru);
        }
        fun('ABC');
        （1）fun是变量名，不是函数名
        （2）函数表达式声明方式和声明变量差不多，只不过变量里面存的是值，而函数表达式里面存的是函数
         (3)函数表达式也可以进行传递参数

javaScript作用域（全局变量和局部变量）

（1）作用域：代码名字（变量）在某个范围起效果，目的是提高程序的可靠性，减少命名冲突
（2）js的作用域（es6）之前：全局作用域    局部作用域
（3）全局作用域：整个script标签或者是一个单独的  js 文件
（4）不同作用域之间不会互相冲突
（5）函数的形参也可以看做一个局部变量
**如果在
## 函数内部没有被声明直接赋值的变量也属于全局变量
**
(6)全局变量：只有浏览器关闭的时候才会销毁，比较占内存资源
   局部变量：当我们程序执行完毕就会销毁，比较节约内存资源
   
   现阶段js没有块级作用域，是在（es6）的时候新增的
  块级作用域：{} 、if{}、for{}
(7)作用域链【链式查找的方式一层一层的（就近原则）】
函数里面套函数（内部函数可以访问外部函数变量）

JavaScript预解析

（1）js的解析器在运行js代码时先进行  **预解析**  和  **代码执行**
（2）预解析：js引擎会把js里面所有的var(变量) 还有function（函数）提升到当前作用域的最前面 
（3）代码执行：按照代码书写的顺序从上往下执行

预解析分为 【*变量*】预解析（变量提升）和【*函数*】预解析（函数提升）
（1）变量提升：把所有的变量申明提升到当前的作用域的最前面 不提升赋值操作
（2）函数提升：把所有的变量申明提升到当前的作用域的最前面  不调用函数
  console.log(num);//undefined
        var num=10;
        
        fun();【变量提升】
        var fun=function (){//报错
            console.log(22);
        }预解析转化
        var  fun
        fun()
         fun=function (){//报错
            console.log(22);
        }
(坑1)
console.log(num);//undefined
var num=10

fun()[无论在上在下]//11
funtion fn(){【函数提升】
console.log(11)
}预解析转换
fun()[无论在上在下]//11
funtion fn(){
console.log(11)
}
（坑2）
fun()
var fun=fiuntion(){//报错
console.log(22);
}
函数表达式调用时必须写在函数表达式的下面

综合案列

  （1）
    var num=10;
        fun()
        function fun() {
            console.log(num);
            var num=20;
        }
        预解析
        var num
        function fun() {
            var num
            console.log(num);
            num=20;
        }
        num=10;
        fun()
   （2）
       var num=10;
        function fn() {
            console.log(num);
            var num=20;
            console.log(num);
        }
        fun();
        预处理
        var num
        function fn() {
            var num
            console.log(num);
            num=20;
            console.log(num);
        }
        num=10;
        fun();

js对象：是一组无序的相关属性和方法的集合，所有的事物都是对象，字符、数值、数组、函数（万物皆对象）

对象：是一个具体的事物，看的见，摸得着的事务，一本书，一个网页，一个数据库，一个远程链接也是对象（独一无二的具体事物）
属性：事物的特征，在对象中用属性来表示（常用名词）
方法：事物的行为，在对象中用方法来表示（常用动词）

       （1）为什么需要对象：可以使用变量，保存多个值（一组值）时，可以使用数组
       （2） js中的对象表达更清晰，更强大，
        var arr=['张三','男',120,154];
     （一）  里面的方法我们采用键值对的形式
           键（属性名）：值（属性值）
          多个属性方法之间用逗号隔开的
         

## 创建对象的三种方式

        【1】利用字面量创建对象
        var obj={}    创建了一个空的对象
        var obj={
            uname:'张三',
            age:18,
            sex:男,
            sayhi:function () {    方法后面更一个匿名函数
                console.log('hi--');
            }
        }
        console.log(obj.uname);   对象名.属性名（方法
        console.log(obj["age"]);   对象名【属性名】（方法2）
        console.log(obj.sayhi());

变量：**单独申明**并赋值  使用的时候直接写变量名  【**单独存在**】
属性：在对象里面不需要声明的，使用的时候必须是【对象.属性】（obj.uname）

函数和方法的相同点：都是实现某种功能，某件事情

函数：是单独声明，并且调用的 函数名（）单独存在的
方法：在对象里面调用的时候  对象.方法(obj.sayhi())

利用new object创建对象
var obj=new object
 (1)我们是利用 等号=赋值的方法 添加对象的属性和方法
（2）每个属性和方法之间用分号结束
    【2】利用new Object创建对象
        var obj=new Object() //创建了一个空的对象
        obj.uname='张三';
        obj.age=18;
        obj.sex="女";
        obj.sayhi=function () {
            console.log("hi");
        }
        console.log(obj.uname);
        console.log(obj['sex']);
        obj.sayhi();
        

利用构造函数创建对象
为什么我们要用构造函数创建对象
【1】我们一次创建一个对象，里面很多的属性和方法时大量相同的，我们只能复制
【2】我们可以利用函数的方法，重复这些下相同的代码，把这个函数称为构造函数
【3】这个函数不一样，里面封装的不是普通函数，而是  对象
【4】构造函数：就是吧我们对象里面一些相同的属性和方法抽象出封装到函数里面
   function 构造函数名() {  首字母要大写  Year
            this.属性=值;
            this.方法=function () {}
        }
        new 构造函数名();

 function Star(uname,age,sex) {
            this.name=uname;
            this.age=age;
            this.sex=sex;
            this.sing=function (SANG) {
                console.log(SANG);
            }
        }
        var l= new Star('小刘',18,"男")
        var z=new Star("小张",19,'女')
        console.log(l.name);
        console.log(l.sex);
        l.sing('冰雨');
        console.log(z.name);
        console.log(z.sex);
  我们只要new Star()  调用函数就创建一个对象1dh{}
  我们的属性和方法前面必须添加this

列题游戏：
  function WZRY(name,type,blood) {
            this.name=name;
            this.type=type;
            this.blood=blood;
          this.play=function (A){
              console.log(A);
          }
        }
        var lianpu=new WZRY('廉颇','力量型',500+"c");
        console.log(lianpu)
        lianpu.play('近战')
        var houyi=new WZRY('后裔','射手型',300+"c");
        console.log(houyi.name)
        console.log(houyi.type)
        console.log(houyi.blood)
        houyi.play('远战')
        
        构造函数：泛指的某一大类，它类似于Java语言的某一个类（class）；
        
        对象：指的是某一个具体人（个）
我们利用构造函数创建对象的过程我们也称为对象的实例化

new关键字执行的过程
【1】构造函数可以在内存中创建一个空的对象
【2】this就会指向刚才创建的空对象
【3】执行构造函数里面的代码，给这个空对象添加属性和方法
【4】返回这个对象
遍历对象


var obj={
            name:'A',
            age:18,
            sex:'女'
            fn:function (){
            66666
            }
        }
        // console.log(obj.name);
        // console.log(obj.age);
        // 我们可以用for  in  循环
        for (var k in obj){
            console.log(k);    k 变量 输出  得到的是  属性名
            console.log(obj[k]);    obj[k] 得到的是  属性值
        }
 我们使用for in 里面的变量 我们喜欢写k 或者 key

内置对象

  js里面的三大类：                 前两个对象是js基础内容，属于ECMAScript；
         (1) 自定义对象:自己创建的对象  var object={}
         (2)内置对象：手机自带的一种功能，js语言自带的一些对象，这些对象供
            开发者使用，并提供一些常用的或是最基本而必要的功能（属性和方法）
        （3）浏览器对象属于我们js独有的，我们js API讲解
        内置对象最大优点就是帮助我们快速开发
        js提供了多少内置对象L:Math,Date,Array,String等
文档查阅:可用MDN 或 W3C  来查阅
官方网址：https://developer.mozilla.org/zh-CN/

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

     var myMath={
            PI:3.1415926537,
            max:function (){
                var max=arguments[0];
                for(var i=1;i<arguments.length;i++){
                    if (arguments[i]>max){
                        max=arguments[i];
                    }
                }
                return max;
            },
            min:function (){
                var min=arguments[0];
                for(var i=1;i<arguments.length;i++){
                    if (arguments[i]<min){
                        min=arguments[i];
                    }
                }
                return min;
            }
        }
        console.log(myMath.PI)
        console.log(myMath.max(1,5,9))
        console.log(myMath.min(5,9,8))
        console.log(Math.abs('1'))//绝对值 隐式转换
        console.log(Math.abs('pink'));//NAN
        console.log(Math.floor(1.1))//向下取整1
        console.log(Math.ceil(1.1))//向上取整2
        console.log(Math.round(1.5))//四舍五入 2
        负数唯独5这个数在负数往大取

随机数的读取
console.log(Math.random());左闭右开【0，1）
随机点名

  function getRandom(min,max) {
            return Math.floor(Math.random() * (max - min + 1)) + min;
        }
        var arr=['A','B','C','D'];
        console.log(arr[getRandom(0,arr.length-1)]);

猜数字游戏

   function getRandom(min,max) {
            return Math.floor(Math.random() * (max - min + 1)) + min;
        }
        var random=getRandom(1,10);
        var flag=0;
        while (flag<3){
            var num =prompt('请猜出一到十里面的数字')
            flag++;
            if(num>random){
                alert('你猜大了');
            }else if(num<random){
                alert('你猜小了');
            }else{
                alert('猜对了')
                break;
            }
        }
        alert('输入次数上线，退出程序')

日期对象

Date()日期对象 是一个构造函数，必须使用new 来调用创建我们的日期对象
        (1)var arr=new Array();//创建一个数组对象
        (2)var obj=new Object();//创建一个对象实列
        (3)使用Date
        var date=new Date();
        console.log(date);
        var date1=new Date(2019,10,1);//Fri Nov 01 2019 00:00:00 GMT+0800 (中国标准时间)
        console.log(date1)
        var date2=new Date('2022-10-1 8:8:8')//Sat Oct 01 2022 08:08:08 GMT+0800 (中国标准时间)
        console.log(date2)
        Date 对象和math对象不一样，他是个构造函数，所以我们需要实列化后才能使用
        Date 实列用来处理日期和时间
         

## 格式改变

        var date=new Date()
        console.log(date.getFullYear());//返回当前的年份2022
        console.log(date.getMonth())//返回的月份小一个月 月份记的+1
        console.log(date.getDate())//正常返回
        console.log(date.getDay())//周日0-周六6
        //我们写一个格式化的年月日
        var year=date.getFullYear();
        var month=date.getMonth()+1;
        var dates=date.getDate()
        var arr=['星期日','星期一','星期二','星期三','星期四','星期五','星期六']
        var day=date.getDay()

        console.log('今天是：'+year+'年'+month+'月'+dates+'日 '+arr[day]);
      

## 要求封装一个函数返回当前的十分秒 格式：08：08：08

        function getTime() {
            var time=new Date()
            var h=time.getHours();
            h=h<10?"0"+h:h;
            var m=time.getMinutes();
            m=m<10?"0"+m:m;
            var s=time.getSeconds();
            s=s<10?"0"+s:s;
            return h+":"+m+":"+s;
        }
        console.log(getTime());
        
         加密独一无二*，
**时间戳*过去了就不会回来（时间戳能够证明某个数据在某个时间点就已经完整存在了。 
时间戳在区块链中与密码学相关的工作原理是节点会先对区块中的信息进行哈希加密生
成一个信息摘要也就是哈希值。通过相关的服务器提取该哈希值以及数据的时间信息。
 服务器会对哈希值进行二次加密生成时间戳。最后，返回到系统之中。这样做能够提
 高时间的不可篡改性和防伪的作用。时间戳也让每个区块按照时间顺序层层嵌套。）

          （1）通过 valueof()   gettime()
        var date=new Date()
        console.log(date.valueOf())//是我们现在时间据1970.1.1总的毫秒数
        console.log(date.getTime())
          （2）简单的写法(最常用的写法)
        var date1=+new Date()//+new date 就是返回的总的毫秒数
        console.log(date1)
          （3）h5新增的，获取毫秒数的总数
        console.log(Date.now());//



    倒计时案列（时间戳来计算）
        计算天数：parseInt(总秒数/60/60/24)
        计算小时：parseInt(总秒数/60/60%24)
        计算分数：parseInt(总秒数/60%60)
        计算当前秒数：parseInt(总秒数%60)
        function countDown(time) {
            var nowTime=+new Date()//返回的是当前时间总的毫秒数
            var input=+new Date(time)//返回用户输入时间的总毫秒数
            var times=(input-nowTime)/1000;//剩余时间总的秒数  1秒=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('2022-11-9 17:25:25'))

数组对象

   数组对象
        创建数组的两种方式
        1、利用数组字面量
        var arr=[1,2,3];
        console.log(arr[0]);
        2、利用 new Array()
        var arr1=new Array();
        var arr1=new Array(2)//这个2表示 数组的长度为2   里面有两个空的数组元素
        var arr2=new Array(2,3)//这样写表示里面有两个数组元素 时2和3
 判断是否为数组
                function reserse(arr) {
            if(Array.isArray(arr)){
                var newArr=[]
                for (var i=arr.length-1;i>=0;i--){
                    newArr[newArr.length]=arr[i]
                }
                return newArr;
            }else{
                return 'error 这个参数要求必须是数组格式[1,2,3]'
            }
        }
        console.log(reserse([1,2,3]))
        console.log(reserse(1,2,3))

  检测是否为数组
        //（1）instanceof 运算符 它可以用来检测是否为数组
        var arr=[]
        console.log(arr instanceof Array);
        var obj={}
        console.log(obj instanceof Array)
        //(2)Array.isArray(参数)   H5新增的方法，ie9以上版本支持
        console.log(Array.isArray(arr))
        console.log(Array.isArray(obj))

添加删除元素的方法  
		push（参数1）:末尾添加一个或多个元素，注意修改数组    返回新的长度
		
        var arr=[1,2,3]
        arr.push(4,'A');
        console.log(arr.push())//数组的长度。原数组长度发生变化
        console.log(arr);

        pop() ：删除数组最后一个元素，把数组长度减1无参数，修改原版组          返回它删除的元素值
        
        arr.pop();
        console.log(arr.pop())
        console.log(arr)
         unshift(参数1)：像数组的开头添加一个或更多元素，注意修改原数组         并返回新的长度、
         
        arr.unshift(0,'B')
        console.log(arr.unshift())
        console.log(arr)

       shift()：删除数组的第一个元素，数组长度减一无参数，修改原数组           并返回第一个元素的值
       

        console.log(arr.shift())
        console.log(arr)

  筛选数组
        var arr=[1500,2000,2000,2100,1000]
        newArr=[];
        for (var i=0;i<arr.length;i++){
            if (arr[i]<2000){
                // newArr[newArr.length]=arr[i];或
                newArr.push(arr[i]);
            }
        }
        console.log(newArr);

        翻转数组
        // reverse()  颠倒数组中的元素顺序，无参数     该方法会改变原来的数组，返回新的数组
        arr1=['A','B','C','D']
        console.log(arr1.reverse())
        // sort()     对数组元素进行排序             该方法会改变原来的数组，返回新的数组
        arr2=[1,56,6,45,6]
        arr2.sort(function (a,b) {
            return a-b//升序的顺序
            //return b-a降序的顺序
        })
        console.log(arr2)

数组对象
        indexOf()  数组中查找给定元素的第一个索引    返回值：如果存在返回索引,如果不存在则返回-1
        lastIdexOf() 在数组中最后一个索引          返回值：如果存在返回索引,如果不存在则返回-1
        var arr=['A','B','C','D','E'];
        console.log(arr.lastIndexOf('A'))
        console.log(arr.indexOf('B'))
        lastIndexOf从后往前    indexOf从前往后

        var arr=['A','A','B','B','B','C','D']
        数组去重复
        遍历旧数组，用indexof判断新数组中有没有该数字，无就返回-1
        封装一个去重的函数 unique 独一无二的
        function unique(arr) {
            newArr=[]
         for (var i=0;i<arr.length;i++){
             if(newArr.indexOf(arr[i])===-1){
                 newArr.push(arr[i]);
             }
           }
         return newArr
        }
        var demo=unique(['A','A','B','B','B','C','D'])
        console.log(demo)

数组转化成字符串
        toString()  把数组转换成字符串，逗号分隔每一项  返回追：返回一个字符串
        join (分隔符)  方法用于吧数组中所有元素转化成一个字符串  返回值：返回一个字符串
        var arr=['A','A','B','B','B','C','D']
        console.log(arr.toString())
        console.log(arr.join('&'))
       
        concat()  连接两个或多个数组，不影响原数组  返回一个新的数组
        slice()   数组截取slice(begin-end);    返回被截取项目的新数组
        splice()  数组删除splice(第几个开始，要删除的个数)  返回被删除项目的新数组，注意这个会影响原数组

 字符串对象
        对象才有 属性和方法 复杂数据类型才有 属性和方法
        简单数据类型为什么会有length 属性呢？
        基本包装对象
        var str='anday'
        console.log(str.length)
        // (基本包装类型--->简单数据类型包装成复杂数据类型)
        (1)把简单数据类型包装成复杂数据类型
        var temp=new String('andy')
        （2）把临时变量的值给 str
        str=temp
        (3)销毁这个临时变量
        temp=null

        字符串的不可变性：指的是里面的值不可变，虽然看上去可以改变内容
        但其实地址改变了，内存中新开辟了一个内存空间，指向了新开辟的地方
       【因为我们字符串的不可变所以不要大量的评接字符串，空间浪费】
         根据字符串的返回位置
        字符串所有的方法，都不会修改字符串本身（字符串是不可变的），操作完成都会返回一个新的字符串
       str.indexOf('要查找的字符',[起始的位置])

        var str='一去二三里。烟囱四五家，一'
        console.log(str.indexOf('一'))
        console.log(str.indexOf('一',1))//从索引号是1的位置开始往后查找 lastindexof()也是一样的

        查找字符串'hdschshbcvhbvhvvcgdsvcdh'中c出现的位置和次数
        var str='chdschshbcvhbvhvvcgdsvcdh'
        var str=['A','A','A','B','C','D']
        var index=str.indexOf('A')
        var num=0;
        while (index!==-1){
            console.log(index);
            index=str.indexOf('A',index+1)
            num++;
        }
        console.log('A出现的次数是'+num);

        根据位置返回字符
        chatAt(index)   根据位置返回字符（index字符串的索引号） 使用：str.charAt(0)
        var str='andy'
        // console.log(str.charAt(3))
        // 遍历字符串
        for(var i=0;i<str.length;i++){
            console.log(str.charAt(i));
        }
        // charCodeAt(index) 获取指定位置处字符的ASCLL码（index索引号） 使用str.charCodeAt(0)
        //目的：判断用户按下了哪个键，游戏开发，按下哪个键发射子弹
        console.log(str.charCodeAt(0))
        // str[index]  H5新增的 获取指定位置处字符      HTML5，IEB+支持和charAt()等效
        console.log(str[0]);

        返回字符串对象，有一个对象，来判断是否有该属性
        var o={
            age:18
        }
        if (o['age']){
            console.log('里面有该属性')
        }else{
            console.log('没有该属性')
        }
        找出最多的数
        var str='hfdcbjdsnckdsmcksvfd'
        var o={}
        for(var i=0;i<str.length;i++){
            var chars=str.charAt(i);
            if (o[chars]){
                o[chars]++
            }else{
                o[chars]=1
            }
        }
        console.log(o);
        //遍历对象
        var max=0;
        var ch=''
        for(var k in o){
            //k得到的是属性名
            //o[k]得到的是属性值
            if(o[k]>max){
                max=o[k]
                ch=k
            }
        }
        console.log(max)
        console.log('最多出现的次数是'+ch)

        concat(str1,str2,str3.....) 方法用于来链接两个或多个字符串，拼接字符串，等效于+，+更常用
        var str='A';
        console.log(str.concat('B'));
        // substr(start,length)  (从start位置开始索引号，length取的个数)
        var str1="ABCDEF";
        console.log(str1.substr(2,2))
        // slice（start,end） 从start位置开始，截取到end位置，end取不到（他们俩都是索引号）
        // substring(start,end)从start位置开始，截取到end位置，end取不到（他们俩都是索引号），不接受负值

        // （1）替换字符串replace('被替换的字符'，替换为的字符).他只会替换第一个字符
        var str2='AB'
        console.log(str2.replace('A','b'));

           （2）字符转换为数组，split('分隔符')

        concat(str1,str2,str3.....) 方法用于来链接两个或多个字符串，拼接字符串，等效于+，+更常用
        var str='A';
        console.log(str.concat('B'));
        // substr(start,length)  (从start位置开始索引号，length取的个数)
        var str1="ABCDEF";
        console.log(str1.substr(2,2))
        // slice（start,end） 从start位置开始，截取到end位置，end取不到（他们俩都是索引号）
        // substring(start,end)从start位置开始，截取到end位置，end取不到（他们俩都是索引号），不接受负值

        // （1）替换字符串replace('被替换的字符'，替换为的字符).他只会替换第一个字符
        var str2='AB'
        console.log(str2.replace('A','b'));
        eg:
        var str3='hdvwegfdvwejwe';
        while(str3.indexOf('o')!==-1){
            str3=str3.split('w','*')
        }
        console.log(str3)
        //（2）字符转换为数组，split('分隔符')
        var str4='red,pink,blue'
        console.log(str4.split(','))

		toUpperCase---->转换大写
        toLowerCase---->转换小写

简单数字类型和复杂数字类型

        简单数据类型:基本数据类型或者值类型，复杂类型又叫做应用类型
                  (值类型):在存储变量中存储的是值本身，因此叫做值类型
        （1）String  （2）number （3） boolean  （4）undefined  （5）null

        var timer=null;//简单数据类型null 返回是一个空的对象 object
        如果有个变量我们以后打算存储为对象，暂时没想好放啥，这个时候就给一个null就行
        console.log(typeof  timer)


        复杂数据类型(引用类型)
        在存储变量中存储的仅仅是地址(引用)，因此叫做引用数据类型
        通过 new关键字创建的对象(系统对象，自定义对象)，如Object,Array,Date等

        堆和栈的分配
        （1）（简单数据类型）  栈(操作系统)：由操作系统自动分配释放存储函数的参数值，局部变量的值等，其操作方式类似于数据结构的栈
        （2）（复杂数据类型）  堆(操作系统)：存储复杂类型(对象)，一般由程序员分配释放，由垃圾回收机制回收


  复杂参数类型引用
        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)//小张