js对象都有哪些呢？

1.布尔对象

a.创建：
new Boolean() 作用是构建布尔对象，将其他数据转化为布尔类型。

b.创建布尔对象与转换布尔值：
布尔对象的属性 : constructor(返回对创建此对象的Boolean函数的引用)。
使用“new Boolean()”构造函数将参数转换成一个布尔值，并创建一个布尔对象，而使用“Boolean()”转变函数只是将一个值转换成布尔类型的数据。
（1）如果参数为0、null、NaN、false、空字符串或undefined，都将转为false；
（2）除了以上的情况之外，全部转为true，包括字符串“false”。

    // 布尔对象
    var boolstr1 = new Boolean('aaa');//true
    var boolstr2 = new Boolean('true');//true
    var boolstr3 = new Boolean('');//false
    var boolstr4 = new Boolean(true);//true
    var boolstr5 = new Boolean(false);//false
    var boolstr6 = new Boolean(0);//false
    var boolstr7 = new Boolean(NaN);//flase
    var boolstr8 = new Boolean(35);//true
    var boolstr9 = new Boolean(null);//false
    var boolstr10 = new Boolean({ a: false });//true
    var boolstr11 = new Boolean([]);//true
    var boolstr12 = new Boolean(undefiner);//false

2.日期对象

a.创建
new Date();
Date()作用创建日期对象
b.日期对象的方法：
getFullYear()：返回年份，4位数。
getMonth()+1：返回月份，取值范围是0-11；
getDate()：天数，一月中的第几天。
getDay()：周几，一周中的第几天。
getHours()：返回当前时间的小时部分。
getMinutes():返回当前时间的分钟部分。
getSeconds():返回当前时间的秒钟部分。
getMilliseconds():返回当前时间的毫秒部分。
getTime()：返回当前时间的时间戳的毫秒总数。时间戳具有唯一性。
getTimezoneOffset()：返回日期对象中的时区差数，单位是分。

   // 1.创建一个日期对象 Date()
    var date = new Date();
    var year = date.getFullYear();
    var month = date.getMonth() + 1;
    var day = date.getDate();
    var hours = date.getHours();
    var minutes = date.getMinutes();
    var seconds = date.getSeconds();

    document.write(date + '<br>');
    document.write(year + ' ' + month + ' ' + day + ' ' + hours + ' ' +
        ':' + minutes + ' ' + ':' + seconds + ' ');
        
    //Wed Aug 14 2019 21:45:45 GMT+0800 (中国标准时间)
    //2019 8 14 21 :45 :45

3.字符串对象

a.字符串对象特点
1:有索引值，从0开始
2：有长度
3：字符可重复
b.创建字符串对象
var str = new String(“abcdefg”);
String() 构造字符串对象，将其他类型的数据转化为字符串类型
参数为任意类型的数据
var str = “abcdefg”;

转义字符

    var str = '\0';
    var str2 = '\t';
    var str3 = '\\';
    //  字符串与字符对象的区别
    // 相同点：构造函数都是String()
    // 不同点 : typeof 判断数据类型输出结果不同
    var strObj = new String('ppppp');
    // typeof xxx  作用 判断JS 的数据类型
    // 弊端 针对 数组  对象 函数；一律输出 Object 
    console.log(typeof str); // string
    console.log(typeof strObj); // object

字符串对象的方法：
indexof(str) // 查询 str 第一次在某字符串中出现的位置 ，不存在返回-1

	var person = '日本人美人国美国人美国人韩国人';
    // indexof(str) 查询 str 第一次在某字符串中出现的位置 ，不存在返回-1
    var res = person.indexOf('美国人');
    console.log(res);//6

lastIndexOf(str) // 查询str在某字符串中最后一次出现的位置,如果不存在返回-1

    // lastIndexOf(str) 查询str在某字符串中最后一次出现的位置,如果不存在返回-1
    var res2 = person.lastIndexOf('aaaa');//-1

match(regexp) //找到一个或多个正则表达式的匹配

replace(表达式,替换的字符串) //替换一个与正则表达式相匹配的子串

    var str = '日本人美国人韩国人';
    // 将人变为狗 res 接受变狗结果
    var res = str.replace(/['人']/g,',');
    console.log(res);//日本,美国,韩国,
    // 要想匹配某个字符 简单正则   /[待匹配字符]/g

search(reg) 查询与参数匹配到的字符 返回匹配结果第一次出现的位置

    // search(reg) 查询与参数匹配到的字符 返回匹配结果第一次出现的位置
    var str = 'abc123abc';
    var res = str.search('abc');//0

split(正则表达式,数组最大长度) //切割作用 返回切割后字符组成的数组

    var person = '中国人，日本人，美国人';
    // split(reg,len) 切割作用 返回切割后字符组成的数组
    // ---> reg 匹配的字符，以什么字符来切割
    // ---> len 返回会新数组的长度，若无表示默认为最大长度
    var res = person.split('，',2);//Array [ "中国人", "日本人" ]
 
    var arr = [1,3,4,5,7,'8i',9,0]
    // 将数组变字符串
    var str1 = arr.toString();
    console.log(str1);//1,3,4,5,7,8i,9,0,
    // 将字符串还原回去数组
    var arr1 = str1.split(',');
    console.log(arr1);
    //Array(9) ["1", "3", "4", "5", "7", "8i", "9", "0"]

slice(startindex,endindex) //返回一个子字符串

    var str = 'djfawjefwefwerfwe234234fsef';
    // slice(start,end) 作用从start索引开始到end索引结束截取字符串片段
    //  ----> start 表示从哪索引开始（包含本诉）
    // -----> end 表示到哪里索引结束（不包含本诉）
    var res = str.slice(3,6);//awj

substr(startindex,length) //返回一个子字符串

    var str = 'dfqefwfwer';
    // substr(start,len) 作用；返回一个子字符
    // -----> start 从哪个索引值开始 （包含本诉）
    // -----> len 表示截取字符长度，如果大于剩余字符长度；
    //则返回最大可截取字符长度，如果len 没有值 ；默认截取剩余字符
    var res = str.substr(3,4);//efwf

substring(startindex,endindex) //返回一个子字符串

    var str  = 'dfwejflwsjfelfjwejr';
    // 本方法与slice 一样  返回一个子字符
    var res  = str.substring(3,7);
    console.log(res);//ejfl

toLowerCase() //将字符串转换为小写

    // 初始化字符
    var str = 'SFJOWEI djfwejfewk';
    // toLowerCase() 作用将大写字母转小写字符,返回变化后字符，原来字符无变化
    // res 作用：接收 toLoweCase() 方法返回的结果，res为新的字符；与str没关系
    var res = str.toLowerCase();
    console.log(res);//sfjowei djfwejfewk

toUpperCase() //将字符串转换为大写

    // toUpperCase 将小写字母变为大写字母，返回变化后的字符
    var str = 'SFJOWEI djfwejfewk';
    var res1 = str.toUpperCase();
    console.log(res1);//SFJOWEI DJFWEJFEWK

charAt(index) 作用根据索引查询字符。并返回查询到的字符

    // charAt(index) 作用根据索引查询字符。并返回查询到的字符
    var str = 'slfjel';
    var res1 = str.charAt(3);//'j'

字符串对象拥有的属性：
length /获取/字符串的长度

4.数值对象

1: 如何创建数值对象?
Number()
例如：var num = new Number();

2: Number()的作用是什么?
Number()是创建数值对象的构造函数，作用是创建数值对象，将其他类型数据转化为数值型

3.数值的转换：

通过三个函数Number(),parseInt(),parseFloat()将一个非数值转换为数值型。

    Number()函数转换规则：
        1.如果是布尔值，true和false会转换为1和0;
        2.如果是数值型，只是简单的传入和输出。
        3.如果是null，返回0
        4.undefined，返回NaN。
        5.如果是字符串类型，遵循以下规则：
            a."11"会返回11
            b."1.1"会返回1.1
            c.空字符串返回0
            d."0xA"会转化为十进制整数值，以"070"会忽略掉前面的0，输出整数值。
            e.除了上面内容，其他全部返回NaN


   // 创建数值对象
    //  Number()是创建数值对象的构造函数，作用是创建数值对象，
    //将其他类型数据转化为数值型
        
    var num = new Number();  
    var num1 = new Number('aa'); //NaN
    var num2 = new Number('');//0
    var num3 = new Number(true); //1
    var num4 = new Number(false);//0
    var num5 = new Number(123);//123
    var num6 = new Number({});//NaN
    var num7 = new Number([]);//0
    var num8 = new Number(null);//0
    var num9 = new Number('0');//0
    var num10 = new Number('123');//123
    var num11 = new Number('00000011');//11


    parseInt()函数转换规则：
    1.会忽略掉字符串前面的空格，直到找到第一个非空字符。
    2.如果第一个字符不是数字或者负号，会返回NaN
    3.如果是空字符串返回NaN
    4.如果第一个字符是数字，会继续解析第二个，直到解析到非数字字符停止。
    5."0xA"会转化为十进制整数值，以"070"会忽略掉前面的0，输出整数值。
    
    // parseInt()作用:将其他数据类型转化为数值型。
    var pInt = parseInt(' 123');//123
    var pInt1 = parseInt('123blue');//123
    var pInt2 = parseInt('');//NaN
    var pInt3 = parseInt('0xA');//10
    var pInt4 = parseInt(22.5);//22
    var pInt5 = parseInt('0xf');//15
    var pInt6 = parseInt('070');//70
    var pInt7 = parseInt(0);//0
    var pInt8 = parseInt('我爱你中国');//NaN
    var pInt9 = parseInt(null);//NaN


    // parseInt()作用将其他数据类型转化为数值型，如果字符为十六进制或者八进制，
    // 会将十六进制或八进制先转化为十进制在输出
    //参一:为待转化的数据
    //参二:默认为十进制如果有值 取值范围为2-36

    var str = '0xf';
    console.log(parseInt(str, 36));



    parseFloat()函数转换规则：
    1.会忽略掉字符串前面的空格，直到找到第一个非空字符。
    2.如果第一个字符不是数字或者负号，会返回NaN。
    3.如果是空字符串返回NaN
    4.如果第一个字符是数字，会继续解析第二个，直到解析到非数字字符停止。
    5."0xA"会返回0，以"070"会忽略掉前面的0，输出整数值。
        
    var pFloat = parseFloat("1234blue");//1234
    var pFloat1 = parseFloat("0xA");//0
    var pFloat2 = parseFloat('');//NaN
    var pFloat3 = parseFloat('22.5');//22.5
    var pFloat4 = parseFloat("22.34.5");//22.34
    var pFloat5 = parseFloat('070.5');//70.5
    var pFloat6 = parseFloat("3.12e7");//31200000    
    var pFloat7 = parseFloat("我爱你中国");//NaN
    var pFloat8 = parseFloat({});//NaN
    var pFloat9 = parseFloat([]);//NaN
    var pFloat10 = parseFloat(true);//NaN
    var pFloat11 = parseFloat(undefined);//NaN

5.数学对象

a.主要作用：为数学计算提供常量和计算函数

b.方法：Math

c. 数学对象的属性：
abs()：获取绝对值
ceil()；进一取整
floor();退一取整
max();取最大值
min();取最小值
sqrt();平方根
random()：获取随机数，0.0-1.0之间的随机数，包括0不包括1
pow(x,y)；获取x的y次幂
round();四舍五入

   // 数学对象Math  数学对象有很多API

   var num = Math.random(); //：获取随机数，[0,1)
   var num1 = Math.floor(2.5);//2
   var num2 = Math.ceil(2.3);//3
   var num3 = Math.round(2.6);//3
   var num4 = Math.max(2, 6);//6
   var num5 = Math.min(2, 6);//2
   var num6 = Math.sqrt(4, 2);//2
   var num7 = Math.pow(2, 3);//8
   var num8 = Math.abs(-10);//10

   // 参数如果是非数值型，会将其他数据类型转化为数值型再触发方法
   var num9 = Math.ceil('123');//123

d.随机数小例题：

    //求1-100的随机数
    //理解： [0,1)   [1,100)     [0,99)  + 1     [1,100)
    var num = Math.random() * 99 + 1;
    console.log(num);
    
    //求10-10000的随机整数
    //理解： [0,1)   [10,10000]  [0,9990]  + 10     [10,10000] 
    var num1 = Math.floor(Math.random() * 9991) + 10;//向下取整
    //var num1 = Math.ceil(Math.random() * 9989) + 10; //向上取整
    //var num1 = Math.round(Math.random() * 9990) + 10;
    console.log(num1);

6.数组对象

1.创建数组
方式一：构造函数 Array()数组的构造函数，作用：创建数组数组，参数为数组中数据
var arr = new Array();
方式二：直接定义数组
var arr = [];

2.数组特点：
1.有序 从0开始 0-n是数组【索引值 index】
注意：索引值具有唯一性，有序性
2.数组中数据，可以为任意数据类型
3.数据中数据可重复
注意：未来遇到的数据结构，数组中全是对象，对象中有数组

3.数组中取值
a. 语法 array[index] array 数组名字 index 索引值

    var arr1 = [1, 2, 3, 4, 5, 6];

b. 获取数组长度，表示数组中有多少数据

    var len = arr.length;
    console.log(len);

c.获取数组中最后一个数据 索引值：length-1

    var len = arr.length;
    console.log(arr[len - 1]);

4.更改数组中数据

    arr[2] = '你真好';
    console.log(arr[2]);

点名器小例子：

    var arr = ['孙悟空', '猪八戒', '沙僧', '唐僧', '白龙马'];
    // 求随机索引值
    var i = Math.floor(Math.random() * 5);
    // 需求：在页面中输出被点到的人名
    document.write('<h1>' + '点名点到'+ ' ' + arr[i] + ' ' + '就是帅哥');

className增加例子：

<script>
    var className = 'icon,icon1';
    // split() 切割字符，并返回一个新的数组
    var arr = className.split(',');
    console.log(arr);
    // 添加类型    往数组中添加数据
    arr[2] = 'icon2';
    arr[3] = 'icon3';
    arr[4] = 'icon4';
    console.log(arr);

    // 数组变字符串
    className = arr.toString();
 
    // 空格分开每个数据，转化为字符串
    className = arr.join(' ');
    console.log(className);
   
    document.write('<div class="' + className + '">' +'我真帅' +'</div>');
</script>

数组中的方法：
push() 向数组的末尾添加一个或更多元素，并返回新的长度。

    // push()在数组尾部添加元素并返回一个新的长度，
    // 参数为添加的元素，参数有几个就添加几个元素
    var arr = [1, 2, 3, 4, 5, 6];
    // len 作用：接收push()的返回值
    var len = arr.push('haha');
    console.log(arr, len);

unshift() 向数组的开头添加一个或更多元素，并返回新的长度。

    // unshift()在数组头部添加元素并返回一个新的长度
    // 参数为添加的元素，参数有几个就添加几个元素
    var arr1 = [1, 2, 3, 4, 5, 6];
    // len 接收返回的长度
    var len = arr1.unshift(3, [1, 2, 3]);
    console.log(arr1, len);

concat() 连接两个或更多的数组，并返回结果。

    // concat() 合并数组，并返回合并好新的数组   
    // 参数为被合并的数组，可以合并多个数组
    // 使用方式，array.concat(被合并的数组)
    var arr2 = [1, 2, 3];
    var arr3 = [4, 5, 6];
    var arr4 = [7, 8, 9];
    // newArr 作用：接收concat返回的新数组
    // 把arr3合并到arr2中
    var newArr = arr2.concat(arr3);
    console.log(newArr);
    var newArr1 = arr2.concat(arr3.concat(arr4));
    console.log(newArr1);

join() 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。

    // join()将数组转化为字符串，返回一个新的字符串
    // 参数 作用 表示替代逗号的字符
    // 用[参数字符]替代[逗号字符]
    var res1 = arr.join();
    // var res1 = arr.join('a');
    console.log(res1);

删除数组中元素
pop() 删除并返回数组的最后一个元素

    // 数组一旦被定义就不能被删除，除非使用数组中的API
    // pop() 从数组尾部删除元素，并返回删除的元素
    // 无参
    var arr = [1, 2, 3, 4, 5, 6];
    // data 接收返回的被删除元素
    var data = arr.pop();
    console.log(arr, data);

shift() 删除并返回数组的第一个元素

     // shift()从数组头部删除元素，并返回被删除的元素
     // 无参
     var arr1 = [1, 2, 3, 4, 5, 6];
     // data 接收返回的被删除元素
     var data = arr1.shift();
     console.log(arr1, data);

splice() 删除元素，并向数组添加新元素。

    // splice(index，howmany)    
    // 作用一 删除  并返回当前被删除后元素组成的新数组
    // 每执行一行，执行行所做的工作
    //参数1：表示从第index元素开始，
    //参数2：表示删除howmany个数据
    var arr = [1, 2, 3, 4, 5, 6];
    // data 接收返回的被删除元素
    var data = arr.splice(2, 2);
    console.log(arr, data);

    // 作用二 替换  从第几个元素开始，替换几个元素，新数据
    // 参数1：从第几个索引值元素开始，参数2:替换几个元素
    // 参数...：表示用这几个参数来替换
    var arr1 = [1, 2, 3, 4, 5, 6];
    // newArr 作用：接收返回被替换数组组成的新数组
    var newArr = arr1.splice(2, 2, '陈达', '真帅');
    console.log(arr1, newArr);

    // 作用三 插入：一个不删除就是插入
    // splice(index,0,...) 插入 从第几个索引值开始插入几个元素
    // 参数1：从第几个索引值元素开始，参数2:表示不删除元素
    // 参数...：表示用插入的元素
    var arr2 = [1, 2, 3, 4, 5, 6];
    var data = arr2.splice(2, 0, '陈达', '真帅');
    console.log(arr2, data);

    /*
 	   总结
   		 splice()作用：删除，替换，插入的作用，
  		  参数可以多个,参数一表示从第几个索引值开始
  		  参数二表示从索引值开始删除几个元素
  		  其他多个参数表示从索引值开始，删除元素后，添加几个新元素
    */

slice() 从某个已有的数组返回选定的元素

    // slice(start,end) 作用：返回数组中一部分，并组成新的数组
    // 参数1：表示从第几个索引值开始截取（包含本诉）
    // 参数2：表示到第几个索引值结束（不包含本诉）
    // 截取数据区间 [start,end)
    var arr = [1, 2, 3, 4, 5, 6];
    // res 接收slice返回的截取数组，组成的新数组
    var res = arr.slice(2, 4);//[2,4)
    console.log(arr, res);

排序
sort() 对数组的元素进行排序

    var arr = [1, 'A', 4, 3, 2, 6, 5, 'b', '啊'];
    var res = arr.sort();
    console.log(arr, res);
    // 返回排序后的数组，升序。原来的数组也经过排序
    // sort() 排序步骤
    // 1.将数组中每一个数据，转化为字符串类型
    // 2.检索第一个字符，然后将该字符转化为ASCII码值
    // 3.用转化后的ASCII码值 进行大小排列，按照从小到大顺序排列

reverse()颠倒数组中元素的顺序。

    // reverse() 颠倒数组中的元素，返回颠倒后的数组
    var arr1 = [1, 2, 3, 4, 5, 6];
    var res1 = arr1.reverse();
    console.log(arr1, res1);

toString() 把数组转换为字符串，并返回结果。

    // toSting()将数组中所有字段转化为字符串，包括逗号，返回一个新的字符串
    var arr = [1, 2, 3, 4, 5, 6];
    var res = arr.toString();
    console.log(res);

知识点：
在JavaScript中可以通过数组元素存取运算符[]，在[]运算符的左侧是数组的名称，而在[]之间是数组的下标。在JavaScript中，数组的第一个元素的下标为0.
删除数组元素
数组元素一旦被定义就不能被删除。使用delete运算符只能删除数组元素的值，使其恢复到未赋值的状态，即元素值为undefined，而不能删除一个数组元素，不能让数组中的元素减少一个。delete arr[0];
delete 删除数据

     // 数组中数据一旦被定义就不能被删除
     var arr = [1, 2, 3, 4, 5, 6];
     // delect 删除数据，但是数组长度不变，相当于该位置数据处于未赋值状态
     delete arr[3];
     console.log(arr);
     //返回数组对象的构造函数
     console.log(arr.constructor);