var a = ‘hello‘
typeof a    //"string"
typeof(a)    //"string"
//  数据类型      typeof()后返回的值
/*  Undefined   --->   undefined
 *  Null        --->   object
 *  Boolean     --->   boolean
 *  Number      --->   number
 *  String      --->   string
 *  Object      --->   object
 *  函数         --->   function
 */

/* true    --->  1
 * false   --->  0
 * null     --->  0
 * undefined  ---> NaN
 * 转换字符串时，若字符串中只包含数字，则转换为数字，否则转换为NaN，空字符串转换为0
 * 转换对象时，则调用该对象的valueOf()方法，对该方法返回的值进行转换
 */

/*  忽略字符前的空格，若第一个非空字符不是数字或者负号，则返回NaN，若第一个
 *  非空字符串是数字，则向后解析，直到碰到第一个非数字字符。
 */
//  parseInt()函数可以接受第二个参数，用来明确指定基数。建议明确指定基数
parseInt(‘22dkfj‘)    //  22
parseInt(‘22.5‘)    //  22，转换为整形
parseInt(‘070‘,8)    //  八进制转换
parseInt(‘0x23‘)    //  十六进制转换

//Number的基本包装类型的方法

    // 方法

    //toFixed(num)  将数字转换为字符格式，若指定num，则按照指定的num返回数字的小数位格式
    var a = 2;
    a.toFixed(2);  // ‘2.00‘
    //toExponential(num) 类似于toFixed()，返回数字的指数字符串格式
    a.toExponential(); //‘2e+0‘

    //不建议直接实例化Number类型，因为在使用typeof 和 instanceof测试基本类型与引用类型，结果不同
    var b = new Number(2);
    alert(typeof b); // ‘object‘
    alert(typeof a); // ‘number‘
    alert(b instanceof Number ); // false
    alert(a instanceof Number ); // true

// 布尔，数值，对象，字符串类型都有 toString()方法 。 Null Nndefined 类型无此方法
var a = 21;
a.toString();  // ‘21‘
a = true;
a.toString()  //  "true"

String(null)  //"null"
String(undefined)  //"undefined"

    str.length  　　　　　　　　  返回字符串长度
    str.charAt(index)　　　　　　 返回str索引为index数值的单个字符,index为空则默认为0，没有找到返回空字符串；
    str.charCodeAt(index)　　　　返回str索引为index数值的单个字符的unicode(统一码),index为空则默认为0，没有找到返回NaN；
    str1.concat(str2)　　　　　　 字符串连接，两个字符串连接用空格隔开，返回新连接的字符串；
    str.indexOf(str1)　　　　　　 返回子字符串str1在查找字符串str中第一次出现的位置，没有找到则返回-1,； 
    str1.localeCompare(str2)　　 判定两个字符串排序，如果str1排在str2,之前那么返回-1，之后返回1，相等返回0；
    str.match(regexp)　　　　　　 在str中匹配正则，以数组形式返回匹配到的字符串；
    str.replace(old,new) 　　　　在字符串str中查找old字符串(可以是正则)，用new字符串来替换；返回替换后的新字符串；
    str.search(str1) 　　　　　　 在字符串str中查找str1，返回第一次出现str1的位置，没有找到返回-1；
    str.slice(start,end(可选))   返回start和end数值下标之间的字符串.end为空返回start后全部字符串；
    str.split(" ")　　　　　　　　 把str用split方法中的符号为间隔切割字符串返回一个数组；可以使用正则pattern
    str.substr(start,length(可选))返回以start下标开始以length为长度之间的字符串，若length为空，则返回下标后得全部字符  串；
    str.substring(start,end)　　　　一个参数的话返回下标后所有字符串，两个参数的话，以小的为开始以大的为结束，返回量下标之间的字符   串 ；
    str.toString()　　　　　　　　　　把str或obj返回字符串对象；
    str.trim()　　　　　　　　　　　　除去str两端的空格，返回去空格的字符串，不支持IE8及前面版本； 
    str.valueOf() 　　　　　　　　　　返回str原始值;
    str.toUpperCase()　　　　　　　　把str字母全部转成大写；
    str.toLowerCase()　　　　　　　　把str字母全部转成小写； 
    str.toLocaleUpperCase()　　　　以本地方式把str字母全部转换成大写；
    str.toLocaleLowerCase()　　　　以本地方式把str字母全部转换成小写； 

//创建-----------------------------------
/*  创建分为两种方式
 *    1  使用构造函数
 *    2  使用字面量
 */
    var a = new Array();  // 第一种方式，创建一个空的数组
    a = [];               // 第二种方式，创建一个空的数组


//属性----------------------------------
    a = [1,‘df‘,true];

    //1  获取数组的长度
    r = a.length;       // 3
        //请注意，直接给Array的length赋一个新的值会导致Array大小的变化
        a.length = 2;   // a:[1, "df"]


//方法----------------------------------

    //----------操作方法
    // concat() 连接      一个参数：数组
    // slice()  切片      两个参数：开始索引,结束索引
    // splice()     参数：指定起始索引，从该索引开始删除的项数，要插入的项1，要插入的项2 ……
    a = [1,2,3];
    var r = a.concat([4,5]);  // r: [1,2,3,4,5]  a:[1,2,3]

    a = [1,2,3];
    a.slice(1,2);   // 从索引1开始到索引2结束，但不包括2   [2]
    a.slice(1);     // 从索引1开始到最后   [2,3]
    a.slice();      //  从头至尾 [1,2,3]

    a = [1,2,3,4,5];
    a.splice(1,2);  //返回删除的项组成的数组[2,3]  a:[1,4,5]
    a.splice(1,0,2.1,2.2);  //返回[]  a:[1, 2.1, 2.2, 4, 5]

    //----------栈方法，先进后出。
    // pop()    删除最后一个元素
    // push()   在数组后添加若干元素 多个参数：
    a.push(4,5);    // 返回数组的长度 a: [1,2,3,4,5]
    a.pop();        // 返回删除的元素，  a: [1,2,3,4]

    //---------队列方法，先进先出。
    //shift()   删除头部元素
    //unshift() 在头部添加元素
    a = [1,2,3];
    a.shift();      //  返回删除的元素  a:  [2,3]
    a.unshift(4,5);  //  返回数组长度   a: [4,5,1,2,3]

    //---------重排序方法
    //reverse()     反转
    //sort()        排序,默认按照升序排序，可接收一个比较函数作为参数，比较函数接收两个参数，
                    // 若第一个参数应该位于第二个参数之前，则返回负数；……之后，则返回正数；
                    // 若相等，则返回0
    a = [1,2,3];
    a.reverse();    // a: [3,2,1]
    a.sort();       // 返回 [1,2,3]
    a.sort(function(v1,v2){
        return v2 - v1;
    });                      //  返回[3,2,1]

    //----------位置方法
    //indexOf()     两个参数：要查找的项，表示查找位置起点的索引
    a = [1,2,3];
    a.indexOf(2);   //返回1

    //----------转换方法
    //join()  它把当前Array的每个元素都用指定的字符串连接起来，然后返回连接后的字符串
    a = [1,2,3];
    a.join(‘-‘);    //返回"1-2-3"

    //----------迭代方法
    //一共5个，都接受两个参数：函数，运行该函数的作用域对象
    //every()       对每一项运行给定函数，若每项都返回true，则返回true
    // filter()     对每一项运行给定函数，返回函数返回true的项数
    // forEach()    对每一项运行给定函数，无返回值
    // map()        对每一项运行给定函数，返回每次含数调用的结果组成的数组
    // some()       对每一项运行给定函数，若有一项项返回true，则返回true
    a = [1,2,3];
    a.every(function(v1){
        return v1 >= 2;
    });     //返回 false
    a.filter(function(v1){
        return v1 >= 2;
    });     //返回[2,3]
    a.map(function(v1){
        return v1 >= 2;
    });     //返回[false,true,true]
    a.some(function(v1){
        return v1 >= 2;
    });    //返回true

    //------------缩小方法
    //reduce()  支持两个参数：函数，初始值
        //第一次运行时，将数组的第一个元素作为参数一，第二个元素作为参数二；
        //第二次运行时，将第一次运行的结果作为参数一，第三个元素作为参数二，以此类推。
    a = [1,2,3];
    a.reduce(function(v1,v2){
        return v1 + v2;
    });     //返回6

//获取当前时间
//注意，当前时间是浏览器从本机操作系统获取的时间，所以不一定准确，因为用户可以把当前时间设定为任何值。
    var now = new Date();

// 创建指定日期和时间的Date对象
    var d = new Date(2015, 5, 19, 20, 15, 30, 123);
    d; // Fri Jun 19 2015 20:15:30 GMT+0800 (CST)

// 创建指定日期的时间戳
    var d = Date.parse(‘2015-06-24T19:49:22.875+08:00‘);
    d; // 1435146562875
    var d = new Date(1435146562875); //根据时间戳创建Date对象
    
// 方法
    now; // Thu Oct 13 2016 21:05:16 GMT+0800 (中国标准时间)
    now.getFullYear(); // 2016, 年份
    now.getMonth(); // 9, 月份，注意！！月份范围是0~11，9表示10月
    now.getDate(); // 13, 表示13号
    now.getDay(); // 4, 表示星期4
    now.getHours(); // 21, 24小时制
    now.getMinutes(); // 05, 分钟
    now.getSeconds(); // 16, 秒
    now.getMilliseconds(); // 875, 毫秒数
    now.getTime(); // 1476363916265, 以number形式表示的时间戳

//Date对象表示的时间总是按浏览器所在时区显示的，不过我们既可以显示本地时间，
// 也可以显示调整后的UTC时间：
    now.toLocaleString(); // "2016/10/13 下午9:05:16"，本地时间（北京时区+8:00），显示的字符串与操作系统设定的格式有关
    now.toUTCString(); // "Thu, 13 Oct 2016 13:05:16 GMT"，UTC时间，与本地时间相差8小时

/*创建
*分为两种方式：
*  1  字面量
*  2  使用构造函数
*/

    /* 使用字面量创建的格式为：         var expression = /pattern/flags ;
     * 使用构造函数进行创建的格式：      var expression = new RegExp(‘pattern‘,‘flags‘)
     *      flags:
     *          g:  全局模式，将pattern应用于所有字符串，而非在发现第一个字符串时停止
     *          i:  不区分大小写
     *          m:  多行模式
     *
     *      pattern:
     *          模式中所使用的所有元字符必须转义
     *          \d      匹配一个数字
     *          \w      匹配一个数字或者字母
     *          \s      匹配一个空格
     *          .       匹配任意一个字符
     *
     *          [a-z]   匹配任意一个a-z之间的字符
     *          [amn]   匹配任意一个a或者m或者n
     *          a|A     匹配a或者A
     *          \\      特殊字符需要进行转义，也就是添加一个反斜杠     *              特殊字符包括： - + { } [ ] \ | . ( ) ^ $ ? _
     *
     *          *       匹配前面的字符任意次
     *          +       匹配前面的字符一次或者多次
     *          ?       匹配前面的字符0次或1次
     *          {n}     匹配前面的字符n次
     *          {n,m}   匹配前面的字符n-m次
     *
     *          ^       匹配行首
     *          $       匹配行尾
     */

    var re1 = /ABC\-001/;
    var re2 = new RegExp(‘ABC\\-001‘);// 因为构造函数传入的pattern是字符串，所以需要双重转义

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

/* 方法
 * 存在两个方法：
 *      1  exec()  接受一个参数，也就是将要应用模式的字符串，然后返回第一个匹配信息的数组，
 *          若没有匹配项，则返回null。全局标识 g 对该方法无效。
 *          返回的数组是一个array，且包含两个额外的属性：index input
 *          index: 匹配项在字符串中的位置   input：应用正则的字符串
 *      2  text()  接受一个字符串餐宿，若匹配则返回true，否则返回false
 */

+true  // 1
+‘01‘  // 1
+‘undefined‘   // NaN
+null   // 0

var foo = "11"+2-"1";
console.log(foo);
console.log(typeof foo);   // 111

var foo = "11"+2+"1";    //体会加一个字符串‘1‘ 和 减去一个字符串‘1‘的不同
console.log(foo);
console.log(typeof foo);  //1121

‘10‘ < ‘5‘    //  true  注意事项 1
‘10‘ < 5     // false  注意事项 2
‘a‘ < 5     //  false  注意事项 2.1
‘a‘ >= 5    //false  注意事项 2.1