整合营销服务商
电脑端+手机端+微信端=数据同步管理
免费咨询热线：
电脑端+手机端+微信端=数据同步管理
免费咨询热线：
、关于HTML语义化，你知道都有哪些标签？
语义化就是让计算机能够快速读懂内容，高效的处理信息。搜索引擎只能通过标签来判断内容的语义，因为页面的很大一部分流量来自搜索引擎，要使页面尽可能地对搜索引擎友好，所以尽可能地使用语义化标签，如：
div是division分离，span是span范围，table是表格，ol是orderList有序列表，ul是unorderList无序列表，li是list item列表选项，html5进一步推进web语义化的发展，使用了一些新的标签有header、artical、address等。
2、HTML标签分类有哪些？都有啥特点?
默认宽度是100%
块级标签独占一行
块级标签可以使用height设置高度
常见块级标签：div、p、h1~h6、ol、ul、table、form等等。
默认宽度由内容撑开
行级标签不会自动换行，从左到右一次排列
行级标签height设置高度失效，高度由内容撑开。
常见行级标签：span、a、br、strong、lable、i、em。
结合行级和块级的优点
可以设置元素的宽高
还可以将多个元素显示在一行从左到右一次排列。
常见行内块标签：img、input。
3、网页编码设置有几种方式？
Charset属性规定HTML文档的字符编码，常见的属性值有以下几个：
4、HTML的框架优缺点有哪些？
Html框架有iframe和frame两个，将多个页面通过一个浏览器窗口显示。
框架的优点：
缺点：
5、HTML5有哪些新特性，移除了哪些元素？
H5新增了图像、位置、存储、多任务等功能。
新增元素：
移除元素：
Html5新增了 27 个元素，废弃了 16 个元素，根据现有的标准规范，把 HTML5 的元素按优先级定义为结构性属性、级块性元素、行内语义性元素和交互性元素 4 大类。
6、如何区分HTML和HTML5？
DOCUMENT声明方式是区分的重要元素。
根据新增加的结构、功能来区分。H5有好多新增语义化标签。
7、H5文件离线存储怎么使用，工作原理是什么？
在线情况下，浏览器发现html头部有manifest属性，它会请求manifest文件，如果是第一次访问那么浏览器就会根据manifest文件的内容下载相应的资源，并进行离线存储。如果已经访问过并且资源已经离线存储了，那么浏览器就会使用离线的资源加载页面。然后浏览器会对比新的manifest文件与旧的manifest文件，如果文件没有改变，就不会有任何操作，如果文件改变了，那么就会重新下载资源，并进行离线缓存。
页面头部加入manifest属性。如：<html manifest="demo.appcache">
在cache.manifest文件中编写离线存储的资源。
8、Cookies,sessionStorage和localStorage的区别？
共同点：都是保存在浏览器端，而且都是同源的。
区别：
9、title与h1的区别、b与strong的区别、i与em的区别？
title属性没有明确意义，只表示标题，h1表示层次明确的标题，对页面信息抓取也有很大的影响。
strong标明重点内容，语气加强含义，b表示无意义的视觉表示
em表示强调文本，i是斜体，是无意义的视觉表示
视觉样式标签：b、u、i、s
语义样式标签：strong、em、ins、del、code
10、viewport 所有属性 ？
viewport是用户网页的可视区域，使用meta设置viewport时有很多属性，分别对以下各个属性介绍
安卓中还支持：target-densitydpi，表示目标设备的密度等级，作用是决定css中的1px 代表多少物理像素。
11、meta标签的name属性值？
name属性主要用于描述网页，与之对应的属性值为content，content中的内容主要是便于搜索机器人查找信息和分类信息用的。
Meta标签的name属性语法格式是：
<meta name=”参数”content=”具体的参数值”>
Name主要有以下几个参数：
Content的参数主要有name的参数来决定，如果是关键字的时候，多个关键字之间使用逗号隔开，一般使用5个关键字为宜；如果是描述的时候，描述长度一般控制在200字左右；如果是索引的时候，一般使用inde、noindex、none、all，默认是all。
见浏览器兼容性问题与解决方案？
参考答案
(1)浏览器兼容问题一：不同浏览器的标签默认的外补丁和内补丁不同
问题症状：随便写几个标签，不加样式控制的情况下，各自的margin 和padding差异较大。
碰到频率:100%
解决方案：CSS里 {margin:0;padding:0;}
备注：这个是最常见的也是最易解决的一个浏览器兼容性问题，几乎所有的CSS文件开头都会用通配符来设置各个标签的内外补丁是0。
(2)浏览器兼容问题二：块属性标签float后，又有横行的margin情况下，在IE6显示margin比设置的大
问题症状:常见症状是IE6中后面的一块被顶到下一行
碰到频率：90%（稍微复杂点的页面都会碰到，float布局最常见的浏览器兼容问题）
解决方案：在float的标签样式控制中加入 display:inline;将其转化为行内属性
备注：我们最常用的就是div+CSS布局了，而div就是一个典型的块属性标签，横向布局的时候我们通常都是用div float实现的，横向的间距设置如果用margin实现，这就是一个必然会碰到的兼容性问题。
(3)浏览器兼容问题三：设置较小高度标签（一般小于10px），在IE6，IE7，遨游中高度超出自己设置高度
问题症状：IE6、7和遨游里这个标签的高度不受控制，超出自己设置的高度
碰到频率：60%
解决方案：给超出高度的标签设置overflow:hidden;或者设置行高line-height 小于你设置的高度。
备注：这种情况一般出现在我们设置小圆角背景的标签里。出现这个问题的原因是IE8之前的浏览器都会给标签一个最小默认的行高的高度。即使你的标签是空的，这个标签的高度还是会达到默认的行高。
(4)浏览器兼容问题四：行内属性标签，设置display:block后采用float布局，又有横行的margin的情况，IE6间距bug
问题症状：IE6里的间距比超过设置的间距
碰到几率：20%
解决方案 ： 在display:block;后面加入display:inline;display:table;
备注：行内属性标签，为了设置宽高，我们需要设置display:block;(除了input标签比较特殊)。在用float布局并有横向的margin后，在IE6下，他就具有了块属性float后的横向margin的bug。不过因为它本身就是行内属性标签，所以我们再加上display:inline的话，它的高宽就不可设了。这时候我们还需要在display:inline后面加入display:talbe。
(5) 浏览器兼容问题五：图片默认有间距
问题症状：几个img标签放在一起的时候，有些浏览器会有默认的间距，加了问题一中提到的通配符也不起作用。
碰到几率：20%
解决方案：使用float属性为img布局
备注 ： 因为img标签是行内属性标签，所以只要不超出容器宽度，img标签都会排在一行里，但是部分浏览器的img标签之间会有个间距。去掉这个间距使用float是正道。（我的一个学生使用负margin，虽然能解决，但负margin本身就是容易引起浏览器兼容问题的用法，所以我禁止他们使用）
(6) 浏览器兼容问题六：标签最低高度设置min-height不兼容
问题症状：因为min-height本身就是一个不兼容的CSS属性，所以设置min-height时不能很好的被各个浏览器兼容
碰到几率：5%
解决方案：如果我们要设置一个标签的最小高度200px，需要进行的设置为：{min-height:200px; height:auto !important;
height:200px; overflow:visible;}
备注：在B/S系统前端开时，有很多情况下我们又这种需求。当内容小于一个值（如300px）时。容器的高度为300px；当内容高度大于这个值时，容器高度被撑高，而不是出现滚动条。这时候我们就会面临这个兼容性问题。
(7)浏览器兼容问题七：透明度的兼容CSS设置
一般在ie中用的是filter:alpha(opacity=0);这个属性来设置div或者是块级元素的透明度，而在firefox中，一般就是直接使用opacity:0,对于兼容的，一般的做法就是在书写css样式的将2个都写上就行，就能实现兼容
列出display的值并说明他们的作用？
参考答案
display： none | inline | block |
list-item | inline-block | table | inline-table |
table-caption | table-cell | table-row | table-row-group | table-column |
table-column-group | table-footer-group | table-header-group | run-in | box |
inline-box | flexbox | inline-flexbox | flex | inline-flex
默认值：inline
none： 隐藏对象。与visibility属性的hidden值不同，其不为被隐藏的对象保留其物理空间
inline： 指定对象为内联元素。
block： 指定对象为块元素。
list-item：指定对象为列表项目。
inline-block： 指定对象为内联块元素。（CSS2）
table： 指定对象作为块元素级的表格。类同于html标签<table>（CSS2）
inline-table：指定对象作为内联元素级的表格。类同于html标签<table>（CSS2）
table-caption：指定对象作为表格标题。类同于html标签<caption>（CSS2）
table-cell：指定对象作为表格单元格。类同于html标签<td>（CSS2）
table-row：指定对象作为表格行。类同于html标签<tr>（CSS2）
table-row-group：指定对象作为表格行组。类同于html标签<tbody>（CSS2）
table-column：指定对象作为表格列。类同于html标签<col>（CSS2）
table-column-group： 指定对象作为表格列组显示。类同于html标签<colgroup>（CSS2）
table-header-group： 指定对象作为表格标题组。类同于html标签<thead>（CSS2）
table-footer-group： 指定对象作为表格脚注组。类同于html标签<tfoot>（CSS2）
run-in：根据上下文决定对象是内联对象还是块级对象。（CSS3）
box：将对象作为弹性伸缩盒显示。（伸缩盒最老版本）（CSS3）
inline-box：将对象作为内联块级弹性伸缩盒显示。（伸缩盒最老版本）（CSS3）
flexbox：将对象作为弹性伸缩盒显示。（伸缩盒过渡版本）（CSS3）
inline-flexbox：将对象作为内联块级弹性伸缩盒显示。（伸缩盒过渡版本）（CSS3）
flex：将对象作为弹性伸缩盒显示。（伸缩盒最新版本）（CSS3）
inline-flex：将对象作为内联块级弹性伸缩盒显示。（伸缩盒最新版本）（CSS3）
如何居中div, 如何居中一个浮动元素?
参考答案
(1)、非浮动元素居中：可以设置margin:0 auto 令其居中, 定位 ,父级元素text-algin:center等等
(2)、浮动元素居中:
方法一:设置当前div的宽度，然后设置margin-left:50%; position:relative; left:-250px;其中的left是宽度的一半。
方法二:父元素和子元素同时左浮动，然后父元素相对左移动50%，再然后子元素相对左移动-50%。
方法三:position定位等等。
CSS中link 和@import 的区别是？
参考答案
(1)、link属于HTML标签，而@import是CSS提供的;
(2)、页面被加载的时，link会同时被加载，而@import引用的CSS会等到页面被加载完再加载;
(3)、import只在IE5以上才能识别，而link是HTML标签，无兼容问题;
(4)、link方式的样式的权重高于@import的权重.
请列举几种清除浮动的方法(至少两种)?
参考答案
(1)、父级div定义 height
原理：父级div手动定义height，就解决了父级div无法自动获取到高度的问题。
优点：简单、代码少、容易掌握
缺点：只适合高度固定的布局，要给出精确的高度，如果高度和父级div不一样时，会产生问题
建议：不推荐使用，只建议高度固定的布局时使用
(2)、结尾处加空div标签 clear:both
原理：添加一个空div，利用css提高的clear:both清除浮动，让父级div能自动获取到高度
优点：简单、代码少、浏览器支持好、不容易出现怪问题
缺点：不少初学者不理解原理；如果页面浮动布局多，就要增加很多空div，让人感觉很不好
建议：不推荐使用，但此方法是以前主要使用的一种清除浮动方法
(3)、父级div定义
伪类:after 和 zoom
原理：IE8以上和非IE浏览器才支持:after，原理和方法2有点类似，zoom(IE转有属性)可解决ie6,ie7浮动问题
优点：浏览器支持好、不容易出现怪问题（目前：大型网站都有使用，如：腾迅，网易，新浪等等）
缺点：代码多、不少初学者不理解原理，要两句代码结合使用才能让主流浏览器都支持。
建议：推荐使用，建议定义公共类，以减少CSS代码。
(4)、父级div定义 overflow:hidden
原理：必须定义width或zoom:1，同时不能定义height，使用overflow:hidden时，浏览器会自动检查浮动区域的高度
优点：简单、代码少、浏览器支持好
缺点：不能和position配合使用，因为超出的尺寸的会被隐藏。
建议：只推荐没有使用position或对overflow:hidden理解比较深的朋友使用。
(5)、父级div定义 overflow:auto
原理：必须定义width或zoom:1，同时不能定义height，使用overflow:auto时，浏览器会自动检查浮动区域的高度
优点：简单、代码少、浏览器支持好
缺点：内部宽高超过父级div时，会出现滚动条。
建议：不推荐使用，如果你需要出现滚动条或者确保你的代码不会出现滚动条就使用吧。
block，inline和inlinke-block细节对比？
参考答案
•
display:block
a、block元素会独占一行，多个block元素会各自新起一行。默认情况下，block元素宽度自动填满其父元素宽度。
b、block元素可以设置width,height属性。块级元素即使设置了宽度,仍然是独占一行。
c、block元素可以设置margin和padding属性。
• display:inline
a、inline元素不会独占一行，多个相邻的行内元素会排列在同一行里，直到一行排列不下，才会新换一行，其宽度随元素的内容而变化。
b、inline元素设置width,height属性无效。
c、inline元素的margin和padding属性，水平方向的padding-left, padding-right, margin-left,
margin-right都产生边距效果；但竖直方向的padding-top, padding-bottom, margin-top,
margin-bottom不会产生边距效果。
• display:inline-block
a、简单来说就是将对象呈现为inline对象，但是对象的内容作为block对象呈现。之后的内联对象会被排列在同一行内。比如我们可以给一个link（a元素）inline-block属性值，使其既具有block的宽度高度特性又具有inline的同行特性。
补充说明
a、一般我们会用display:block，display:inline或者display:inline-block来调整元素的布局级别，其实display的参数远远不止这三种，仅仅是比较常用而已。
b、IE（低版本IE）本来是不支持inline-block的，所以在IE中对内联元素使用display:inline-block，理论上IE是不识别的，但使用display:inline-block在IE下会触发layout，从而使内联元素拥有了display:inline-block属性的表象。
什么叫优雅降级和渐进增强？
参考答案
优雅降级： Web站点在所有新式浏览器中都能正常工作，如果用户使用的是老式浏览器，则代码会检查以确认它们是否能正常工作。由于IE独特的盒模型布局问题，针对不同版本的IE的hack实践过优雅降级了,为那些无法支持功能的浏览器增加候选方案，使之在旧式浏览器上以某种形式降级体验却不至于完全失效.
渐进增强： 从被所有浏览器支持的基本功能开始，逐步地添加那些只有新式浏览器才支持的功能,向页面增加无害于基础浏览器的额外样式和功能的。当浏览器支持时，它们会自动地呈现出来并发挥作用。
说说浮动元素会引起的问题和你的解决办法
参考答案
问题：
（1）父元素的高度无法被撑开，影响与父元素同级的元素
（2）与浮动元素同级的非浮动元素会跟随其后
（3）若非第一个元素浮动，则该元素之前的元素也需要浮动，否则会影响页面显示的结构
解决方法：
使用CSS中的clear:both;属性来清除元素的浮动可解决问题(2)、(3)，对于问题(1)，添加如下样式，给父元素添加clearfix样式：
.clearfix:after{content: ".";display: block;height: 0;clear:
both;visibility: hidden;}
.clearfix{display: inline-block;} /* for IE/Mac */
清除浮动的几种方法：
(1)、额外标签法，<div
style="clear:both;"></div>（缺点：不过这个办法会增加额外的标签使HTML结构看起来不够简洁。）
(2)、使用after伪类
content:" ";
height:0;
visibility:hidden;
display:block;
clear:both;
}
(3)、浮动外部元素
(4)、设置overflow为hidden或者auto
你有哪些性能优化的方法？
参考答案
回答一：
（1）、减少http请求次数：CSS Sprites, JS、CSS源码压缩、图片大小控制合适；网页Gzip，CDN托管，data缓存
，图片服务器。
（2）、前端模板 JS+数据，减少由于HTML标签导致的带宽浪费，前端用变量保存AJAX请求结果，每次操作本地变量，不用请求，减少请求次数
（3）、用innerHTML代替DOM操作，减少DOM操作次数，优化javascript性能。
（4）、当需要设置的样式很多时设置className而不是直接操作style。
（5）、少用全局变量、缓存DOM节点查找的结果。减少IO读取操作。
（6）、避免使用CSS Expression（css表达式)又称Dynamic properties(动态属性)。
（7）、图片预加载，将样式表放在顶部，将脚本放在底部加上时间戳。
回答二：
(1)、减少HTTP请求次数
(2)、使用CDN
(3)、避免空的src和href
(4)、为文件头指定Expires
(5)、使用gzip压缩内容
(6)、把CSS放到顶部
(7)、把JS放到底部
(8)、避免使用CSS表达式
(9)、将CSS和JS放到外部文件中
(10)、避免跳转
(11)、可缓存的AJAX
(12)、使用GET来完成AJAX请求
为什么要初始化CSS样式？
参考答案
因为浏览器的兼容问题，不同浏览器对有些标签的默认值是不同的，如果没对CSS初始化往往会出现浏览器之间的页面显示差异。
当然，初始化样式会对SEO有一定的影响，但鱼和熊掌不可兼得，但力求影响最小的情况下初始化。
最简单的初始化方法就是： {padding: 0; margin: 0;} （不建议）
解释下浮动和它的工作原理？清除浮动的技巧？
参考答案
浮动元素脱离文档流，不占据空间。浮动元素碰到包含它的边框或者浮动元素的边框停留。
(1)、使用空标签清除浮动。
这种方法是在所有浮动标签后面添加一个空标签 定义css clear:both. 弊端就是增加了无意义标签。
(2)、使用overflow。
给包含浮动元素的父标签添加css属性 overflow:auto; zoom:1; zoom:1用于兼容IE6。
(3)、使用after伪对象清除浮动。
该方法只适用于非IE浏览器。具体写法可参照以下示例。使用中需注意以下几点。一、该方法中必须为需要清除浮动元素的伪对象中设置height:0，否则该元素会比实际高出若干像素；
CSS样式表根据所在网页的位置，可分为哪几种样式表？
参考答案
行内样式表，内嵌样式表，外部样式表
谈谈你对CSS中刻度的认识？
参考答案
在CSS中刻度是用于设置元素尺寸的单位。
a、特殊值0可以省略单位。例如：margin:0px可以写成margin:0
b、一些属性可能允许有负长度值，或者有一定的范围限制。如果不支持负长度值，那应该变换到能够被支持的最近的一个长度值。
c、长度单位包括：相对单位和绝对单位。
相对长度单位有： em, ex, ch, rem, vw, vh, vmax,
vmin
绝对长度单位有： cm, mm, q, in, pt, pc, px
绝对长度单位：1in = 2.54cm = 25.4 mm = 72pt = 6pc = 96px
文本相对长度单位：em
相对长度单位是相对于当前对象内文本的字体尺寸，如当前对行内文本的字体尺寸未被人为设置，则相对于浏览器的默认字体尺寸。(相对父元素的字体大小倍数)
body { font-size: 14px; }
h1 { font-size: 16px; }
.size1 p { font-size: 1em; }
.size2 p { font-size: 2em; }
.size3 p { font-size: 3em; }
文本相对长度单位：rem
rem是CSS3新增的一个相对单位（root em，根em），相对于根元素(即html元素)font-size计算值的倍数
只相对于根元素的大小
浏览器的默认字体大小为16像素，浏览器默认样式也称为user agent stylesheet，就是所有浏览器内置的默认样式，多数是可以被修改的，但chrome不能直接修改，可以被用户样式覆盖。
请你说说em与rem的区别？
参考答案
rem
rem是CSS3新增的一个相对单位（root em，根em），相对于根元素(即html元素)font-size计算值的倍数
只相对于根元素的大小
rem（font size of the root element）是指相对于根元素的字体大小的单位。简单的说它就是一个相对单位。
作用：利用rem可以实现简单的响应式布局，可以利用html元素中字体的大小与屏幕间的比值设置font-size的值实现当屏幕分辨率变化时让元素也变化，以前的天猫tmall就使用这种办法
em
文本相对长度单位。相对于当前对象内文本的字体尺寸。如当前对行内文本的字体尺寸未被人为设置，则相对于浏览器的默认字体尺寸(默认16px)。(相对父元素的字体大小倍数)
em（font size of the element）是指相对于父元素的字体大小的单位。它与rem之间其实很相似，区别在。（相对是的HTML元素的字体大，默认16px）
em与rem的重要区别： 它们计算的规则一个是依赖父元素另一个是依赖根元素计算
请你说说box-sizing属性的的用法？
参考答案
设置或检索对象的盒模型组成模式
a、box-sizing:content-box： padding和border不被包含在定义的width和height之内。对象的实际宽度等于设置的width值和border、padding之和，即( Element width = width + border + padding，但占有页面位置还要加上margin ) 此属性表现为标准模式下的盒模型。
b、box-sizing:border-box： padding和border被包含在定义的width和height之内。对象的实际宽度就等于设置的width值，即使定义有border和padding也不会改变对象的实际宽度，即( Element width = width ) 此属性表现为怪异模式下的盒模型。
浏览器标准模式和怪异模式之间的区别是什么？
参考答案
在“标准模式”(Standards Mode) 页面按照 HTML 与 CSS 的定义渲染，而在“怪异模式”(Quirks Mode)就是浏览器为了兼容很早之前针对旧版本浏览器设计、并未严格遵循W3C 标准的网页而产生的一种页面渲染模式。浏览器基于页面中文件类型描述的存在以决定采用哪种渲染模式；如果存在一个完整的DOCTYPE则浏览器将会采用标准模式，而如果它缺失则浏览器将会采用怪异模式。
强烈建议阅读加深理解：怪异模式（Quirks Mode）对 HTML 页面的影响，这里列下浏览器标准模式和怪异模式的区别：
（1）盒模型：
在怪异模式下，盒模型为IE盒模型而非标准模式下的W3C 盒模型：在 IE 盒模型中，
box width = content width + padding left + padding right + border left + border
right，
box height = content height + padding top + padding bottom + border top +
border bottom。
而在 W3C 标准的盒模型中，box 的大小就是 content 的大小。
（2）图片元素的垂直对齐方式:
对于inline元素和table-cell元素，在 IE Standards Mode 下 vertical-align 属性默认取值为baseline。而当inline元素的内容只有图片时，如table的单元格table-cell。在 IE Quirks Mode 下，table单元格中的图片的 vertical-align 属性默认为bottom，因此，在图片底部会有几像素的空间。
（3）<table>元素中的字体:
CSS 中，描述font的属性有font-family，font-size，font-style，font-weigh,上述属性都是可以继承的。而在IE Quirks Mode 下，对于table 元素，字体的某些属性将不会从body或其他封闭元素继承到table中，特别是 font-size属性。
（4）
内联元素的尺寸:
在 IE Standards Mode 下，non-replaced inline 元素无法自定义大小，而在IE Quirks Mode 下，定义这些元素的width和height 属性，能够影响该元素显示的大小尺寸。
（5）
元素的百分比高度:
a、CSS 中对于元素的百分比高度规定如下，百分比为元素包含块的高度，不可为负值。如果包含块的高度没有显式给出，该值等同于“auto”（即取决于内容的高度）。所以百分比的高度必须在父元素有声明高度时使用。
b、当一个元素使用百分比高度时，在IE Standards Mode 下，高度取决于内容的变化，而在Quirks Mode 下，百分比高度则被正确应用。
（6）
元素溢出的处理：
在 IE Standard Mode 下，overflow取默认值 visible，即溢出可见，这种情况下，溢出内容不会被裁剪，呈现在元素框外。而在Quirks Mode 下，该溢出被当做扩展box来对待，即元素的大小由其内容决定，溢出不会被裁剪，元素框自动调整，包含溢出内容。
怪异Quirks模式是什么，它和标准Standards模式有什么区别？
参考答案
从IE6开始，引入了Standards模式，标准模式中，浏览器尝试给符合标准的文档在规范上的正确处理达到在指定浏览器中的程度。
在IE6之前CSS还不够成熟，所以IE5等之前的浏览器对CSS的支持很差， IE6将对CSS提供更好的支持，然而这时的问题就来了，因为有很多页面是基于旧的布局方式写的，而如果IE6 支持CSS则将令这些页面显示不正常，如何在即保证不破坏现有页面，又提供新的渲染机制呢？
在写程序时我们也会经常遇到这样的问题，如何保证原来的接口不变，又提供更强大的功能，尤其是新功能不兼容旧功能时。遇到这种问题时的一个常见做法是增加参数和分支，即当某个参数为真时，我们就使用新功能，而如果这个参数 不为真时，就使用旧功能，这样就能不破坏原有的程序，又提供新功能。IE6也是类似这样做的，它将DTD当成了这个“参数”，因为以前的页面大家都不会去写DTD，所以IE6就假定 如果写了DTD，就意味着这个页面将采用对CSS支持更好的布局，而如果没有，则采用兼容之前的布局方式。这就是Quirks模式（怪癖模式，诡异模式，怪异模式）。
区别：总体会有布局、样式解析和脚本执行三个方面的区别。
盒模型： 在W3C标准中，如果设置一个元素的宽度和高度，指的是元素内容的宽度和高度，而在Quirks 模式下，IE的宽度和高度还包含了padding和border。
设置行内元素的高宽： 在Standards模式下，给<span>等行内元素设置wdith和height都不会生效，而在quirks模式下，则会生效。
设置百分比的高度： 在standards模式下，一个元素的高度是由其包含的内容来决定的，如果父元素没有设置百分比的高度，子元素设置一个百分比的高度是无效的用margin:0 auto设置水平居中：使用margin:0 auto在standards模式下可以使元素水平居中，但在quirks模式下却会失效。
（还有很多，答出什么不重要，关键是看他答出的这些是不是自己经验遇到的，还是说都是看文章看的，甚至完全不知道。）
说说你对边距折叠的理解?
参考答案
外边距折叠： 相邻的两个或多个外边距 (margin) 在垂直方向会合并成一个外边距（margin）
相邻： 没有被非空内容、padding、border 或 clear 分隔开的margin特性. 非空内容就是说这元素之间要么是兄弟关系或者父子关系
垂直方向外边距合并计算:
a、参加折叠的margin都是正值：取其中 margin 较大的值为最终 margin 值。
b、参与折叠的margin 都是负值：取的是其中绝对值较大的，然后，从0 位置，负向位移。
c、参与折叠的margin 中有正值，有负值：先取出负 margin 中绝对值中最大的，然后，和正margin 值中最大的 margin 相加。
内联与块级标签有何区别？
参考答案
Html中的标签默认主要分为两大类型，一类为块级元素，另一类是行内元素，许多人也把行内称为内联，所以叫内联元素，其实就是一个意思。为了很好的布局，必须理解它们间的区别。
说说隐藏元素的方式有哪些？
参考答案
a、使用CSS的display:none，不会占有原来的位置
b、使用CSS的visibility:hidden，会占有原来的位置
c、使用HTML5中的新增属性hidden="hidden"，不会占有原来的位置
为什么重置浏览器默认样式，如何重置默浏览器认样式？
参考答案
每种浏览器都有一套默认的样式表，即user agent stylesheet，网页在没有指定的样式时，按浏览器内置的样式表来渲染。这是合理的，像word中也有一些预留样式，可以让我们的排版更美观整齐。不同浏览器甚至同一浏览器不同版本的默认样式是不同的。但这样会有很多兼容问题。
a、最简单的办法：（不推荐使用）*{margin: 0;padding: 0;}。
b、使用CSSReset可以将所有浏览器默认样式设置成一样。
c、normalize：也许有些cssreset过于简单粗暴，有点伤及无辜，normalize是另一个选择。bootstrap已经引用该css来重置浏览器默认样式，比普通的cssreset要精细一些，保留浏览器有用的默认样式，支持包括手机浏览器在内的超多浏览器，同时对HTML5元素、排版、列表、嵌入的内容、表单和表格都进行了一般化。
天猫 使用的css reset重置浏览器默认样式：
@charset
"gb2312";body, h1, h2, h3, h4, h5, h6, hr, p, blockquote, dl, dt, dd,
ul, ol, li, pre, form, fieldset, legend, button, input, textarea, th, td
{margin: 0;padding: 0}body, button, input, select, textarea
{font: 12px "microsoft yahei";line-height: 1.5;-ms-overflow-style: scrollbar}h1,
h2, h3, h4, h5, h6 {font-size: 100%}ul, ol {list-style: none}a
{text-decoration: none;cursor:pointer}a:hover
{text-decoration: underline}img {border: 0}button, input, select,
textarea {font-size: 100%}table {border-collapse: collapse;border-spacing: 0}.clear
{clear:both}.fr {float:right}.fl {float:left}.block
{display:block;text-indent:-999em}
谈谈你对BFC与IFC的理解？(是什么，如何产生，作用)
参考答案
(1)、什么是BFC与IFC
a、BFC（Block Formatting Context）即“块级格式化上下文”， IFC（Inline Formatting Context）即行内格式化上下文。常规流（也称标准流、普通流）是一个文档在被显示时最常见的布局形态。一个框在常规流中必须属于一个格式化上下文，你可以把BFC想象成一个大箱子，箱子外边的元素将不与箱子内的元素产生作用。
b、BFC是W3C CSS 2.1 规范中的一个概念，它决定了元素如何对其内容进行定位，以及与其他元素的关系和相互作用。当涉及到可视化布局的时候，Block Formatting Context提供了一个环境，HTML元素在这个环境中按照一定规则进行布局。一个环境中的元素不会影响到其它环境中的布局。比如浮动元素会形成BFC，浮动元素内部子元素的主要受该浮动元素影响，两个浮动元素之间是互不影响的。也可以说BFC就是一个作用范围。
c、在普通流中的Box(框) 属于一种 formatting context(格式化上下文) ，类型可以是 block ，或者是 inline ，但不能同时属于这两者。并且，Block boxes(块框) 在 block formatting context(块格式化上下文) 里格式化， Inline boxes(块内框) 则在 Inline Formatting Context(行内格式化上下文) 里格式化。
(2)、如何产生BFC
当一个HTML元素满足下面条件的任何一点，都可以产生Block Formatting Context：
a、float的值不为none
b、overflow的值不为visible
c、display的值为table-cell, table-caption, inline-block中的任何一个
d、position的值不为relative和static
CSS3触发BFC方式则可以简单描述为：在元素定位非static，relative的情况下触发，float也是一种定位方式。
(3)、BFC的作用与特点
a、不和浮动元素重叠，清除外部浮动，阻止浮动元素覆盖
如果一个浮动元素后面跟着一个非浮动的元素，那么就会产生一个重叠的现象。常规流（也称标准流、普通流）是一个文档在被显示时最常见的布局形态，当float不为none时，position为absolute、fixed时元素将脱离标准流。
说说你对页面中使用定位(position)的理解？
参考答案
使用css布局position非常重要，语法如下：
position：static | relative | absolute | fixed |
center | page | sticky
默认值：static，center、page、sticky是CSS3中新增加的值。
(1)、static
可以认为静态的，默认元素都是静态的定位，对象遵循常规流。此时4个定位偏移属性不会被应用，也就是使用left，right，bottom，top将不会生效。
(2)、relative
相对定位，对象遵循常规流，并且参照自身在常规流中的位置通过top，right，bottom，left这4个定位偏移属性进行偏移时不会影响常规流中的任何元素。
(3)、absolute
a、绝对定位，对象脱离常规流，此时偏移属性参照的是离自身最近的定位祖先元素，如果没有定位的祖先元素，则一直回溯到body元素。盒子的偏移位置不影响常规流中的任何元素，其margin不与其他任何margin折叠。
b、元素定位参考的是离自身最近的定位祖先元素，要满足两个条件，第一个是自己的祖先元素，可以是父元素也可以是父元素的父元素，一直找，如果没有则选择body为对照对象。第二个条件是要求祖先元素必须定位，通俗说就是position的属性值为非static都行。
(4)、fixed
固定定位，与absolute一致，但偏移定位是以窗口为参考。当出现滚动条时，对象不会随着滚动。
(5)、center
与absolute一致，但偏移定位是以定位祖先元素的中心点为参考。盒子在其包含容器垂直水平居中。（CSS3）
(6)、page
与absolute一致。元素在分页媒体或者区域块内，元素的包含块始终是初始包含块，否则取决于每个absolute模式。（CSS3）
(7)、sticky
对象在常态时遵循常规流。它就像是relative和fixed的合体，当在屏幕中时按常规流排版，当卷动到屏幕外时则表现如fixed。该属性的表现是现实中你见到的吸附效果。（CSS3）
如何解决多个元素重叠问题？
参考答案
使用z-index属性可以设置元素的层叠顺序
z-index属性
语法：z-index: auto | <integer>
默认值：auto
适用于：定位元素。即定义了position为非static的元素
取值：
auto：元素在当前层叠上下文中的层叠级别是0。元素不会创建新的局部层叠上下文，除非它是根元素。
整数： 用整数值来定义堆叠级别。可以为负值。 说明：
检索或设置对象的层叠顺序。
z-index用于确定元素在当前层叠上下文中的层叠级别，并确定该元素是否创建新的局部层叠上下文。
当多个元素层叠在一起时，数字大者将显示在上面。
排序是比较基础的算法，与很多语言一样，Python也提供了对列表的排序方法和内建排序函数。
方式一：
li = [1, 3, 4, 9, 0]
li.sort() # 提供方法
方式二：
li = [1, 3, 4, 9, 0]
li = sorted(li) # 提供方法
两种方式都可以实现对列表元素的排序，从接受参数更能看出两者区别和相同点。
（1）：sort()属于列表对象特有的排序方法，因此调用方法直接在列表本身进行修改，返回值为None或者说无需返回值。
（2）： sorted()属于python提供内建函数，无需导入可直接用，而从接受对象来看，sorted()方法可以直接接受iterable可迭代对象，因此作用对象更广泛，包括字符串，元组甚至字典都可以，返回一个列表，如下所示
test_string = "dvsegh"
print(sorted(test_string)) # 输出['d', 'e', 'g', 'h', 's', 'v']
test_tuple = (5, 4, 3, 2, 1)
print(sorted(test_tuple)) # 输出[1, 2, 3, 4, 5]
test_list = [5, 4, 3, 2, 1]
print(sorted(test_list)) # 输出[1, 2, 3, 4, 5]
test_dic = {1:"a", 2:"b", 0:"z"}
print(sorted(test_dic)) # 输出[0, 1, 2]，字典的key作为排序结果返回
（3）：对于Python3.x中的sort()无法函数自定义排序规则后面会说到。
（1）：都支持reverse反转操作，参数reverse接收布尔类型，比如reverse=True，则表示排序结果逆序。
li = [1, 3, 4, 9, 0]
li.sort(reverse=True)
print(li) # [9, 4, 3, 1, 0]
（2）： 都支持关键函数排序，也就是key参数指定排序规则，参数的接收值为一个函数，该函数可以接收一个参数并返回一个值用来比较，如下，len接收字符串，返回长度作为比较值。
test_string = "Hello World Welcome to My City"
print(sorted(test_string.split(" "), key=len)) # 根据字符串长度排序
# 输出：['to', 'My', 'City', 'Hello', 'World', 'Welcome']
print(sorted(test_string.split(" "), key=str.lower)) # 根据小写之后的字典序排序
# 输出：['City', 'Hello', 'My', 'to', 'Welcome', 'World']
test_list = [-5, 4, 0, 2, 1]
print(sorted(test_list, key=abs)) # 根据绝对值排序
# 输出：[0, 1, 2, 4, -5]
（3）：更广泛的可以使用lambda表达式来完成更复杂排序。如下对二维列表多级排序
li = [
[3 ,5],
[5 ,0],
[5 ,6],
[3 ,-1],
[2, 9]
]
# 多级排序
# 根据第一个元素从小打到排列，当第一个元素相等，按照第二个元素从大到小排列
li.sort(key=lambda x: (x[0], -x[1]))
print(li)
# 输出 [[2, 9], [3, 5], [3, -1], [5, 6], [5, 0]]
也或者可以根据复杂对象的某些属性排序。对对象根据属性进行排序
# 学生对象，包括年龄，身高体重等
class Student:
def __init__(self, age, height, weight):
self.age = age
self.height = height
self.weight = weight
s1 = Student(18, 180, 75)
s2 = Student(19, 175, 80)
s3 = Student(17, 176, 70)
s4 = Student(18, 177, 65)
s5 = Student(19, 180, 65)
# 班级里有很多学生
classes = [s1, s2, s3, s4, s5]
# 根据学生的年龄排序
classes.sort(key=lambda s: s.age)
for stu in classes:
print("stu age: %d, height: %d, weight: %d" % (stu.age, stu.height, stu.weight))
输出：
stu age: 17, height: 176, weight: 70
stu age: 18, height: 180, weight: 75
stu age: 18, height: 177, weight: 65
stu age: 19, height: 175, weight: 80
stu age: 19, height: 180, weight: 65
从以上排序结果中相同年龄的学生还保持排序前的相对顺序，说明sort()排序也是稳定排序，sort()底层是基于合并排序和插入排序集合的一种更高效排序算法。以上是使用lambda表达式指定排序规则，也可以使用operator中提供的其他更加简洁的方式。
# 同样适用上述的Student例子
from operator import itemgetter, attrgetter
# 实现根据学生年龄排序
print(sorted(classes, key=attrgetter('age')))
print(sorted(classes, key=itemgetter(1)))
# 实现多级排序 新根据身高，再根据年龄排序
sorted(classes, key=attrgetter('height', 'age'))
其他语言中普遍提供的有cmp函数，也就是自定义更高级函数作为排序规则。而在python3.x中sort()不在支持cmp自定义函数比较，想要使用cmp，则需要是使用sorted()，并额外的做一些包装。
比如，同样使用如上的Student例子，想要完成自定义排序规则，比如首先按照年龄大小排序，当年龄相同的时候按照体重逆序排序，如果体重也相同则按照身高逆序排序。
from functools import cmp_to_key
def func(stu1, stu2):
# 年龄相同
if stu1.age == stu2.age:
# 体重相同 安装身高逆序
if stu1.weight == stu2.weight:
return stu2.height - stu1.height
else: # 体重不同，逆序排序
return stu2.weight - stu1.weight
else: # 年龄不同，则按照年龄排序
return stu1.age - stu2.age
class Student:
def __init__(self, age, height, weight):
self.age = age
self.height = height
self.weight = weight
s1 = Student(18, 180, 55)
s2 = Student(19, 175, 80)
s3 = Student(17, 162, 70)
s4 = Student(18, 177, 65)
s5 = Student(19, 180, 65)
s6 = Student(16, 160, 55)
s7 = Student(17, 164, 70)
# 班级有7个学生
classes = [s1, s2, s3, s4, s5, s6, s7]
# 排序
classes = sorted(classes, key=cmp_to_key(func))
for stu in classes:
print("stu age: %d, height: %d, weight: %d" % (stu.age, stu.height, stu.weight))
输出结果
stu age: 16, height: 160, weight: 55
stu age: 17, height: 164, weight: 70
stu age: 17, height: 162, weight: 70
stu age: 18, height: 177, weight: 65
stu age: 18, height: 180, weight: 55
stu age: 19, height: 175, weight: 80
stu age: 19, height: 180, weight: 65
对于sorted(iterable, key=lambda x:x)，这种比较倾向于待排序的每个元素都有一个绝对的大小值作为排序标准，而有时候会绝对大小是根据两个元素才能得出的衡量，因此可以使用如上functools.cmp_to_key构建多个元素的比较函数。cmp_to_key包装后的自定义比较函数可以接受两个元素，将两个元素的对比结果作为返回值，另外注意，自定义的比较函数返回值需要是整型。
cmp_to_key的源码如下
def cmp_to_key(mycmp):
"""Convert a cmp= function into a key= function"""
class K(object):
__slots__ = ['obj']
def __init__(self, obj):
self.obj = obj
def __lt__(self, other):
return mycmp(self.obj, other.obj) < 0
def __gt__(self, other):
return mycmp(self.obj, other.obj) > 0
def __eq__(self, other):
return mycmp(self.obj, other.obj) == 0
def __le__(self, other):
return mycmp(self.obj, other.obj) <= 0
def __ge__(self, other):
return mycmp(self.obj, other.obj) >= 0
__hash__ = None
return K
cmp_to_key接收myfunc，并在内部定义一个K类并返回这个K类，这个类内部完成了各种比较运算符的重载（也就是mycmp的定义的排序规则），这个类是可调用的，在参与比较的时候其实是K的对象，而在使用lambda匿名表达式的时候使用是列表中的元素进行大小比较。如下：
li = [1, 0, 0, 8, 4]
sorted(li, key=lambda x: x) # x代指li中的每个元素
以下是笔试面试过程中遇到的关于一些自定义排序规则的题目。可以结合实际场景做下应用。
注：以下只给出大概代码样例，水平有限，不保证完全正确。
（1）：华为通用软件暑期实习笔试4.13场次算法题第一题
题干：硬件资源分配（不花点时间，题干都理不顺.....）
有M台服务器，每台服务器有以下属性：编号、CPU核数（1100）、内存、CPU架构（08）、是否支持NP加速的标识（0,1）。然后有一个资源分配要求，要求分配N台满足要求的服务器。具体如下：CPU核数>=cpuCount、内存>=memSize、CPU架构=cpuArch、是否支持NP加速=supportNP。其中，cpuCount、memSize、cpuArch、supportNP为这个要求输入的分配参数。
分配时会指定优先级策略，策略如下：
策略1：CPU优先，优先选择CPU核数满足分配要求并且最接近分配要求的cpuCount。如果CPU核数相同，在按内存满足要求并选择最接近memSize的服务器分配。
策略2：内存优先，优先选择内存满足分配要求并且最接近分配要求的memSize。如果内存相同，在按cpu核数满足要求并选择最接近cpuCount的服务器分配
如果两台服务器属性都相同，则按服务器编号从小到大选择（编号不会重复）
输入：
第一行：服务器数量M
接下来M行为M台服务器属性的数组
下一行为分配要求：最大分配数量N，分配策略strategy，cupCount，memSize，cpuArch，supportNP
其中：
1<=M<=1000
1<=N<=1000
strategy：1表示策略1,2表示策略2
1<=cpuCount<=100
10<=memSize<=1000
0<=cpuArch<=8，另外，cpuArch使用9表示所有服务器架构都满足分配要求
0<=supportNP<=1，另外，为2时表示无论是否支持NP加速都满足分配要求
输出
先输出实际分配数量，后按照分配的服务器编号从小到大依次输出，以空格分开
样例1
输入
4
0,2,200,0,1
1,3,400,0,1
2,3,400,1,0
3,3,300,0,1
3 1 3 200 0 1
输出
2 1 3
解释：只有1和3满足要求，要求分配2台服务器，所以结果为2 1 3
样例2
输入
6
0,2,200,0,1
1,4,330,2,1
2,3,400,3,1
3,3,310,1,1
4,3,320,8,1
5,3,330,0,1
3 2 3 300 9 2
（这里注意一下输入的格式，最后一行是空格分开）
输出
3 3 4 5
解释：编号1~5都满足分配要求，按策略2分配即内存优先，内存>=300并且最接近300的服务器编号是3 4 1 5 2。
其中1和5内存相同，然后会比较CPU，即CPU>=3且最接近的，所以5优先于1.因此最后分配的三台服务器是3 4 5。
输出时先输出数量3，再按编号排序输出3 4 5
（2）思路自定义排序：
主要先对一些特殊情况考虑，并且不同的策略不同的排序规则，但是都类似。
inp = list(map(int, input().strip().split(" ")))
N, strategy, cpuCount, memSize, cpuArch, SupportNP = inp
# N, strategy, cpuCount, memSize, cpuArch, SupportNP = 2, 1, 3, 300, 9, 1
res = []
for item in ans:
if cpuArch != 9 and item[3] != cpuArch:
continue
if SupportNP != 2 and item[4] != SupportNP:
continue
res.append(item)
if strategy == 1:
res = list(filter(lambda item: item[1]>=cpuCount and item[2]>=memSize, res))
# res = list(filter(lambda item: item[2]>=memSize, res))
res.sort(key=lambda x: (x[1], x[2]))
if len(res) <= N and len(res) > 0:
tmp = [len(res)] + sorted([item[0] for item in res])
print(" ".join([str(i) for i in tmp]))
elif len(res) > N:
tmp = [N] + sorted([res[i][0] for i in range(N)])
print(" ".join([str(i) for i in tmp]))
else:
print(0)
elif strategy == 2:
res = list(filter(lambda item: item[2]>=memSize and item[1]>=cpuCount, res))
# res = list(filter(lambda item: item[1]>=cpuCount, res))
res.sort(key=lambda x: (x[2], x[1]))
if len(res) <= N and len(res) > 0:
tmp = [len(res)] + sorted([item[0] for item in res])
print(" ".join([str(i) for i in tmp]))
elif len(res) > N:
tmp = [N] + sorted([res[i][0] for i in range(N)])
print(" ".join([str(i) for i in tmp]))
else:
print(0)
（1）、华为通用软件暑期实习业务一面算法题
Leetcode最大数：链接https://leetcode-cn.com/problems/largest-number/
题干：
给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。
示例：
输入：nums = [3,30,34,5,9]
输出："9534330"
（2）、三种思路
version1：
由于没有看到nums数组的容量范围，第一反应直接全排列，然后对每一种结果作比较。
from itertools import permutations
nums = [3, 30, 34, 5, 9]
res = set(permutations(nums)) # 全排列结果去重
res = [int("".join(list(map(str, item)))) for item in res] # 结果拼接再类型转换
print(max(res)) # 取最大值 输出 9534330
但是nums这么大范围，使用全排列做得无用功太多了，时间和空间复杂度都不满足。
version2：
维持一个单调队列，队列中的元素拼接之后保证最大，逐个遍历当前元素，再往队列逐个位置尝试插入，并最终找到插入位置保持队列的规则。
class Solution:
def largestNumber(self, nums: List[int]) -> str:
queue = []
# 逐个遍历列表元素
for i in range(len(nums)):
# 队列为空，直接入队
if len(queue) == 0:
queue.append(nums[i])
continue
# 假定当前nums[i]放在队尾，拼接后的值为mx
mx_ind = -1
mx = int("".join(list(map(str, queue + [nums[i]]))))
# 逐个插入队列中，作比较，谁大
for j in range(len(queue)):
tmp = int("".join(list(map(str, queue[:j] + [nums[i]] + queue[j:]))))
if tmp > mx:
mx = tmp
mx_ind = j
# 找到插入位置
if mx_ind != -1:
queue = queue[:mx_ind] + [nums[i]] + queue[mx_ind:]
else:
queue = queue[:] + [nums[i]]
# 合并
st = "".join(list(map(str, queue)))
# 去除首部0
st = st.lstrip("0")
# 如果全为0，如nums=[0, 0]，则输出0
if len(st) == 0:
return "0"
else:
return st
执行结果：
version3：
nums中的元素的位置不是由单一的元素决定，而是根据两个元素拼接之后的谁大决定的，如果"xy" > "yx"，那就[x, y]，否则[y, x]。因此可以使用自定义排序。
class Solution:
def largestNumber(self, nums: List[int]) -> str:
from functools import cmp_to_key
def func(a, b):
# 当前两元素长度相等，则按照大小排列
if len(str(a)) == len(str(b)):
return b - a
else:
# 长度不同，则根据拼接后的大小排序
return int(str(b)+str(a)) - int(str(a)+str(b))
nums = sorted(nums, key=cmp_to_key(func))
# 突然发现这样写更简洁 ，不用额外定义func
# nums = sorted(nums, key=cmp_to_key(lambda x, y: int(str(y)+str(x)) - int(str(x)+str(y))))
s = "".join(list(map(str, nums)))
s = s.lstrip("0")
if len(s) != 0:
return s
else:
return "0"
执行结果：
（1）、荣耀通用软件暑期开发实习生笔试第二题
题目记不太清了，大概就是把日志文件中的一行一行记录根据时间戳排序，记录是字符串，不过整个记录中包含其他的一些无用字符串，因此要自己过滤出有用的时间戳。
实例输入：
5
my/2019-01-01T09:00:01
my/2019-01-01T09:00:01
abc/2018-12-24T08:00:00/test/you
1/2018-12-24T08:00:00/test/Test1
123/2018-12-24T08:00:09/test/me
说明：5表示5行记录
输出：
1/2018-12-24T08:00:00/test/Test1
abc/2018-12-24T08:00:00/test/you
123/2018-12-24T08:00:09/test/me
my/2019-01-01T09:00:01
说明：优先根据时间戳信息排序，时间戳满足一定的格式XXXX-XX-XXTXX:XX:XX，T为分隔符，分割日期和时间，前半部分为日期，后半部分为时间，时间戳相同根据字符串长度排序，如果长度也相同，则按照首字母的ascii码表比较从小到大排序，如果两个记录字符串完全相同，则输出一条即可。
（2）、思路
主要还是自定义排序规则，不过对于所有记录都要做下处理判断是否满足时间戳规则，以及去重
代码如下
from functools import cmp_to_key
# 判断记录字符串是否符合时间戳格式
def is_time_format(s):
if len(s) != 19:
return False
if s[4] != "-" or s[7] != "-" or s[10] != "T" or s[13] != ":" or s[16] != ":":
return False
return True
# 自定义排序规则
def func(a, b):
if a[0] != b[0]:
if a[0] > b[0]:
return 1
else:
return -1
else:
if len(a[1]) != len(b[1]):
return len(a[1]) - len(b[1])
else:
return ord(a[1][0]) - ord(b[1][0])
# 处理输入
size = int(input().strip())
time_str = []
for _ in range(size):
# 并将记录分割成列表暂存起来
tmp = input().strip().split("/")
time_str.append(tmp)
# 保存满足时间戳的记录
res = []
for i in range(len(time_str)):
for j in range(len(time_str[i])):
if is_time_format(time_str[i][j]):
res.append([time_str[i][j], "/".join(time_str[i])])
break
res = sorted(res, key=cmp_to_key(func)) # 自定义排序
# 重塑结果
ans = []
for i in range(len(res)):
if res[i][1] not in ans:
ans.append(res[i][1])
# 处理输出
print("\n".join(ans))文章来自https://www.cnblogs.com/welan/p/16243852.html
*请认真填写需求信息，我们会在24小时内与您取得联系。
