css列表list、表格table（css中列表）

25-04-06 3

本文的目的是介绍css列表list、表格table的详细情况，特别关注css中列表的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解css列表list、表格table的

本文的目的是介绍css列表list、表格table的详细情况，特别关注css中列表的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解css列表list、表格table的机会，同时也不会遗漏关于00028-layui 表单有子列表，如何动态新增和保存（表格table行编辑）？、Bootstrap框架----DataTables列表折叠列、Bootstrap框架----DataTables列表示例、C# ArrayList、HashSet、HashTable、List、Dictionary 的区别的知识。

本文目录一览：

css列表list、表格table（css中列表）
00028-layui 表单有子列表，如何动态新增和保存（表格table行编辑）？
Bootstrap框架----DataTables列表折叠列
Bootstrap框架----DataTables列表示例
C# ArrayList、HashSet、HashTable、List、Dictionary 的区别

css列表list、表格table（css中列表）

列表list，无序列表ul，有序列表ol

1.列表项样式list-style-type

无列表默认为dist实心圆，有序列表默认为decimal阿拉伯数字（前面不带0）

其他无序列表常用none无样式，circle空心圆，square实心方块

有序列表常用decimal-leading-zero以0开头的数字，lower-roman、upper-roman小写、大写罗马数字，lower-alpha、upper-alpha小写、大写英文字母

ul.a {list-style-type: circle;}
ul.b {list-style-type: square;}
 
ol.c {list-style-type: upper-roman;}
ol.d {list-style-type: lower-alpha;}

例如上述设置后，显示的为

2.列表项标记的图像list-style-image: url

ul { list-style-image: url(‘sqpurple.gif‘); }

3.列表项标记的位置list-style-position

默认值outside，标记位于文本的左侧，且放置在文本以外，环绕文本不根据标记对齐

inside，标记放置在文本以内，且环绕文本根据标记对齐

上述三个属性可集合在一起，通过list-style表示，顺序为type、position、image，可根据需要选择

例如ul { list-style: square url("sqpurple.gif"); }

表格table

1.边框border

如果仅使用border，例如table,th,td { border: 1px solid black; }，得到的效果如下，因为th和td都有各自的边框

可再通过border-collapse属性设置表格的边框被折叠成一个单一的边框或隔开

table {border-collapse: collapse;}

table,td,th {border: 1px solid red;background-color:lightgray;color:green;text-align:center}

2.表格宽度和高度，例如

table{width:100%;}
th{height:40px;}
tr{height:30px;}

3.表格内文本对齐方式

text-align水平对齐，vertical-align垂直对齐（设置垂直对齐方式时必须指定td的高度）

00028-layui 表单有子列表，如何动态新增和保存（表格table行编辑）？

html:

<div>
			<div>
				<div>资料清单</div>
				<div>
					<tableid="serviceMaterialListTable" lay-filter="serviceMaterialListTable"></table>

					<script type="text/html" id="serviceMaterialListTable-toolbar">
						<div>
							<buttondata-type="addMaterial">添加</button>
						</div>
					</script>

					<script type="text/html" id="serviceMaterialListTable-bar">
						<%--<alay-event="editMaterial">编辑</a>--%>
						<alay-event="delMaterial">删除</a>
					</script>
					<script type="text/html" id="serviceMaterialTypeTpl">
						<select name="type" lay-filter="service_material_type" autocomplete="off">
							<option value="">请选择</option>
							{{#
							var typeArr = layui.dict.options("service_materialType");
							layui.each(typeArr, function(index, item){
							}}
							<option value="{{item[0]}}" {{d.type==item[0]?''selected'':''''}}>{{item[1]}}</option>
							{{# }) }}
						</select>
					</script>
					<script type="text/html" id="certTypeTpl">
						<select name="type" lay-filter="cert_type"  autocomplete="off">
							<option value="">请选择</option>
							{{#
							var certTypeArr = layui.dict.options("company_paper_certType");
							layui.each(certTypeArr, function(index, item){
							}}
							<option value="{{item[0]}}" {{d.certType==item[0]?''selected'':''''}}>{{item[1]}}</option>
							{{# }) }}
						</select>
					</script>
				</div>
			</div>
		</div>

方法：

var active = {
            getSubData:function () {
				var materialList = active.getMaterialList();
				var flowList = active.getFlowList();
				var minDay = 0;
				var maxDay = 0;
                $.each(flowList,function (index,item) {
                    minDay += item.minDay?parseFloat(item.minDay):0;
                    maxDay += item.maxDay?parseFloat(item.maxDay):0;
                });
                return {
                    materialList:materialList,
                    flowList:flowList,
                    minDay:minDay,
                    maxDay:maxDay
				}
            },
            getMaterialList:function () {
                var tableObj = materialTable;
                var config = tableObj.config;
                var dataTemp = config.data||[];
                $.each(dataTemp,function (index,item) {
                    item = $.extend(item,{createTime:null,modifyTime:null});
                })
                return dataTemp;
            },
            getFlowList:function () {
                var tableObj = serviceFlowTable;
                var config = tableObj.config;
                var dataTemp = config.data||[];
                $.each(dataTemp,function (index,item) {
                    item = $.extend(item,{createTime:null,modifyTime:null});
                });
                return dataTemp;
            },
            addFlow:function () {
                var tableObj = serviceFlowTable;
                var config = tableObj.config;
                var dataTemp = config.data||[];
                var len = dataTemp?(dataTemp.length+1):1;
                dataTemp.push({sortOrder:len,minDay:1,maxDay:1});
                serviceFlowTable = table.reload(config.id, $.extend(true, {
                    // 更新数据
                    data: dataTemp,
                }, config.page ? {
                    // 一般新增都是加到最后，所以始终打开最后一页
                    page: {
                        curr: Math.ceil(dataTemp.length / config.page.limit)
                    }
                } : {}));
            },
            editFlow:function (obj) {

            },
            delFlow:function (data) {
                var tableObj = serviceFlowTable;
                var config = tableObj.config;
                var dataTemp = config.data||[];
                // 得到tr的data-index
                var trElem = data.tr.first();
                var index = trElem.data(''index'');
                // 计算出在data中的index
                var dataIndex = index;
                // 删除对应下标的数据
                dataTemp.splice(dataIndex, 1);

                // 重新接收reload返回的对象，这个很重要
                serviceFlowTable = table.reload(config.id, $.extend(true, {
                    // 更新数据
                    data: dataTemp
                }, {}));
            },
            addMaterial:function () {
                var tableObj = materialTable;
                var config = tableObj.config;
                var dataTemp = config.data||[];
                var len = dataTemp?(dataTemp.length+1):1;
                dataTemp.push({sortOrder:len});
                materialTable = table.reload(config.id, $.extend(true, {
                    // 更新数据
                    data: dataTemp,
                }, config.page ? {
                    // 一般新增都是加到最后，所以始终打开最后一页
                    page: {
                        curr: Math.ceil(dataTemp.length / config.page.limit)
                    }
                } : {}));
            },
            editMaterial:function (obj) {

            },
            delMaterial:function (data) {
                var tableObj = materialTable;
                var config = tableObj.config;
                var dataTemp = config.data||[];
                // 得到tr的data-index
                var trElem = data.tr.first();
                var index = trElem.data(''index'');
                // 计算出在data中的index
                var dataIndex = index;
                // 删除对应下标的数据
                dataTemp.splice(dataIndex, 1);

                // 重新接收reload返回的对象，这个很重要
                materialTable = table.reload(config.id, $.extend(true, {
                    // 更新数据
                    data: dataTemp
                }, {}));
            },
            setDataList:function () {
                window.parent.formData = $.extend(window.parent.formData,{serviceMaterialList:serviceMaterialList})
                window.parent.formData = $.extend(window.parent.formData,{serviceFlowList:serviceFlowList})
            },
		}

js:

var serviceMaterialList = [];

        if(id){
            var rtnList2 = admin.syncReq(ctx+"/base/serviceMaterial/queryByAll",{serviceId:id});
            serviceMaterialList = rtnList2.data;
        }
        var materialTable = table.render({
            elem:''#serviceMaterialListTable''
			,data:serviceMaterialList
            ,cellMinWidth: 80
            ,toolbar: ''#serviceMaterialListTable-toolbar''
            ,defaultToolbar: []
            ,cols: [[
                {field:''licenceName'', title: ''证照名称'', align: ''center'',minWidth:100,edit:''text'' }
                ,{field:''type'', title: ''资料类型'', align: ''center'',minWidth:100,templet:''#serviceMaterialTypeTpl''}
                ,{field:''certType'', title: ''证件类型'', align: ''center'',minWidth:100,templet:''#certTypeTpl''}
                ,{field:''sortOrder'', title: ''排序'', align: ''center'',minWidth:100,edit:''text''}
                ,{title:''操作'', toolbar: ''#serviceMaterialListTable-bar'', width:120}
            ]]
            ,done: function(res, curr, count){
                serviceMaterialList = res.data;
            }
            ,height: ''250''
        });



        table.on(''tool(serviceMaterialListTable)'', function(obj){
            switch(obj.event){
                case ''delMaterial'':
                    active.delMaterial(obj);
                    break;
            }
        });
        
        form.on(''select(service_material_type)'', function(obj){
            var tr_index = $(obj.othis).parent().parent().parent().data("index");
            $.each(serviceMaterialList,function (index,item) {
				if(tr_index==index){
                    item = $.extend(item,{type:obj.value})
				}
            })

        });
        form.on(''select(cert_type)'', function(obj){
            var tr_index = $(obj.othis).parent().parent().parent().data("index");
            $.each(serviceMaterialList,function (index,item) {
                if(tr_index==index){
                    item = $.extend(item,{certType:obj.value})
                }
            })
        });
        
        $("body").on(''click'',''.layui-btn-container .layui-btn'', function(){
            var type = $(this).data(''type'');
            active[type] ? active[type].call(this) : '''';
        });

        window.parent._active = active;

父页面获取表单的所有数据：

var subData = window._active.getSubData();
                            var materialList = subData.materialList;
                            var flowList = subData.flowList;
                            var minDay = subData.minDay;
                            var maxDay = subData.maxDay;
                            field = $.extend(field,{
                                serviceMaterialJson:JSON.stringify(materialList),
                                serviceFlowJson:JSON.stringify(flowList),
                                minDay:minDay,
                                maxDay:maxDay,
                            })

                            field.id = rec.id;
                            var rtn = admin.syncReq(ctx+"/base/service/modify",field);
                            if(rtn && rtn.code==0){
                                layer.msg(''操作成功'');
                                active.reload();
                                layer.close(index);
                            }else{
                                layer.msg(''操作失败'');
                            }

Bootstrap框架----DataTables列表折叠列

总结

以上是小编为你收集整理的Bootstrap框架----DataTables列表折叠列全部内容。

如果觉得小编网站内容还不错，欢迎将小编网站推荐给好友。

Bootstrap框架----DataTables列表示例

总结

以上是小编为你收集整理的Bootstrap框架----DataTables列表示例全部内容。

如果觉得小编网站内容还不错，欢迎将小编网站推荐给好友。

C# ArrayList、HashSet、HashTable、List、Dictionary 的区别

在 C# 中，数组由于是固定长度的，所以常常不能满足我们开发的需求。

由于这种限制不方便，所以出现了 ArrayList。

ArrayList、List<T>

ArrayList 是可变长数组，你可以将任意多的数据 Add 到 ArrayList 里面。其内部维护的数组，当长度不足时，会自动扩容为原来的两倍。

但是 ArrayList 也有一个缺点，就是存入 ArrayList 里面的数据都是 Object 类型的，所以如果将值类型存入和取出的时候会发生装箱、拆箱操作 (就是值类型与引用类型之间的转换)，这个会影响程序性能。在.Net 2.0 泛型出现以后，就提供了 List<T>。

List<T> 是 ArrayList 的泛型版本，它不再需要装箱拆箱，直接取，直接用，它基本与 ArrayList 一致，不过在使用的时候要先设置好它的类型，而设置好类型之后，不是这种类型的数据，是不允许 Add 进去的。

就性能来说，如果要存进数组的只有一种数据，那么无疑 List<T> 是最优选择。

List<int> ListInt = new List<int>();

如果一个变长数组，又要存 int，又要存 string。那么就只能用 ArrayList。

HashTable (哈希表)、Dictionary<T,T>

HashTable 是一种根据 key 查找非常快的键值数据结构，不能有重复 key，而且由于其特点，其长度总是一个素数，所以扩容后容量会比 2 倍大一点点，加载因子为 0.72f。

当要大量使用 key 来查找 value 的时候，HashTable 无疑是最有选择，HashTable 与 ArrayList 一样，是非泛型的，value 存进去是 object, 存取会发生装箱、拆箱，所以出现了 Dictionary<T,T>。

Dictionary<T,T> 是 HashTable 的泛型版本，存取同样快，但是不需要装箱和拆箱了。而且，其优化了算法，Hashtable 是 0.72，它的浪费容量少了很多。

Dictionary<string,Person> Dic = new Dictionary<string,Person>();

HashSet<T>

HashSet<T> 类，算法，存储结构都与哈希表相同，主要是设计用来做高性能集运算的，例如对两个集合求交集、并集、差集等。集合中包含一组不重复出现且无特定顺序的元素。

Queue、Queue<T>

Queue 队列，Queue<T> 泛型队列，大学都学过，队列，先进先出，很有用。

Stack、Stack<T>

Stack 堆栈，先进后出。

SortedList、SortedList<TKey,TValue>

SortedList 集合中的数据是有序的。可以通过 key 来匹配数据，也可以通过 int 下标来获取数据。

添加操作比 ArrayList，Hashtable 略慢；查找、删除操作比 ArrayList 快，比 Hashtable 慢。

SortedDictionary<TKey,TValue>

SortedDictionary<TKey,TValue> 相比于 SortedList<TKey,TValue > 其性能优化了，SortedList<TKey,TValue > 其内部维护的是数组而 SortedDictionary<TKey,TValue > 内部维护的是红黑树 (平衡二叉树) 的一种，因此其占用的内存，性能都好于 SortedDictionary<TKey,TValue>。唯一差在不能用下标取值。

ListDictionary (单向链表),LinkedList<T>(双向链表)

List<T>,ArrayList,Hashtable 等容器类，其内部维护的是数组 Array 来，ListDictionary 和 LinkedList<T > 不用 Array，而是用链表的形式来保存。链表最大的好处就是节约内存空间。

ListDictionary 是单向链表。

LinkedList<T> 双向链表。双向链表的优势，可以插入到任意位置。

HybridDictionary

HybridDictionary 的类，充分利用了 Hashtable 查询效率高和 ListDictionary 占用内存空间少的优点，内置了 Hashtable 和 ListDictionary 两个容器，添加数据时内部逻辑如下：

当数据量小于 8 时，Hashtable 为 null，用 ListDictionary 保存数据。

当数据量大于 8 时，实例化 Hashtable，数据转移到 Hashtable 中，然后将 ListDictionary 置为 null。

BitArray

BitArray 这个东东是用于二进制运算，"或"、"非"、"与"、"异或非" 等这种操作，只能存 true 或 false；

应用场景

ArrayList,List<T>：变长数组；

HashTable,Dictionary<T,T>：频繁根据 key 查找 value；

HashSet<T>：集合运算；

Queue、Queue<T>：先进先出；

Stack、Stack<T>：堆栈，先进先出；

SortedList、SortedList<TKey,TValue>：哈希表，要通过下标，又要通过 key 取值时，可选用；

ListDictionary：单向链表，每次添加数据时都要遍历链表，数据量大时效率较低，数据量较大且插入频繁的情况下，不宜选用。

LinkedList<T>：双向链表；

HybridDictionary：未知数据量大小时，可用。

SortedDictionary<TKey,TValue>：SortedList<TKey,TValue > 的优化版，内部数组转平衡二叉树。

BitArray：二进制运算时可选用；

引用于 https://blog.csdn.net/wildlifeking/article/details/58605587

我们今天的关于css列表list、表格table和css中列表的分享已经告一段落，感谢您的关注，如果您想了解更多关于00028-layui 表单有子列表，如何动态新增和保存（表格table行编辑）？、Bootstrap框架----DataTables列表折叠列、Bootstrap框架----DataTables列表示例、C# ArrayList、HashSet、HashTable、List、Dictionary 的区别的相关信息，请在本站查询。

本文标签：