用面对对象方式定tab标签

一些公共的底层的JS方法

var GLOBAL = {};
        GLOBAL.namespace = function (str) {
            var arr = str.split(‘.‘), o = GLOBAL;
            for (var i = (arr[0] == ‘GLOBAL‘) ? 1 : 0; i < arr.length; i++) {
                o[arr[i]] = o[arr[i]] || {};
                o = o[arr[i]];
            }
        }
        GLOBAL.namespace(‘Dom‘);
        GLOBAL.Dom.getElementsByClassName = function (str, root, tag) {
            if (root) {
                root = typeof root == ‘string‘ ? document.getElementById(root) : root;
            } else {
                root = document.body;
            }
            tag = tag || "*";
            var els = root.getElementsByTagName(tag), arr = [];
            for (var i = 0, n = els.length; i < n; i++) {
                for (var j = 0, k = els[i].className.split(‘ ‘), l = k.length; j < l; j++) {
                    if (k[j] == str) {
                        arr.push(els[i]);
                        break;
                    }
                }
            }
            return arr;
        }
        GLOBAL.Dom.addClass = function (node, str) {
            if (!new RegExp("(^|\\s+)" + str).test(node.className)) {
                node.className = node.className + " " + str;
            }
        }
        GLOBAL.Dom.removeClass = function (node, str) {
            node.className = node.className.replace(new RegExp("(^|\\s+)" + str), "");
        }
        GLOBAL.namespace(‘Event‘);
        GLOBAL.Event.on = function (node, eventType, handler, scope) {
            node = typeof node == ‘string‘ ? document.getElementById(node) : node;
            scope = scope || node;
            if (document.all) {
                node.attachEvent(‘on‘ + eventType, function () {
                    handler.apply(scope, arguments);
                });
            } else {
                node.addEventListener(eventType, function () {
                    handler.apply(scope, arguments);
                }, false);
            }
        }

基础的HTML

<div class="J_tab">
        <div class="tab">
            <ul class="tab-menuWrapper">
                <li class="J_tab-menu">menu1</li>
                <li class="J_tab-menu">menu2</li>
                <li class="J_tab-menu">menu3</li>
            </ul>
            <div class="tab-contentWrapper">
                <div class="J_tab-content">
                    <div>content1</div>
                    <ul>abc</ul>
                </div>
                <div class="J_tab-content" style="display: none;">
                    <p>content2</p>
                </div>
                <div class="J_tab-content" style="display: none;">content3</div>
            </div>
        </div>
        <hr />
        <div class="tab">
            <ul class="tab-menuWrapper">
                <li class="J_tab-menu">menu1</li>
                <li class="J_tab-menu">menu2</li>
                <li class="J_tab-menu">menu3</li>
            </ul>
            <div class="tab-contentWrapper">
                <div class="J_tab-content">
                    <div>content1</div>
                    <ul>abc</ul>
                </div>
                <div class="J_tab-content" style="display: none;">
                    <p>content2</p>
                </div>
                <div class="J_tab-content" style="display: none;">content3</div>
            </div>
        </div>
        <hr />
        <div class="tab">
            <ul class="tab-menuWrapper">
                <li class="J_tab-menu">menu1</li>
                <li class="J_tab-menu">menu2</li>
                <li class="J_tab-menu">menu3</li>
            </ul>
            <div class="tab-contentWrapper">
                <div class="J_tab-content">
                    <div>content1</div>
                    <ul>abc</ul>
                </div>
                <div class="J_tab-content" style="display: none;">
                    <p>content2</p>
                </div>
                <div class="J_tab-content" style="display: none;">content3</div>
            </div>
        </div>
    </div>

一些基本的CSS

ul {
            padding: 0;
            margin: 0;
        }

        .tab {
            width: 400px;
        }

            .tab .tab-currentMenu {
                background-color: #333;
                color: #fff;
            }

            .tab .tab-currentMenu1 {
                background-color: blue;
                color: #fff;
            }

        .underline {
            text-decoration: underline;
        }

        .tab-menuWrapper {
            padding-left: 20px;
        }

            .tab-menuWrapper li {
                float: left;
                display: inline;
                padding: 5px;
                border: 1px solid #333;
                border-bottom: none;
                margin-right: 5px;
            }

        .tab-contentWrapper {
            border: 1px solid #333;
            clear: left;
            padding: 5px;
        }

实现tab效果的JS

function Tab(config) {
            debugger;
            this._root = config.root;
            this._currentClass = config.currentClass;
            var trigger = config.trigger || ‘click‘;
            this._handler = config.handler;
            var autoPlay = config.autoPlay;
            var playTime = config.playTime || 3000;
            this._tabMenus = GLOBAL.Dom.getElementsByClassName("J_tab-menu", this._root);
            this._tabContents = GLOBAL.Dom.getElementsByClassName("J_tab-content", this._root);
            this.currentIndex = 0;
            var This = this;
            if (autoPlay) {
                setInterval(function () {
                    This._autoHandler();
                }, playTime);
            }
            for (var i = 0; i < this._tabMenus.length; i++) {
                this._tabMenus[i]._index = i;
                GLOBAL.Event.on(this._tabMenus[i], trigger, function () {
                    This.showItem(this._index);
                    this.currentIndex = this._index;
                });
            }
        }
        Tab.prototype = {
            showItem: function (n) {
                for (var i = 0; i < this._tabContents.length; i++) {
                    this._tabContents[i].style.display = ‘none‘;
                }
                this._tabContents[n].style.display = ‘block‘;
                if (this._currentClass) {
                    var currentMenu = GLOBAL.Dom.getElementsByClassName(this._currentClass, this._root)[0];
                    if (currentMenu) {
                        GLOBAL.Dom.removeClass(currentMenu, this._currentClass);
                    }
                    GLOBAL.Dom.addClass(this._tabMenus[n], this._currentClass);
                }
                if (this._handler) {
                    this._handler(n);
                }
            },
            _autoHandler: function () {
                this.currentIndex++;
                if (this.currentIndex >= this._tabMenus.length) {
                    this.currentIndex = 0;
                }
                this.showItem(this.currentIndex);
            }
        };

调用tab的JS

        var tabs = GLOBAL.Dom.getElementsByClassName("tab");
        console.dir(tabs.length);
        new Tab({ root: tabs[0], trigger: "mouseover" });
         new Tab({ root: tabs[1], currentClass: "tabcurrentMenu", autoPlay: true, playTime: 5000 });
         new Tab({
             root: tabs[2], currentClass: "tabcurrentMenu", trigger: "mouseover", handler: function (index) {
                 console.log(‘您激活的是第‘ + (index + 1) + ‘个标签‘);
             }
         });
时间: 2024-12-29 06:52:43

用面对对象方式定tab标签的相关文章

搞定tab标签切换效果

<!doctype html><html lang="en"><head>    <meta charset="UTF-8">    <title>搞定tab标签切换效果</title><style>*{ margin:0; padding:0;list-style: none;}body {font:12px/1.5 Tahoma;}#big{border: 1px solid b

Tab标签页接口(1)

Tab标签接口的用简单的应用是把不同的标签页的接口组件集中放在同一个接口布局文件,而且程序代码也会集中放在主类的程序文件中.这种方法的好处就是项目中的文件数目不会增加,但是如果Tab标签的接口组件个数比较多,或者是程序代码比较复杂,把它们集中放在同一个文件会造成日后程序维护上的困难.我们已经学习过Intent对象的使用方法,这里我们就用Intent对象来建立Tab标签页接口.这个新的方法其实是基于一个很简单的概念,就是每一个Tab标签页都对应到一个独立的Activity类,因此不同标签页的接口布

Android 内功心法(番外)——写在设计模式前,面对对象编程基础

我写的一系列"Android 内功心法"着重讲到android中经常使用的设计模式.那么如果有些程序员刚刚接触设计模式,那就有必要确定一下自己面对对象编程的基础是否牢固了. 因为这直接关系到你阅读设计模式的速度和理解质量. 接下来我将简单介绍java中面对对象编程的一些基础知识. 1,类和修饰符 public class ClassTest{ public ClassTest{ } public void test(){ } } 其中类的定义是以"class"来决定

Python - 面对对象(基础)

目录 Python - 面对对象(基础) 一. 概述 二. 创建类和对象 三. 面向对象三大特征 封装 继承 多态 Python - 面对对象(基础) 一. 概述 面向过程:根据业务逻辑从上到下写垒代码 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 面向对象:对函数进行分类和封装,让开发"更快更好更强..." 面向过程编程(Object Oriented Programming,OOP,面向对象程序设计) 最易被初学者接受,其往往用一长段代码来实现指定功能,开发

Android(java)学习笔记129:Tab标签的使用

1.案例1---TabProject (1)首先是main.xml文件: 1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 3 android:orientation="vertical" 4 android:layout_wid

Android 底部TabActivity(3)——ActivityGroup|顶部底部均有Tab标签之二

上一篇使用过时的ActivityGroup简单实现了顶部底部均有Tab标签的效果,是页面底部只有文字的样式,今天想完善一下效果,底部实现文字加图标的样式. 本文属于半成品,本来想着放弃的,想着先放博客吧,好歹也是一种思路,以后作参考用!追求完美效果的可以忽略本篇,我会在后续文章中实现更优的效果! 先看下效果图 首先是主页面MainActivity.java,这种方式其实不是真正意义上的Tab,只是实现了这样的效果.底部用了GridView实现三个切换开关,放到页面底部. package sun.

js面对对象编程

说到js,很大一部分人会说我很熟悉,在日常的web开发中经常用,那么你的js代码是符合面对对象思路的吗?那你会问我面向过程的js代码有什么不好吗?我的感受是面对对象的js编码更加简洁,减少了混乱,可维护行增强,适合编写富客户端时应用. 好了,首先看看js里如何定义对象: <html> <head> <script type="text/javascript"> var obj=new Object(); obj.name='josh'; obj.ag

Java入门——(2)面对对象(上)

关键词:面对对象.类..构造方法.this.static.内部类 一.面对对象的概念:把解决的问题安装一定规则划分为多个独立的对象,然后通过调用对象的方法来解决问题.其特点可概括为封装性.继承性.多态性. 1.封装性:面对对象的核心,将对象的属性和行为封装起来,不需要让外界知道具体实现细节,这就是封装思想. 2.继承性:主要描述的是类与类之间的关系,通过继承,可以在无需重新编写原有类的情况下,对原有类的功能进行扩展. 3.多态性:是在程序中允许出现重名现象,它指在一个类中定义的属性和方法被其他类

整理用js实现tab标签页

首先是css样式,比如这样的: 1 <style> 2 *{ 3 margin:0; 4 padding: 0; 5 list-style: none; 6 font-size: 12px; 7 } 8 .notice{ 9 width: 298px; 10 height: 98px; 11 margin: 10px; 12 border:1px solid #7c7c7c; 13 overflow: hidden; 14 } 15 .notice-tit{ 16 height: 27px;