JavaScript学习笔记3：标准对象

标准对象

对象

// 使用typeof操作符获取对象类型
typeof 123; // 'number'
typeof NaN; // 'number'
typeof 'str'; // 'string'
typeof true; // 'boolean'
typeof undefined; // 'undefined'
typeof Math.abs; // 'function'
typeof null; // 'object'
typeof []; // 'object'
typeof {}; // 'object'

// 包装对象(闲的蛋疼也不要使用!)
var n = new Number(123); // 123,生成了新的包装类型
var b = new Boolean(true); // true,生成了新的包装类型
var s = new String('str'); // 'str',生成了新的包装类型
// 包装对象类型是object，与原始值比较是false
typeof n; // 'object'
new Number(123) === 123; // false
typeof b; // 'object'
new Boolean(true) === true; // false
typeof s; // 'object'
new String('str') === 'str'; // false

// 不使用new关键字会被当作普通转换函数(不是包装类型)
var n = Number('123'); // 123，相当于parseInt()或parseFloat()
typeof n; // 'number'
var b = Boolean('true'); // true
typeof b; // 'boolean'
var b2 = Boolean('false'); // true! 'false'字符串转换结果为true！因为它是非空字符串！
var b3 = Boolean(''); // false
var s = String(123.45); // '123.45'
typeof s; // 'string'
(123).toString(); // 123要加括号

/**
 * 总结一下，有这么几条规则需要遵守：
 * 不要使用new Number()、new Boolean()、new String()创建包装对象；
 * 用parseInt()或parseFloat()来转换任意类型到number；
 * 用String()来转换任意类型到string，或者直接调用某个对象的toString()方法；
 * 通常不必把任意类型转换为boolean再判断，因为可以直接写if (myVar) {...}；
 * typeof操作符可以判断出number、boolean、string、function和undefined；
 * 判断Array要使用Array.isArray(arr)；
 * 判断null请使用myVar === null；
 * 判断某个全局变量是否存在用typeof window.myVar === 'undefined'；
 * 函数内部判断某个变量是否存在用typeof myVar === 'undefined'。
 **/

Date

// Date对象用来表示日期和时间
var now = new Date();
now; // Wed Jun 24 2015 19:49:22 GMT+0800 (CST)
now.getFullYear(); // 2015, 年份
now.getMonth(); // 5, 月份，注意月份范围是0~11，5表示六月
now.getDate(); // 24, 表示24号
now.getDay(); // 3, 表示星期三
now.getHours(); // 19, 24小时制
now.getMinutes(); // 49, 分钟
now.getSeconds(); // 22, 秒
now.getMilliseconds(); // 875, 毫秒数
now.getTime(); // 1435146562875, 以number形式表示的时间戳

// 创建指定日期和时间的Date对象
// 月份参数从0开始，0表示1月，5表示6月
var d = new Date(2015, 5, 19, 20, 15, 30, 123);
d; // Fri Jun 19 2015 20:15:30 GMT+0800 (CST)

// 解析一个符合ISO 8601格式的字符串，并生成时间戳
// Date.parse()时传入的字符串使用实际月份01~12
var t = Date.parse('2015-06-24T19:49:22.875+08:00');
t; // 1435146562875
// 使用时间戳创建Date对象
var d = new Date(1435146562875);
d; // Wed Jun 24 2015 19:49:22 GMT+0800 (CST)
// 转换为Date对象后getMonth()获取的月份值为0~11
d.getMonth(); // 5

// Date对象表示的时间默认按浏览器所在时区显示
var d = new Date(1435146562875);
// 转为本地时间（北京时区+8:00），显示的字符串与操作系统设定的格式有关
d.toLocaleString(); // '2015/6/24 下午7:49:22'
// 转为UTC时间，与本地时间相差8小时
d.toUTCString(); // 'Wed, 24 Jun 2015 11:49:22 GMT'，UTC时间，与本地时间相差8小时

RegExp

// 创建正则表达式
var re1 = /ABC\-001/;
var re2 = new RegExp('ABC\\-001'); // 字符串转义 \\ 实际上是一个\

re1; // /ABC\-001/
re2; // /ABC\-001/

// 判断正则表达式是否匹配
var re = /^\d{3}\-\d{3,8}$/;
re.test('010-12345'); // true
re.test('010-1234x'); // false
re.test('010 12345'); // false

// 切分字符串
'a b   c'.split(' '); // ['a', 'b', '', '', 'c']
'a b   c'.split(/\s+/); // ['a', 'b', 'c']
'a,b, c  d'.split(/[\s\,]+/); // ['a', 'b', 'c', 'd']
'a,b;; c  d'.split(/[\s\,\;]+/); // ['a', 'b', 'c', 'd']

// 分组
// 如果正则表达式中定义了组，就可以在RegExp对象上用exec()方法提取出子串来
// exec()方法在匹配成功后，会返回一个Array，第一个元素是正则表达式匹配到的整个字符串，后面的字符串表示匹配成功的子串
// exec()方法在匹配失败时返回null
// 取出区号和本地号码
var re = /^(\d{3})-(\d{3,8})$/;
re.exec('010-12345'); // ['010-12345', '010', '12345']
re.exec('010 12345'); // null
// 识别合法的时间
var re = /^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$/;
re.exec('19:05:30'); // ['19:05:30', '19', '05', '30']

// 贪婪匹配
// 默认是贪婪匹配，把后面的0全匹配了
var re = /^(\d+)(0*)$/;
re.exec('102300'); // ['102300', '102300', '']
// 加个?可以让\d+采用非贪婪匹配
var re = /^(\d+?)(0*)$/;
re.exec('102300'); // ['102300', '1023', '00']

// 全局搜索
// 添加 g 标志表示全局匹配
var r1 = /test/g;
// 等价于:
var r2 = new RegExp('test', 'g');
// 全局匹配可以多次执行exec()方法来搜索一个匹配的字符串，
var s = 'JavaScript, VBScript, JScript and ECMAScript';
var re=/[a-zA-Z]+Script/g;

// 使用全局匹配:
re.exec(s); // ['JavaScript']
re.lastIndex; // 10
re.exec(s); // ['VBScript']
re.lastIndex; // 20
re.exec(s); // ['JScript']
re.lastIndex; // 29
re.exec(s); // ['ECMAScript']
re.lastIndex; // 44
re.exec(s); // null，直到结束仍没有匹配到

// 全局匹配类似搜索，因此不能使用/^...$/，那样只会最多匹配一次
// 正则表达式还可以指定i标志，表示忽略大小写，m标志，表示执行多行匹配

/**
 * 在正则表达式中，如果直接给出字符，就是精确匹配。用\d可以匹配一个数字，\w可以匹配一个字母或数字，所以：

 * '00\d'可以匹配'007'，但无法匹配'00A'；

 * '\d\d\d'可以匹配'010'；

 * '\w\w'可以匹配'js'；

 * .可以匹配任意字符，所以：

 * 'js.'可以匹配'jsp'、'jss'、'js!'等等。
 * 要匹配变长的字符，在正则表达式中，用*表示任意个字符（包括0个），用+表示至少一个字符，用?表示0个或1个字符，用{n}表示n个字符，用{n,m}表示n-m个字符：

 * 来看一个复杂的例子：\d{3}\s+\d{3,8}。

 * 我们来从左到右解读一下：

 * \d{3}表示匹配3个数字，例如'010'；

 * \s可以匹配一个空格（也包括Tab等空白符），所以\s+表示至少有一个空格，例如匹配' '，'\t\t'等；

 * \d{3,8}表示3-8个数字，例如'1234567'。

 * 综合起来，上面的正则表达式可以匹配以任意个空格隔开的带区号的电话号码。

 * 如果要匹配'010-12345'这样的号码呢？由于'-'是特殊字符，在正则表达式中，要用'\'转义，所以，上面的正则是\d{3}\-\d{3,8}。

 * 但是，仍然无法匹配'010 - 12345'，因为带有空格。所以我们需要更复杂的匹配方式。

 * 进阶
 * 要做更精确地匹配，可以用[]表示范围，比如：

 * [0-9a-zA-Z\_]可以匹配一个数字、字母或者下划线；

 * [0-9a-zA-Z\_]+可以匹配至少由一个数字、字母或者下划线组成的字符串，比如'a100'，'0_Z'，'js2015'等等；

 * [a-zA-Z\_\$][0-9a-zA-Z\_\$]*可以匹配由字母或下划线、$开头，后接任意个由一个数字、字母或者下划线、$组成的字符串，也就是JavaScript允许的变量名；

 * [a-zA-Z\_\$][0-9a-zA-Z\_\$]{0, 19}更精确地限制了变量的长度是1-20个字符（前面1个字符+后面最多19个字符）。

 * A|B可以匹配A或B，所以(J|j)ava(S|s)cript可以匹配'JavaScript'、'Javascript'、'javaScript'或者'javascript'。

 * ^表示行的开头，^\d表示必须以数字开头。

 * $表示行的结束，\d$表示必须以数字结束。

 * 你可能注意到了，js也可以匹配'jsp'，但是加上^js$就变成了整行匹配，就只能匹配'js'了。**/

JSON

// 序列化
var xiaoming = {
    name: '小明',
    age: 14,
    gender: true,
    height: 1.65,
    grade: null,
    'middle-school': '\"W3C\" Middle School',
    skills: ['JavaScript', 'Java', 'Python', 'Lisp'],
    // 精确控制序列化方式
    /*toJSON: function () {
        return { // 只输出name和age，并且改变了key：
            'Name': this.name,
            'Age': this.age
        };
    }*/
};
// 序列化方法
var s = JSON.stringify(xiaoming);
console.log(s);
// 可以加上参数，按缩进输出
var s = JSON.stringify(xiaoming, null, '    ');
console.log(s);
// 第二个参数用于控制如何筛选对象的键值
var s = JSON.stringify(xiaoming, ['name', 'skills'], '  ');
console.log(s);
// 第二个参数也可以传入函数
// 把所有string都变成大写
function convert(key, value) {
    if (typeof value === 'string') {
        return value.toUpperCase();
    }
    return value;
}
var s = JSON.stringify(xiaoming, convert, '  ');
console.log(s);

// 反序列化
JSON.parse('[1,2,3,true]'); // [1, 2, 3, true]
JSON.parse('{"name":"小明","age":14}'); // Object {name: '小明', age: 14}
JSON.parse('true'); // true
JSON.parse('123.45'); // 123.45
// JSON.parse()还可以接收一个函数，用来转换解析出的属性
var obj = JSON.parse('{"name":"小明","age":14}', function (key, value) {
    if (key === 'name') {
        return value + '同学';
    }
    return value;
});
console.log(JSON.stringify(obj)); // {name: '小明同学', age: 14}