《JavaScript程序设计》课堂交流区问题汇总(基础篇)

最新推荐文章于 2024-10-11 17:39:47 发布

「已注销」

最新推荐文章于 2024-10-11 17:39:47 发布

阅读量1.2k

点赞数

分类专栏： Web开发文章标签： javascript 网易微专业

本文链接：https://blog.csdn.net/Lovejulyer/article/details/51438515

版权

Web开发专栏收录该内容

50 篇文章 1 订阅

订阅专栏

这篇博客总结了网易云课堂《JavaScript程序设计》课程中的五个关键问题：1) 如何获取0-9之间的随机整数；2) 字符串删除第一个字符的方法；3) 不同的数组求和策略；4) 正则表达式中贪婪与惰性量词的区别；5) JSON.stringify在IE6/7的兼容解决方案。

摘要由CSDN通过智能技术生成

本课程为网易云课堂 - - 前端开发工程师 - - 《JavaScript程序设计》学习总结

问题一：获取随机整数

获取一个大于等于0且小于等于9的随机整数？

解答：

// 方法一：Math.random() -- 返回0和1之间的伪随机数 可能为0，但总是小于1，即取值范围为[0,1)。
   Math.floor(Math.random()*10);
 // 方法二 : 先取0-1的随机数，然后乘以10，获得0-10的随机数，然后向上取整，然后减1，或者乘以9，获得0-9的随机数，然后向上取整
　var number=(Math.ceil(Math.random()*10))-1;
　var number=Math.ceil(Math.random()*9);
// 方法三：先取0-1的随机数，然后乘以10，获得0-10的随机数，然后保留0位小数点，获得整数
　var number=(Math.random()*10).toFixed(0);
//方法四：先取0-1的随机数，然后乘以9.5，获得0-9.5的随机数，然后四舍五入，获得整数
　var number=Math.round(Math.random()*9.5);
//方法五：先取0-1的随机数，然后乘以10，获得0-10的随机数，然后使用parseInt进行数值转换
　var number=parseInt(Math.random()*10);

问题二：字符删除

想要去除一个字符串的第一个字符，有哪些方法可以实现？

解答：

    "hellomiaomiao".replace("hellomiaomiao".charAt(0),"");
    "ellomiaomiao"//运行结果
    "hellomiaomiao".slice(1);
    "ellomiaomiao"//运行结果
    "hellomiaomiao".substr(1);
    "ellomiaomiao"//运行结果
    "hellomiaomiao".substring(1);
    "ellomiaomiao"//运行结果

问题三：数组求和

对一个数组（每项都是数值）求和，有哪些方法？

解答：

首先设定一个作为数据源的数组

    var arr = [1, 2, 3, 4, 5, 6,7,8,9,10];

every()方法：

    (function() {
        var sum = 0;
        function getSum(item, index, array) {
            sum += item;
            console.log(sum);
            return true;//由于every方法是会在遇到回调函数返回的第一个false时停止遍历所以需要始终返回true
        };
        arr.every(getSum);
        console.log("use every:sum = " + sum);})();

some()方法：

   (function() {
        var sum = 0;
        function getSum(item, index, array) {
            sum += item;
            console.log(sum);
        };
        arr.some(getSum);
        console.log("use some:sum = " + sum);})();

array.filter()方法：

  (function() {
        var sum = 0;
        function getSum(item, index, array) {
            sum += item;
            console.log(sum);
        };
        arr.filter(getSum);
        console.log("use filter:sum = " + sum);})();

array.map()方法：

 (function() {
        var sum = 0;
        function getSum(item, index, array) {
            sum += item;
            console.log(sum);
        };
        arr.map(getSum);
        console.log("use map:sum = " + sum);})();

array.froEach()方法：

 (function() {
        var sum = 0;
        function getSum(item, index, array) {
            sum += item;
            console.log(sum);
        };
        arr.forEach(getSum);
        console.log("use forEach:sum = " + sum);})();

array.reduce()正向归并方法：

 arr.reduce(function(prevResult, item, index, array) {
        return prevResult += item;
    });

array.reduceRight()逆向归并方法：

  arr.reduceRight(function(prevResult, item, index, array) {
        return prevResult += item;
    });

for循环方法

 (function() {
        for (var i = 0, sum = 0; i < arr.length; i++) {
            sum += arr[i];
            console.log(sum);
        }
        console.log("use for:sum = " + sum);})();

while循环方法

  (function(){
        var i = 0, sum = 0;
        while(i<arr.length){
            sum+=arr[i];
            console.log(sum);
            i++;
        }
        console.log("use while:sum = " + sum);})();

for -in方法

 (function() {
        var sum = 0;
        for (var index in arr) {
            sum += arr[index];
            console.log(sum);
        }
        console.log("use for-in:sum = " + sum);})();

forEach()方法

 var calc = {    sum: 0};
    function getSum(item, index, array) {
        this.sum += item;
        console.log(this.sum);
    }
    arr.forEach(getSum,calc);
    console.log('use forEach and change this:sum=' + calc.sum);

join()方法

 eval(arr.join("+"));
    /*这里先将所有数组项通过字符串"+"连为一个字符串"1+2+3+4+5+6"，然后返回的这个字符串传给eval()方法，eval()方法接收了这段字符串后，就直接将这段字符串中的代码放在当前作用域下执行了。*/

重点相关文章推荐：《数组求和方法比较》

问题四：量词

正则表达式中，量词的贪婪模式与惰性模式有什么区别？

解答：

贪婪与非贪婪模式影响的是被量词修饰的子表达式的匹配行为，贪婪模式在整个表达式匹配成功的前提下，尽可能多的匹配，而非贪婪模式在整个表达式匹配成功的前提下，尽可能少的匹配。非贪婪模式只被部分NFA引擎所支持。

贪婪量词：先看整个字符串是否匹配，如果不匹配就把最后一个字符去掉在进行匹配，不匹配继续去掉最后一个字符，指导找到一个匹配或者不剩任何字符才停止。

惰性量词：先看第一个字符串是否匹配，如果第一个不匹配就在加入第二个字符串依此类推，指导找到一个匹配或者不剩任何字符才停止，贪婪量词与贪婪量词的方法正好相反.

浏览器对量词的支持还不完善，IE和OPERA都不支持量词，MOZILLA把支配量词看作是贪婪的。

参考文章：

问题五：JSON.stringify兼容

JSON.stringify函数在ie6/7中不支持，如何兼容？

解答：

jQuery插件支持的转换方式：

    $.parseJSON( jsonstr ); //jQuery.parseJSON(jsonstr),可以将json字符串转换成json对象

Javascript支持的转换方式：

    eval('(' + jsonstr + ')'); //可以将json字符串转换成json对象,注意需要在json字符外包裹一对小括号

**注：**ie8(兼容模式),ie7和ie6可以使用eval()将字符串转为JSON对象，但不推荐这些方式，这种方式不安全eval会执行json串中的表达式。

JSON官方的转换方式：

http://www.json.org/提供了一个json.js,这样ie8(兼容模式),ie7和ie6就可以支持JSON对象以及其stringify()和parse()方法；
可以在https://github.com/douglascrockford/JSON-js上获取到这个js，一般现在用json2.js。

    <!--[if lt IE 9]>
        <script src="json2.js"></script>
    <![endif]-->

这样JSON.stringify 便可以正常使用！

判断类型加算法实现：

    function forIn(obj, handler) {
        for (var i in obj) {
            if (obj.hasOwnProperty(i)) {
                handler(i, obj[i]);
            }
        }
    }
    function each(arr, handler) {
        for (var i = 0, len = arr.length; i < len; i += 1) {
            handler(i, arr[i]);
        }
    }
    if (!JSON) {
        JSON = {};
    }
    if (!JSON.parse) {
        JSON.parse = function(json) {
            return eval('1,' + json)
        };
    }
    if (!JSON.stringify) {
        (function(JSON) {
            var arr = '[object Array]',
                obj = '[object Object]';
            JSON.stringify = function(json) {
                var t = '';
                var m = Object.prototype.toString.call(json);
                if (m == arr) {
                    t = ArrPartten(json);
                } else if (m == obj) {
                    t = ObjectJson(json);
                } else {
                    t = json;
                }
                return t;
            }
            function ObjectParse() {
                var t = '{';
                forIn(json, function(i, ele) {
                    var m = Object.prototype.toString.call(ele);
                    if (m == arr) {
                        t += i + ':' + ArrPartten(ele) + ',';
                    } else if (m == obj) {
                        t += i + ':' + ObjectJson(ele) + ',';
                    } else {
                        t += i + ':' + ele + ',';
                    }
                });
                if (t.length != 1) {
                    t = t.substring(0, t.length - 1);
                }
                return t + '}';
            }
            function ArrayParse() {
                var t = '[';
                each(json, function(i, ele) {
                    var m = Object.prototype.toString.call(ele);
                    if (m == arr) {
                        t += ArrPartten(ele) + ',';
                    } else if (m == obj) {
                        t += ObjectJson(ele) + ',';
                    } else {
                        t += ele + ',';
                    }
                });
                if (json.length > 0) {
                    t = t.substring(0, t.length - 1);
                }
                return t + ']';
            }
        }(JSON));
    }

判断类型加算法实现（版本二）

    if(!window.JSON){
        window.JSON = {
            parse: function(sJson){
                return eval("(" + sJSON + ")");
            },
            stringify: function(obj){
                var result = "";
                for(var key in obj){
                    if(typeof obj[key] == "string"){
                        // 如果属性值是String类型，属性值需要加上双引号
                        result += "\"" + key + "\":\"" + obj[key] + "\",";
                    }else if(obj[key] instanceof RegExp){
                        // 如果属性是正则表达式，属性值只保留一对空大括号{}
                        result += "\"" + key + "\":{},";
                    }else if(typeof obj[key] == "undefined" || obj[key] instanceof Function){
                        // 如果属性值是undefined, 该属性被忽略。忽略方法。
                    }else if(obj[key] instanceof Array){
                        // 如果属性值是数组
                        result += "\"" + key + "\":[";
                        var arr = obj[key];
                        for(var item in arr){
                            if(typeof arr[item] == "string"){
                                // 如果数组项是String类型，需要加上双引号
                                result += "\"" + arr[item] + "\",";
                            }else if(arr[item] instanceof RegExp){
                                // 如果属数组项是正则表达式，只保留一对空大括号{}
                                result += "{},";
                            }else if(typeof arr[item] == "undefined" || arr[item] instanceof Function){
                                // 如果数组项是undefined, 则显示null。如果是函数，则显示null?。
                                result += null +",";
                            }else if(arr[item] instanceof Object){
                                //如果数组项是对象(非正则，非函数，非null)，调用本函数处理
                                result += this.stringify(arr[item]) +",";
                            }else{
                                result += arr[item] + ",";
                            }
                        }
                        result = result.slice(0,-1)+"],"

                    }else if(obj[key] instanceof Object){
                        // 如果属性值是对象(非null，非函数，非正则)，调用本函数处理
                        result += "\"" + key + "\":" + this.stringify(obj[key]) + ",";
                    }else{
                        result += "\"" + key + "\":" + obj[key] + ",";
                    }
                }
                // 去除最后一个逗号,两边加{}
                return "{" + result.slice(0,-1) + "}";
            }
        };