javascript中是否有內建物件

javascript中有內建物件。內建物件是JS語言自帶的一些物件，常見的有：String物件、Array物件、Date物件、Boolean物件、Number物件、Math物件、RegExp物件、Global物件等等。

本教學操作環境：windows7系統、javascript1.8.5版、Dell G3電腦。

JavaScript中的物件分為3中：自定義物件、內建物件、瀏覽器物件

前面兩種物件是JS基礎內容，屬於ECMAScript；第三個瀏覽器物件屬於我們JS獨有的

內建物件就是指JS語言自帶的一些物件，這些物件供開發者使用，並提供了一些常用的或是最基本而必要的功能（屬性和方法）

內建物件最大的優點就是幫助我們快速開發

JavaScript提供了多個內建物件，Math、Date、Array、String等

• String物件：字串物件，提供了對字串進行操作的屬性和方法。

• Array物件：陣列物件，提供了陣列操作方面的屬性和方法。

• Date物件：日期時間物件，可以獲取系統的日期時間資訊。

• Boolean物件：布林物件，一個布林變數就是一個布林物件。(沒有可用的屬性和方法)

• Number物件：數值物件。一個數值變數就是一個數值物件。

• Math物件：數學物件，提供了數學運算方面的屬性和方法。

• Object物件

• RegExp物件

• Global物件

• Function物件

• .....

Math物件

// Math數學物件 不是一個建構函式，所以我們不需要 new來呼叫 而是直接使用裡面的屬性和方法即可
        console.log(Math.PI); //一個屬性 圓周率
        console.log(Math.max(1, 2, 99)); //99
        console.log(Math.max(-1, -12)); //-1
        console.log(Math.max(1, 99, '數學物件')); //NaN
        console.log(Math.max()); //-Infinity

案例：封裝自己的數學物件

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(1, 5, 9));
        console.log(myMath.min(1, 5, 9));

1Math概述

Math物件不是建構函式，它具有數學常數和函數的屬性和方法。跟數學相關的執行（求絕對值，取整，最大值等）可以使用Math中的成員。

Math.PI                 //圓周率
Math.floor()           //向下取整
Math.ceil()            //向上取整
Math.round()           //四捨五入版  就近取整 注意-3,5  結果是 -3
Math.abs()             //絕對值
Math.max()/Math.min()  //求最大和最小值

// 1.絕對值方法
        console.log(Math.abs(1));    //1
        console.log(Math.abs(-1));   //1
        console.log(Math.abs('-1')); //隱式轉換 會把字串型 -1 轉換為數位型
        console.log(Math.abs('wode')); //NaN

// 2.三個取整方法
// (1)Math.floor()  地板 向下取整 往最小了取整
        console.log(Math.floor(1.1));   //1
        console.log(Math.floor(1.9));   //1
// (2)Math.ceil()   ceil 天花板 向上取整 往最大了取整
        console.log(Math.ceil(1.1));   //2
        console.log(Math.ceil(1.9));   //2
// (3)Math.round()   四捨五入  其他數位都是四捨五入，但是 .5特殊，它往大了取
        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亂數方法 random（）

//1. Math物件亂數方法 random() 返回一個隨機的小數  0 =< x < 1
//2.這個方法裡面不跟引數
// 3.程式碼驗證
        console.log(Math.random());
// 4.我們想要得到兩個數之間的隨機整數 並且包含這兩個數
        // return 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));
// 5.隨機點名
        var arr = ['張三', '李四', '王五', '趙六', '張三瘋']
            // console.log(arr[0]);
            // 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) { //死迴圈
            var num = prompt('你來猜，輸入1~10之間的一個數位');
            if (num > random) {
                alert('猜大了');
            } else if (num < random) {
                alert('猜小了');
            } else {
                alert('猜對了');
                break;
            }
        }

// 要求使用者猜1~50之間的一個數位 但是隻有10次猜的機會
        function getRandom(min, max) {
            return Math.floor(Math.random() * (max - min + 1)) + min;
        }
        var random = getRandom(1, 50);
        var i = 0;
        while (i < 10) { //死迴圈
            var num = prompt('你來猜，輸入1~50之間的一個數位');
            if (num > random) {
                alert('猜大了');
            } else if (num < random) {
                alert('猜小了');
            } else {
                alert('猜對了');
                break; //退出整個迴圈結束程式
            }
            i++;
        }
        if (i = 10) {
            alert('全部猜錯了');
        }

日期物件

1Date概述

• Date物件和Math物件不一樣，他是一個建構函式，所以我們需要範例化後才能使用
• Date範例用來處理日期和時間

2Date()方法的使用

1.獲取當前時間必須範例化

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

2.Date()建構函式的引數

如果括號裡面有時間，就返回引數裡面的時間，例如日期格式字串為‘2019-5-1’，可以寫成new Date('2019-5-1')或者new Date('2019/5/1')

//Date() 日期物件 是一個建構函式 必須使用new 來呼叫建立我們的日期物件
        var arr = new Date(); //建立一個陣列物件
        var obj = new Object(); //建立了一個物件範例
// 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);

3日期格式化

我們想要2019-8-8 8:8:8格式的日期，要怎麼辦？

需要獲取日期指定的部分，所以我們要手動的得到這種格式

// 格式化日期  年月日
        var date = new Date();
        console.log(date.getFullYear()); //返回當前日期的年 2020
        console.log(date.getMonth() + 1); //月份 返回的月份小1個月 記得月份 +1
        console.log(date.getUTCDate()); //返回的是幾號
        console.log(date.getDay()); //6 週一返回的是 1  週六返回的是 6 但是 週日返回的是 0
// 寫一個 2020年 5月 23日 星期六
        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]);
        
// 格式化日期 時分秒
        var date = new Date();
        console.log(date.getHours()); //時
        console.log(date.getMinutes()); //分
        console.log(date.getSeconds()); //秒
// 要求封裝一個函數返回當前的時分秒  格式是 08:08:08
        function getTimer() {
            var time = new Date();
            var h = date.getHours();
            h = h < 10 ? '0' + h : h;
            var m = date.getMinutes();
            m = m < 10 ? '0' + m : m;
            var s = date.getSeconds();
            s = s < 10 ? '0' + s : s;
            return h + ':' + m + ':' + s;
        }
        console.log(getTimer());

4獲取日期的總的毫秒形式

Date物件是基於1970年1月1日（世界標準時間）起的毫秒數

我們經常利用總的毫秒數來計算時間，因為它更精確

// 獲取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());

案例：倒計時效果

// 倒計時效果
// 1.核心演演算法：輸入的時間減去現在的時間就是剩餘的時間，即倒計時，但是不能拿著時分秒相減，比如05分減去25分，結果會是負數的
// 2.用時間戳來做，使用者輸入時間總的毫秒數減去現在時間的總的毫秒數，得到的就是剩餘時間的毫秒數
// 3.把剩餘時間總的毫秒數轉換為天、時、分、秒(時間戳轉換為時分秒)
// 轉換公式如下：
// d = parseInt(總秒數 / 60 / 60 / 24); //計算天數
// h = parseInt(總秒數 / 60 / 60 % 24); //計算小時
// m = parseInt(總秒數 / 60 % 60); //計算分數
// s = parseInt(總秒數 % 60); //計算當前秒數
        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-5-24 00:00:00'));
        var date = new Date();
        console.log(date);

陣列物件

1陣列物件的建立

建立陣列物件的兩種方式

• 字面量方式
• new Array()

// 建立陣列的兩種方式
// 1.利用陣列字面量
        var arr = [1, 2, 3];
        console.log(arr);
// 2.利用new Array()
        // var arr1 = new Array(); //建立了一個空的陣列
        // var arr1 = new Array(2); //這個2 表示 陣列的長度為 2 裡面有兩個空的陣列元素
        var arr1 = new Array(2, 3); //等價於[2,3] 這樣寫表示 裡面有2個陣列元素 是2和3
        console.log(arr1);

2檢測是否為陣列

// 翻轉陣列
        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 'error 這個引數要求必須是陣列格式[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));

3新增刪除陣列元素的方法

// 新增刪除陣列元素的方法
// 1.push() 在我們陣列的末尾 新增一個或者多個陣列元素 push 推
        var arr = [1, 2, 3];
        // arr.push(4, 'white');
        console.log(arr.push(4, 'white')); //5 陣列長度
        console.log(arr);
        // (1)push 是可以給陣列追加新的元素
        // (2)push() 引數直接寫 陣列元素就可以了
        // (3)push完畢之後，返回的結果是 新陣列的長度
        // (4)原陣列也會發生變化

//2.unshift 在我們陣列的開頭 新增一個或者多個陣列元素
        console.log(arr.unshift('red', 'green')); //7
        console.log(arr);
        // (1)unshift 是可以給陣列前面追加新的元素
        // (2)unshift() 引數直接寫 陣列元素就可以了
        // (3)unshift完畢之後，返回的結果是 新陣列的長度
        // (4)原陣列也會發生變化

// 3.pop() 它可以刪除陣列的最後一個元素
        console.log(arr.pop()); //white
        console.log(arr);
        // (1)pop 是可以刪除陣列的最後一個元素  一次只能刪除一個元素
        // (2)pop() 沒有引數
        // (3)pop完畢之後，返回的結果是 刪除的那個元素
        // (4)原陣列也會發生變化

// 4.shift() 它可以刪除陣列的第一個元素
        console.log(arr.shift()); //red
        console.log(arr);
        // (1)shift 是可以刪除陣列的第一個元素  一次只能刪除一個元素
        // (2)shift() 沒有引數
        // (3)shift完畢之後，返回的結果是 刪除的那個元素
        // (4)原陣列也會發生變化

案例：篩選陣列

// 有一個包含工資的陣列[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);

4陣列排序

// 陣列排序
// 1.翻轉陣列
        var arr = ['red', 'white', 'blue'];
        arr.reverse();
        console.log(arr);
// 2.陣列排序(氣泡排序)
        var arr1 = [2, 5, 77, 4, 7, 11, 1];
        arr1.sort(function(a, b) {
            // return a - b;//升序的順序排列
            return b - a; //降序的順序排列

        });
        console.log(arr1);

5陣列索引方法

// 返回陣列元素索引號方法  indexOf(陣列元素)  作用就是返回該陣列元素的索引號 從前面開始查詢
//它只返回第一個滿足條件的索引號
// 它如果在該陣列裡面找不到元素，則返回的是 -1
        var arr = ['red', 'green', 'blue', 'white', 'bule'];
        console.log(arr.indexOf('blue')); //2
        console.log(arr.indexOf('black')); //-1
// 返回陣列元素索引號方法  lastIndexOf(陣列元素)  作用就是返回該陣列元素的索引號 從後面開始查詢
        var arr = ['red', 'green', 'blue', 'white', 'blue'];
        console.log(arr.lastIndexOf('blue')); //4

案例：陣列去重

// 陣列去重['c', 'a', 'z', 'a', 'x', 'a', 'x', 'c', 'b'] 要求去除陣列中重複的元素
// 1.目標： 把舊陣列裡面不重複的元素選取出來放到新陣列中，重複的元素只保留一個，放到新陣列中去重
// 2.核心演演算法：我們遍歷舊陣列，然後拿著舊陣列元素去查詢新陣列，如果該元素在新陣列裡面沒有出現過，我們就新增，否則不新增
// 3.我們怎麼知道該元素沒有存在？利用 新陣列.indexOf(陣列元素) 如果返回是 -1 就說明 新陣列裡面沒有該元素
// 封裝一個 去重的函數 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'])
        var demo1 = unique(['red', 'blue', 'blue'])
        console.log(demo);
        console.log(demo1);

6陣列轉換為字串

// 陣列轉換為字串
// 1.toString() 將我們的陣列轉換為字串
        var arr = [1, 2, 3];
        console.log(arr.toString()); //1,2,3
// 2.join(分隔符)
        var arr1 = ['green', 'blue', 'red'];
        console.log(arr1.join());    //green,blue,red
        console.log(arr1.join('-')); //green-blue-red
        console.log(arr1.join('&')); //green&blue&red

slice（）和 splice（）目的基本相同

字串物件

1基本包裝型別

為了方便操作基本資料型別，JavaScript還提供了上特殊的參照型別：String、Number和Boolean。

基本包裝型別就是把簡單資料型別包裝稱為複雜資料型別，這樣基本資料型別就有了屬性和方法。

// 基本包裝型別
        var str = 'andy';
        console.log(str.length);
// 物件 才有 屬性和方法  複雜資料型別才有 屬性和方法
// 簡單資料型別為什麼會有length屬性？
// 基本包裝型別：就是把簡單的資料型別 包裝稱為了 複雜資料型別
// (1)把簡單資料型別包裝為複雜資料型別
        var temp = new String('andy');
// (2)把臨時變數的值 給str
        str = temp;
// (3)銷燬這個臨時變數
        temp = null;

2字串的不可變

指的是裡面的值不可變，雖然看上去可以改變內容，但其實是地址變了，記憶體中新開闢了一個記憶體空間。

// 字串的不可變性
        var str = 'andy';
        console.log(str);
        str = 'red';
        console.log(str);
// 當重新給 str 賦值的時候，常數 'andy'不會被修改，依然在記憶體中
// 重新給字串賦值，會重新在記憶體中開闢空間，這個特點就是字串的不可變
// 由於字串的不可變，在大量拼接字串的時候會有效率問題
// 因為我們字串的不可變 所以不要大量的拼接字串
        var str = '';
        for (var i = 1; i <= 100000000; i++) {
            str += i;
        }
        console.log(str);//這個結果需要花費大量時間來顯示，因為需要不斷的開闢新的空間

3根據字元返回位置

字串所有的方法，都不會修改字串本身（字串是不可變的），操作完成會返回一個新的字串。

// 字串物件 根據字元返回位置 str.indexOf('要查詢的字元',[起始的位置])
        var str = '改革春風吹滿地，春天來了';
        console.log(str.indexOf('春'));
        console.log(str.indexOf('春', 3)); //從索引號是 3 的位置開始往後查詢

案例：返回字元位置

// 查詢字串 'abcoefoxyozzopp'中所有o出現的位置以及次數
// 核心演演算法：先查詢第一個o出現的位置
// 然後 只要indexOf 返回的結果不是 -1 就繼續往後查詢
// 因為 indexOf 只能查詢到第一個，所以後面的查詢，一定是當前索引加 1，從而繼續查詢
        var str = 'abcoefoxyozzopp';
        var index = str.indexOf('o');
        var num = 0;
        // console.log(index);
        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 str = ['red', 'blue', 'red', 'green', 'pink', 'red'];
        var index = str.indexOf('red');
        var num = 0;
        // console.log(index);
        while (index !== -1) {
            console.log(index);
            num++;
            index = str.indexOf('red', index + 1);
        }
        console.log('red出現的次數是' + num);

4根據位置返回字元

// 根據位置返回字元
// 1.charAt(index) 根據位置返回字元
        var str = 'andy';
        console.log(str.charAt(3)); //y
// 遍歷所有的字元
        for (var i = 0; i < str.length; i++) {
            console.log(str.charAt(i));
        }
// 2.charCodeAt(index) 返回相應索引號的字元ASCII值 目的：判斷使用者按下了哪個鍵
        console.log(str.charCodeAt(0)); //97(a的ASCII碼是97)
// 3.str[index]  H5 新增的
        console.log(str[0]);  //a

案例：返回字元位置

// 有一個物件 來判斷是否有該屬性 物件['屬性名']
        var o = {
            age: 18
        }
        if (o['age']) {
            console.log('裡面有該屬性');
        } else {
            console.log('沒有該屬性');
        }
// 判斷一個字串 'abcoefoxyozzopp'中出現次數最多的字元，並統計其次數
// o.a = 1
// 0.b = 1
// 0.c = 1
// o.o = 4
// 核心演演算法：利用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]得到的是屬性值
                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(max);  //4
        console.log('最多的字元是' + ch); //最多的字元是o

5字串操作方法

// 字串操作方法
// 1.concat('字串1','字串2'....)
        var str='andy';
        console.log(str.concat('red'));
//2. substr('擷取的起始位置','擷取幾個字元');
        var str1='改革春風吹滿地';
        console.log(str1.substr(2,2));  //第一個2 是索引號的 2 從第幾個開始  第二個2 是取幾個字元

// 1.替換字元 replace('被替換的字元','替換為的字元')  它只會替換第一個字元
        var str = 'andyandy';
        console.log(str.replace('a', 'b'));
        // 有一個字串 'abcoefoxyozzopp' 要求把裡面所有的 o 替換為 *
        var str1 = 'abcoefoxyozzopp';
        while (str1.indexOf('o') !== -1) {
            str1 = str1.replace('o', '*');
        }
        console.log(str1);
// 2.字元轉換為陣列 split('分隔符')    join 把陣列轉換為字串
        var str2 = 'red,pink,blue';
        console.log(str2.split(','));
        var str3 = 'red&pink&blue';
        console.log(str3.split('&'));

• toUpperCase() //轉換大寫
• toLowerCase() //轉換小寫

【相關推薦：】

以上就是javascript中是否有內建物件的詳細內容，更多請關注TW511.COM其它相關文章！