יצירת טבלה רספונסיבית עם HTML ו-CSS: ארבע שיטות

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

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

  1. גלילה אופקית: הטבלה שומרת על המבנה שלה ונגללת הצידה בתוך קופסה משלה.
  2. כרטיסים: במסכים קטנים כל שורה הופכת לכרטיס עם תוויות משלה.
  3. כותרת ועמודה ראשונה קבועות (sticky): שמות העמודות והשורות נשארים מול העיניים בזמן שהנתונים נגללים.
  4. Container query: הטבלה מחליפה layout לפי הרוחב שעומד לרשותה בפועל, ולא לפי רוחב המסך.

את הגרסה הראשונה של פוסט זה כתבתי סביב טריק אחד, ה-layout של הכרטיסים עם data-label. החלטתי לכתוב אותו מחדש ולכסות את כל ארבע השיטות. לכל אחת תמצאו את הקוד, את היבט הנגישות שחשוב להכיר ודוגמה חיה שאפשר לשנות את הרוחב שלה. בלוג זה (אגב) משתמש בשיטה הראשונה בכל הטבלאות בפוסטים, בעזרת פילטר קטן של וורדפרס שאציג לקראת הסוף.

באיזו שיטה לבחור לטבלה רספונסיבית?

הנה הגרסה הקצרה. בהמשך הפוסט כל שיטה מפורטת לעומק.

שיטה מתאימה ל… החיסרון העיקרי
גלילה אופקית טבלאות נתונים עם הרבה עמודות, בהן משווים ערכים לאורך עמודה הגולשים צריכים רמז לכך שיש עוד תוכן בצד
כרטיסים טבלאות קצרות שקוראים שורה אחר שורה: הזמנות, חבילות, אנשי קשר קשה להשוות ערכים בין שורות, וכל תא צריך data-label
כותרת ועמודה ראשונה ב-sticky טבלאות ארוכות או רחבות, בהן קל לאבד את העמודה או את השורה דורשת רקע אטום לתאים, ונשברת אם לאלמנט אב יש overflow משלו
Container query טבלאות בסיידבר, בכרטיסים ובקומפוננטות לשימוש חוזר דורשת אלמנט עוטף שישמש כ-container

אף אחת מהשיטות לא דורשת JavaScript. כל הדוגמאות בהמשך משתמשות באותם נתונים: דו"ח Core Web Vitals עם עד תשע עמודות, רחב מדי למסך טלפון.

שיטה 1: גלילה אופקית של הטבלה

הפתרון הפשוט ביותר הוא גם העמיד ביותר. שימו את הטבלה בתוך אלמנט עוטף (wrapper) עם overflow-x: auto. כשהטבלה רחבה מה-container שלה, ה-wrapper מקבל פס גלילה אופקי ושאר העמוד נשאר במקומו.

הטבלה עצמה לא משתנה, כך שהעמודות נשארות מיושרות ועדיין אפשר להשוות ערכים לאורך עמודה. זו הסיבה שזו ברירת המחדל הנכונה לטבלאות נתונים אמיתיות. גם ה-class .table-responsive של Bootstrap עובד באותו אופן: wrapper עם overflow-x: auto.

הנה ה-HTML:

<div class="table-wrap" role="region" aria-labelledby="cwv-caption" tabindex="0">
  <table>
    <caption id="cwv-caption">Core Web Vitals by page</caption>
    <thead>
      <tr>
        <th scope="col">Page</th>
        <th scope="col">LCP</th>
        <th scope="col">INP</th>
        <th scope="col">CLS</th>
        <th scope="col">Page weight</th>
        <th scope="col">Requests</th>
        <th scope="col">Status</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>/checkout/</td>
        <td>4.6 s</td>
        <td>520 ms</td>
        <td>0.31</td>
        <td>3.4 MB</td>
        <td>92</td>
        <td>Poor</td>
      </tr>
      <!-- more rows -->
    </tbody>
  </table>
</div>

שלושת ה-attributes על ה-wrapper חשובים יותר מכפי שנדמה:

  • tabindex="0" מאפשר למשתמשי מקלדת להגיע לקופסה עם Tab ולגלול בה בעזרת החיצים.
  • role="region" הופך את הקופסה ל-landmark שמשתמשי קוראי מסך יכולים לקפוץ אליו.
  • aria-labelledby נותן לאותו region שם מתוך ה-caption של הטבלה, כך שהוא לא מוקרא כאזור ללא שם.

ועכשיו ה-CSS:

.table-wrap {
  overflow-x: auto;
}

.table-wrap table {
  width: 100%;
  border-collapse: collapse;
}

.table-wrap th,
.table-wrap td {
  padding: 12px 16px;
  text-align: start;
  white-space: nowrap;
}

.table-wrap:focus-visible {
  outline: 2px solid #ffb42f;
  outline-offset: 2px;
}

white-space: nowrap מונע מהדפדפן לכווץ את העמודות. בלעדיו, טבלה צרה כמעט אף פעם לא גולשת לרוחב. היא פשוט נעשית גבוהה מאוד וקשה לקריאה.

הוספת רמז לגלילה

פס גלילה לבדו הוא רמז חלש. בטלפונים, וגם ב-macOS בהגדרות ברירת המחדל, הוא מוסתר עד שמתחילים לגלול. הדוגמה הבאה משתמשת בטכניקת ה-scrolling shadows של Lea Verou: זוהר עדין מופיע בכל צד שמאחוריו יש עוד תוכן.

.table-wrap {
  overflow-x: auto;
  background:
    /* Covers: scroll with the content and hide the glow at each end */
    linear-gradient(to right, #12161a 30%, transparent) left / 48px 100% no-repeat local,
    linear-gradient(to left, #12161a 30%, transparent) right / 48px 100% no-repeat local,
    /* Glows: stay pinned to the edges of the box */
    radial-gradient(farthest-side at 0 50%, rgba(255, 180, 47, 0.3), transparent) left / 16px 100% no-repeat scroll,
    radial-gradient(farthest-side at 100% 50%, rgba(255, 180, 47, 0.3), transparent) right / 16px 100% no-repeat scroll;
  background-color: #12161a;
}

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

דוגמה 1: גלילה אופקית עם רמז לגלילה
רוחב: -
Core Web Vitals לפי עמוד (נתוני דוגמה)
עמוד LCP INP CLS משקל עמוד בקשות סטטוס
/ 1.9 s 140 ms 0.04 1.2 MB 38 טוב
/pricing/ 2.3 s 180 ms 0.08 980 KB 31 טוב
/blog/ 2.8 s 160 ms 0.12 1.6 MB 54 דורש שיפור
/blog/css-grid-guide/ 3.4 s 240 ms 0.06 2.1 MB 67 דורש שיפור
/contact/ 1.6 s 90 ms 0.01 640 KB 22 טוב
/checkout/ 4.6 s 520 ms 0.31 3.4 MB 92 גרוע

בחרו 375px וגללו את הטבלה, או הגיעו אליה עם Tab והשתמשו בחיצים. שימו לב לזוהר בצד שעדיין יש מאחוריו תוכן.

אם אתם מעדיפים להשאיר את פס הגלילה גלוי, תוכלו לעצב את פס הגלילה עם CSS כך שיתאים לעיצוב שלכם.

שיטה 2: הפיכת שורות הטבלה לכרטיסים במובייל

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

שמות העמודות מגיעים מה-attribute data-label שעל כל תא:

<table class="table-cards">
  <caption>Core Web Vitals by page</caption>
  <thead>
    <tr>
      <th scope="col">Page</th>
      <th scope="col">LCP</th>
      <th scope="col">INP</th>
      <th scope="col">CLS</th>
      <th scope="col">Page weight</th>
      <th scope="col">Status</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td data-label="Page">/blog/</td>
      <td data-label="LCP">2.8 s</td>
      <td data-label="INP">160 ms</td>
      <td data-label="CLS">0.12</td>
      <td data-label="Page weight">1.6 MB</td>
      <td data-label="Status">Needs improvement</td>
    </tr>
    <!-- more rows -->
  </tbody>
</table>

לאחר מכן, media query מגדיר display: block לטבלה, לשורות ולתאים, ומציג כל תווית בעזרת pseudo-element:

@media (max-width: 600px) {
  /* Hide the header row visually, but keep it for screen readers */
  .table-cards thead {
    position: absolute;
    width: 1px;
    height: 1px;
    overflow: hidden;
    clip: rect(0 0 0 0);
    white-space: nowrap;
  }

  .table-cards,
  .table-cards tbody,
  .table-cards tr {
    display: block;
  }

  .table-cards tr {
    margin-bottom: 14px;
    border: 1px solid #2a2f36;
    border-radius: 6px;
  }

  .table-cards td {
    display: flex;
    justify-content: space-between;
    gap: 16px;
    padding: 10px 16px;
    text-align: end;
    border-bottom: 1px dashed #2a2f36;
  }

  .table-cards td:last-child {
    border-bottom: 0;
  }

  /* Print the column name next to each value */
  .table-cards td::before {
    content: attr(data-label);
    font-weight: 600;
    text-align: start;
    text-transform: uppercase;
  }
}

השורה החשובה היא content: attr(data-label). הפונקציה attr() קוראת attribute מהאלמנט ומחזירה אותו כטקסט, כך שכלל CSS אחד נותן לכל תא את התווית שלו. אם לא עבדתם איתם בעבר, הנה עוד מידע על data attributes ב-JavaScript וב-CSS.

שני פרטים שקל לפספס:

  • הגבילו את הקוד ל-class. הגרסה הישנה של פוסט זה עיצבה את הסלקטור table עצמו, דבר שהופך כל טבלה בעמוד לכרטיסים. השתמשו ב-class כמו .table-cards.
  • אל תסתירו את שורת הכותרות עם display: none. כך היא נעלמת גם מקוראי מסך. ה-clip שבקוד למעלה מסתיר אותה ויזואלית בלבד.
דוגמה 2: כרטיסים עם data-label
רוחב: -
Core Web Vitals לפי עמוד (נתוני דוגמה)
עמוד LCP INP CLS משקל עמוד סטטוס
/ 1.9 s 140 ms 0.04 1.2 MB טוב
/blog/ 2.8 s 160 ms 0.12 1.6 MB דורש שיפור
/blog/css-grid-guide/ 3.4 s 240 ms 0.06 2.1 MB דורש שיפור
/checkout/ 4.6 s 520 ms 0.31 3.4 MB גרוע

הדוגמה עוברת לכרטיסים ב-600px בעזרת container query במקום media query, כך שהכפתורים יכולים להציג אותה גם במסך דסקטופ. שיטה 4 מסבירה את ההבדל.

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

שיטה 3: כותרת טבלה ועמודה ראשונה קבועות (Sticky)

לטבלאות ארוכות יש בעיה אחרת. גוללים למטה ושמות העמודות נעלמים. גוללים הצידה ומאבדים את השורה בה אתם נמצאים. position: sticky פותר את שתי הבעיות, ובלי JavaScript.

תנו ל-wrapper ערך max-height ו-overflow: auto בכדי שיהפוך ל-scroll container. לאחר מכן קבעו את תאי הכותרת לחלק העליון ואת התא הראשון בכל שורה לצד בו השורה מתחילה (מימין בעברית):

.table-sticky {
  max-height: 360px;
  overflow: auto;
}

.table-sticky table {
  border-collapse: separate;
  border-spacing: 0;
}

/* Column headers stick to the top */
.table-sticky thead th {
  position: sticky;
  top: 0;
  z-index: 2;
  background: #161b22;
}

/* Row headers stick to the start edge (left in LTR, right in RTL) */
.table-sticky tbody th {
  position: sticky;
  inset-inline-start: 0;
  z-index: 1;
  background: #12161a;
}

/* The corner cell sticks both ways and stays on top */
.table-sticky thead th:first-child {
  inset-inline-start: 0;
  z-index: 3;
}

/* On phones, keep the pinned column narrow */
@media (max-width: 600px) {
  .table-sticky tbody th {
    min-width: 120px;
    max-width: 120px;
    white-space: normal;
    overflow-wrap: anywhere;
  }
}

התא הראשון בכל שורה הוא כותרת שורה, ולכן ה-HTML נראה כך:

<div class="table-sticky" role="region" aria-labelledby="cwv-caption" tabindex="0">
  <table>
    <caption id="cwv-caption">Core Web Vitals by page</caption>
    <thead>
      <tr>
        <th scope="col">Page</th>
        <th scope="col">LCP</th>
        <!-- more column headers -->
      </tr>
    </thead>
    <tbody>
      <tr>
        <th scope="row">/checkout/</th>
        <td>4.6 s</td>
        <!-- more cells -->
      </tr>
    </tbody>
  </table>
</div>

שלושה דברים קובעים אם השיטה תעבוד:

  • ה-scroll container קובע היכן התאים ננעלים. אלמנט sticky ננעל בתוך אלמנט האב הקרוב ביותר הנגלל. אם לאלמנט אחר בין הטבלה ל-wrapper יש overflow משלו, התאים יינעלו אליו במקום, או שייראה כאילו הם לא עובדים בכלל. עוד על כך בפוסט מה עושים כש-position: sticky לא עובד.
  • תאי sticky צריכים רקע אטום. אחרת רואים את השורות נגללות מתחתיהם.
  • השתמשו ב-border-collapse: separate. עם border-collapse: collapse, ה-borders לא זזים יחד עם תאי ה-sticky. בבדיקה שלי ב-Chrome 156, הכותרת הקבועה איבדה את ה-borders שלה והשורות נראו מעליה.
דוגמה 3: כותרת ועמודה ראשונה ב-sticky
Core Web Vitals לפי עמוד (נתוני דוגמה)
עמוד LCP INP CLS TTFB FCP משקל עמוד בקשות סטטוס
/ 1.9 s 140 ms 0.04 0.42 s 1.1 s 1.2 MB 38 טוב
/pricing/ 2.3 s 180 ms 0.08 0.51 s 1.3 s 980 KB 31 טוב
/blog/ 2.8 s 160 ms 0.12 0.63 s 1.6 s 1.6 MB 54 דורש שיפור
/blog/css-grid-guide/ 3.4 s 240 ms 0.06 0.71 s 1.9 s 2.1 MB 67 דורש שיפור
/contact/ 1.6 s 90 ms 0.01 0.38 s 0.9 s 640 KB 22 טוב
/checkout/ 4.6 s 520 ms 0.31 1.20 s 2.8 s 3.4 MB 92 גרוע
/about/ 1.8 s 110 ms 0.02 0.40 s 1.0 s 720 KB 26 טוב
/services/ 2.4 s 190 ms 0.09 0.55 s 1.4 s 1.1 MB 35 טוב
/case-studies/ 3.1 s 210 ms 0.14 0.66 s 1.8 s 2.4 MB 71 דורש שיפור
/shop/ 3.9 s 380 ms 0.18 0.92 s 2.2 s 2.9 MB 84 דורש שיפור
/cart/ 2.2 s 260 ms 0.05 0.88 s 1.5 s 1.3 MB 40 דורש שיפור
/account/ 2.0 s 150 ms 0.03 0.74 s 1.2 s 890 KB 29 טוב

גללו בתוך הטבלה למטה ולצדדים. שמות העמודות נשארים למעלה, ושמות העמודים נשארים מימין.

עוד דבר שכדאי לשים לב אליו בטלפונים: עמודה קבועה עם ערכים ארוכים עלולה לתפוס חצי מסך ולא להשאיר מקום לנתונים. לשם כך נועד ה-media query שבסוף ה-CSS. הוא מאפשר לטקסט בעמודה הראשונה לרדת שורה ברוחב 120px.

השימוש ב-<th scope="row"> לעמודה הראשונה עוזר גם לקוראי מסך להקריא לאיזו שורה שייך כל ערך.

שימו לב שה-CSS משתמש ב-inset-inline-start: 0 ולא ב-left: 0. זו בדיוק הנקודה החשובה באתר בעברית: left: 0 מקבע את העמודה השמאלית, כלומר את העמודה האחרונה בטבלה מימין לשמאל. inset-inline-start מתייחס לצד בו השורה מתחילה, ולכן אותו CSS מקבע את העמודה הימנית בעברית ואת השמאלית באנגלית.

מאותה סיבה שאר השיטות בפוסט משתמשות ב-text-align: start וב-end ולא ב-left וב-right. כל הדוגמאות החיות בפוסט זה רצות מימין לשמאל עם אותו קובץ CSS בדיוק שמשמש את הגרסה האנגלית.

שיטה 4: טבלה רספונסיבית עם Container Queries

ה-layout של הכרטיסים בשיטה 2 מגיב לרוחב המסך. זה עובד עד שאותה טבלה מופיעה במקום צר במסך רחב, כמו סיידבר, כרטיס או layout של שתי עמודות. המסך ברוחב 1440px, ה-media query לא מופעל אף פעם, והטבלה גולשת מחוץ לעמודה שלה.

Container query פותר זאת בכך שהוא מגיב לרוחב ה-wrapper של הטבלה ולא לרוחב המסך:

<div class="table-container">
  <table>
    <!-- same table markup as Method 2, with data-label on every cell -->
  </table>
</div>
/* The wrapper is the container the query measures */
.table-container {
  container-type: inline-size;
}

@container (max-width: 420px) {
  .table-container thead {
    position: absolute;
    width: 1px;
    height: 1px;
    overflow: hidden;
    clip: rect(0 0 0 0);
    white-space: nowrap;
  }

  .table-container table,
  .table-container tbody,
  .table-container tr {
    display: block;
  }

  .table-container td {
    display: flex;
    justify-content: space-between;
    gap: 12px;
  }

  .table-container td::before {
    content: attr(data-label);
    font-weight: 600;
  }

  /* ...plus the card borders and spacing from Method 2 */
}

ה-container חייב להיות אלמנט עוטף, מכיוון שאלמנט לא יכול לבצע query על הגודל של עצמו. container-type: inline-size מודד רק את הרוחב, וזה כל מה שטבלה צריכה.

דוגמה 4: אותה טבלה בשני containers
עמודה ראשית-
Core Web Vitals לפי עמוד (נתוני דוגמה)
עמוד LCP INP סטטוס
/ 1.9 s 140 ms טוב
/blog/ 2.8 s 160 ms דורש שיפור
/checkout/ 4.6 s 520 ms גרוע
סיידבר-
Core Web Vitals לפי עמוד (נתוני דוגמה)
עמוד LCP INP סטטוס
/ 1.9 s 140 ms טוב
/blog/ 2.8 s 160 ms דורש שיפור
/checkout/ 4.6 s 520 ms גרוע

אותו markup, אותו CSS, אותו מסך. העותק שבסיידבר צר מ-420px ולכן עובר לכרטיסים, בזמן שהעותק בעמודה הראשית נשאר טבלה. בטלפון שניהם צרים, ולכן בשניהם יופיעו כרטיסים.

Container queries נתמכים ב-Chrome וב-Edge מגרסה 106, ב-Safari מגרסה 16 וב-Firefox מגרסה 110, כך שאפשר להשתמש בהם כבר היום. לתמונה המלאה, תנו מבט במדריך המלא ל-CSS Container Queries.

טבלאות רספונסיביות ונגישות

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

היום זו, ברובה, כבר היסטוריה. Adrian Roselli עוקב אחרי הבאג הזה מאז 2018. בעדכון מאוקטובר 2023 הוא מדווח שטבלאות עם מאפייני display של CSS עובדות כעת ב-Chromium, ב-Gecko וב-WebKit, כש-Safari 17 היה האחרון לתקן זאת. Chrome הפסיק לאבד את הסמנטיקה כבר בגרסה 80. display: contents הוא עדיין יוצא הדופן, ולכן הימנעו ממנו באלמנטים של טבלה.

אם אתם עדיין תומכים בגרסאות ישנות של Safari, הוסיפו את ה-roles של ARIA במפורש, כפי שעושה המאמר שלו:

<table role="table">
  <thead role="rowgroup">
    <tr role="row">
      <th role="columnheader" scope="col">Page</th>
      <th role="columnheader" scope="col">LCP</th>
    </tr>
  </thead>
  <tbody role="rowgroup">
    <tr role="row">
      <td role="cell" data-label="Page">/blog/</td>
      <td role="cell" data-label="LCP">2.8 s</td>
    </tr>
  </tbody>
</table>

בכל שיטה שתבחרו, אותה רשימת בדיקה רלוונטית:

  • תנו לטבלה <caption>, ותנו שם ל-wrapper הנגלל בעזרת aria-labelledby.
  • השתמשו ב-<th scope="col"> לכותרות עמודה וב-<th scope="row"> לכותרות שורה.
  • אפשרו פוקוס על scroll containers בעזרת tabindex="0".
  • אל תסתמכו על צבע בלבד. תוויות הסטטוס בדוגמאות מציגות לצד כל צבע גם טקסט.

טבלאות רספונסיביות בוורדפרס

אם הטבלאות שלכם נמצאות באתר וורדפרס, ייתכן שחלק מהעבודה כבר נעשה. בלוק הטבלה של עורך הבלוקים עוטף כל טבלה ב-<figure class="wp-block-table">, וה-stylesheet של הבלוק עצמו נותן לאותו figure את overflow-x: auto. כלומר, טבלאות של בלוקים כבר נגללות הצידה, כל עוד התבנית שלכם לא מסירה את ה-CSS של ספריית הבלוקים.

טבלאות בתוכן של העורך הקלאסי, בבלוקי Custom HTML ובפוסטים ישנים לא מקבלות את אותו wrapper. פילטר קטן על the_content מוסיף אותו לכל טבלה בזמן שהעמוד מרונדר, בלי לגעת בתוכן השמור:

/**
 * Wrap every table in post content in a scrolling container.
 */
function savvy_wrap_tables( $content ) {
    if ( ! is_singular() || false === stripos( $content, '<table' ) ) {
        return $content;
    }

    $open    = '<div class="table-wrap" role="region" aria-label="Scrollable table" tabindex="0"><table';
    $content = preg_replace( '#<table\b#i', $open, $content );

    return str_ireplace( '</table>', '</table></div>', $content );
}
add_filter( 'the_content', 'savvy_wrap_tables', 20 );

הוסיפו אותו לקובץ functions.php של תבנית הבת שלכם (child theme), ועצבו את .table-wrap עם ה-CSS משיטה 1. הפילטר רץ בעדיפות 20, אחרי שוורדפרס סיים לעבד את התוכן. אם הפילטרים של the_content חדשים לכם, התחילו מהבנת ההוקים בוורדפרס.

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

שאלות נפוצות

שאלות נפוצות על טבלאות רספונסיביות:

איך יוצרים טבלה רספונסיבית עם CSS?
עטפו אותה ב-div עם overflow-x: auto, כך שהיא תיגלל הצידה כשהיא רחבה מהמסך. כך העמודות נשארות מיושרות, וזה עובד עם כל טבלה. אם קוראים את הטבלה שורה אחר שורה, אפשר במקום זאת להפוך כל שורה לכרטיס מתחת ל-breakpoint, בעזרת display: block ו-content: attr(data-label).
מה עושה ה-class table-responsive של Bootstrap?
.table-responsive הוא wrapper עם overflow-x: auto, בדיוק כמו הגלילה האופקית בשיטה 1. הגרסאות עם breakpoint, כמו .table-responsive-md, גוללות רק מתחת לאותו breakpoint.
אפשר ליצור טבלה רספונסיבית בלי media queries?
כן. גלילה אופקית לא דורשת media query בכלל, מכיוון שפס הגלילה מופיע רק כשהטבלה רחבה מה-container שלה. בכדי להחליף layout, container query הופך את הטבלה לכרטיסים לפי רוחב ה-wrapper שלה ולא לפי רוחב המסך.
איך משאירים את כותרת הטבלה גלויה בזמן גלילה?
שימו את הטבלה בתוך wrapper עם max-height ו-overflow: auto, ותנו לתאי הכותרת position: sticky, top: 0 ורקע אטום. השתמשו ב-border-collapse: separate, מכיוון שעם border-collapse: collapse ה-borders לא זזים יחד עם תאי ה-sticky.
האם שינוי display בטבלה פוגע בנגישות?
לא בדפדפנים העדכניים. Chromium, Firefox ו-Safari מגרסה 17 שומרים על הסמנטיקה של הטבלה כשמשנים display באלמנטים שלה. display: contents הוא יוצא הדופן. לגרסאות ישנות של Safari, הוסיפו ל-markup את ה-roles של ARIA, כמו role="row" ו-role="cell".
כדאי להשתמש ב-CSS Grid במקום בטבלה?
לא לנתונים טבלאיים. <table> מסביר לדפדפנים ולקוראי מסך איך השורות והעמודות קשורות זו לזו, וגריד של אלמנטי div לא עושה זאת. Grid הוא הכלי הנכון כשהתוכן הוא layout, למשל סט של כרטיסים. לשם כך, תנו מבט בlayout רספונסיבי עם CSS Grid ובלי media queries.
איך הופכים טבלאות לרספונסיביות בוורדפרס?
טבלאות מבלוק הטבלה של עורך הבלוקים כבר יושבות בתוך figure עם overflow-x: auto. לתוכן קלאסי ולפוסטים ישנים, הוסיפו פילטר על the_content שעוטף כל <table> ב-div נגלל, כפי שמוצג בחלק על וורדפרס למעלה.

סיכום

טבלה רספונסיבית לא חייבת להיות מתוחכמת. ברוב טבלאות הנתונים, wrapper עם גלילה ורמז גלוי הוא התשובה הנכונה, והלב שלו הוא שורת CSS אחת. עברו לכרטיסים כשקוראים שורה אחת בכל פעם, הוסיפו כותרות sticky כשהטבלה מתארכת, והשתמשו ב-container query כשאותה טבלה מופיעה ב-containers ברוחבים שונים.

בכל שיטה שתבחרו, שמרו על markup אמיתי של <table>, הוסיפו caption ו-scope לכותרות, ונסו את הטבלה עם המקלדת. אני מקווה שהפוסט היה ברור, ואם תבנו משהו בעזרת השיטות האלו, אשמח לראות אותו בתגובות.

דיון ותגובות
[  1 תגובות  ]
  • דניאל
    דניאל 14 אפריל 2022, 0:47

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

השאירו תגובה

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