我是靠谱客的博主 可耐金鱼,最近开发中收集的这篇文章主要介绍js第11(内置对象),觉得挺不错的,现在分享给大家,希望可以做个参考。

概述

内置对象

(1)js对象
1,自定义对象、内置对象、浏览器对象;
2,自定义对象和内置对象是js基础内容,属于ECMAScript;浏览器对象是js独有的;
3,内置对象是js语言中自带的一些对象,供给开发者使用,并提供一些常用的或是最基本而必要的功能;
4,内置对象:Math、Date、Array、String;
(2)查文档MDN
1,查阅该方法的功能;
2,查看里面参数的意义和类型;
3,查看返回值的意义和类型;
(3)Math对象
1,Math数学对象不是一个构造函数,不需要使用new调用,可以直接使用里面的属性和方法;
例子:利用对象封装自己的数学对象,里面有PI、最大值、最小值;

var myMath = {
            PI: 3.141592653,
            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(4, 8, 6));
        console.log(myMath.min(4, 8, 6));

2, Math对象具有数学常数和函数的属性和方法,跟数学相关的运算可以使用Math中的成员;
绝对值方法:Math.abs
三个取整方法:Math.floor(向下取整)、Math.ceil(向上取整)、Math.round(四舍五入)
随机数方法
1,Math.random(返回一个随机的小数、里面不跟参数)
2,return Math.random();得到一个大于等于0,小于1之间的随机数
3,return Math.random() * (max - min) + min;得到一个两数之间的随机数
例子:得到一个两个数之间的随机整数包括这两个数

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

例子:猜数字游戏

function getRandom(min, max) {
            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;
            }
        }

(4)Date对象
1,日期对象,是一个构造函数,必须使用new来调用和创建日期对象
2,使用Date:var date=new Date(); console.log(date);
3,如果没有参数,则返回当前系统的当前时间;
4,有参数的常见写法:数字型:2020,4,09 字符型(常用):‘2020-4-09 17:04:13’
日期格式化
getFullYear():获取当年
getMonth():获取当月(0-11)月份需要+1
getDate():获取当天日期
getDay():获取星期几(周日0到周六6)
getHours():获取当前小时
getMinutes():获取当前分钟
getSeconds():获取当前秒钟
例子:

var now = new Date();
        console.log(now.getFullYear());	

例子:封装一个函数返回当前的时分秒格式为:00:00:00

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());

获取Date总的毫秒数(时间戳)
1,获取的是距离1970年1月1号过来的毫秒数;
2,方法:valueOf、getTime

var date = new Date();
        console.log(date.valueOf());
        console.log(date.getTime());

简单方法(最常用):var date1 = +new Date(); console.log(date1);
H5新增: console.log(Date.now());
例子:倒计时(使用时间戳)

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

(5)Array对象
1,创建数组的两种方式:var arr=[] var arr1=new Array(2,3)
2,Array对象是一个构造函数,第二种创建函数的方式,括号里必须要有两个数组元素;只有一个表示数组的长度为2,里面有两个空的数组元素;
检测是否为数组
1,利用instanceof检测(是运算符):arr instanceof Array
2,利用Array.isArray(参数)H5新增的方法:Array.isArray(arr)
添加删除数组元素
1,push():在数组末尾添加一个或多个数组元素 arr.push(添加的元素) 返回值是新数组的长度console.log(arr.push(添加的元素));
2,unshift():在数组开头添加一个或多个数组元素 arr.unshift(添加的元素) 返回值是新数组的长度console.log(unshift.push(添加的元素));
3,pop():删除数组的最后一个元素arr.pop() 一次只能删除一个元素,没有参数,返回值是删除的那个元素 console.log(arr.pop());
4,shift():删除数组的第一个元素arr.shift() 一次只能删除一个元素,没有参数,返回值是删除的那个元素 console.log(arr.shift());
数组排序
1,翻转数组:arr.reverse()
2,冒泡排序:arr.sort(function(a,b){ return a-b;//升序排序 return b-a;//降序排序 })
数组索引
1,返回数组元素的索引号:indexOf(数组元素)、只返回第一个满足条件的索引号,从前往后查找、如果在数组中找不到该元素,则返回-1;
2,返回数组元素的索引号:lastIndexOf(数组元素)、只返回第一个满足条件的索引号,从后往前查找、如果在数组中找不到该元素,则返回-1;
3,例子:数组去重(封装一个去重的函数unique)

function unique(arr) {
            var newArray = [];
            for (var i = 0; i < arr.length; i++) {
                if (newArray.indexOf(arr[i]) == -1) {
                    newArray.push(arr[i]);
                }
            }
            return newArray;
        }
        var arr1 = unique([1, 5, 2, 5, 2, 4, 4, 6, 2]);
        console.log(arr1);

数组转换为字符串
1,利用toString转换 arr.toString()
2,利用join转换,可以添加分隔符 arr.join(分隔符)
(6)字符串对象
为了方便操作基本数据类型,js还提供了三个特殊的引用类型:String、Number、Boolean
基本包装类型:把简单数据类型包装成复杂数据类型,这样基本数据类型就有了属性和方法 ;
字符串的不可变:里面的值不可变,看上去可以改变内容,其实是又开辟了一个内存空间,地址改变了,所以建议不要大量拼接字符串;
根据字符返回位置 例子:查找字符串中某个字符出现的位置和次数

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

根据位置返回字符
1,返回指定位置的字符(index是字符串的索引号):str.charAt(index)
2,返回相应索引号的字符ASCII值目的:判断用户按了哪个键:str.charCodeAt(index)
3,获取指定位置的字符,和第一种等效(H5新增):str[index]
字符串操作方法
1,concat(str1,str2):拼接多个字符串等效于 ’ + ’
2,substr(截取的位置,截取的字符数):截取字符串,位置是索引号;
3,replace(被替换的字符,替换的字符):只会替换第一个字符
4,split(分隔符):字符串转换为数组

扩展(简单类型和复杂类型)

(1)概念
1,简单数据类型又叫做基本数据类型或者是值类型,复杂数据类型又叫做引用类型
值类型:在存储时变量中存储的是值本身,因此叫做值类型;
引用类型:在存储对象时存储的仅仅是地址(引用),因此叫做引用数据类型,通过new关键字创建的对象(系统对象,自定义对象)如:Object、Array、Date
(2)堆和栈
1,栈(操作系统):由操作系统自动分配释放存放函数的参数值、局部变量的值等。其操作方式类似数据结构中的栈,简单数据类型存放在栈里面
2,堆(操作系统):存储复杂类型(对象),一般由程序员分配释放,若程序员不释放,由垃圾回收机制回收,复杂类型存放到堆里面
(3)传参
1,简单类型传参:函数的形参可以看做是一个变量,当我们把一个值类型变量作为参数传给函数的形参时,其实是把变量在栈空间里的值复制了一份给形参,在方法内部对形参做任何修改,都不会影响到外部变量;
2,复杂类型传参: 函数的形参可以看做是一个变量,当我们把引用类型变量传给形参时,其实是把变量在栈空间里保存的堆地址复制给了形参,形参和实参其实保存的是同一个堆地址,所以操作的是同一个对象;

最后

以上就是可耐金鱼为你收集整理的js第11(内置对象)的全部内容,希望文章能够帮你解决js第11(内置对象)所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错,欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供,作为学习参考使用,或来自网络收集整理,版权属于原作者所有。
点赞(63)

评论列表共有 0 条评论

立即
投稿
返回
顶部