内置对象 数据类型

最新推荐文章于 2022-08-04 16:47:33 发布
最新推荐文章于 2022-08-04 16:47:33 发布
阅读量101 收藏 2
点赞数
分类专栏： 笔记 文章标签： 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61923897/article/details/120937115
版权

一、内置对象

 查文档

 

 1、Math 对象：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // Math数学对象 不是一个构造函数，所以不需要 new 来调用 而是直接使用里面的方法和属性即可
        console.log(Math.PI);     // 一个属性：圆周率
        console.log(Math.max(1 , 99 ,2023));             //2023
        console.log(Math.max(-1 , -9));   //-1
        console.log(Math.max(1 , 4, 'TFBOYS'));     //NaN
        console.log(Math.max());    //-Infinity
</script>
</head>
<body>
    
</body>
</html>

案例：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>

        // 案例∶封装自己的数学对象
        // 利用对象封装自己的数学对象里面有PI\最大值和最小值
        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;
            },
            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, 3, 2013, 2023));
        console.log(myMath.min(23, 454 ,67));
    </script>
</head>
<body>
    
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 1、绝对值方法：
        console.log(Math.abs(-10));     //10
        console.log(Math.abs(10));       //10
        console.log(Math.abs('-10'));     //10    隐式转换 ： 会把字符串型 '-10' 转换为数字型

        // 2、三个取整方法：
        // Math.floor()       //向下取整 往最小了取值
        console.log(Math.floor(1.4));       //1
        console.log(Math.floor(1.9));      //1
        console.log(Math.floor(3.8));       3


        // Math.ceil()    向上取整  往最大了取值   ceil 天花板
        console.log(Math.ceil(4.5));       //5
        console.log(Math.ceil(10.1));        //11
        console.log(Math.ceil(3.9));             //4


        // Math.round()   四舍五入     其他数字都是四舍五入   但是  .5  特殊 它往大了取
        console.log(Math.round(3.5));         //4
        console.log(Math.round(8.9));       //9
        console.log(Math.round(2.1));        //2
        console.log(Math.round(-4.5));       //-4


    </script>
</head>
<body>
    
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // Math对象随机数方法   random（）  返回一个随机的小数   0 <= x < 1
        // 这个方法里面不跟参数
        // 代码验证
        console.log(Math.random());


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


        // 随机点名
            function getRandom(max , min){
               
                return Math.floor(Math.random() * (max - min + 1)) + min;
            }
            var arr = ['王俊凯' , '王源', '易烊千玺', '王凯莉', '罗伊', '刘艳芬'];
            console.log(arr[getRandom(0 ,arr.length -1)]);
    </script>
</head>
<body>
    
</body>
</html>

案例：

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>

        // 案例︰猜数字游戏
        // 程序随机生成一个1~10之间的数字，并让用户输入一个数字，
        // 1.如果大于该数字，就提示，数字大了，继续猜﹔
        // ⒉如果小于该数字，就提示数字小了，继续猜;
        // 3.如果等于该数字，就提示猜对了，结束程序。

        // 案例分析
        // 随机生成一个1~10的整数我们需要用到 Math.random0方法。
        // 需要一直猜到正确为止，所以一直循环。
        // 用while循环合适更简单。
        // 核心算法∶使用if else if多分支语句来判断大于、小于、等于。

        function getRandom(max , min){ 
               return Math.floor(Math.random() * (max - min + 1)) + min;
           }
           var random = getRandom(1, 10);
           while(true){      //死循环
               var num = prompt('你来猜？ 输入1~10之间的一个数字');
               if( num > random){
                   alert('你猜大了');

               } else if( num < random){
                   alert('你猜小了');
               } else {
                   alert('你好棒棒哦！猜对了哦');
                   break;     //退出整个循环结束进程
               }
           }

2、日期对象：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // Date()  日期对象 是一个构造函数，必须使用new 来调用创建日期对象
        // 1、使用Date   如果没有参数 返回当前系统的当前时间
       var date =  new Date();
       console.log(date);

    //    2、参数常用的写法  数字型：2013，  08 ，06    或者是 字符串型  '2013-08-06  8:8:8'
    var date1 = new Date(2023, 08 ,06);
    console.log(date1);

    var date2 = new Date('2013-7-28 12:13:45');
    console.log(date2);
    </script>
</head>
<body>
    
</body>
</html>

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 格式化日期 年月日
        var date = new Date();
        console.log(date.getFullYear());        //返回当前日期的年  2021
        console.log(date.getMonth() +1);       //月份 返回的月份小一个月 记得月份+1   10月
        console.log(date.getDate());      //返回的是几号
        console.log(date.getDay());   // 0  周一返回的是1 ，周六返回的是6  但是周日返回的是0


        // 写一个 2021年 10月 24日 星期日
        var year =date. getFullYear();
        var month = date.getMonth() +1;
        var dates= date.getDate();
        var arr = ['星期日', '星期一', '星期三', '星期四' , '星期五' , '星期六'];
        var day = date.getDay();
        console.log('今天是：' + year + '年' + month + '月' + dates + '日\t' + 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 ;
            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());

    </script>
</head>
<body>
    
</body>
</html>

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>

        // 获得Date总的毫秒数(时间戳)  不是当前时间的毫秒数  而是距离1970年1月1号过来多少毫秒数
        // 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());
    </script>
</head>
<body>
    
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 案例∶倒计时效果
        // 做一个倒计时效果

        // 案例分析
        // 核心算法∶输入的时间减去现在的时间就是剩余的时间，即倒计时，但是不能拿着时分秒相减，比如05分减去25分，结果会是负数的。

        // 用时间戳来做。用户输入时间总的毫秒数减去现在时间的总的毫秒数，得到的就是剩余时间的毫秒数。

        // 把剩余时间总的毫秒数转换为天、时、分、秒（时间戳转换为时分秒)

        // 转换公式如下:
        // d = parselnt(总秒数/60/60/24);            计算天数
        // h = parselnt(总秒数/60/60%24);            计算小时
        // m = parselnt(总秒数/60 %60);              计算分数
        // s = parselnt(总秒数%60);                  计算当前秒数

        function countDown(time){
            var nowTime = +new Date();     //返回的是当前时间总的毫秒数
            var inputTime = +new Date(time);     //返回的是用户输入时间总的毫秒数
            var times = (inputTime - nowTime) / 1000;    //time 是剩余时间总的秒数
            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('2021-10-25 00:00:00'));

    </script>
</head>
<body>
    
</body>
</html>

 3、数组对象：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 创建数组对象Array的两种方式   
        // 1、利用数组字面量
        var arr = [1,2,3];
        console.log(arr[0]);

        // 2、利用 new Array()
        var arr1 = new Array();    //创建了一个空的数组
        var arr2 = new Array(2);      //这个2 表示 数组的长度为2  里面有两个空的数组元素
        console.log(arr2);   
        var arr3 = new Array(2, 3);    //等价于[2 ,3]这样写表示里面有2个数组元素  是 2 和3
        console.log(arr3);
    </script>
</head>
<body>
    
</body>
</html>

检测是否为数组的方法：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 翻转数组
        function reverse(arr){
            // if(arr instanceof Array){
                if(Array.isArray(arr)){
                 var newArr = [];
            for(var i = arr.length -1 ; i >= 0; i--){
                newArr[newArr.length] = arr[i];

            }
            return newArr;
            }else {
                return '这个参数要求是数组格式 [1, 2, 3]'
            }
           

        }
        console.log(reverse([1, 2, 3]));
        console.log(reverse(1, 2, 3));


        // 检查是否为数组
        // (1)  instanceof  运算符  它可以用来检测是否为数组
        var arr = [];
        var obj = {};
        console.log(arr instanceof Array);
        console.log(obj instanceof Array);



        // (2)  Array.isArray(参数)    H5新增的方法  IE9以上版本支持
        console.log(Array .isArray(arr));
        console.log(Array .isArray(obj));

    </script>
</head>
<body>
    
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 添加数组元素方法
        // 1、 push() 在我们数组的末尾添加一个或者多个数组元素    push 推
        var arr = [1, 2, 3];
        // arr.push(5, 'TFBOYS');
        console.log(arr.push(5, 'TFBOYS'));
        console.log(arr);
        // //(1) push是可以给数组追加新的元素
        // //(2) push(参数直接写数组元素就可以了
        // (3) push完毕之后，返回的结果是新数组的长度
        // (4)原数组也会发生变化



        // 2、unshift  在我们数组的开头 添加一个或多个数组元素
        console.log(arr.unshift('王俊凯', '王源', '易烊千玺'));
        console.log(arr);
        //  (1)unshift是可以给数组前面追加新的元素
        //  (2)unshift(）参数直接写数组元素就可以了
        //  (3)unshift完毕之后，返回的结果是新数组的长度
        //  (4）原数组也会发生变化



          // 删除数组元素方法
        //   3、 pop()  可以删除数组的最后一个元素
        // arr.pop();
        console.log( arr.pop());
        console.log(arr);
        // (1）pop是可以删除数组的最后一个元素记住一次只能删除一个元素
        // (2) pop()）没有参数
        // (3）pop完毕之后，返回的结果是删除的那个元素
        // (4）原数组也会发生变化

        // 4、shift()   可以删除数组第一个元素
        console.log(arr.shift());
        console.log(arr);
        // (1）shift是可以删除数组的最后一个元素记住一次只能删除一个元素
        // (2) shift()）没有参数
        // (3）shift完毕之后，返回的结果是删除的那个元素
        // (4）原数组也会发生变化
    </script>
</head>
<body>
    
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
   <script>
    //    案例︰筛选数组
    // 有一个包含工资的数组[1500,1200,2000,2100,1800]，
    // 要求把数组中工资超过2000的删除，剩余的放到新数组里面
    var arr = [1500,1200,2000,2100,1800];
    var 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);
   </script>
</head>
<body>
    
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 数组排序
        // 1、翻转数组
        var arr = ['王俊凯', '王源', '易烊千玺'];
        arr.reverse();
        console.log(arr);

        // 2、数组排序（冒泡排序）
        var arr1 = [12 , 6, 46, 8];
        arr1.sort(function(a ,b){
            // return a-b;     //升序的顺序排列
            return b-a;        //降序的顺序排列
        });
        console.log(arr1);

    </script>
</head>
<body>
    
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 数组索引
        // 返回数组元素索引号方法  indexOf（数组元素）  作用就是返回该数组元素的索引号  从前面开始查找
        // 它只返回第一个满足条件的索引号
        // var arr = ['red' , 'green' , 'blue', 'pink']
        var arr = ['red' , 'green' , 'pink']
        console.log(arr.indexOf('blue'));     //-1


        //  返回数组元素索引号方法  lastIndexOf（数组元素）  作用就是返回该数组元素的索引号  从后面开始查找
         var arr = ['red' , 'green' , 'blue', 'pink' , 'blue']
        console.log(arr.lastIndexOf('blue'));   // 4
    </script>
</head>
<body>
    
</body>
</html>

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 案例︰数组去重(重点案例)
        // 有一个数组[ 'c','a', 'z', 'a', 'x', 'a', 'x', 'c'，'b' ]，
        // 要求去除数组中重复的元素。

        // 案例分析
        // 目标:把旧数组里面不重复的元素选取出来放到新数组中，重复的元素只保留一个，放到新数组中去重。
        // 核心算法:我们遍历日数组，然后拿着旧数组元素去查询新数组，如果该元素在新数组里面没有出现过，我们就添加，否则不添加。
        // 我们怎么知道该元素没有存在? 利用新数组.indexOf(数组元素)    如果返回时-1就说明新数组里面没有改元素
        // 旧数组[ 'c', 'a， , 'z', 'a' , 'x，, 'a', 'x', 'c', 'b"]
        // 新数组[]
        // 封装一个去重函数   unique   

        function unique(arr){
            var newArr = [];
            for(var i = 0; i < arr.length; i++){
                if(newArr.indexOf(arr[i]) === -1){
                    newArr.push(arr[i]);
                }
            }
            return newArr;

        }
        var demo = unique( [ 'c','a', 'z', 'a', 'x', 'a', 'x', 'c','b' ] );
        console.log(demo);
    </script>
</head>
<body>
    
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 数组转换为字符串
        // 1、 toString()  将我们的数组转换为字符串
        var arr = [1 , 2 , 3];
        console.log(arr.toString());


        // 2、 join(分隔符)
        var arr1 = ['王俊凯' , '王源', '易烊千玺'];
        console.log(arr1.join());          //王俊凯,王源,易烊千玺
        console.log(arr1.join('|'));        //王俊凯|王源|易烊千玺
        console.log(arr1.join('&'));        //王俊凯&王源&易烊千玺

    </script>
</head>
<body>
    
</body>
</html>

 4、字符串对象：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 基本包装类型
        var str = 'TFBOYS';
        console.log(str.length);

        // 对象才有属性和方法 复杂数据类型 才有属性和方法
        // 简单数据类型为什么会有length 属性呢？

        // 基本包装类型 ： 就是把简单数据类型 包装成了 复杂数据类型
        // (1) 把简单数据类型 包装为 复杂数据类型
        var temp = new String('四叶草');
        
        // (2)把临时变量的值 给str
        str = temp;

        // (3)  销毁这个临时变量
        temp = null;
        console.log(str);
    </script>
</head>
<body>
    
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 字符串的不可变
        var str = 'TFBOYS';
        console.log(str);
        str = '添福宝';
        console.log(str);


        // 因为字符串的不可变，所以不要大量的拼接字符串  因为可能会导致电脑卡死
        var str = '';
        for(var i = 1; i< 100000000; i++){
            str +=  i;
        }
        console.log(str);

    </script>
</head>
<body>
    
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 字符串对象  根据字符返回对象  str.indexOf('要查找的字符' , [起始的位置])
        var str = '改革春风吹满地 ， 春天来啦';
        console.log(str.indexOf('春'));
        console.log(str.indexOf('春' , 3));   //从索引号是3的位置开始往后查找
    </script>
</head>
<body>
    
</body>
</html>

 

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 案例:返回字符位置
        // 查找字符串"abcoefoxyozzopp"中所有o出现的位置以及次数

        // 核心算法:先查找第一个o出现的位置
        // 然后只要indexOf返回的结果不是-1就继续往后查找
        // 因为indexOf只能查找到第一个，所以后面的查找，利用第二个参数，当前索引加1，从而继续查找

        var str = "abcoefoxyozzopp";
        var index = str.indexOf('o');
        var num = 0;
        while(index !== -1){
            console.log(index);
            num++;
            index = str.indexOf('o' , index+1);
        }
        console.log('o出现的次数是:' + num);

        

        //课后作业[ "red' , 'blue' , 'red', 'green ' , 'pink ' , ' red']，求red 出现的位置和次数
        var arr = ['red' , 'blue' , 'red', 'green', 'pink', 'red'];
        var index = arr.indexOf('red');
        var num = 0;
        while(index !== -1){
            console.log(index);
            num++;
            index = arr.indexOf('red' , index+1);
        }
        console.log('red出现的次数是：' +num);

    </script>
</head>
<body>
    
</body>
</html>

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>

    <script>
        // 根据位置返回字符
        // 1、charAt(index)  根据位置返回字符
        var str = 'TFBOYS';
        console.log(str.charAt(3));

        // 遍历所有的字符
        for(var i =0; i< str.length; i++){
            console.log(str.charAt(i));
        }



        // 2、charCodeAt(index)  返回相应索引号的字符ASCII值  目的：判断用户按下了哪个键
        console.log(str.charCodeAt(0));    //84


        // 3、str[index]  H5新增的
        console.log(str[0]);
    </script>
</head>
<body>
    
</body>
</html>

 

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 有一个对象   来判断是否有该属性
        var o = {
            age :10 
        }
        if(o['sex']){
            console.log('里面有该属性');

        } else {
            console.log('没有该属性');
        }

        // 案例∶返回字符位置
        // 判断一个字符串'abcoefoxyozzopp'中出现次数最多的字符，并统计其次数。
        
        // 案例∶核心算法
        // 判断一个字符串'abcoefoxyozzopp'中出现次数最多的字符，并统计其次数。
        // 核心算法∶利用charAt()遍历这个字符串
        // 把每个字符都存储给对象，如果对象没有该属性，就为1，如果存在了就+1
        // 遍历对象，得到最大值和该字符

            var str = 'abcoefoxyozzopp';
            var o = {};
            for(var i = 0; i < str.length; i++){
                var chars = str.charAt(i);      //chars  是字符串的每一个字符
                if(o[chars]){
                    o[chars]++;
                } else{
                    o[chars] = 1;
                }
            }
            console.log(o);


            // 2、遍历对象
            var max = 0;
            var ch = '';
            for(var k in o){
                // k得到的是属性名
                // o[k]得到的是属性值
                if(o[k] > max){
                    max = o[k];
                    ch = k;
                }
            }
            console.log('最多的字符是'+ch);
            console.log(max);
    </script>
</head>
<body>
    
</body>
</html>

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 字符串操作方法
        // 1、concat('字符串1' , '字符串2' , '字符串3' ... )
        var str = 'TFBOYS';
        console.log(str.concat('四叶草'));


        // 2、substr('截取的起始位置', '截取几个字符');
        var str1 = '橙海不会暗，我啵不会散';
        console.log(str1.substr(2,2));    //第一个2：是索引号的2从第几个开始    第二个2  是取几个字符
        



    </script>
</head>
<body>
    
</body>
</html>

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 1、替换字符  replace('被替换的字符', '替换为的字符')   只会替换第一个字符
        var str = '王俊凯';
        console.log(str.replace('王','A'));
        // 有一个字符串' abcoefoxyozzopp'要求把里面所有的 o 替换为 *
        var str1 = 'abcoefoxyozzopp';
        while(str1.indexOf('o') !== -1){
            str1 = str1.replace('o' , '*');
        }
        console.log(str1);

        // 2、字符转换为数组 split('分隔符')   前面学过 join 把数组转为字符串
        var str2 = 'red , blue, yellow';
        console.log(str2.split(','));

        var str3 = 'red&blue&yellow';
        console.log(str3.split('&'));


    </script>
</head>
<body>
    
</body>
</html>

 

 

 

 

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 简单数据类型  null   返回的是一个空的对象 object
        var timer = null;
        console.log(typeof timer);
        // 如果有个变量以后打算存储为对象，但是暂时没想好放啥，这个时候就给 null
        // 1、简单数据类型 是存放在栈里面 里面直接开辟一个空间存放的是值
        // 2、复杂数据类型  首先在栈里面存放地址 十六进制表示  然后这个地址指向堆里面的数据
    </script>
</head>
<body>
    
</body>
</html>

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 简单数据类型传参
        function fn(a){
            a++;
            console.log(a);
        }
        var x = 10;
        fn(x);
        console.log(x);
    </script>
</head>
<body>
    
</body>
</html>

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        // 复杂数据类型传参
        function Person(name){
            this.name = name;
        }


        function f1(x){   //x = p
            console.log(x.name);     //2、这个输出什么？   王源
            x.name = '王俊凯';
            console.log(x.name);    //3、这个输出什么？  王俊凯
        }
        var p = new Person('王源');
        console.log(p.name);     //1、这个输出什么   王源
        f1(p);
        console.log(p.name);   //4、这个输出什么？  王俊凯
    </script>
</head>
<body>
    
</body>
</html>

添福宝615
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript基础第06天笔记
Smart_coding的博客
09-03 185
JavaScript基础第06天笔记 1 - 内置对象 1.1 内置对象 ​ JavaScript 中的对象分为3种：自定义对象 、内置对象、 浏览器对象 ​ 前面两种对象是JS 基础 内容，属于 ECMAScript； 第三个浏览器对象属于 JS 独有的， JS API 讲解内置对象就是指 JS 语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是最基本而必要的功能（属性和方...
object数据类型
weixin_30807677的博客
06-11 1028
1 object数据类型是dataframe中特殊的数据类型,当某一列出现数字、字符串、特殊字符和时间格式两种及以上时,就会出现object类型,即便把不同类型的拆分开,仍然是object类型. 如下replace()函数改变数据类型后,用astype()函数再转化一次才能将object格式转化,但有的时候不用. print(train.info()) train['repay_date...
九大内置对象及其数据类型
weixin_30361641的博客
07-04 59
JSP中一共预先定义了9个这样的对象，分别为：request、response、session、application、out、pagecontext、config、page、exception 1、request对象 request 对象是 javax.servlet.httpServletRequest类型的对象。 该对象代表了客户端的请求信息，主要用于接受通过HTTP协议传送到服务器的数...
内置对象类型
weixin_47700141的博客
02-21 4601
初步了解对象 Python研究什么？ 比如：要写一个点外卖的程序，这个现实问题涉及哪些要素？ 如果把上述的要素描述清楚，就如同制造了三个模型，剩下的事情只需要把三个模型组合起来，就能实现“点外卖”了。 因此，Python研究的是要素，并把这些要素统一命名为“对象”，即Python认为，“世界是由对象组成的”。 涉及的概念：对象、类、内置对象类型、内置对象 对象的特征？ 数字 整数（integer） 分解type(3)的使用方式 查看文档 “内置函数”的所有使用方法都在Python帮助文档中，阅读的方式.
九大内置对象与其详解
杨小白的博客
08-24 936
一、什么是内置对象? 在jsp开发中会频繁使用到一些对象，如ServletContext HttpSession PageContext等。如果每次我们在jsp页面中需要使用这些对象都要自己亲自动手创建就会特别的繁琐。SUN公司因此在设计jsp时，在jsp页面加载完毕之后自动帮开发者创建好了这些对象，开发者只需要使用相应的对象调用相应的方法即可。这些系统创建好的对象就叫做内置对象。 在serv...
Python 对象中的数据类型
12-23
计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。 class 指自定义类型，type 指内置类型。两者都表示数据类型，称呼不同而已 每个对象都...
浅析C++ 数据类型
12-17
为了能够体现C++语言和传统C语言在非基本数据类型上的区别，在这里把能够体现面向对象特性的非基本数据类型成为构造函数类型，而将其他非基本数据类型称为复合数据类型。C++的数据类型数据如下图所示： 基本数据...
PHP面向对象程序设计内置标准类，普通数据类型转为对象类型示例
10-16
主要介绍了PHP面向对象程序设计内置标准类，普通数据类型转为对象类型,结合实例形式分析了php面向对象程序设计中的内置标准类，普通数据类型概念、功能及对象类型转换相关操作技巧,需要的朋友可以参考下
Python-内置数据类型.zip
最新发布
05-27
==================内置数据类型========================= 第二章 009.程序的构成 010.对象的基本组成和内存示意图 011.引用的本质_栈内存和堆内存_内存示意图 012.标识符_帮助系统的简单使用_命名规则 013....
“jsp内置对象”单元习题.doc
11-16
JSP内置对象是JavaServer Pages（JSP）技术中的一种重要概念，它提供了一些预定义的对象，这些对象可以在JSP页面中直接使用，帮助开发者快速构建基于Web的应用程序。这些内置对象包括Request对象、Response对象、...
JS内置对象和数据类型20200420
luojunjie1999的博客
04-21 137
查文档 查文档学习不同对象，在mdn中查 math对象 不是构造函数，不用new可以直接使用 圆周率：Math.PI 绝对值：Math.abs() 向下取整：Math.floor() 向上取整：Math.ceil() 四舍五入（数字.5会往大取整）：Math.round() 随机数：Math.random()，随机数的范围：[0，1) 前闭后开 使用方法：math.random() 1到10取整：...
九大内置对象
yuanmomoya的博客
09-08 1594
jsp的9大内置对象(隐含对象)：在jsp页面翻译后的servlet的service方法中初始化过的对象   面试题               jsp脚本片段和jsp表达式在翻译后会翻译到service方法中，所以可以直接使用service方法内初始化 的对象               范围对象： 在一定范围内对象仍然存在，可以共享数据 javaWeb主要用四个域对象         ...
内置对象及使用方法
m0_62337846的博客
03-30 412
创建的对象的方式: 通过调用系统的构造函数创建对象new object() var obj1=new object(); 2.自定义构造函数创建对象 var obj2=new自定义构造函数(); 3.字面量的方式创建对象 var obj3={}; 变量instanceof 对象------->布尔类型,判断这个变量是不是这个类型的 JSON格式的数据,都是键值对,成对的数据 var obj={ name : "小明” }; var json={ "name" : "小明..
Effective C++读书笔记之确定对象被使用前已被初始化
张小酒的博客
01-10 372
为内置型对象进行手工初始化，因为c++不保证初始化它们。构造函数最好使用成员初值列(member initialization list )，而不要在构造函数本体内使用赋值操作(assignment )。初值列列出的成员变量，其排列次序应该和它们在class中的声明次序相同。为免除“跨编译单元之初始化次序”问题，请以local static对象替换non-local static对象。
C++内置类型对象之间的隐式转换
懒人_人懒
03-28 735
C++内部类型间的隐式转换发生在下列典型的情况：1. 在混合类型的算术表达式中    在这种情况下最宽的数据类型成为目标转换类型，例如：    int ival = 3;    double dval = 3.14259;    ival + dval;     // ival被提升为double类型：3.02. 用一种类型的表达式复制给另一种类型的对象    在这种情况下目标转换类型是被赋值对象...
JavaScript基础第06天笔记——内置对象、简单数据类型和复杂数据类型
m0_55879104的博客
08-04 172
​ 前面两种对象是JS 基础 内容，属于 ECMAScript；第三个浏览器对象属于 JS 独有的， JS API 讲解内置对象就是指 JS 语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是。
JavaScript的基本数据类型、内置对象
04-25
JavaScript 的基本数据类型包括：字符串 (String)、数值 (Number)、布尔值 (Boolean)、空值 (null)、未定义值 (undefined)。 JavaScript 的内置对象包括：全局对象 (Global Object)、数组 (Array)、日期 (Date)、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值