Day12

一：将任意字符串中出现次数最多的字母弹框输出

 // 定义函数
        function num(str) {
            // 定义一个空对象，因为这边要求出现最多次数，以及出现的字符，这边使用对象的方式再合适不过了，键值对的形式
            var obj = {};
            // 求出字符串的长度
            var len = str.length;
            // for循环如果遍历整个字符串
            for (var i = 0; i < len; i++) {
                // 将每个字符赋值给alpha
                var alpha = str[i];
                // 如果定义的obj里有这个字符的话,那么这个字符的值加1
                if (obj[alpha]) {
                    obj[alpha]++;
                }
                // 否则的话这个字符的值等于1,刚开始肯定都是走这边,因为对象使我们定义的空对象,现在才开始增加属性
                else {
                    obj[alpha] = 1;
                }
            }
            // 随意定义一个出现最多的次数
            var maxNum = -1;
            // 遍历obj对象
            for (key in obj) {
                // 求出obj里出现最多字符的次数并且赋值给maxNum
                if (obj[key] > maxNum) {
                    maxNum = obj[key];
                }
            }
            // 定义一个空数组
            var maxKey = [];
            // 再次遍历obj对象
            for (key in obj) {
                // 如果当前的obj里的字符出现次数等于maxNum的话,就像我们定义的空数组里添加这个字符
                if (obj[key] == maxNum) {
                    maxKey.push(key);
                }
            }
            alert(maxKey)
        }
二：深克隆
//深度克隆
function deepClone(origin, target) {
    var target = target || {},
        toStr = Object.prototype.toString,
        arrStr = "[object Array]"
        //遍历对象
    for (var prop in origin) {
        //判断是不是origin身上的属性 
        if (origin.hasOwnProperty(prop)) {
            //判断origin里面的类型  是原始值还是引用值  object为引用值 堆里存放的是栈的地址 引用值不能直接克隆
            if (typeof(origin[prop]) == "object" && typeof(origin[prop]) !== "null") {
                //判断引用值的类型  是对象还是数组 
                if (toStr.call(origin[prop]) == arrStr) {
                    //对象即创建对象
                    target[prop] = []
                } else {
                    //数组即创建数组
                    target[prop] = {}
                }
                deepClone(origin[prop], target[prop])
            } else {
                //这是原始值 在堆里可以直接赋值 
                target[prop] = origin[prop]
            }
        }
    }
    return target
}
三：对象方法的继承
var inherit = (function() {
    //通过闭包令F变为私有化变量  只有通过自身方法能访问到  其他无法访问
    var F = function() {}
    return function(Target, Origin) {
        F.prototype = Origin.prototype
        Target.prototype = F.prototype
            //constructor是查看元素的构造函数
        Target.prototype.constructor = Target
            //uber是查看该元素的超级父类
        Target.prototype.uber = Origin.prototype
    }
})()
四：左右定宽 中间自适应布局 圣杯布局
<!DOCTYPE html>
<html lang="en">
<head>
<title></title>
<meta charset="UTF-8" />
<style>
.container {
padding: 0 100px 0 200px;
}
.left {
width: 200px;
background: red;
/* 关键点：会让元素沿文档流向左移动，负数值比较大的话会一直移动到上一行 */
margin-left: -100%; 
left: -200px;
}
.right {
width: 100px;
background: blue;

margin-left: -100px;
right: -100px;
}
.main {
background: yellow;
width: 100%;
}
.left, .main, .right{
float: left;
min-height: 200px;
position: relative;
}

</style>
</head>
<body>
<div class="container">
<div class="main">main</div>
<div class="left">left</div>
<div class="right">right</div>
</div>
</body>
</html>

五：封装自己的jquery插件（返回高度最大的div元素的高度）

(function ($) {

$.fn.m​​axHeight = function () {

var max = 0;

this.each(function () {
max = Math.max(max, $(this).height());
});

return max;
};
})(jQuery);

posted @ 2021-02-28 16:05  heartru  阅读(53)  评论(0)    收藏  举报