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')    //

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;       //

        //请注意，直接给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] , 若数组为空，则返回undefined

    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
    a.indexOf(3);   // 返回 -1，如果要检索的字符串值没有出现，则该方法返回 -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; //

    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  //

+'01'  //

+'undefined'   // NaN

+null   //

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