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;

 

posted @ 2015-08-11 16:42  Skylor.min  阅读(216)  评论(0编辑  收藏