JavaScript小笔记の经典算法等....

1.利用toString()里面的参数，实现各进制之间的快速转换：

var n = 17;

binary_string = n.toString(2);

//->二进制"10001"

octal_tring = n.toString(8);

//->八进制"021"

hex_string = n.toString(16);

//->十六进制"0x11"

2.parseInt()可以接受第二个可选参数，这个参数是指定数字转换的基数，合法的取值范围是2~36.（进制）

parseInt('11', 2); //->3 (1*2 + 1)

parseInt('ff', 16); //->255 (15*16 + 15)

parseInt('zz', 36); //->1295 (35*36 + 35)

parseInt('077', 8); //->63 (7*8 + 7)

parseInt('077', 10); //->77 (7*10 +7)

3.申明提前（预编译时进行的）

：即JavaScript函数里声明的所有变量（但不涉及赋值）都被‘提前’至函数体的顶部。在函数体内的局部变量覆盖了同名的全局变量。（JavaScript没有块级作用域）

4.当使用var声明一个变量的时候，这个变量是不可配置的，也就是说这个变量无法通过delete运算符进行删除操作。

5.一元加法（+）和一元减法（-）一元加法（+）：一元加法操作符把操作数转换为数字或者NaN，并返回这个转换后的数字。如果操作数本身就是个数字，则直接返回这个数字。（可用来简单的把‘数字字符串’转换为数字）一元减法（-）：当‘-’用作一元运算符的时候，它会根据需要把操作数转换为数字，然后改变运算结果的符号。

6.NaN和任何值都不想等，包括它本身。

通过X!===X来判断X是否为NaN，只有在X为NaN的时候这个表达式的结果才为true.(用isNaN()来判断一个变量是否为NaN)

7.Infinity (无限大)、-Infinity (无限小)

8.JavaScript实现的几种排序算法。

1>快速排序算法：

/*快速排序法*/

        function quickSort(a) {

                if (a.length <= 1) {

                        return a;

                }

                var midLength = Math.floor(a.length / 2);

                var midValue = a.splice(midLength,1);

                var left = [];

                var right = [];

                for (var i = 0; i < a.length; i++) {

                        if (a[i] < midValue) {

                                left.push(a[i]);

                        } else {

                                right.push(a[i]);

                        }

                }

                return quickSort(left).concat(midValue,quickSort(right));

        }

        console.log(quickSort([1,5,3,6,2,4,0]));

2>冒泡排序算法：

/*冒泡排序法*/

        function bubbleSort(a) {

                var length = a.length;

                var sortArray;

                for (var i = 0; i < length-1; i++) {

                        for (var j = 0; j < length-i-1 ; j++) {

                                if (a[j] > a[j+1]) {

                                        sortArray = a[j];

                                        a[j] = a[j+1];

                                        a[j+1] = sortArray;

                                }

                        }

                }

                return a;

        }

        console.log(bubbleSort([2,1,3,6,5,4,7,0]));

3>插入排序算法：

/*插入排序法*/

        function insertSort(a) {

                var length = a.length;

                var sortArray;

                for (var i = 1; i < length; i++) {

                        for (var j = 0; j < i ; j++) {

                                if (a[i] < a[j]) {

                                        sortArray = a[i];

                                        a[i] = a[j];

                                        a[j] = sortArray;

                                }

                        }

                }

                return a;

        }

        console.log(insertSort([0,6,5,3,4,2,1,7]));

4>选择排序算法：

/*选择排序法*/

        function selectSort(a) {

                for (var i = 0; i < a.length; i++) {

                        var min = a[i];

                        var k = i;

                        for (var j = i + 1; j < a.length; j++) {

                                if (min > a[j]) {

                                        min = a[j];

                                        k = j;

                                }

                        }

                        a[k] = a[i];

                        a[i] = min;

                }

                return a;

        }

        console.log(selectSort([5,1,4,0,3,2,7,6]));

9) 不要在循环内部使用try-catch-finally

try-catch-finally中catch部分在执行时会将异常赋给一个变量，这个变量会被构建成一个运行时作用域内的新的变量。

切忌：

    var object = ['foo', 'bar'], i;

    for (i = 0, len = object.length; i < len; i++) {

        try {

            // do something that throws an exception

        }

        catch (e) {

            // handle exception

        }

    }

而应该：

  var object = ['foo', 'bar'], i;

    try {

        for (i = 0, len = object.length; i <len; i++) {

            // do something that throws an exception

        }

    }

    catch (e) {

        // handle exception

    }

10) 使用XMLHttpRequests时注意设置超时

XMLHttpRequests在执行时，当长时间没有响应（如出现网络问题等）时，应该中止掉连接，可以通过setTimeout()来完成这个工作：

    var xhr = new XMLHttpRequest ();

    xhr.onreadystatechange = function () {

        if (this.readyState == 4) {

            clearTimeout(timeout);

            // do something with response data

        }

    }

    var timeout = setTimeout( function () {

        xhr.abort(); // call error callback

    }, 60*1000 /* timeout after a minute */ );

    xhr.open('GET', url, true);

    xhr.send();

同时需要注意的是，不要同时发起多个XMLHttpRequests请求。

11) 处理WebSocket的超时

通常情况下，WebSocket连接创建后，如果30秒内没有任何活动，服务器端会对连接进行超时处理，防火墙也可以对单位周期没有活动的连接进行超时处理。

为了防止这种情况的发生，可以每隔一定时间，往服务器发送一条空的消息。可以通过下面这两个函数来实现这个需求，一个用于使连接保持活动状态，另一个专门用于结束这个状态。

    var timerId = 0;

    function keepAlive() {

        var timeout = 15000;

        if (webSocket.readyState == webSocket.OPEN) {

            webSocket.send('');

        }

        timerId = setTimeout(keepAlive, timeout);

    }

    function cancelKeepAlive() {

        if (timerId) {

            cancelTimeout(timerId);

        }

    }

keepAlive()函数可以放在WebSocket连接的onOpen()方法的最后面，cancelKeepAlive()放在onClose()方法的最末尾。

12) 注意原始操作符比函数调用快

比如，一般不要这样：

    var min = Math.min(a,b);

    A.push(min);

可以这样来代替：

    var min = a < b ? a : b;

    A[A.length] = min;

巴特西