ප්ලස් ලකුණ ( +
) ඊළඟ සහෝදරයා සඳහා වේ.
කලින් සහෝදරයාට සමාන දෙයක් තිබේද?
ප්ලස් ලකුණ ( +
) ඊළඟ සහෝදරයා සඳහා වේ.
කලින් සහෝදරයාට සමාන දෙයක් තිබේද?
Answers:
නැත, "පෙර සහෝදර සහෝදරියන්" තේරීම් කාරකයක් නොමැත.
ආශ්රිත සටහනක, ~
සාමාන්ය අනුප්රාප්තික සහෝදර සහෝදරියන් සඳහා වේ (මෙයින් අදහස් කරන්නේ මූලද්රව්යය මෙයින් පසුව පැමිණේ, නමුත් අවශ්යයෙන්ම වහාම නොවේ) සහ CSS3 තේරීම් කාරකයෙකි. +
ඊළඟ සහෝදරයා සඳහා වන අතර එය CSS2.1 වේ.
බලන්න යාබදව පිහිටා ඇති සහෝදර සහෝදරියන් combinator සිට තේරීම් පෙළ 3 සහ 5.7 යාබදව පිහිටා ඇති සහෝදර සහෝදරියන් තේරීම් සිට කඩා හැලෙන Style Sheets සඳහා 2 වන මහල සංශෝධනය 1 (CSS 2.1) පිරිවිතර .
~
ඔබට අවශ්ය දේ අනුව ක්රියා කළ හැකි පෙර සිටි සහෝදර සහෝදරියන් (ප්රතිවිරුද්ධ ) විලාසිතාවට ක්රමයක් මම සොයා ගතිමි .
අපි ඔබට සබැඳි ලැයිස්තුවක් ඇති බව කියමු. එකක් මත සැරිසරන විට, පෙර තිබූ සියල්ල රතු පැහැයට හැරිය යුතුය. ඔබට එය මේ ආකාරයෙන් කළ හැකිය:
/* default link color is blue */
.parent a {
color: blue;
}
/* prev siblings should be red */
.parent:hover a {
color: red;
}
.parent a:hover,
.parent a:hover ~ a {
color: blue;
}
<div class="parent">
<a href="#">link</a>
<a href="#">link</a>
<a href="#">link</a>
<a href="#">link</a>
<a href="#">link</a>
</div>
pointer-events: none
කන්ටේනරයට සහ pointer-events: auto;
තනි සබැඳිවලට එකතු කළ හැකිය . එවිට හිස් අවකාශය සියල්ල රතු පැහැයට හැරේ. කෙසේ වෙතත්, තනි සබැඳියන්ගෙන් සැරිසරන සිදුවීම් කෙසේ හෝ මවුපියන්ට ප්රචාරය කළ යුතුය.
තේරීම් මට්ටම 4 හඳුන්වා දෙයි:has()
(මීට පෙර විෂය දර්ශකය !
) මෙය ඔබට පෙර සහෝදරයෙකු තෝරා ගැනීමට ඉඩ සලසයි:
previous:has(+ next) {}
… නමුත් ලියන අවස්ථාව වන විට, එය බ්රව්සර් සහාය සඳහා ලේ ගැලීමේ සීමාවෙන් ඔබ්බට යම් දුරකි.
:has()
ව්යාජ පන්තිය භාවිතා කළ නොහැක .
order
නම්යශීලී හා ජාලක පිරිසැලසුම් වල දේපල සලකා බලන්න .පහත උදාහරණ වල මම නම්යශීලි කොටුව කෙරෙහි අවධානය යොමු කරමි, නමුත් එම සංකල්පම ග්රිඩ් සඳහාද අදාළ වේ.
නම්ය පෙට්ටිය සමඟ, පෙර සහෝදර සහෝදරියන් තෝරා ගැනීම අනුකරණය කළ හැකිය.
විශේෂයෙන් නම්යශීලී order
දේපල මඟින් තිරය වටා මූලද්රව්ය චලනය කළ හැකිය.
මෙන්න උදාහරණයක්:
B මූලද්රව්යය සැරිසැරූ විට A මූලද්රව්යය රතු පැහැයට හැරීමට ඔබට අවශ්යය.
<ul> <li>A</li> <li>B</li> </ul>
පියවර
ul
නම්යශීලී බහාලුමක් සාදන්න .
ul { display: flex; }
සලකුණු කිරීමේදී සහෝදර සහෝදරියන්ගේ අනුපිළිවෙල ආපසු හරවන්න.
<ul>
<li>B</li>
<li>A</li>
</ul>
මූලද්රව්ය A ඉලක්ක කිරීම සඳහා සහෝදර සහෝදරියන් තෝරා ගැනීමක් භාවිතා කරන්න ( ~
හෝ එසේ +
කරනු ඇත).
li:hover + li { background-color: red; }
order
දෘශ්ය සංදර්ශනයේ සහෝදර සහෝදරියන්ගේ අනුපිළිවෙල යථා තත්වයට පත් කිරීම සඳහා නම්ය දේපල භාවිතා කරන්න .
li:last-child { order: -1; }
... සහ voilà! කලින් සහෝදර සහෝදරියන් තෝරා ගැනීමක් උපත ලබයි (හෝ අවම වශයෙන් අනුකරණය කර ඇත).
සම්පූර්ණ කේතය මෙන්න:
ul {
display: flex;
}
li:hover + li {
background-color: red;
}
li:last-child {
order: -1;
}
/* non-essential decorative styles */
li {
height: 200px;
width: 200px;
background-color: aqua;
margin: 5px;
list-style-type: none;
cursor: pointer;
}
<ul>
<li>B</li>
<li>A</li>
</ul>
නම්යශීලි කොටුවෙන්:
ෆ්ලෙක්ස් අයිතම පෙරනිමියෙන් ප්රදර්ශනය වන අතර ඒවා ප්රභව ලේඛනයේ පෙනෙන ආකාරයටම පිළිවෙලට තබා ඇත.
order
මෙම ඇණවුම වෙනස් කිරීම සඳහා දේපල භාවිතා කළ හැකිය.මෙම
order
දේපල අයින් භාණ්ඩ ordinal කණ්ඩායම් සඳහා අනුයුක්ත වන විට, අයින් රුවනයකි තුළ පෙනී අනුපිළිවල පාලනය කරයි. එය තනි<integer>
අගයක් ගනී , එමඟින් නම්ය අයිතමය අයත් වන්නේ කුමන සාමාන්ය කණ්ඩායමටද යන්න නියම කරයි.
order
සියලුම නම්ය අයිතම සඳහා ආරම්භක අගය 0 වේ.
order
CSS ජාලක පිරිසැලසුම් පිරිවිතරයේ ද බලන්න .
නම්ය order
දේපල සමඟ නිර්මාණය කරන ලද "පෙර සහෝදර සහෝදරියන් තේරීම්කරුවන්ගේ" උදාහරණ .
.container { display: flex; }
.box5 { order: 1; }
.box5:hover + .box4 { background-color: orangered; font-size: 1.5em; }
.box6 { order: -4; }
.box7 { order: -3; }
.box8 { order: -2; }
.box9 { order: -1; }
.box9:hover ~ :not(.box12):nth-child(-1n+5) { background-color: orangered;
font-size: 1.5em; }
.box12 { order: 2; }
.box12:hover ~ :nth-last-child(-1n+2) { background-color: orangered;
font-size: 1.5em; }
.box21 { order: 1; }
.box21:hover ~ .box { background-color: orangered; font-size: 1.5em; }
/* non-essential decorative styles */
.container {
padding: 5px;
background-color: #888;
}
.box {
height: 50px;
width: 75px;
margin: 5px;
background-color: lightgreen;
display: flex;
justify-content: center;
align-items: center;
text-align: center;
cursor: pointer;
}
<p>
Using the flex <code>order</code> property to construct a previous sibling selector
</p>
<div class="container">
<div class="box box1"><span>1</span></div>
<div class="box box2"><span>2</span></div>
<div class="box box3"><span>3</span></div>
<div class="box box5"><span>HOVER ME</span></div>
<div class="box box4"><span>4</span></div>
</div>
<br>
<div class="container">
<div class="box box9"><span>HOVER ME</span></div>
<div class="box box12"><span>HOVER ME</span></div>
<div class="box box6"><span>6</span></div>
<div class="box box7"><span>7</span></div>
<div class="box box8"><span>8</span></div>
<div class="box box10"><span>10</span></div>
<div class="box box11"><span>11</span></div>
</div>
<br>
<div class="container">
<div class="box box21"><span>HOVER ME</span></div>
<div class="box box13"><span>13</span></div>
<div class="box box14"><span>14</span></div>
<div class="box box15"><span>15</span></div>
<div class="box box16"><span>16</span></div>
<div class="box box17"><span>17</span></div>
<div class="box box18"><span>18</span></div>
<div class="box box19"><span>19</span></div>
<div class="box box20"><span>20</span></div>
</div>
ෆ්ලෙක්ස්බොක්ස් යනු CSS පිළිබඳ දිගුකාලීන විශ්වාසයන් බිඳ දමයි.
එවැනි එක් විශ්වාසයක් නම් , කලින් සහෝදර සහෝදරියන් තෝරා ගැනීම CSS හි කළ නොහැකි බවයි.
මෙම විශ්වාසය පුළුල් යැයි කීම අඩු තක්සේරුවක් වනු ඇත. තොග පිටාර ගැලීම පිළිබඳ අදාළ ප්රශ්න නියැදියක් මෙන්න:
ඉහත විස්තර කර ඇති පරිදි, මෙම විශ්වාසය මුළුමනින්ම සත්ය නොවේ. නම්ය order
දේපල භාවිතා කරමින් පෙර සහෝදර සහෝදරියන් තෝරා ගැනීම CSS හි අනුකරණය කළ හැකිය .
මෙම z-index
මිථ්යාව
තවත් දිගුකාලීන විශ්වාසයක් වී z-index
ඇත්තේ ස්ථානගත කරන ලද මූලද්රව්ය මත පමණක් ක්රියාත්මක වන බවයි.
ඇත්ත වශයෙන්ම, පිරිවිතරයේ වඩාත්ම වර්තමාන අනුවාදය - W3C සංස්කාරක කෙටුම්පත - මෙය තවමත් සත්ය බව සහතික කරයි:
9.9.1 තොග මට්ටම නියම කිරීම:
z-index
දේපල
z-index
- වටිනාකම: ස්වයංක්රීය | | උරුමය
- ආරම්භක: ස්වයංක්රීය
- අදාළ වේ: ස්ථානගත කළ මූලද්රව්ය
- උරුමය: නැත
- ප්රතිශත: එන් / ඒ
- මාධ්ය: දෘශ්ය
- ගණනය කළ අගය: නිශ්චිතව දක්වා ඇති පරිදි
(අවධාරණය එකතු කරන ලදි)
කෙසේ වෙතත් යථාර්ථයේ දී මෙම තොරතුරු යල් පැන ගිය සහ සාවද්ය ය.
බව කොටස් අයින් භාණ්ඩ හෝ විදුලිබල පද්ධතියට භාණ්ඩ විට පවා මුසපත්ව සන්දර්භයන් නිර්මාණය කළ හැකි position
ය static
.
4.3. නම්ය අයිතමය ඉසෙඩ් ඇණවුම් කිරීම
එම නියෝගය-වෙනස් ලියවිල්ල සඳහා අමු ලියවිල්ල සඳහා වෙනුවට භාවිතා කරන අතර, ඇත හැර Flex භාණ්ඩ, පේළිගත කුට්ටි ලෙස හරියටම එම තීන්ත ආලේප
z-index
හැර වෙනත් අගයauto
පවා නම් මුසපත්ව සන්දර්භය නිර්මාණයposition
වන්නේstatic
.5.4. ඉසෙඩ් අක්ෂය ඇණවුම් කිරීම:
z-index
දේපලඑම නියෝගය-වෙනස් ලියවිල්ල සඳහා අමු ලියවිල්ල සඳහා වෙනුවට භාවිතා කරන අතර, ඇත හැර විදුලිබල පද්ධතියට භාණ්ඩ වල තීන්ත ආලේප සඳහා, පේළිගත කුට්ටි ලෙස හරියටම සමාන වන්නේ
z-index
හැර වෙනත් අගයauto
පවා නම් මුසපත්ව සන්දර්භය නිර්මාණයposition
වන්නේstatic
.
z-index
ස්ථානගත නොකළ නම්ය අයිතම මත වැඩ කිරීම පිළිබඳ නිරූපණයක් මෙන්න : https://jsfiddle.net/m0wddwxs/
order
හුෙදක් වෙනස් කිරීමට අදහස් කරන බැවින් දේපල විසඳුමක් නොවේ දෘශ්ය එය කරන්නේ එසේ කළේ නැහැ මුල් නැවත semantical ඔබ වැඩ කිරීමට මෙම දුෂ්කරතාවය මගහැර සඳහා HTML හි වෙනස් කරන ලෙස බල කරන බව පිණිස.
z-index
වැඩ කරන්නේ කවදාදැයි තේරුම් ගැනීමට යමෙකුට අපහසුතාවයක් තිබේ නම්, “ඔම්ග්, position
නිශ්චිතව දක්වා නැත !”, පිරිවිතරයන් සන්දර්භය සැකසීමේ සංකල්පය ගැන සඳහන් කරයි , එය
float: right
(හෝ ඇණවුම ආපසු හැරවීමට වෙනත් ක්රමයක් සමඟ හොඳින් ක්රියා කරයි , එයින් flex/order
සුළු (අවම?) අතුරු ආබාධ ඇත). ප්රහේලිකා දෙකක් තළා: ප්රවේශය නිරූපණය කිරීමfloat: right
සහ නිරූපණය කිරීමdirection: rtl
මට එකම ප්රශ්නය තිබුනි, නමුත් පසුව මට "ඩු" මොහොතක් තිබුණි. ලිවීම වෙනුවට
x ~ y
ලියන්න
y ~ x
නිසැකවම මෙය "y" වෙනුවට "x" සමඟ ගැලපේ, නමුත් එය පිළිතුරු දෙන්නේ "ගැලපීමක් තිබේද?" ප්රශ්නය, සහ සරල DOM ගමන් කිරීම ජාවාස්ක්රිප්ට් වල ලූපයට වඩා කාර්යක්ෂමව නිවැරදි මූලද්රව්යයට ඔබව ගෙන යනු ඇත.
මුල් ප්රශ්නය CSS ප්රශ්නයක් බව මට වැටහී ඇති බැවින් මෙම පිළිතුර බොහෝ දුරට අදාළ නොවේ, නමුත් වෙනත් ජාවාස්ක්රිප්ට් භාවිතා කරන්නන් මා කළාක් මෙන් සෙවීම හරහා ප්රශ්නයට බාධා පමුණුවනු ඇත.
y ~ x
මගේ ගැටලුව විසඳන්නේ කෙසේද යන්න ගැන මෝඩ සිතුවිල්ලක් මට දැනෙන්නට පටන්
y ~ x
"ගැලපීමක් තිබේද?" ප්රශ්නය, මන්ද මෙහි දී ඇති තේරීම්කරුවන් දෙදෙනා අදහස් කරන්නේ සම්පූර්ණයෙන්ම වෙනස් දේවල් ය. නිදසුනක් ලෙස උප y ~ x
කුලකයට අනුව තරඟයක් බිහි කිරීමට කිසිඳු ක්රමයක් නොමැත <root><x/><y/></root>
. ප්රශ්නය "y පවතීද?" එවිට තේරීම සරලයි y
. ප්රශ්නය නම් “කිසියම් අත්තනෝමතික ස්ථානයක සහෝදර සහෝදරියකට x ලබා දී තිබේද?” එවිට ඔබට තේරීම්කරුවන් දෙදෙනාම අවශ්ය වේ. (නමුත් සමහර විට මම මේ අවස්ථාවේදී ඩබ් කරනවා ...)
උපක්රම දෙකක් . මූලික වශයෙන් HTML හි ඔබ අපේක්ෂිත මූලද්රව්යයන්ගේ HTML අනුපිළිවෙල හරවා
~
ඊළඟ සහෝදර සහෝදරියන් ක්රියාකරු භාවිතා කිරීම :
float-right
+ HTML මූලද්රව්යයන්ගේ අනුපිළිවෙල ප්රතිලෝම කරන්නdiv{ /* Do with the parent whatever you know just to make the
inner float-right elements appear where desired */
display:inline-block;
}
span{
float:right; /* float-right the elements! */
}
span:hover ~ span{ /* On hover target it's "previous";) elements */
background:red;
}
<div>
<!-- Reverse the order of inner elements -->
<span>5</span>
<span>4</span>
<span>3</span>
<span>2</span>
<span>1</span>
</div>
direction: rtl;
අභ්යන්තර මූලද්රව්යයන්ගේ අනුපිළිවෙල + ප්රතිලෝමව දෙමාපිය.inverse{
direction: rtl;
display: inline-block; /* inline-block to keep parent at the left of window */
}
span:hover ~ span{ /* On hover target it's "previous";) elements */
background:gold;
}
Hover one span and see the previous elements being targeted!<br>
<div class="inverse">
<!-- Reverse the order of inner elements -->
<span>5</span>
<span>4</span>
<span>3</span>
<span>2</span>
<span>1</span>
</div>
+
ඊළඟ සහෝදරයා වෙනුවෙන්. කලින් සහෝදරයාට සමාන දෙයක් තිබේද?
!
සහ?
ඇත 2 පසුව සහෝදර සහෝදරියන් තේරීම් සාම්ප්රදායික CSS දී:
+
යනු වහාම පසුව සහෝදර සහෝදරියන් තේරීම්~
යනු ඕනෑම පසුව සහෝදර සහෝදරියන් තේරීම්සාම්ප්රදායික CSS හි, පෙර සහෝදර සහෝදරියන් තෝරාගැනීමක් නොමැත .
කෙසේ වෙතත්, අක්ෂය CSS පශ්චාත් සකසනය පුස්තකාලයේ, පෙර සහෝදර සහෝදරියන් තේරීම්කරුවන් දෙදෙනෙකු ඇත :
?
යනු වහාම පෙර සහෝදර සහෝදරියන් තේරීම් (ප්රතිවිරුද්ධ +
)!
යනු ඕනෑම පෙර සහෝදර සහෝදරියන් තේරීම් (ප්රතිවිරුද්ධ ~
)වැඩ කරන උදාහරණය:
පහත උදාහරණයේ:
.any-subsequent:hover ~ div
ඕනෑම පසුව තෝරා ගනී div
.immediate-subsequent:hover + div
ක්ෂණික පසුව තෝරා ගනී div
.any-previous:hover ! div
පෙර ඕනෑම දෙයක් තෝරා ගනී div
.immediate-previous:hover ? div
ආසන්නතම පෙර තේරීම div
div {
display: inline-block;
width: 60px;
height: 100px;
color: rgb(255, 255, 255);
background-color: rgb(255, 0, 0);
text-align: center;
vertical-align: top;
cursor: pointer;
opacity: 0;
transition: opacity 0.6s ease-out;
}
code {
display: block;
margin: 4px;
font-size: 24px;
line-height: 24px;
background-color: rgba(0, 0, 0, 0.5);
}
div:nth-of-type(-n+4) {
background-color: rgb(0, 0, 255);
}
div:nth-of-type(n+3):nth-of-type(-n+6) {
opacity: 1;
}
.any-subsequent:hover ~ div,
.immediate-subsequent:hover + div,
.any-previous:hover ! div,
.immediate-previous:hover ? div {
opacity: 1;
}
<h2>Hover over any of the blocks below</h2>
<div></div>
<div></div>
<div class="immediate-previous">Hover for <code>?</code> selector</div>
<div class="any-previous">Hover for <code>!</code> selector</div>
<div class="any-subsequent">Hover for <code>~</code> selector</div>
<div class="immediate-subsequent">Hover for <code>+</code> selector</div>
<div></div>
<div></div>
<script src="https://rouninmedia.github.io/axe/axe.js"></script>
ඔබට HTML හි මූලද්රව්යවල ප්රතිලෝම අනුපිළිවෙල භාවිතා කළ හැකිය. එවිට භාවිතා හැර order
මෙන් Michael_B පිළිතුර ඔබට භාවිතා කළ හැකි flex-direction: row-reverse;
හෝflex-direction: column-reverse;
ඔබේ සැකැස්ම මත පදනම්ව.
වැඩ කරන නියැදිය:
.flex {
display: flex;
flex-direction: row-reverse;
/* Align content at the "reversed" end i.e. beginning */
justify-content: flex-end;
}
/* On hover target its "previous" elements */
.flex-item:hover ~ .flex-item {
background-color: lime;
}
/* styles just for demo */
.flex-item {
background-color: orange;
color: white;
padding: 20px;
font-size: 3rem;
border-radius: 50%;
}
<div class="flex">
<div class="flex-item">5</div>
<div class="flex-item">4</div>
<div class="flex-item">3</div>
<div class="flex-item">2</div>
<div class="flex-item">1</div>
</div>
මේ මොහොතේ එය කිරීමට නිල ක්රමයක් නොමැති නමුත් මෙය සාක්ෂාත් කර ගැනීම සඳහා ඔබට කුඩා උපක්රමයක් භාවිතා කළ හැකිය! එය පර්යේෂණාත්මක බවත් එයට යම් සීමාවක් ඇති බවත් මතක තබා ගන්න ... ( ඔබ යාත්රා අනුකූලතාව ගැන කරදර වන්නේ නම් මෙම සබැඳිය පරීක්ෂා කරන්න )
ඔබට කළ හැක්කේ CSS3 තේරීම් කාරකයක් භාවිතා කිරීමයි: ව්යාජ ක්ලාස් යනුවෙන් හැඳින්වේ nth-child()
#list>* {
display: inline-block;
padding: 20px 28px;
margin-right: 5px;
border: 1px solid #bbb;
background: #ddd;
color: #444;
margin: 0.4em 0;
}
#list :nth-child(-n+4) {
color: #600b90;
border: 1px dashed red;
background: orange;
}
<p>The oranges elements are the previous sibling li selected using li:nth-child(-n+4)</p>
<div id="list">
<span>1</span><!-- this will be selected -->
<p>2</p><!-- this will be selected -->
<p>3</p><!-- this will be selected -->
<div>4</div><!-- this will be selected -->
<div>5</div>
<p>6</p>
<p>7</p>
<p>8</p>
<p>9</p>
</div>
:nth-child(-n+4)
එය ව්යාජ පන්තියක් බැවින් නිසියාකාරව වැඩ කිරීම සඳහා තේරීම් කරුවෙකුට අදාළ විය යුතුය. ඔබට ඒත්තු ගැන්වීමට නොහැකි නම්, මගේ
*
තේරීම් කාරකය භාවිතා කර නෝඩ් වර්ගයේ ස්වාධීනව යා හැකිය , නමුත් එය පිළිකුල් සහගත නරක පුරුද්දකි.
li#someListItem
මට නෝඩ් (ය) අවශ්ය විය (එය මම "පෙර" ලෙස අර්ථකථනය කරන ආකාරයයි) - ඔබ ලබා දුන් තොරතුරු CSS හරහා ප්රකාශ කිරීමට මට උපකාර කරන්නේ කෙසේදැයි මම නොදනිමි. ඔබ පළමු n සහෝදර සහෝදරියන් තෝරා ගන්නවා, මම n දන්නවා යැයි සිතන්න. මෙම තර්කනය මත පදනම්ව, ඕනෑම තේරීම් කරුවෙකුට උපක්රමය කළ හැකි අතර මට අවශ්ය මූලද්රව්යය (ය) තෝරා ගත හැකිය (උදා: නොවේ ()).
CSS හරහා එය කළ නොහැකිය. එය "කඳුරැල්ල" හදවතට ගෙන යයි ;-).
කෙසේ වෙතත්, ඔබට ඔබේ පිටුවට ජාවාස්ක්රිප්ට් එක් කිරීමට හැකි නම්, jQuery ස්වල්පයක් ඔබේ අවසාන ඉලක්කය කරා ළඟා විය හැකිය. ඔබේ ඉලක්ක මූලද්රව්යය / පංතිය / හැඳුනුම්පත මත "ඉදිරියෙන් බැලීමට"
ඔබට jQuery භාවිතා කළ හැකිය find
, ඉන්පසු ඔබේ ඉලක්කය තෝරා ගැනීමට පසුපසට යන්න.
ඔබේ මූලද්රව්යය සඳහා DOM (CSS) නැවත ලිවීමට ඔබ jQuery භාවිතා කරයි.
මයික් බ්රැන්ට්ගේ මෙම පිළිතුර මත පදනම්ව , පහත දැක්වෙන jQuery ස්නිපටය උදව් විය හැකිය.
$('p + ul').prev('p')
මෙය පළමුව <ul>
a අනුගමනය කරන සියලුම s තෝරා ගනී <p>
.
එය, මීට පෙර තේරීමට "backtracks" <p>
බව කට්ටලයක් වෙතින්<ul>
.
Query ලදායී ලෙස, "පෙර සහෝදරයා" jQuery හරහා තෝරාගෙන ඇත.
දැන්, .css
එම මූලද්රව්යය සඳහා ඔබේ CSS නව අගයන් ලබා දීමට ශ්රිතය භාවිතා කරන්න.
මගේ නඩුවේදී මම හැඳුනුම්පත සමඟ ඩීඅයිවී එකක් තෝරා ගැනීමට ක්රමයක් සෙවීමට උත්සාහ කළෙමි #full-width
, නමුත් එහි (වක්ර) පැවත එන ඩීඅයිවී පන්තියක් තිබේ නම් පමණි .companies
.
මට යටින් ඇති සියලුම HTML පාලනය කළ .companies
නමුත් ඊට ඉහළින් ඇති ඕනෑම HTML එකක් වෙනස් කිරීමට මට නොහැකි විය.
කඳුරැල්ල යන්නේ දිශාව 1 ක් පමණි: පහළට.
මේ අනුව මට සියලු #full-width
s තෝරා ගත හැකිය .
නැතහොත් මට තෝරා .companies
ගත හැක්කේ එය අනුගමනය කිරීමෙන් පසුව පමණි #full-width
.
නමුත් මම හැකි නොවේ තෝරා පමණක් #full-width
නොවන බව කීවේය .companies
.
නැවතත්, මට එකතු කිරීමට නොහැකි විය .companies
HTML හි වැඩි . HTML හි එම කොටස බාහිරව ලියා ඇති අතර අපගේ කේතය ඔතා.
නමුත් jQuery සමග, මම හැකි අවශ්ය තෝරා #full-width
s, පසුව සුදුසු ආකාරයේ අනුයුක්ත:
$("#full-width").find(".companies").parents("#full-width").css( "width", "300px" );
මෙය සියල්ල සොයා #full-width .companies
ගන්නා .companies
අතර CSS හි සම්මතයේ නිශ්චිත අංග ඉලක්ක කිරීමට තේරීම්කරුවන් භාවිතා කරන ආකාරයට සමාන ඒවා තෝරා ගනී .
ඉන්පසු එය .parents
"පසුපසට" ගොස් සියළුම දෙමව්පියන් තෝරා ගැනීමට භාවිතා කරයි .companies
,
නමුත් එම ප්රති results ල #fill-width
මූලද්රව්ය පමණක් තබා ගැනීමට පෙරහන් කරයි, එවිට අවසානයේදී
එය #full-width
මූලද්රව්යයක් තෝරා ගන්නේ .companies
පන්ති පරම්පරාවක් තිබේ නම් පමණි .
අවසාන වශයෙන්, එය ප්රති CS ලයක් ලෙස width
ලැබෙන මූලද්රව්යයට නව CSS ( ) අගයක් පවරයි .
$(".parent").find(".change-parent").parents(".parent").css( "background-color", "darkred");
div {
background-color: lightblue;
width: 120px;
height: 40px;
border: 1px solid gray;
padding: 5px;
}
.wrapper {
background-color: blue;
width: 250px;
height: 165px;
}
.parent {
background-color: green;
width: 200px;
height: 70px;
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<html>
<div class="wrapper">
<div class="parent">
"parent" turns red
<div class="change-parent">
descendant: "change-parent"
</div>
</div>
<div class="parent">
"parent" stays green
<div class="nope">
descendant: "nope"
</div>
</div>
</div>
Target <b>"<span style="color:darkgreen">parent</span>"</b> to turn <span style="color:red">red</span>.<br>
<b>Only</b> if it <b>has</b> a descendant of "change-parent".<br>
<br>
(reverse cascade, look ahead, parent un-descendant)
</html>
jQuery යොමු ලියකියවිලි:
$ () හෝ jQuery () : DOM මූලද්රව්යය.
. සොයන්න : තේරීම් කාරකයක්, jQuery වස්තුවක් හෝ මූලද්රව්යයක් මගින් පෙරහන් කරන ලද ගැලපෙන මූලද්රව්ය සමූහයේ එක් එක් මූලද්රව්යයේ පරම්පරාව ලබා ගන්න.
. දෙමව්පියන් : ගැලපෙන මූලද්රව්ය සමූහයේ එක් එක් මූලද්රව්යයට පෙර සහෝදරයා හෝ සහෝදරිය ලබා ගන්න. තේරීම් කාරකයක් සපයා ඇත්නම්, එය පෙර සහෝදරයා ලබා ගන්නේ එම තේරීම් කාරකයට ගැලපෙන්නේ නම් පමණි (ප්රති results ල පෙරහන් කරන්නේ ලැයිස්තුගත මූලද්රව්ය / තේරීම් ඇතුළත් කිරීමට පමණි).
. css : ගැලපෙන මූලද්රව්ය සමූහය සඳහා CSS ගුණාංග එකක් හෝ කිහිපයක් සකසන්න.
previousElementSibling
.
previousElementSibling()
දේශීය JS DOM කාර්යයන් සමග වඩා හුරු පුරුදු අය සඳහා සැපයිය හැකි තවත් ඉදිරියට CSS නොවන මාර්ගය.
+
කිසිවක් OP විශේෂයෙන් ඉල්ලා ඇති (නොපවතින) තේරීම් භාවිතා කරයි . මෙම පිළිතුර JS "හැක්" ලෙස සලකන්න. විසඳුමක් සෙවීම සඳහා මා ගත කළ කාලය වෙනත් කෙනෙකුගේ ඉතිරි කිරීම සඳහා මෙහි ඇත.
ඔබ නිශ්චිත පිහිටීම දන්නේ නම්, :nth-child()
පහත සඳහන් සියලු සහෝදර සහෝදරියන් බැහැර කිරීම සාර්ථක වනු ඇත.
ul li:not(:nth-child(n+3))
එය සියල්ල තෝරා ගනු ඇත li
3 වන දිනට පෙර ගත හැකි (උදා: 1 සහ 2). නමුත්, මගේ මතය අනුව මෙය කැත ලෙස පෙනෙන අතර ඉතා තදින් භාවිතා කළ හැකි ය.
ඔබට නව වැනි දරුවා දකුණේ සිට වමට තෝරා ගත හැකිය:
ul li:nth-child(-n+2)
එයම කරයි.
අවාසනාවකට "පෙර" සහෝදර සහෝදරියන් තේරීම් කරුවෙකු නොමැත, නමුත් ඔබට සමහර විට එසේ කළ හැකිය ස්ථානගත කිරීම භාවිතා කිරීමෙන් තවමත් එකම බලපෑමක් ලබා (උදා: පාවෙන දකුණ). එය ඔබ කිරීමට උත්සාහ කරන දේ මත රඳා පවතී.
මගේ නඩුවේදී, මට අවශ්ය වූයේ මූලික වශයෙන් CSS 5-තරු වර්ගීකරණ පද්ධතියක්. මට පෙර තරු වර්ණ ගැන්වීමට (හෝ නිරූපකය මාරු කිරීමට) අවශ්ය වනු ඇත. සෑම මූලද්රව්යයක්ම නිවැරදිව පාවීමෙන්, මම අනිවාර්යයෙන්ම එකම බලපෑමක් ලබා ගනිමි (තරු සඳහා වන html මේ අනුව 'පසුපසට' ලිවිය යුතුය).
මම මෙම උදාහරණයේ දී FontAwesome භාවිතා කරන අතර fa-star-o සහ fa-star යුනිකෝඩ් අතර හුවමාරු වෙමි http://fortawesome.github.io/Font-Awesome/
CSS:
.fa {
display: inline-block;
font-family: FontAwesome;
font-style: normal;
font-weight: normal;
line-height: 1;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
}
/* set all stars to 'empty star' */
.stars-container {
display: inline-block;
}
/* set all stars to 'empty star' */
.stars-container .star {
float: right;
display: inline-block;
padding: 2px;
color: orange;
cursor: pointer;
}
.stars-container .star:before {
content: "\f006"; /* fontAwesome empty star code */
}
/* set hovered star to 'filled star' */
.star:hover:before{
content: "\f005"; /* fontAwesome filled star code */
}
/* set all stars after hovered to'filled star'
** it will appear that it selects all after due to positioning */
.star:hover ~ .star:before {
content: "\f005"; /* fontAwesome filled star code */
}
HTML: (40)
+
නැතහොත් ~
තේරීම් කරුවන් මට පහර දෙන්නේ අවට ඇති පිරිසිදුම වැඩය ලෙස ය.
ඔබගේ නිශ්චිත පරමාර්ථය මත පදනම්ව, එකක් භාවිතා නොකර මව් තේරීම් කරුවෙකුගේ ප්රයෝජනය සාක්ෂාත් කර ගැනීමට ක්රමයක් තිබේ (එකක් පැවතියද) ...
අපට ඇති බව පවසන්න:
<div>
<ul>
<li><a>Pants</a></li>
<li><a>Socks</a></li>
<ul>
<li><a>White socks</a></li>
<li><a>Blue socks</a></li>
</ul>
</ul>
</div>
මේස් බ්ලොක් (මේස් වර්ණ ඇතුළුව) දෘශ්යමාන ලෙස පරතරය භාවිතා කිරීමට අපට කුමක් කළ හැකිද?
හොඳ නමුත් නොපවතින දේ:
ul li ul:parent {
margin-top: 15px;
margin-bottom: 15px;
}
පවතින දේ:
li > a {
margin-top: 15px;
display: block;
}
li > a:only-child {
margin-top: 0px;
}
මෙමඟින් සියලුම නැංගුරම් සම්බන්ධතා ඉහළින් 15px ආන්තිකයක් ඇති අතර LI තුළ UL මූලද්රව්ය (හෝ වෙනත් ටැග්) නොමැති අය සඳහා එය නැවත 0 වෙත යලි සකසයි.
කලින් සහෝදරයා තෝරා ගැනීමට මට විසඳුමක් අවශ්ය විය. ප්රතික්රියා සහ ශෛලීය සංරචක භාවිතා කරමින් මම මෙම විසඳුම ඉදිරිපත් කළෙමි. මෙය මගේ නිශ්චිත විසඳුම නොවේ (මෙය මතකයෙන්, පැය ගණනකට පසුව). SetHighlighterRow ශ්රිතයේ දෝෂයක් ඇති බව මම දනිමි.
OnMouseOver පේළියක පේළි දර්ශකය තත්වයට සකසනු ඇති අතර පෙර පේළිය නව පසුබිම් වර්ණයක් සමඟ යොමු කරන්න
class ReactClass extends Component {
constructor() {
this.state = {
highlightRowIndex: null
}
}
setHighlightedRow = (index) => {
const highlightRowIndex = index === null ? null : index - 1;
this.setState({highlightRowIndex});
}
render() {
return (
<Table>
<Tbody>
{arr.map((row, index) => {
const isHighlighted = index === this.state.highlightRowIndex
return {
<Trow
isHighlighted={isHighlighted}
onMouseOver={() => this.setHighlightedRow(index)}
onMouseOut={() => this.setHighlightedRow(null)}
>
...
</Trow>
}
})}
</Tbody>
</Table>
)
}
}
const Trow = styled.tr`
& td {
background-color: ${p => p.isHighlighted ? 'red' : 'white'};
}
&:hover {
background-color: red;
}
`;
නැත, නැත .
ඔබ තැබිය යුතු නම් ලේබලය පෙර ආදාන , හුදෙක් තැනින් ලේබලය පසු ආදාන හා දෙකම තබා ලේබලය සහ එම ආදාන ඇතුළේ div , සහ ශෛලිය div පහත සඳහන් පරිදි:
.input-box {
display: flex;
flex-direction: column-reverse;
}
<div class="input-box">
<input
id="email"
class="form-item"
/>
<label for="email" class="form-item-header">
E-Mail*
</label>
</div>
දැන් ඔබට css හි ඇති සම්මත ඊළඟ සහෝදර සහෝදරියන්ගේ විකල්පයන් යෙදිය හැකි අතර, ඔබ පෙර සහෝදර සහෝදරියන්ගේ මෝස්තරයක් භාවිතා කරන බවක් පෙනේ.
මට සමාන ගැටළුවක් ඇති අතර මේ ආකාරයේ සියලු ගැටලු පහත පරිදි විසඳා ගත හැකි බව මම දැන ගතිමි:
මේ ආකාරයෙන් ඔබට ඔබගේ වර්තමාන, පෙර අයිතම (වර්තමාන හා ඊළඟ අයිතම සමඟ අභිබවා ඇති සියලුම අයිතම) සහ ඔබගේ ඊළඟ අයිතම මෝස්තර කිරීමට ඔබට හැකි වේ.
උදාහරණයක්:
/* all items (will be styled as previous) */
li {
color: blue;
}
/* the item i want to distinguish */
li.milk {
color: red;
}
/* next items */
li ~ li {
color: green;
}
<ul>
<li>Tea</li>
<li class="milk">Milk</li>
<li>Juice</li>
<li>others</li>
</ul>
එය යමෙකුට උපකාරී වේ යැයි සිතමි.