Media Queries ב-CSS: תחביר הטווח והפער שהוא סוגר

Media Queries מחילות CSS רק כשתנאי מסוים מתקיים, למשל רוחב מסך מינימלי, העדפה למצב כהה או שימוש בעכבר. כמעט כל אתר רספונסיבי נעזר בהן, ורוב המדריכים עדיין מציגים את אותה תבנית: max-width: 767px לטלפונים ו-min-width: 768px למסכים רחבים יותר.

הבעיה היא שרוחב חלון הדפדפן בפיקסלים לא חייב להיות מספר שלם. במחשב נייד עם הגדלת תצוגה של 125%, רוחב החלון יכול להיות 767.2px. ברוחב כזה אף אחת משתי השאילתות לא תתאים. בדקתי את זה במנועי הדפדפנים Chrome, Firefox ו-Safari ומצאתי את אותו פער גם בליבת וורדפרס. אחר כך הרצתי את כלי ה-Build הנפוצים בכדי לבדוק איך הם מתמודדים עם התחביר הפותר את הבעיה.

בפוסט זה אסביר איך עובד תחביר הטווח (Range Syntax) המודרני, למה הוא סוגר את הפער ואיך תוכלו לאתר פערים כאלה ב-CSS שלכם.

יסודות ה-Media Queries

Media Query מגדירה תנאי. ה-CSS שבתוכה חל רק כשהתנאי מתקיים:

@media (min-width: 768px) {
  .sidebar {
    display: block;
  }
}

התנאי בודק מאפיין מדיה (media feature): במקרה הזה, רוחב ה-viewport. תוכלו לציין גם סוג מדיה כמו screen או print ולנסח תנאים מורכבים בעזרת and, or ו-not. פסיק פועל כמו or:

@media screen and (min-width: 768px) and (hover: hover) { }
@media print { }
@media (orientation: portrait), (width < 600px) { }

אם אתם עושים את הצעדים הראשונים שלכם ב-CSS, התחילו במדריך ל-CSS למתחילים.

תחביר הטווח (Range Syntax)

החל מ-Media Queries Level 4 תוכלו לנסח תנאים על רוחב בעזרת אופרטורי השוואה במקום הקידומות min- ו-max-:

/* min- and max- prefixes */
@media (min-width: 768px) { }
@media (max-width: 767px) { }
@media (min-width: 768px) and (max-width: 1023px) { }

/* Range syntax */
@media (width >= 768px) { }
@media (width < 768px) { }
@media (768px <= width < 1024px) { }

הנה השוואה בין שתי צורות הכתיבה:

תחביר עם קידומת תחביר הטווח טווח הרוחבים
(min-width: 768px) (width >= 768px) 768px ומעלה
(max-width: 768px) (width <= 768px) עד 768px ועד בכלל
אין מקבילה (width > 768px) מעל 768px, לא כולל 768px
אין מקבילה (width < 768px) כל רוחב מתחת ל-768px, כולל ערכים לא שלמים

ההבדל העיקרי מופיע בשתי השורות האחרונות. בתחביר עם קידומת ערך הגבול תמיד נכלל בטווח, ולכן אי אפשר לבטא כך ״מתחת ל-768px״. תחביר הטווח מאפשר בדיוק את זה.

האופרטורים האלה עובדים עם כל מאפיין טווח, לא רק עם רוחב:

@media (height < 500px) { }
@media (aspect-ratio > 16/9) { }
@media (resolution >= 2dppx) { }

טעויות תחביר שלא תקבלו עליהן הודעת שגיאה

בדקתי כל אחת מהשורות הבאות בעזרת matchMedia() ב-Chromium 158, ב-Firefox 159 וב-WebKit 27.2. בכל הבדיקות קיבלתי false, ואף אחד משלושת המנועים לא זרק שגיאה:

  • (400px <= width >= 1000px): שני האופרטורים צריכים להצביע לאותו כיוון.
  • (width < = 768px): אל תשאירו רווח בין שני הסימנים המרכיבים את האופרטור <=.
  • (width => 768px): האופרטור הוא >= ולא =>.
  • (min-width >= 768px): אל תשלבו קידומת עם אופרטור.
  • (width >= 768): כשאתם מציינים אורך, חובה לציין גם יחידת מידה.

הערך יכול להופיע מימין לאופרטור או משמאלו. התנאי (768px <= width) תקין ושקול ל-(width >= 768px).

הפער בין 767px ל-768px

זה צמד התנאים בו משתמשים ברוב האתרים:

@media (max-width: 767px) {
  /* phones */
}

@media (min-width: 768px) {
  /* tablets and up */
}

על פניו אין כאן פער: הצמד מכסה כל רוחב שלם. הבעיה היא שרוחב ה-viewport שהדפדפן מודד לא חייב להיות מספר שלם של פיקסלים.

כשמגדילים את התצוגה, רוחב ה-CSS מתקבל מחלוקת הרוחב הפיזי במקדם ההגדלה. למשל, בהגדלה של 125%, רוחבו של חלון ברוחב 959 פיקסלים פיזיים הוא 767.2 פיקסלי CSS. הרוחב הזה גדול מ-767, ולכן התנאי max-width לא מתקיים. הוא גם קטן מ-768, ולכן גם התנאי min-width לא מתקיים. אף אחד משני הבלוקים לא נכנס לתוקף.

בסעיף העוסק בקידומות, המפרט מזהיר מפני המקרה הזה בדיוק:

"It does not take into account the possibility of fractional viewport sizes which can occur as a result of non-integer pixel densities (e.g. on high-dpi displays or as a result of zooming/scaling). Any viewport widths that fall between 320px and 321px will result in none of the styles being applied."
Media Queries Level 4, section 2.4.4

שחזרתי את הבעיה בארבע רמות הגדלה נפוצות. כל שורה מציגה תוצאה של מדידה בחלון Chromium אמיתי. בהגדלה של 125% קיבלתי את אותה תוצאה גם ב-Firefox:

הגדלת התצוגה רוחב החלון (פיקסלים פיזיים) רוחב CSS הצמד 767px / 768px (width < 768px)
110% 844 767.27px אף תנאי לא מתקיים מתקיים
125% 959 767.2px אף תנאי לא מתקיים מתקיים
150% 1151 767.33px אף תנאי לא מתקיים מתקיים
175% 1343 767.43px אף תנאי לא מתקיים מתקיים

בהגדלה של 125%, רוחב ה-CSS הוא מספר שלם רק כשהרוחב הפיזי מתחלק ב-5. כלומר, בארבעה מכל חמישה רוחבי חלון מתקבל רוחב CSS שאינו מספר שלם.

רוב הרוחבים האלה נמצאים מחוץ לפער, משני צדי נקודת השבירה. ברוחבים שבין 767 ל-768, לעומת זאת, אף אחד מהסגנונות שהוגדרו לנקודת השבירה לא חל. כשאתם משנים את גודל החלון, אתם רק חולפים על פני הפער. אבל אם רוחב החלון שלכם נופל בתוך הפער, העימוד נשאר שבור עד שתשנו את גודל החלון.

היחס הזה משתנה גם כשאתם משנים את רמת ההגדלה בדפדפן. הדוגמה הבאה מציגה את רוחב ה-viewport שלכם כפי שהוא נמדד ב-Media Queries. נסו להגדיל ולהקטין את התצוגה ושימו לב למספרים:

Demo 1: your viewport, as media queries see it
Media query width-
window.innerWidth-
devicePixelRatio-

Measuring...

איך תחביר הטווח סוגר את הפער

(width < 768px) מתקיים בכל רוחב קטן מ-768px, גם אם הרוחב אינו מספר שלם. שלבו אותו עם (width >= 768px), ובכל רוחב אפשרי יחול כלל אחד בדיוק:

@media (width < 768px) {
  /* phones */
}

@media (width >= 768px) {
  /* tablets and up */
}

גררו את הסליידר לערך שבין 767 ל-768 ובדקו איך כל אחת משלוש הגישות מתנהגת:

Demo 2: three ways to write the same breakpoint
767.40px
Fast hosting for WordPress
Daily backups
Support by email and chat

הסליידר קובע רוחב מדומה ובודק כל קבוצת כללים באמצעות אותן השוואות בהן משתמש הדפדפן. בתוך הפער הכרטיסים חוזרים לסגנונות הבסיס שלהם, בדיוק כמו בעמוד אמיתי.

אותו פער קיים גם בליבת וורדפרס

במסכים קטנים, בלוק העמודות (Columns) בוורדפרס 7.1.3 מסדר את העמודות זו מתחת לזו בעזרת צמד התנאים הבא, מתוך wp-includes/blocks/columns/style.css:

@media (max-width: 781px) {
  .wp-block-columns:not(.is-not-stacked-on-mobile) > .wp-block-column {
    flex-basis: 100% !important;
  }
}

@media (min-width: 782px) {
  .wp-block-columns:not(.is-not-stacked-on-mobile) > .wp-block-column {
    flex-basis: 0;
    flex-grow: 1;
  }
}

טענתי את אותו CSS בדיוק ב-Chromium ובדקתי אותו בשלושה רוחבים: 781px, 781.09px ו-782px. בתוך הפער העמודות לא מסתדרות זו מתחת לזו, אבל גם לא מתחלקות שווה בשווה ברוחב הזמין. הרוחב של כל עמודה נקבע לפי הטקסט שלה, וכשאין מקום לעמודה נוספת, היא עוברת לשורה הבאה:

בלוק העמודות של וורדפרס ב-781px מסודר בעמודה אחת, ב-781.09px בלי שאף Media Query מתאימה, וב-782px בעמודות שוות

כך נראה בלוק העמודות בשלושה רוחבים שונים עם ה-CSS המקורי של וורדפרס 7.1.3. רק הרוחב האמצעי נופל בפער שבין שתי השאילתות.

ב-244 גיליונות הסגנון של ליבת וורדפרס ספרתי 27 צמדים כאלה: max-width ו-min-width באותו קובץ, עם הפרש של 1px בין הערכים. לא מצאתי שם אפילו שימוש אחד בתחביר הטווח.

בקוד החדש יותר התמונה כבר שונה. לסגנונות הבלוקים הרספונסיביים שנוספו בוורדפרס 7.1, הקוד בקובץ class-wp-theme-json.php מייצר שאילתות בתחביר הטווח. עם ערכי ברירת המחדל, 480px ו-782px, שאילתת הטאבלט היא (480px < width <= 782px) ושאילתת הדסקטופ היא (width > 782px), בלי שום פער ביניהן.

ומה לגבי 767.98px?

Bootstrap מפחיתה 0.02px מכל ערך max כדי לעקוף את הבעיה. כך מתקבל הצמד max-width: 767.98px ו-min-width: 768px.

בפועל זה עבד: בכל רוחב לא שלם שיצרתי התקיים אחד התנאים. אבל הפער עדיין קיים, גם אם רוחבו רק 0.02px, ובכל שאילתה שתכתבו תצטרכו לזכור להפחית את הערך הזה. בתחביר הטווח אין פער שצריך להביא בחשבון.

שימוש ב-matchMedia

window.innerWidth מחזיר מספר שלם, אבל ה-CSS עובד גם עם רוחבים שיש בהם שבר של פיקסל. ב-Chromium, כשה-viewport היה ברוחב 781.6px, innerWidth החזיר 782, ואילו השאילתה (min-width: 782px) החזירה false.

לכן, אם הסקריפט שלכם בודק innerWidth >= 782, הוא יריץ את הקוד המיועד לדסקטופ כשה-CSS עדיין מציג את הפריסה למסכים קטנים. במקום זאת, בקשו מהדפדפן לבדוק את אותו תנאי שה-CSS שלכם בודק:

const wide = window.matchMedia('(width >= 782px)');

function apply(query) {
  document.body.classList.toggle('is-wide', query.matches);
}

apply(wide);
wide.addEventListener('change', apply);

matchMedia() תומכת בתחביר הטווח ומשווה ערכים בדיוק כמו בגיליון הסגנונות, כך שה-JavaScript וה-CSS שלכם מגיעים לאותה תוצאה. האירוע change מופעל רק כשתוצאת הבדיקה משתנה, ולכן יעיל יותר להאזין לו מאשר להשתמש ב-listener לאירוע resize.

em ו-rem ב-Media Queries

אתרים רבים משתמשים ב-html { font-size: 62.5% } כך ש-1rem שווה ל-10px. גם בתבנית של הבלוג הזה גודל הגופן הבסיסי מוגדר כ-10px. אבל Media Queries מתעלמות מההגדרה הזו:

html {
  font-size: 62.5%; /* 1rem = 10px in your rules */
}

@media (width >= 40rem) {
  /* starts at 640px, not 400px */
}

בדקתי את זה בשלושת המנועים, עם viewport ברוחב 500px וגודל גופן בסיסי של 10px. התנאי (width >= 40rem) לא התקיים, אבל (width >= 30rem) כן. כלומר, בשאילתה עצמה 1rem היה שווה ל-16px.

המפרט מגדיר יחידות יחסיות ב-Media Queries כך: "relative to the initial value of font-size, defined by the user agent or the user's preferences, not any styling on the page." היתרון הוא שנקודות שבירה המבוססות על em נקבעות לפי גודל הגופן שהגולש בחר כברירת מחדל.

אותו כלל חל גם על נקודות השבירה של Tailwind. Tailwind CSS 4.3.5 תרגם את md: ל-(width >= 48rem) ואת max-md: ל-(width < 48rem). נקודת השבירה md נשארת ב-768px גם בתבנית עם גודל גופן בסיסי של 10px. להנחיות ההגדרה ראו את המדריך להתקנת Tailwind CSS v4 בתבנית וורדפרס.

ועוד מלכודת: אי אפשר להשתמש ב-משתני CSS בתוך Media Query. התנאי (width >= var(--bp)) לא מתקיים בשום רוחב. לעומת זאת, calc() כן עובדת: התנאי (width >= calc(700px + 10px)) התקיים ברוחב 800px.

תמיכה בדפדפנים ובכלי Build

תחביר הטווח עובד בכל הדפדפנים העדכניים. לפי נתוני התאימות של MDN ו-caniuse, נתח השימוש העולמי של הדפדפנים התומכים בו עומד על כ-96%:

דפדפן הגרסה הראשונה התומכת בתחביר הטווח
Chrome ו-Edge 104
Firefox 102 (גרסאות 63 עד 101 תמכו רק בנוסח בו שם המאפיין מופיע ראשון, למשל (width > 500px))
Safari ו-iOS Safari 16.4

דפדפן ישן לא מפרש אפילו חלק משאילתת טווח. המפרט קובע מה דינה של שאילתה שאינה עומדת בכללי התחביר: "must be replaced by not all". לכן הדפדפן מדלג על הבלוק כולו.

לכן כלי Build מציעים אפשרות להמיר את תחביר הטווח לתחביר המתאים לדפדפנים ישנים. הרצתי את אותן שלוש שאילתות בכל אחד מהכלים. הנה הפלט שקיבלתי מכל כלי עבור (width < 768px):

כלי וגרסה הפלט עבור (width < 768px)
Dart Sass 1.108.1 ללא שינוי
cssnano 9.9.0,
clean-css 5.6.3
ללא שינוי (מכווץ)
esbuild 0.28.2, ללא target ללא שינוי
esbuild 0.28.2,
--target=chrome100,safari15
not (min-width: 768px)
Lightning CSS 1.33.0, דפדפן יעד: Safari 15 not (min-width: 768px)
postcss-preset-env 11.6.2, רשימת הדפדפנים המוגדרת כברירת מחדל (max-width: 767.98px)
postcss-media-minmax 5.0.0 (max-width: 767px)
Tailwind CSS 4.3.5 מייצר בעצמו שאילתות בתחביר הטווח

בשניים מהכלים הפער חוזר בלי שום אזהרה. postcss-media-minmax מחזיר אתכם לגרסת ה-767px ולפער שהיא משאירה. עם postcss-preset-env קיבלתי את גרסת ה-0.02px של Bootstrap, וזה קרה עם רשימת הדפדפנים המוגדרת בו כברירת מחדל, לא עם רשימה ישנה.

מלכודת ההמרה: not (min-width) בדפדפנים ישנים

esbuild ו-Lightning CSS נוקטים גישה אחרת. השאילתה not (min-width: 768px) שקולה במדויק ל-(width < 768px) ואינה משאירה פער.

אבל יש כאן מלכודת: גם השימוש ב-not ישירות לפני תנאי הוא חלק מהתחביר של Media Queries Level 4. בגרסה 104 של Chrome נוספה התמיכה בו יחד עם התמיכה בתחביר הטווח, כחלק מאותה תכונה. במפענח ה-Media Queries של Chromium 103, התמיכה ב-not בתוך @media תלויה באותו דגל, CSSMediaQueries4, שהופעל רק בגרסה 104.

כלומר, דווקא בדפדפני היעד הכלל המומר אינו תקין, ולכן הדפדפנים האלה מתעלמים ממנו. הבעיה ב-Lightning CSS כבר דווחה ב-iOS 16.3 ובגרסאות קודמות (issue #1361, עדיין פתוח). לא מצאתי דיווח דומה על esbuild.

את הפרט הזה מצאתי בקוד המקור של Chromium 103. לא יכולתי להריץ את Chrome 103 עצמו, כי גרסאות ישנות של Chrome כבר לא פועלות בגרסאות העדכניות של macOS.

אם אתם עדיין תומכים ב-Chrome 103 או ב-Safari 16.3 ומטה, אל תסמכו על המרה אוטומטית של < ו->. כל אחת משתי הדרכים הבאות עובדת בכל הדפדפנים:

/* 1. Mobile first, min-width only: one direction can't leave a gap */
.card { flex-basis: 100%; }

@media (min-width: 768px) {
  .card { flex: 1 1 0; }
}

/* 2. "below 768px" in syntax older browsers understand */
@media not all and (min-width: 768px) {
  .card { flex-basis: 100%; }
}

התחביר not ואחריו סוג מדיה תקין כבר מ-Media Queries Level 3. בגרסאות העדכניות של Chromium ושל Firefox, כשה-viewport היה ברוחב 767.2px, התנאי not all and (min-width: 768px) התקיים, ואילו התנאי בגרסת ה-767px לא התקיים.

מצאו את הפערים ב-CSS שלכם

הדביקו גיליון סגנונות בשדה שלמטה או סרקו את ה-CSS שנטען בעמוד הזה. הכלי מסמן זוגות max/min המשאירים פער של עד 1px בין הערכים. הוא מסמן גם זוגות עם ערכים זהים, כי ברוחב הזה שתי השאילתות חלות. הכלי ממיר כל שאילתה לתחביר טווחים ומשווה בין ערכי em ו-rem לפי ערך בסיס של 16px. התוצאות מתעדכנות תוך כדי הקלדה.

Demo 3: media query gap finder

Findings

Range syntax version

הכלי מזהה רק תנאי min- ו-max- לרוחב ולגובה. התייחסו להמרה כאל נקודת התחלה ובדקו כל תוצאה. כלל שנראה תקין רק בזכות הפער יתנהג אחרת ברגע שתסגרו את הפער.

לחצו על ״Scan this page's CSS״ ותמצאו זוג כזה גם בתבנית של הבלוג הזה: 1122px/1123px. כשסרקתי את כל גיליונות הסגנונות של התבנית, הכלי מצא ארבעה זוגות, בהם גם 767px/768px.

בכדי לבדוק אתר פעיל כלשהו, היכנסו לאחד מעמודי האתר, פתחו את הקונסולה בדפדפן והדביקו את הקוד הבא:

(() => {
  const queries = new Set();
  const walk = (rules) => {
    for (const rule of rules) {
      if (rule.media && rule.cssRules) queries.add(rule.media.mediaText);
      if (rule.cssRules) walk(rule.cssRules);
    }
  };
  for (const sheet of document.styleSheets) {
    try { walk(sheet.cssRules); } catch (e) { /* cross-origin sheet */ }
  }
  const re = /\((min|max)-width:\s*([\d.]+)px\)/g;
  const min = new Set(), max = new Set();
  for (const q of queries) {
    for (const [, kind, value] of q.matchAll(re)) (kind === 'min' ? min : max).add(+value);
  }
  for (const hi of max) for (const lo of min) {
    if (lo - hi > 0 && lo - hi <= 1) console.log(`gap: max-width ${hi}px / min-width ${lo}px`);
  }
})();

סקריפטים לא יכולים לקרוא גיליונות סגנונות הנטענים מדומיין אחר, ולכן גם הקוד הזה וגם כפתור הסריקה שלמעלה מדלגים עליהם.

לא רק רוחב: העדפות וקלט

רוחב המסך מקבל את רוב תשומת הלב, אבל כמה ממאפייני המדיה השימושיים ביותר מספקים מידע על הגולש ולא על המסך:

/* Respect the system "reduce motion" setting */
@media (prefers-reduced-motion: reduce) {
  .hero {
    animation: none;
  }
}

/* Follow the system dark mode */
@media (prefers-color-scheme: dark) {
  :root {
    --bg: #0e1219;
    --text: #eceaea;
  }
}

/* Hover effects only for a real mouse or trackpad */
@media (hover: hover) and (pointer: fine) {
  .card:hover {
    transform: translateY(-2px);
  }
}

/* Combine them with the range syntax */
@media (width >= 768px) and (hover: hover) {
  .menu-item:hover > .submenu {
    display: block;
  }
}

hover ו-pointer מתארים את התקן הקלט הראשי. כשמשתמשים ב-any-hover ו-any-pointer, מספיק שאחד ההתקנים המחוברים יעמוד בתנאי, גם אם הוא לא ההתקן הראשי. ההבחנה הזו שימושית במחשבים ניידים עם מסך מגע.

Media או Container Queries?

Media Queries עונות על השאלה ״מה גודל המסך?״. Container Queries עונות על שאלה אחרת: ״מה גודל התיבה בה נמצא הרכיב?״.

אני משתמש ב-Media Queries לעימוד ברמת העמוד, וב-Container Queries כשרכיב צריך להתאים את עצמו לשטח הזמין לו במקומות שונים. גם ב-Container Queries אפשר להשתמש באותו תחביר טווחים, למשל @container (width > 500px). המדריך ל-Container Queries מראה איך הן עובדות בעזרת דוגמאות חיות.

לפעמים לא צריך אף אחת מהן. גריד עם auto-fit ו-minmax() מסתדר מחדש מעצמו, כמו שתראו במדריך לעימוד רספונסיבי עם CSS Grid ללא Media Queries.

שאלות נפוצות

שאלות נפוצות על Media Queries ועל תחביר הטווח:

מהו תחביר הטווח ב-Media Queries?
תחביר הטווח ב-Media Queries Level 4 מאפשר לכתוב תנאים בעזרת אופרטורי השוואה, למשל (width >= 768px) או (400px <= width < 1024px), במקום להשתמש בקידומות min-width ו-max-width. אפשר גם להגדיר טווח שאינו כולל את ערך הגבול עצמו, למשל (width < 768px). את זה אי אפשר לבטא בעזרת הקידומות.
האם min-width שקול ל-⁦width >=⁩?
כן. התנאים (min-width: 768px) ו-(width >= 768px) מתקיימים בדיוק באותם רוחבים, ו-(max-width: 767px) שקול ל-(width <= 767px). ההבדל הוא שלאופרטורים < ו-> אין מקבילה בקידומות.
למה העימוד נשבר ברמות מסוימות של זום או הגדלת תצוגה?
ברמות מסוימות של זום או הגדלת תצוגה, רוחב ה-viewport בפיקסלים יכול להיות מספר לא שלם, למשל 767.2px. ברוחב כזה אף אחד משני התנאים max-width: 767px ו-min-width: 768px לא מתקיים, ולכן הסגנונות של שתי נקודות השבירה לא חלים על העמוד. אם תכתבו את התנאים כך: (width < 768px) ו-(width >= 768px), תסגרו את הפער.
אפשר להשתמש במשתני CSS בתוך Media Queries?
לא. תנאי כמו (width >= var(--bp)) לעולם לא יתקיים, כי אי אפשר להשתמש במשתני CSS בתוך Media Queries. לעומת זאת, אפשר להשתמש ב-calc() עם ערכים קבועים. בכדי לשתף נקודות שבירה, השתמשו במשתנה של preprocessor או בכלי ה-Build שלכם.
האם הערך של font-size באלמנט ה-html משפיע על נקודות שבירה ב-rem?
לא. בתוך Media Query, היחידות em ו-rem נקבעות לפי גודל הגופן המוגדר כברירת מחדל בדפדפן, בדרך כלל 16px. גם אם הגדרתם html { font-size: 62.5% }, התנאי (width >= 40rem) עדיין מתקיים ברוחב של 640px ומעלה.
האם בטוח להשתמש היום בתחביר הטווח?
ברוב האתרים, כן. התחביר נתמך ב-Chrome וב-Edge מגרסה 104, ב-Firefox מגרסה 102 וב-Safari מגרסה 16.4. הדפדפנים התומכים בתחביר אחראים לכ-96% מהשימוש בדפדפנים בעולם. אם אתם תומכים בדפדפנים ישנים יותר, בדקו איך כלי ה-Build שלכם ממיר את < ו->, כי חלק מההמרות מחזירות את הפער או יוצרות תחביר שהדפדפנים האלה לא מזהים.

סיכום

אם אתם משלבים את max-width: 767px עם min-width: 768px, אף אחד משני התנאים לא מתקיים ברוחבים כמו 767.2px, ולכן הסגנונות לא חלים. הגדלת התצוגה וזום יוצרים רוחבים כאלה, ואותו פער קיים גם בבלוק העמודות של ליבת וורדפרס.

תחביר הטווח סוגר את הפער: כתבו (width < 768px) ו-(width >= 768px). בסקריפטים השתמשו ב-matchMedia() במקום ב-innerWidth, וזכרו שבתוך Media Query יחידת rem שווה ל-16px. אם אתם ממירים את תחביר הטווח לתחביר הנתמך בדפדפנים ישנים, בדקו את הפלט של כלי ה-Build שלכם: שניים מהכלים שבדקתי יוצרים מחדש את אותו פער.

ולסיום, הריצו את הכלי לאיתור פערים על גיליון הסגנונות שלכם. אם נתקלתם פעם בבאג מהסוג המוכר, ״זה נשבר רק במחשב של הלקוח״, יש סיכוי לא רע שתמצאו שם את הפער.

דיון ותגובות
[  0 תגובות  ]

השאירו תגובה

הוסיפו קוד באמצעות הכפתורים מטה. למשל, בכדי להוסיף PHP לחצו על הכפתור PHP והוסיפו את הקוד בתוך השורטקוד. מצאתם שגיאה בפוסט? עדכנו אותנו...