精华内容
下载资源
问答
  • /** 链接伪类 只能作用到链接类的标签元素 */ :link /*表示作为超链接,指向一个未访问的地址的所有锚*/ :visited/*表示作为超链接,指向一个已被访问的地址的所有锚*/ :target/*代表一个特殊的元素,它的id是URI的...
  • CSS 选择器

    2019-06-30 17:30:41
    CSS 选择器:标签选择器、id 选择器、类选择器、通配符选择器、并集选择器、交集选择器、后代选择器、子代选择器、属性选择器

    1. CSS 选择器

    1.1 基出选择器

    基础选择器:标签选择器、id 选择器、类选择器和通配符选择器。
    

    以下是基础选择器的示例代码:
    1.标签选择器、id 选择器、类选择器:

    <!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>Document</title>
    	<style type="text/css">
    		/*标签选择器*/
    
    		p{
    			font-size: 50px;
    			color: red;
    			height: 100px;
    		}
    		/*类选择器*/
    		.W{
    			font-size: 50px;
    			color: green;
    			text-indent: 2em;
    		}
    		/*ID选择器*/
    		/*一个ID选择器只能在一个页面调用一次*/
    		#M{
    			font-size: 50px;
    			color: pink;
                width: 200px;
                height:100px;
    		}
    	</style>
    
    </head>
    <body>
    	<p>世界通史</p>
    	<p>菜根谭</p>
    	<div class="W">百年孤独</div>
    	<div id="M">人间词话</div>
    	<span class="W" >老人与海</span>
    	<br>
    	<span class="W" id="M">巴黎圣母院</span>
    	
    </body>
    </html>
    

    2.通配符选择器:

    <!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>CSS选择器练习</title>
    	<style type="text/css">
    		*{
    			font-size: 50px;
    			color: red;
    			text-indent: 2em;
    		}
    		span{
    			display: inline-block;
    		}
    	</style>
    </head>
    <body>
    	<div >计算机</div>
    	<div>应用数学</div>
    	<P>CSS选择器</P>
    	<P>CSS选择器</P>
    	<span>前端</span>
    </html>
    

    1.2 复合选择器

    复合选择器:交集选择器、并集选择器、后代选择器和子代选择器。
    

    1.交集选择器:

    <!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>交集选择器</title>
    	<!-- 标签+类、ID选择器{属性:值;} -->
    	<!-- 既要满足标签还要满足使用的id或类选择器 -->
    	<style type="text/css">
    		.box{
    			font-size: 50px;
    		}
    		div.box{
    			color: red;
    		}
    		#miss{
    			color: red;
    		}
    		div#miss{
    			width: 200px;
    			height: 60px;
    			font-size: 50px;
    			background-color: yellow;
    		}
    	</style>
    </head>
    <body>
    	<div class="box">高级程序设计</div>
    	<p class="box">穆斯林的葬礼</p>
    	<div id="miss">人间词话</div>
    </body>
    </html>
    

    2.并集选择器:

    <!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>并集选择器</title>
    	<style type="text/css">
    		
    		.box,#fox,span,h1{
    			font-size: 50px;
    			background-color: #00ff00;
    			color: yellow;
    		}
    
    	</style>
    </head>
    <body>
    	<div class="box">人间词话</div>
    	<p id="fox">人性的优点</p>
    	<span>人性的弱点</span>
    	<h1>语言的突破</h1>
    </body>
    </html>
    

    3.后代选择器,元素的所有后代,包含元素后代的后代:

    <!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>后代选择器</title>
    	<!-- 标签+空格+标签{ 属性:值} -->
    	<style type="text/css">
    		div p span{
    			font-size: 50px;
    			color: red;
    		}
    
    		.box p span{
    			font-size: 80px;
    			color: green;
    		}
    
    		#frist span{
    			font-size: 120px;
    			color: blue;
    		}
    
    	</style>
    </head>
    <body>
    	<div>
    		<p><span>亨利之书</span></p>
    	</div>
    
    	<article class="box">
    		<p><span>会计刺客</span></p>
    	</article>
    
    	<div id="frist">
    		<p><span>一个明星的诞生</span></p>
    	</div>
    
    </body>
    </html>
    

    4.子代代选择器,只包含元素的直接后代,不包含元素后代的后代:

    <!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>后代选择器</title>
    	<!-- 标签+空格+标签{ 属性:值} -->
    	<style type="text/css">
    		div p span{
    			font-size: 50px;
    			color: red;
    		}
    
    		.box p span{
    			font-size: 80px;
    			color: green;
    		}
    
    		#frist span{
    			font-size: 120px;
    			color: blue;
    		}
    
    	</style>
    </head>
    <body>
    	<div>
    		<p><span>亨利之书</span></p>
    	</div>
    
    	<article class="box">
    		<p><span>会计刺客</span></p>
    	</article>
    
    	<div id="frist">
    		<p><span>一个明星的诞生</span></p>
    	</div>
    
    </body>
    </html>
    

    1.3 属性选择器:

    <!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>Document</title>
    	<style type="text/css">
    		input[type=text][id=one]{
    			height: 20px;
    			background: pink;
    			/* 取消边框线 */
      			border-style: none;
    		}
    	</style>
    </head>
    <body>
    	文本输入框:<input type="text" value="text">
    	<br>
    	文本输入框:<input type="text" value="text" id="one">
    	<br>
    	密码输入框:<input type="password" >
    	<br>
    	普通按钮:<input type="button" value="button">
    	<br>
    	表单提交按钮:<input type="submit" value="submit">
    	<br>
    </html>
    
    展开全文
  • CSS选择器

    千次阅读 2020-03-08 13:10:24
    CSS选择器 使用CSS对HTML页面中的元素实现一对一,一对多或者多对一的控制,这就需要用到选择器。 HTML页面中的元素就是通过CSS选择器进行控制的。 id选择器 <div id="s1">id选择器</div> <style ...

    CSS选择器

    使用CSSHTML页面中的元素实现一对一,一对多或者多对一的控制,这就需要用到选择器。
    HTML页面中的元素就是通过CSS选择器进行控制的。

    id选择器

    <div id="s1">id选择器</div>
    
    <style type="text/css">
        #s1 {
            color: red;
        }
    </style>
    

    类选择器

    <div class="s2">类选择器1</div>
    <div class="s2">类选择器2</div>
    <div class="s3">类选择器3</div>
    
    <style type="text/css">
        .s2{
            color: green;
        }
        
        /* 可以将多个选择器写在一起 */
        .s2,.s3,#s1{
            font-style:italic;
        }
        </style>
    

    标签选择器

    <p>标签选择器1</p>
    <p>标签选择器2</p>
    
    <style type="text/css">
        p{
            color: blue;
        }
    </style>
    

    相邻选择器

    <div id="s4">相邻选择器 +</div>
    <div>相邻选择器</div>
    <!-- + 只选择紧邻的兄弟 -->
    <div id="s5">相邻选择器 ~</div>
    <div class="s6">相邻选择器</div>
    <div class="s6">相邻选择器</div>
    <div class="s6">相邻选择器</div>
    <!-- ~ 选择兄弟以及兄弟的兄弟..... -->
    
     <style type="text/css">
        #s4 + div{
            color: #0033ff;
        }
        #s5 ~ .s6{
            color: #FFD700;
        }
    </style>
    

    子元素选择器

    <div class="s7">
        <div>子元素选择器</div>
        <em>
            <div>子元素选择器不被选择</div>
            <div>子元素选择器不被选择</div>
        </em>
    </div>
    
    <style type="text/css">
        /* 子选择器会选择下一级 */
        .s7 > div{
            color: #E066FF;
        }
    </style>
    

    后代选择器

    <div class="s8">
        <div>后代选择器</div>
        <em>
            <div>后代选择器</div>
            <div>后代选择器</div>
        </em>
    </div>
    
    <style type="text/css">
        /* 后代选择器会选择全部后代 */
        .s8 div{
            color: #7CFC00;
        }
    </style>
    

    通配符选择器

    <div class="s9">
        <div>通配符选择器</div>
        <em>通配符选择器</em>
    </div>
    
    <style type="text/css">
        .s9 * {
            color: #3370CC
        }
    </style>
    

    属性选择器

    <div rel="s10" >属性选择器</div>
    
    <style type="text/css">
        div[rel="s10"]{
            color: #573CC4
        }
    </style>
    

    伪类选择器

    <div >
        <div class="s11">伪类选择器例</div>
    </div>
    
    <style type="text/css">
        /* 伪类与伪元素参考 https://github.com/WindrunnerMax/EveryDay/blob/master/CSS/%E4%BC%AA%E7%B1%BB%E4%B8%8E%E4%BC%AA%E5%85%83%E7%B4%A0.md */
        .s11:first-child{ 
            color: #55AA55;
        }
    </style>
    

    代码示例

    <!DOCTYPE html>
    <html>
    
    <head>
        <title>CSS选择器</title>
    </head>
    
    <body>
        <div id="s1">id选择器</div>
    
        <div class="s2">类选择器1</div>
        <div class="s2">类选择器2</div>
        <div class="s3">类选择器3</div>
    
        <p>标签选择器1</p>
        <p>标签选择器2</p>
    
        <div id="s4">相邻选择器 +</div>
        <div>相邻选择器</div>
        <!-- + 只选择紧邻的兄弟 -->
        <div id="s5">相邻选择器 ~</div>
        <div class="s6">相邻选择器</div>
        <div class="s6">相邻选择器</div>
        <div class="s6">相邻选择器</div>
        <!-- ~ 选择兄弟以及兄弟的兄弟..... -->
    
        <div class="s7">
            <div>子元素选择器</div>
            <em>
                <div>子元素选择器不被选择</div>
                <div>子元素选择器不被选择</div>
            </em>
        </div>
    
        <div class="s8">
            <div>后代选择器</div>
            <em>
                <div>后代选择器</div>
                <div>后代选择器</div>
            </em>
        </div>
    
    
        <div class="s9">
            <div>通配符选择器</div>
            <em>通配符选择器</em>
        </div>
    
        <div rel="s10" >属性选择器</div>
    
        <div >
            <div class="s11">伪类选择器例</div>
        </div>
        
    
        <style type="text/css">
        #s1 {
            color: red;
        }
    
        .s2{
            color: green;
        }
    
        .s2,.s3,#s1{
            font-style:italic;
        }
    
        p{
            color: blue;
        }
    
        #s4 + div{
            color: #0033ff;
        }
        #s5 ~ .s6{
            color: #FFD700;
        }
    
        /* 子选择器会选择下一级 */
        .s7 > div{
            color: #E066FF;
        }
    
        /* 后代选择器会选择全部后代 */
        .s8 div{
            color: #7CFC00;
        }
    
        .s9 * {
            color: #3370CC;
        }
    
        div[rel="s10"]{
            color: #573CC4;
        }
    
        .s11:first-child{
            color: #55AA55;
        }
        </style>
    
    </body>
    
    </html>
    

    每日一题

    https://github.com/WindrunnerMax/EveryDay
    
    展开全文
  • Css选择器

    千次阅读 2016-05-26 16:40:56
    CSS3 选择器CSS 中,选择器是一种模式,用于选择需要添加样式的元素。 "CSS" 列指示该属性是在哪个 CSS 版本中定义的。(CSS1、CSS2 还是 CSS3。) 选择器 例子 例子描述 CSS ...

    CSS3 选择器

    在 CSS 中,选择器是一种模式,用于选择需要添加样式的元素。

    "CSS" 列指示该属性是在哪个 CSS 版本中定义的。(CSS1、CSS2 还是 CSS3。)

    选择器 例子 例子描述 CSS
    .class .intro 选择 class="intro" 的所有元素。 1
    #id #firstname 选择 id="firstname" 的所有元素。 1
    * * 选择所有元素。 2
    element p 选择所有 <p> 元素。 1
    element,element div,p 选择所有 <div> 元素和所有 <p> 元素。 1
    element element div p 选择 <div> 元素内部的所有 <p> 元素。 1
    element>element div>p 选择父元素为 <div> 元素的所有 <p> 元素。 2
    element+element div+p 选择紧接在 <div> 元素之后的所有 <p> 元素。 2
    [attribute] [target] 选择带有 target 属性所有元素。 2
    [attribute=value] [target=_blank] 选择 target="_blank" 的所有元素。 2
    [attribute~=value] [title~=flower] 选择 title 属性包含单词 "flower" 的所有元素。 2
    [attribute|=value] [lang|=en] 选择 lang 属性值以 "en" 开头的所有元素。 2
    :link a:link 选择所有未被访问的链接。 1
    :visited a:visited 选择所有已被访问的链接。 1
    :active a:active 选择活动链接。 1
    :hover a:hover 选择鼠标指针位于其上的链接。 1
    :focus input:focus 选择获得焦点的 input 元素。 2
    :first-letter p:first-letter 选择每个 <p> 元素的首字母。 1
    :first-line p:first-line 选择每个 <p> 元素的首行。 1
    :first-child p:first-child 选择属于父元素的第一个子元素的每个 <p> 元素。 2
    :before p:before 在每个 <p> 元素的内容之前插入内容。 2
    :after p:after 在每个 <p> 元素的内容之后插入内容。 2
    :lang(language) p:lang(it) 选择带有以 "it" 开头的 lang 属性值的每个 <p> 元素。 2
    element1~element2 p~ul 选择前面有 <p> 元素的每个 <ul> 元素。 3
    [attribute^=value] a[src^="https"] 选择其 src 属性值以 "https" 开头的每个 <a> 元素。 3
    [attribute$=value] a[src$=".pdf"] 选择其 src 属性以 ".pdf" 结尾的所有 <a> 元素。 3
    [attribute*=value] a[src*="abc"] 选择其 src 属性中包含 "abc" 子串的每个 <a> 元素。 3
    :first-of-type p:first-of-type 选择属于其父元素的首个 <p> 元素的每个 <p> 元素。 3
    :last-of-type p:last-of-type 选择属于其父元素的最后 <p> 元素的每个 <p> 元素。 3
    :only-of-type p:only-of-type 选择属于其父元素唯一的 <p> 元素的每个 <p> 元素。 3
    :only-child p:only-child 选择属于其父元素的唯一子元素的每个 <p> 元素。 3
    :nth-child(n) p:nth-child(2) 选择属于其父元素的第二个子元素的每个 <p> 元素。 3
    :nth-last-child(n) p:nth-last-child(2) 同上,从最后一个子元素开始计数。 3
    :nth-of-type(n) p:nth-of-type(2) 选择属于其父元素第二个 <p> 元素的每个 <p> 元素。 3
    :nth-last-of-type(n) p:nth-last-of-type(2) 同上,但是从最后一个子元素开始计数。 3
    :last-child p:last-child 选择属于其父元素最后一个子元素每个 <p> 元素。 3
    :root :root 选择文档的根元素。 3
    :empty p:empty 选择没有子元素的每个 <p> 元素(包括文本节点)。 3
    :target #news:target 选择当前活动的 #news 元素。 3
    :enabled input:enabled 选择每个启用的 <input> 元素。 3
    :disabled input:disabled 选择每个禁用的 <input> 元素 3
    :checked input:checked 选择每个被选中的 <input> 元素。 3
    :not(selector) :not(p) 选择非 <p> 元素的每个元素。 3
    ::selection ::selection 选择被用户选取的元素部分。 3


    CSS中的计数

    在CSS中至今为止都没有提供一个明确的计数API,但我们可以通过CSS3的伪类选择器解决同样的问题。

    数一个

    在CSS3中的:only-child:only-of-type都可以选择只有一个子元素。来看一个简单的示例:

    <ul>
      <li></li>
    </ul>
    <ul>
      <li></li>
      <li></li>
    </ul>
    
    li:only-child{
      background-position: 0 0;
    }
    
    id="WvgKBq" src="http://codepen.io/airen/embed/WvgKBq?WvgKBq=300&theme-id=0&slug-hash=WvgKBq&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    很明显,列表ul只要不是一个li时,都不会选中:

    章鱼

    反过来,除了只有一个li的列表,其他的ul中的li都被选中。怎么感觉有点绕呢?还是来看示例吧。基于上面的示例,使用:not(only-child)选择,选择列表项目数大于1的所有列表的li

    id="EjeePX" src="http://codepen.io/airen/embed/EjeePX?EjeePX=300&theme-id=0&slug-hash=EjeePX&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    章鱼

    数N个

    前面通过:only-child:only-of-type数到只有一个元素的列表,配合:not(only-child):not(:only-of-type)可以数到列表项目数大于一个元素的所有列表。但问题来了,如果我们要数列表项目数刚好是N个li的呢?打个比方吧。我们页面中有多个列表,但只选择列表中有6liul

    在CSS中:nth-last-child(n)选择器,可以从后面开始遍历n个参数。也就是倒数第n个。假设列表中没有nli时,将会直接忽略。来看示例吧。

    li:nth-last-child(6){
      background-position: 0 0;
    }
    
    id="LVJJbd" src="http://codepen.io/airen/embed/LVJJbd?LVJJbd=300&theme-id=0&slug-hash=LVJJbd&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    效果中可以明显看出,只要ulli大于或等于6时,选择器:nth-last-child(6)就能选中倒数第六个li

    问题来了,现在我们选择了具有678liul,但我们的目标仅需要选择只有6li的列表。那要怎么解决呢?试试多层伪类选择器,在原选择器基础上添加:first-child来做数量的过滤:

    li:nth-last-child(6):first-child{
      background-position: 0 0;
    }
    
    id="Wvggjv" src="http://codepen.io/airen/embed/Wvggjv?Wvggjv=300&theme-id=0&slug-hash=Wvggjv&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    章鱼

    离目标越来越近了,现在我们选择到了只有6li的列表,而要选择这个列表中的所有li时,可以通过~选择器来完成选择第2个到6li

    li:nth-last-child(6):first-child ~ li{
      background-position: 0 0;
    }
    
    id="xGaarY" src="http://codepen.io/airen/embed/xGaarY?xGaarY=300&theme-id=0&slug-hash=xGaarY&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    既然:nth-last-child(6):first-child可以选择到第一个,而:nth-last-child(6):first-child ~ li可以选择到第2~6li。如此一来,将这两个选择器组合在一起,就可以选择只有6li的列表,也就达到我们需要的目标:

    li:nth-last-child(6):first-child,
    li:nth-last-child(6):first-child ~ li{
      background-position: 0 0;
    }
    
    id="GJXXvL" src="http://codepen.io/airen/embed/GJXXvL?GJXXvL=300&theme-id=0&slug-hash=GJXXvL&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    章鱼

    最后来看一个动画示意图,让你对整个效果有一个完整的了解:

    章鱼

    数大于或等于N个

    还是基于前面的示例吧,这回要找的是大于或等于有6liul

    前面的示例可以得知:nth-last-child(n)可以选择到倒数第nli。在CSS选择器中和:nth-last-child()有一个刚好相反的选择器:nth-child(),其也可以添加相应的参数,比如n或者n + [整数]。例如:nth-child(n + 6)会选择列表中第六个li后所有li(包括第6个):

    li:nth-child(n + 6){
      background-position: 0 0;
    }
    
    id="MwqqGm" src="http://codepen.io/airen/embed/MwqqGm?MwqqGm=300&theme-id=0&slug-hash=MwqqGm&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    从上面示例可以看出,选择匹配的元素都发生在列表个数大于五个的列表中,从第六个li时开始选中。

    我们要解决的问题时,选择匹配的li是不包括后面的五个,这样一来就可以使用与:nth-child(n + 6)相反的选择器:nth-last-child(n + 6):nth-last-child(n + 6)将会从列表的中的倒数第六个li开始计算,直到没有匹配的li停止:

    li:nth-last-child(n + 6){
      background-position: 0 0;
    }
    
    id="EjdYRM" src="http://codepen.io/airen/embed/EjdYRM?EjdYRM=300&theme-id=0&slug-hash=EjdYRM&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    如此一来,只要列表项目数大于或等于六个li的列表都会有匹配的li,因为:nth-last-child(n + 6)可以从每个列表的中的倒数第6li开始匹配。这样一来,有六个li的列表会选择倒数第六个,有七个li的列表会选择倒数第67 个li,有八个li的列表会选择倒数6~8li,其他的可以依此类推。

    章鱼

    那么问题来了,如果我们要选择的列表数大于6个的所有li时,可以通过:nth-last-child(n+6)结合:nth-last-child(n + 6) ~ li完成:

    li:nth-last-child(n + 6),
    li:nth-last-child(n + 6) ~ li{
      background-position: 0 0;
    }
    
    id="gpBYZm" src="http://codepen.io/airen/embed/gpBYZm?gpBYZm=300&theme-id=0&slug-hash=gpBYZm&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    同样使用一个简单动画,将这个过程串起来。

    章鱼

    数小于或等于N

    前面实现选择列表有N个和大于或等于N个的li。其实有的时候,我们需要选择列表小于或等于N的。打个比方,如果N=6,那么需要选择列表包含有6543 、21li的列表。

    大家都知道:nth-last-child(n+6)会在列表项目数大于或等于6个的列表倒第六个开会匹配选中。那么我们换个思路,使用:nth-last-child(-n + 6)从每个列表中倒数第一个一直选择倒数第六个li。这个时候,只要列表有li都会找到匹配的li

    li:nth-last-child(-n + 6){
      background-position: 0 0;
    }
    
    id="MwPgRz" src="http://codepen.io/airen/embed/MwPgRz?MwPgRz=300&theme-id=0&slug-hash=MwPgRz&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    这并不是咱们需要的效果,理想中是在列表项目数大于六个的列表中应该没有匹配的li。这要如何实现呢?大家是否有想起前面介绍的:first-child选择器。不仿来看看结合后的选择到的li:

    li:nth-last-child(-n + 6):first-child{
      background-position: 0 0;
    }
    
    id="YXJzKG" src="http://codepen.io/airen/embed/YXJzKG?YXJzKG=300&theme-id=0&slug-hash=YXJzKG&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    这个时候选择到了列表项目数小于或等于6的列表中的第一个li。这样一来我们就过滤掉了大于6li的所有列表。而且离我们的目标越来越近。现在要选择小于或等于六个li的所有ul时,只需要使用~选择器:

    li:nth-last-child(-n + 6):first-child,
    li:nth-last-child(-n + 6):first-child ~ li{
      background-position: 0 0;
    }
    
    id="YXJzzG" src="http://codepen.io/airen/embed/YXJzzG?YXJzzG=300&theme-id=0&slug-hash=YXJzzG&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    数大于N小于M

    来看一个中间值,假设我们要选中列表包含的li数是46。其实这就是一个结合体,简单点讲就是将大于或等于4和小于或等于6的结合在一起。根据前面的介绍那就是:

    li:nth-last-child(n + 4):nth-last-child(-n+6):first-child,
    li:nth-last-child(n + 4):nth-last-child(-n+6):first-child ~ li{
      background-position: 0 0;
    }
    
    id="aORbOb" src="http://codepen.io/airen/embed/aORbOb?aORbOb=300&theme-id=0&slug-hash=aORbOb&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    看个动画,来了解具体的过程:

    章鱼

    Sass版数量查询

    上一节介绍的都是通过CSS来实现数量查询。在Sass这样的预处理器中也有类似的功能。@Daniel Guillan写了一个Quantity Queries Mixin。其中就定义了几个混合宏:

    查询等于N

    @include exactly($count){...}
    

    查询大于或等于N

    @include at-least($count){...}
    

    查询小于或等于N

    @include at-most($count){...}
    

    查询大于或等于M与小于或等于N

    @include between($first, $last){...}
    

    来个简单示例:

    ul li {
      @include at-least(6) {
         border: 2px solid green;
      }
      @include at-most(4) {
        border: solid 1px blue;
      }
    
      @include between(5, 7) {
        box-shadow: 0 0 5px rgba(#000, .5);
        border-radius: 5px;
      }
    
      @include exactly(8) {
        background: orange;
        box-shadow: 0 0 5px rgba(#000, .5);
        border-radius: 5px;
      }
    }
    

    效果如下:

    id="XbxWMW" src="http://codepen.io/airen/embed/XbxWMW?XbxWMW=300&theme-id=0&slug-hash=XbxWMW&default-tab=result&user=airen" scrolling="no" frameborder="0" height="300" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    有关于Sass相关的还可以查阅@James Steinbach写的一篇博文Using Sass for Quantity Queries

    PostCSS版数量查询

    除了预处理Sass之外,@Pascal Duez还写了一个PostCSS版本插件。如果你感兴趣的话,不仿看看源码。这里不做过多阐述。

    示例

    咱们回到文章最初的那个示例。

    id="jPeOad" src="http://codepen.io/airen/embed/jPeOad?jPeOad=400&theme-id=0&slug-hash=jPeOad&default-tab=result&user=airen" scrolling="no" frameborder="0" height="400" allowtransparency="true" allowfullscreen="true" class="cp_embed_iframe undefined" style="box-sizing: inherit; width: 940px; overflow: hidden;">

    总结

    CSS的数量查询是一个先进的概念,对于新手来说可能有点难或者蛋疼。然而,当我们理解清楚了CSS3的伪类选择器,并且能运用自如,那么理解文章介绍的数量查询并不是复杂的事情。而且这样的工具将会越来越多,比如CSS的预处理器和后处理器都具备了这方面的功能。

    有了CSS的数量查询这个新概念和功能,我们在页面中就可以根据数量来选择到匹配的元素。如果你感兴趣,不仿自己跟着这篇文章尝试一下。你会有更深入的体会。


    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,329
精华内容 23,731
关键字:

css选择器