JavaScript 학습 요약 [3] JS 객체

JS의 모든 것은 객체이며 String, Array, Date 등과 같은 여러 내장 객체를 제공하고 사용자 정의 객체도 지원합니다. 객체는 속성과 메소드를 갖는 특별한 유형의 데이터일 뿐입니다. 속성은 객체와 연관된 값이고, 메소드는 객체에 대해 수행할 수 있는 작업입니다.

1. String 객체

String 객체는 텍스트, 즉 문자열을 처리하는 데 사용됩니다. 문자열은 일련의 문자를 저장하는 데 사용됩니다. 일반적으로 JS 문자열은 변수 선언을 사용하거나 new 키워드를 사용하여 문자열을 객체로 정의할 수 있습니다. 객체를 생성합니다. 원래 값 문자열에는 속성과 메서드가 없지만 JS는 속성과 메서드를 실행할 때 원래 값을 객체로 처리할 수 있기 때문에 JS의 속성과 메서드를 사용할 수 있습니다.

JS에 내장된 length 속성을 사용하여 문자열의 길이를 계산할 수 있습니다. 예:

var str = "abcdefghijklmnopqrstuvwxyz";
alert(str.length);    //返回：26

다음은 일반적으로 사용되는 문자열 메서드입니다.

　 (1), charAt()

str.charAt(index) 지정된 위치의 문자를 반환합니다. 인덱스 위치, 즉 문자열의 특정 문자를 가져오는 것입니다.

　(2), concat()

str1.concat(str2, str3, ...., strN) 둘 이상의 문자열을 연결하여 연결된 문자열을 반환하는 데 사용됩니다.

　(3), indexOf()

str.indexOf(a 특정 문자, str) 지정된 위치부터 시작하여 문자열에서 특정 문자가 처음 나타나는 위치를 반환합니다. 문자열에서 검색을 시작할 위치를 지정할 수 있습니다. 해당 값은 0부터 문자열 길이 -1까지입니다. 이 매개변수가 설정되지 않은 경우 검색은 문자열의 첫 번째 문자부터 시작됩니다. 문자열. 반환값은 숫자값이며, 발견되면 해당 문자가 처음 나타나는 위치를 반환합니다. 발견되지 않으면 -1을 반환합니다.

　(4), search()

Search(str/RegExp) 문자열에서 특정 문자가 처음 나타나는 위치를 반환합니다. 매개 변수는 문자 또는 정규식이며 정규식입니다. 표현식 효과가 더 좋습니다. 반환 값은 숫자 값입니다. 일치하는 항목이 없으면 -1이 반환됩니다.

indexOf()와 search()의 차이점:

두 방법 모두 문자가 처음 나타나는 위치를 반환하지만 정규 표현식과 함께 search()를 사용하는 것이 더 좋습니다. 추출할 문자열이 일반 문자열이거나 특정 문자열이라면 indexOf()를 사용하는 것이 더 효율적이고 자원도 절약됩니다. 그러면 indexOf()를 실행할 수 없으며 정규식과 search() 메서드를 사용해야 합니다.

(5), match()

match(str/RegExp) 문자열에 지정된 문자를 찾아 해당 문자를 반환하는 데 사용됩니다. 이 메서드는 일반과 협력합니다. 표현식 사용 효과가 더 좋습니다. 정규 표현식을 사용하지 않으면 지정된 문자의 첫 번째 항목만 반환되며 정규 표현식과 일치하고 전역적으로 일치하는 경우에는 지정된 모든 문자가 일치하지 않습니다. 문자열은 배열 형식으로 반환됩니다. 없으면 null이 반환됩니다.

　(6), replacement()

　replace(str/RegExp, newstr)　 문자열의 일부 문자를 다른 문자로 바꾸고 새 문자열을 반환하는 데 사용됩니다. 이 메소드에는 두 개의 매개변수가 있습니다. 첫 번째 매개변수는 대체되어야 하는 문자를 지정합니다. 두 번째 매개변수는 대체 후에 표시될 문자입니다. 정규식과 함께 사용하면 더 잘 작동하며 모든 일치 항목을 바꿀 수 있습니다. 가장 일반적인 응용 프로그램은 민감한 단어 필터링입니다.

　(7), lastIndexOf()

LastIndexOf()는 indexOf, lastIndexOf(a 문자, Strat)의 반대입니다. 문자열에서 지정된 위치부터 시작하여 문자의 마지막 위치를 반환합니다. , 지정된 위치에서 뒤에서 앞으로 검색합니다. 두 번째 매개 변수는 선택 사항이며 유효한 값은 0에서 문자열 길이 -1: str.length-1입니다. 이 매개 변수를 설정하지 않으면 문자열의 마지막 문자부터 검색이 시작됩니다. 반환값은 숫자값이며, 발견되면 해당 문자가 마지막으로 나타난 위치를 반환한다. 발견되지 않으면 -1을 반환한다.

　(8), Slice()

Slice(start, end) 문자열의 특정 부분을 추출하고, 추출된 부분을 끝 위치 문자를 제외하고 새로운 문자열로 반환합니다. 첫 번째 매개변수는 시작 위치, 첫 번째 문자의 위치는 0, 두 번째 매개변수 끝은 선택사항, 끝 위치의 첨자, 이 매개변수가 설정되지 않은 경우 시작 위치부터 마지막 ​​문자까지 추출이 시작됩니다. 문자열. 문자의 하위 문자열입니다. 문자 추출을 위한 매개변수는 음수일 수 있습니다. 즉, 문자열의 끝부터 계산합니다. 즉, -1은 문자열의 마지막 문자를 나타내고, -2는 마지막에서 두 번째 문자를 나타내는 식입니다. 모든 문자를 추출하는 것은 다음과 같이 작성할 수 있습니다: Slice(0), 또는 매개변수 설정 없이 직접 사용할 수 있습니다.

　(9), substr()

substr(start, length) 문자열의 시작 부분부터 지정된 문자열 길이의 문자를 추출하고, 추출된 부분을 새로운 문자열로 반환합니다. 이 메서드는 substring() 및 Slice() 대신 사용할 수 있습니다. 첫 번째 매개변수는 시작 위치이며 음수일 수 있으며 꼬리부터 계산됩니다. 두 번째 매개변수는 추출된 문자열의 길이입니다. 이 매개변수는 선택사항이며 1보다 작을 수 없습니다. 그렇지 않으면 이 매개변수가 설정되지 않은 경우 시작 위치부터 마지막 ​​문자까지의 하위 문자열이 반환됩니다.

　(10), 하위 문자열()

　　substring(from, to)　　提取介于字符串指定的两个下标中间的字符，并以新的字符串返回被提取的部分，不包括结束位置的字符。第一个参数规定提取子串的第一个字符在字符串中的位置，简单说就是开始位置，该参数是一个非负的整数。第二个参数是要提取的子串最后一个字符在字符串中的位置，也就是结束位置，该参数可选，为一个非负的整数，如果不设置该参数，则返回从开始位置到最后一个字符的子字符串。如果第二个参数比第一个参数大，则在提取子串之前会将较小的数作为开始位置，较大的作为结束位置。

　　slice()、substr() 、substring()三者区别：

　　从定义上看，三者都为提取子字符串，slice() 和substring() 可以看成是同类，参数都是字符串的某个开始位置到结束位置，都不包括结束位置。而 substr() 则是提取从字符串的某个位置开始，指定字符串长度的子字符串。他们的共同点都是：第二个参数可选，如果不设置，都返回从开始位置到最后一个字符的子字符串。

　　从可设置的参数看，slice() 的两个参数都可为负数，表示从尾部开始算起。substr() 的第一个参数也可以设置为负数，而 substring() 的参数则不接受负数，如果设置为负数或者其他无效的数，则会被当作 0 处理。

　　(11)、split()

　　str.split()　　用于分割字符串，返回字符串数组。该方法有2个可选的参数，第一个参数为分割方式，可以是正则表达式，第二个参数设置返回字符串的最大长度。

<script> var str = "Good good study day day up！"; 
 //忽略参数：
 var arr = str.split(); document.write(arr); //返回：Good good study day day up！
 
 //分割每个字符包括空格：
 var arr = str.split(&#39;&#39;); document.write(arr); //返回：G,o,o,d, ,g,o,o,d, ,s,t,u,d,y, ,d,a,y, ,d,a,y, ,u,p,！
 
 //使用空格作为分割符：
 var arr = str.split(&#39; &#39;); document.write(arr); //返回：Good,good,study,day,day,up！
 
 //规定返回数组的最大长度
 var arr = str.split(&#39; &#39;, 3); document.write(arr); //返回：Good,good,study
 
 //使用一个字符作为分割符：
 var arr = str.split(&#39;d&#39;); document.write(arr); //返回：Goo, goo, stu,y ,ay ,ay up！
 </script>

(12)、toString()

　　toString()　　方法用于将对象转换为字符串。

　　(13)、valueOf()

　　valueOf()　　方法用于将对象转换为一个基本数据的值，返回对象的原始值。

　　(14)、toLowerCase()

　　str.toLowerCase()　　方法用于将字符串转换为小写。

　　(15)、toUpperCase()

　　str.toUpperCase()　　方法用于将字符串转换为大写。

2、Number 对象

　　JS 只有一种数字类型，可以是整数，也可以是小数。整数最大可以有 15 位，小数最大可以有17位，在 JS 中小数运算并不是非常精确，所以大多数情况下，需要将小数转换为整数。注意：整数的第一位不能为 0，否则会得到意想不到的结果。如下面的运算结果：

var sum = 0.1 + 0.2; alert(sum); 
//返回：0.30000000000000004

(1)、infinity 和 -infinity

　　当数字运算超过了 JS 所能表示的数字上限时，结果就为一个无穷大的值，在 JS 中用infinity表示。当负数运算超过了 JS 的负数范围，结果就为一个负无穷大的值，也叫无穷小，在 JS 中用 -infinity 表示。基于无穷大的加减乘数运算，他们的结果还是无穷大，并保留正负号。一个整数或者负数除以0，得到的都是无穷大。

　　(2)、NaN

　　NaN 表示非数字的特殊值，该属性用于指示一个值不是数字。返回值为布尔值。可以使用函数 isNaN() 判断一个值是否是 NaN 值。

var x = 123; var y = 'abc'; 
 alert(isNaN(x));    //返回：false
 alert(isNaN(y));    //返回：ture
 
 alert(x == y);    //返回：false
 //NaN和NaN是不相等的。所以为假。
 
 var a = 2/0；
 alert(isNaN(a));    //返回：false
 //无穷大是一个数字

Number 对象属性：

　　(1)、MAX_VALUE 和 MIN_VALUE

　　MAX_VALUE 表示最大的数，它的近似值为： 1.7976931348623157 x 10308。如果大于该数则表示无穷大。MIN_VALUE 表示最小的数，它的近似值为：5 x 10-324，MIN_VALUE 是最接近 0 的数，但不是负值。比该属性小的值用 0 表示。由于他们都是 Number 对象的静态属性，只能通过 Number 调用，所以使用自定义的 Number 将无法获取属性，返回值为 undefined。

//JS最大数
 alert(Number.MAX_VALUE); //返回：1.7976931348623157e+308
 
 //JS最小数
 alert(Number.MIN_VALUE); //返回：5e-324
  
 //e为科学计数法：
 var a = 123e5; var b = 123e-5; 
 
 alert(a);    //返回：12300000
 alert(b);    //返回：0.00123

(2)、POSITIVE_INFINITY 和 NEGATIVE_INFINITY

　　POSITIVE_INFINITY 属性代表无穷大，表示比 MAX_VALUE 大的数。NEGATIVE_INFINITY 属性表示负无穷大，表示比 MIN_VALUE 小的数。由于他们都是 Number 对象的静态属性，只能通过 Number 调用，所以使用自定义的 Number 将无法获取属性，返回值为 undefined。

alert(Number.POSITIVE_INFINITY); //返回：Infinity
 
 alert(Number.NEGATIVE_INFINITY); //返回：-Infinity

Number 对象方法：

　　(1)、toExponential()

　　toExponential(n)　　可把对象的值转换成指数计数法。该方法有一个可选的参数，用于规定计数法中的小数位数，包括 0 和 20 之内的值，如果不设置该参数，将使用尽可能多的数字。

　　(2)、toFixed()

　　toFixed(n)　　可把数字转换为字符串，并四舍五入为指定小数点后位数的数字。该方法必须设置一个参数，规定小数的位数，包括 0 和 20 之内的值，如果不设置该参数，将默认为 0。

　　(3)、toPrecision()

　　toPrecision(n)　　可把数字格式化为指定的长度，如果超出指定的长度将转换为指数计数法。该方法必须设置一个参数，规定转换为指数计数法的最小位数，包括 1 和 21 之内的值，如果不设置该参数，则调用 toString() 方法，而不对数字转换。

　　(4)、toString()

　　toString()　　方法用于将对象转换为字符串。

　　(5)、valueOf()

　　valueOf()　　方法用于将对象转换为一个基本数据的值，返回对象的原始值。

3、Math 对象

　　Math 对象的作用是：执行常见的算数任务。该对象无需在使用这个对象之前对它进行定义。

　　下面主要介绍 Math 对象的一些常用方法：

　　(1)、ceil()

　　Math.ceil()　　可对一个数向上取整，如果参数是一个整数，该值不变。向上取整运算返回的是一个大于或等于该值并且与之最接近的整数。

alert(Math.ceil(-0.1));    //返回：0
 
 alert(Math.ceil(-9.9));    //返回：-9
 
 alert(Math.ceil(2.1));     //返回：3
 
 alert(Math.ceil(2.9));     //返回：3
 
 var num = 8; alert(Math.ceil(num));    //返回：8

(2)、floor()

　　Math.floor()　　可对一个数进行向下取整，如果参数是一个整数，该值不变。向下取整运算返回一个小于或等于该值的最大整数。

alert(Math.floor(-0.1));    //返回：-1
 
 alert(Math.floor(-9.9));    //返回：-10
 
 alert(Math.floor(2.1));     //返回：2
 
 alert(Math.floor(2.9));     //返回：2
 
 var num = 8; alert(Math.floor(num));    //返回：8

(3)、round()

　　Math.round()　　可把一个数字四舍五入为最接近的整数。

alert(Math.round(-0.1));    //返回：0
 
 alert(Math.round(-9.9));    //返回：-10
 
 alert(Math.round(2.49));     //返回：2
 
 alert(Math.round(2.5));     //返回：3
 
 var num=8; alert(Math.round(num));    //返回：8

　(4)、random() 方法

　　Math.random()　　可返回介于 0 ~ 1（大于或等于 0 但小于 1 )之间的一个随机数。

 //获得一个随机数：
 alert(Math.random()); 
 //获得 0~10 之间的随机数：
 alert(Math.random()*10); 
 //random ()方法和round()方法配合，可获得一个不大于10的整数：
 alert(Math.round(Math.random()*10)); 
 //随机数每次返回的值都不同。

4、Array 对象

　　数组对象的作用是：使用单个变量来存储一系列的值。

　　数组最常用的属性就是 length，用于返回数组中数据的长度，也可用于设置数组的长度。

 var arr = [1,2,3,4,5,6]; arr.length=3; alert(arr);    //返回1,2,3
 
 //arr.length=0;        可用于快速清空数组

下面主要介绍 Array 对象一些常用方法：

　　(1)、concat()

　　arr.concat(arr1, arr2, ..., arrN)　　用于连接两个或多个数组，该方法返回一个新数组，不改变原来数组。该方法的参数可以是具体的值，也可以是数组对象，可以是任意多个。如果该参数是具体的值，将把该值插入到原来的数组返回。

　　(2)、join()

　　join()　　用于将数组中的所有元素转换成一个字符串，元素是通过指定的分隔符分隔的。该方法有一个可选参数，用于指定分隔方式。如果不设置该参数，默认使用逗号分割。

 var arr1 = [86,'010'] var arr2 = [15278654321] var arr3 = arr1.concat(arr2); 
 document.write(arr3.join()); //返回：86,010,15278654321
 
 document.write(arr3.join(".")); //返回：86.010.15278654321
 
 document.write(arr3.join("-")); //返回：86-010-15278654321
 
 document.write(arr3.join("|")); //返回：86|010|15278654321

(3)、reverse()

　　arr.reverse()　　用于颠倒数组中元素的顺序。

 var arr = ['Banana', 'Orange', 'Apple']; document.write(arr); //返回：Banana, Orange, Apple
 
 document.write(arr.reverse()); //返回：Apple,Orange,Banana

(4)、slice()

　　arr.slice(start, end)　　可从已有的数组中返回选定的元素。该方法也适用于提取子字符串。也不包括开始位置和结束位置的元素。第一个参数规定从何处开始选取，第二个参数可选，规定从何处结束选取，如果省略该参数，则返回从开始位置到数组尾部的所有元素。如果参数为负数，则从数组最后一个元素开始算起。

　　(5)、sort()

　　arr.sort(方法函数)　　用于对数组的元素排序。排序可以是字母或数字，并按升序或降序。默认排序顺序为按字母升序。使用数字排序，你必须通过一个函数作为参数来调用。函数指定数字是按照升序还是降序排列。如果数字排序不指定方法函数，默认是按照字母升序，则 100 会排在 15 前边。

var arr = [99,15,21,2,8,56,100,1]; 
 //默认排序：
 document.write(arr.sort()); //返回：1,100,15,2,21,56,8,99
 
 //指定方法函数，按升序排序。
 function ascNum(a,b) {     return a-b; } document.write(arr.sort(ascNum)); //返回：1,2,8,15,21,56,99,100
 
 //指定方法函数，按降序排序。
 function desNum(a,b) {     return b-a; } document.write(arr.sort(desNum)); //返回：100,99,56,21,15,8,2,1

(6)、shift()

　　arr.shift()　　删除数组的第一个元素。 此方法将改变数组的长度。

 var arr = ['Banana', 'Orange', 'Apple']; document.write(arr.length);    //返回：3
 
 arr.shift(); document.write(arr);    //返回：Orange,Apple
 
 document.write(arr.length);     //返回：2

(7)、pop()

　　arr.pop()　　删除数组的最后一个元素。此方法将改变数组的长度。

var arr = ['Banana', 'Orange', 'Apple']; document.write(arr.length);    //返回：3
 
 arr.pop(); document.write(arr);    //返回：Banana,Orange
 
 document.write(arr.length);     //返回：2

(8)、unshift()

　　arr.unshift()　　向数组开头添加一个或多个元素。此方法将改变数组的长度。

var arr = ['Banana', 'Orange', 'Apple']; document.write(arr.length);    //返回：3
 
 arr.unshift('Mango', 'Pear'); document.write(arr); //返回：Mango,Pear,Banana,Orange,Apple
 
 document.write(arr.length);    //返回：5

(9)、push()

　　arr.push()　　向数组末尾添加一个或多个元素。此方法将该变数组的长度。

 var arr= ['Banana', 'Orange', 'Apple']; document.write(arr.length);    //返回：3
 
 arr.push('Mango', 'Pear','Lemon'); document.write(arr); //返回：Banana,Orange,Apple,Mango,Pear,Lemon
 
 document.write(arr.length);    //返回：6

(10)、splice()

　　arr.splice(start, length, arrElement1, ..., arrElementN)　　用于删除、插入或替换数组的元素。该方法会改变数组的原始数据。该方法有多个参数，前两个为必须的参数。第一个参数规定从何处开始删除或插入。第二个参数规定删除元素的长度，如果设置为 0，则不删除元素，如果不定义该参数，则删除从 start 规定的位置开始到原数组结尾的所有元素。最后的参数可选，要添加到数组的新元素。

 var arr = [1,2,3,4,5,6]; 
 //删除元素的应用：
 //从第2个位置开始，删除长度为3。
 arr.splice(2,3); document.write(arr+&#39;<br>&#39;); //返回：1,2,6
 
 //插入元素的应用：
 //从第2个位置开始，删除为0个元素，也就是不删除，插入abc。
 arr.splice(2,0,&#39;a&#39;,&#39;b&#39;,&#39;c&#39;); document.write(arr+&#39;<br>&#39;); //返回：1,2,a,b,c,3,4,5,6
 
 //替换元素的应用：
 //从第2个位置开始，删除3个元素，再插入def。
 arr.splice(2,3,&#39;d&#39;,&#39;e&#39;,&#39;f&#39;); document.write(arr); //返回：1,2,d,e,f,6

(11)、toString()

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

　　(12)、valueOf()

　　valueOf()　　方法返回数组对象的原始值。

5、Date 对象

　　Date 对象用于处理日期和时间。可以通过 new 关键词来定义 Date 对象。

　　下面例子是获取当前的所有日期：

 var d = new Date(); //获取当前日期
 document.write(d);  
 //获取当前的年份
 document.write(d.getFullYear() + '年'); 
 //获取当前月份，月份从0开始计算，所以需要+1
 document.write(d.getMonth() + 1 + '月'); 
 //获取当前是当月中的哪一天
 document.write(d.getDate() + '日'); 
 //获取当前时间的小时
 document.write(d.getHours() + '时'); 
 //获取当前时间的分钟
 document.write(d.getMinutes() + '分'); 
 //获取当前时的秒数
 document.write(d.getSeconds() + '秒'); 
 //获取当前的毫秒数t
 document.write(d.getMilliseconds() + '毫秒'); 
 //获取星期
 document.write('星期' + d.getDay()); 
 //星期从0开始算起，从星期天开始计算。
 //getDay()返回的是0-6的数字，0表示星期天。如果要返回相对应的“星期”，需要通过数组完成。
 var weekday = ["星期日","星期一","星期二","星期三","星期四","星期五","星期六"]; var week = d.getDay(); document.write(weekday[week]);

　　下面例子用于设置日期：

var d = new Date(); 
 //设置年份
 d.setFullYear(2020); document.write(d); 
 //该方法也可用于设置月份(介于0-11之间)和天数(介于1-31之间)。
 //月份：-1为去年的最后一月，-2为去年的倒数第二个月。
 //12为明年的第一个月，13为明年的第二个月。
 //天数：0为上个月最后一天，-1为上个月最后一天之前的天数。
 //如果当月有31天，32为下个月第一天，如果当天只有30天，32则为下个月的第二天
 d.setFullYear(2020, 11, -1); document.write(d); //设置月份(介于0-11之间)，也可用于设置天数
 d.setMonth(5); document.write(d); 
 
 //设置天数(介于1-31之间)
 d.setDate(12); document.write(d); 
 //设置小时
 //值介于0(午夜)-23(晚上11点)之间，-1为昨天的最后一个小时，24为明天的第一个小时
 d.setHours(24); document.write(d); 
 //该方法也可用于设置分钟、秒以及毫秒数。
 //分钟：介于0-59之间，-1为上一小时最后一分钟，60为下一个小时第一分钟
 //秒：介于0-59之间，-1为上一分钟最后一秒，60为下一分钟第一秒
 //毫秒：介于0-999之间，-1为上一秒钟的最后一毫秒，1000为下一秒钟的第一毫秒
 d.setHours(21,30,1); document.write(d); 
 //获取小时 一个小应用：返回24小时之前的的时间
 var d = new Date(); d.setHours(d.getHours()-24); document.write(d); 
 //设置分钟，也可用于设置秒数和毫秒数
 d.setMinutes(20); document.write(d); 
 //设置秒，也可用于设置毫秒
 d.setSeconds(10); document.write(d); 
 //设置毫秒
 d.setMilliseconds(999); document.write(d);

　　getTime() 和 setTime()

var d = new Date(); 
 //获取1970年元旦距今的毫秒数
 document.write(d.getTime()+'毫秒'); 
 //向1970年元旦增加1325347200000毫秒，返回新日期
 d.setTime(1325347200000); document.write(d); 
 //获取指定时间据1970年之间的毫秒数
 var d = Date.parse("2012, 12, 12"); document.write(d+'毫秒'); 
 //计算1970年元旦至今有多少年：
 var minutes = 1000*60; var hours = minutes*60; var day = hours*24; var year = day*365; var d = new Date(); var t = d.getTime(); var y = Math.round(t/year);
 document.write(y + '年');

　　日期转换：

var d = new Date(); //当前时间
 document.write(d); 
 //将日期部分(不包括时分秒)转换为字符串
 document.write(d.toDateString()); 
 //将日期部分(不包括年月日)转换为字符串
 document.write(d.toTimeString()); 
 //根据本地时间将日期转换为字符串
 document.write(d.toLocaleString()); 
 //根据本地时间将日期部分(不包括时分秒)转换为字符串
 document.write(d.toLocaleDateString()); 
 //根据本地时间将日期部分(不包括年月日)转换为字符串
 document.write(d.toLocaleTimeString()); 
 //使用ISO标准将日期转换为字符串
 //该标准格式为：YYYY-MM-DDTHH:mm:ss.sssZ
 document.write(d.toISOString()); 
 //将日期转换为JSON格式
 //JSON格式与ISO标准是同样的格式
 document.write(d.toJSON());

toString()　　方法可把日期对象转换为字符串，当日期需要显示为一个字符串时，该方法会被自动调用。

　　valueOf()　　方法返回日期对象的原始值。该方法将返回1970年元旦至今的毫秒数。

6、数据类型转换

　　JS 中有5种不同的数据类型：string、number、boolean、object、function。

　　3 种对象类型：Object、Date、Array。2 个不包含任何值的类型：ubll、undefined。

　　可以使用 typeof 操作符来查看 JS 变量的数据类型。

 var str = '小明'; alert(typeof str);    //返回：string
 
 var num = 12; alert(typeof num);    //返回：number
 
 var num1 = NaN; alert(typeof num1);    //返回：number
 
 var fun = function (){alert('abcd');}; alert(typeof fun);    //返回：function
 
 var boo = true; alert(typeof boo);    //返回：boolean
 
 var obj = document; alert(typeof obj);    //返回：object
 
 var arr = [1,2,3,4]; alert(typeof arr);    //返回：object
 
 var d = new Date(); alert(typeof d);    //返回：object
 
 var json = {a:'12', b:21}; alert(typeof json);    //返回：object
 
 var n = null; alert(typeof n);    //返回：object
 
 var x; alert(typeof x);        //返回：undefined
 alert(typeof y);        //返回：undefined
 //未定义有2种情况：
 //1、真的没有定义（如y）
 //2、虽然定义了，但是没有给赋值（如x)

数组对象和日期对象无法通过 typeof 来判断数据类型，因为都返回 object。可以使用 constructor 属性来查看。constructor 属性返回一个对象的构造函数，将返回的构造函数转换为字符串，再判断是否包含数组和日期。

 //返回数组和日期的构造函数：
 var arr = ["abc", "123", "123abc", "abc123"]; alert(arr.constructor); //返回：function Array() { [native code] }
 
 var d = new Date; alert(d.constructor); //返回：function Date() { [native code] }
 
 
 var arr = ["abc", "123", "123abc", "abc123"]; function con(obj) {     return arr.constructor.toString().indexOf("Array") > -1; } alert(con(arr));    //返回：ture
 
 var d = new Date(); function cons(obj) {     return d.constructor.toString().indexOf("Date") > -1; } alert(cons(d));    //返回：ture

强制类型转换，也叫显式类型转换。

　　(1)、转换为字符串：

　　全局方法 string() 和 toString() 方法可用于将一个值转换为字符串。string() 可用于任何类型的数字、字母、变量、表达式。

　　二者区别：

　　大多数值都有 toString() 方法，除了 null 和 undefined。字符串本身也可以使用 toString() 方法，将返回字符串的原始值。

　　任何值都可以使用 string() 方法，如果该值有 toString() 方法，则使用该方法，如果该值没有 toString() 方法，那就为 null 和 undefined，则返回 null 和 undefined。

var str = '小明'; alert(String(str)); alert(str.toString()); //都返回：小明
 
 var num = 123; alert(String(num)); alert(num.toString()); //都返回：123
 
 var and = 123+100; alert(String(and)); alert(and.toString()); //都返回：223

(2)、转换为数字：

　　全局方法 Number() 可以将字符串转换为数字。空字符串转换为 0，特殊值字符串将转换为 NaN。

var str = '123'; alert(Number(str));    //返回：123
 
 var str = ''; alert(Number(str));    //返回：0
 
 var str = '200px'; alert(Number(str));    //返回：NaN

　　最常用的就是转换为整数和小数。parseInt() 方法用于转换整数。parseFloat() 方法用于转换小数。

 var a = '3.1'
 alert(parseInt(a));    //返回：3
 var a = '3.9'
 alert(parseInt(a));    //返回：3
 var a = '12px34'; alert(parseInt(a));    //返回：12
 var a = 'px1234'; alert(parseInt(a));    //返回：NaN
 
 var d = '3.14'; alert(parseFloat(d));    //返回：3.14
 var d = '3.99'; alert(parseFloat(d));    //返回：3.99

　　+ 运算符可以连接字符串，也可以将字符串转换为数字。

var n = '12ab'; var x = '34'; alert(n+x);    //返回：12ab34
 alert(parseInt(n)+x);    //返回：1234
 
 var y = + x; alert(typeof x);    //返回：string
 //若变量不能转换，但仍然是一个数字，NaN
 alert(typeof y);    //返回：number

　　NaN 的数据类型是 number，NaN 表示非数字(Not a Number)，所以本身也为数字。

var a = parseInt('abc'); var b = parseInt('12edf'); var c = 12+NaN; alert(c);    //返回NaN
 
 //判断NaN是否等于NaN
 alert(a==b);    //返回false
 
 //isNaN判断一个变量是不是NaN
 alert(isNaN(a));    //返回：true
 alert(isNaN(b));    //返回：flase

　　利用这一特性，可以做一个简易的文本框求和，用户输入的文本框的值为字符串，需要将字符串转换为数字，再判断输入的值是否为数字。

<!DOCTYPE html>
 <html>
 <head>
     <meta charset="UTF-8">
     <title>文本框求和</title>
 </head>
 <script>
 window.onload = function (){     
 var x = document.getElementById(&#39;txt1&#39;);     
 var y = document.getElementById(&#39;txt2&#39;);    
  var oBth = document.getElementById(&#39;but1&#39;);     
  oBth.onclick = function (){         
  //将输入的值转换为整数：
         var n1 = parseInt(x.value);         
         var n2 = parseInt(y.value);             
         //判断用户输入的n1是不是非数字
             if(isNaN(n1)){                 
             alert(&#39;输入的第一个数字有误&#39;);             
             }             
             else if(isNaN(n2)){                 
             alert(&#39;输入的第二个数字有误&#39;);             
             }             
             //若都输入的为数字，则求和
             else{                 
             alert(n1+n2);             
             }     
             };
              }; 
              </script>
 <body>
 <input id="txt1" type="text" >
 <input id="txt2" type="text" >
 <input id="but1" type="button" value="求和">
 </body>
 </html>

　　全局方法 Number() 可将布尔值转换为数字。

alert(Number(false));    //返回 0
 alert(Number(true));    // 返回 1

隐式类型转换，也叫自动转换类型。

　　当 JS 尝试操作一个“错误”的数据类型时，会自动转换为“正确”的类型再去执行，这就是隐式类型转换。直接看几个例子：

var a = 2; var b = '2'; //比较数字2和字符串2是否相等
 alert(a==b);    //返回：true
 //why? 相等比较实际上比较前是先将a和b转换为同一类型，再进行比较的。
 
 //比较数字2和字符串2是否全等
 alert(a===b);    //返回：返回false
 //why? 全等比较不转换类型，直接比较。a为数字，b为字符串。
 //所以，一般情况下，采用全等比较，更为严谨。
 
 var c = '12'; var d = '5'; //两个值为数字的字符串做+运算
 alert(c+d);    //返回125
 //why? "+"运算符有2种功能：1、字符串连接。2、算术运算(数字相加)。系统会采用最直接的方法。
 
 //两个值为数字的字符串做-运算
 alert(c-d);　　//返回7
 //why? 在做减法运算时会先转换为同类型，再做运算。"-"运算符只有1种功能。算术运算(数字相减)。

以上就是 JavaScript学习总结【3】JS对象的内容，更多相关内容请关注PHP中文网（www.php.cn）！