วิธีทำ Lazy Load รูปภาพอย่างง่าย + ผลต่อ PageSpeed

ถ้าอยากทำ lazy load รูปภาพให้เว็บโหลดเร็วขึ้น วิธีที่ง่ายที่สุดและแนะนำให้ใช้ก่อนเสมอคือเพิ่ม attribute บรรทัดเดียวในแท็ก <img>:

<img src="photo.jpg" alt="..." width="1200" height="800" loading="lazy">

เบราว์เซอร์จะเลื่อนการดาวน์โหลดรูปออกไปจนกว่าผู้ใช้เลื่อนหน้าจอเข้าใกล้รูปนั้น โดยไม่ต้องเขียน JavaScript แม้แต่บรรทัดเดียว แต่มีกฎเหล็กอยู่ 2 ข้อที่ต้องจำก่อนใช้งานจริง: อย่าใส่ loading="lazy" กับรูป hero หรือรูปที่เป็น LCP element เพราะจะทำให้คะแนน Core Web Vitals แย่ลง และรูปสำคัญที่สุดของหน้าควรใส่ fetchpriority="high" เพื่อบอกเบราว์เซอร์ว่าให้โหลดก่อนเพื่อน

ปกบทความวิธีทำ Lazy Load รูปภาพอย่างง่าย โค้ด HTML ในกรอบ dark code editor โทนกรมท่าอมเขียวมิ้นท์และส้ม

บทความนี้จะพาดูกลไกการทำงานเบื้องหลัง โค้ดทั้ง 4 ระดับตั้งแต่ง่ายสุด การใช้ fetchpriority และ srcset ร่วมกับ lazy load รวมถึงผลของมันต่อ Google PageSpeed แบบที่อธิบายได้ว่าทำไมคะแนนถึงขยับ

Lazy Load ทำงานยังไงในเบราว์เซอร์

ปกติเบราว์เซอร์โหลดรูปแบบ eager loading คือเจอแท็ก <img> ตัวไหนก็ดาวน์โหลดทันที ไม่สนว่าอยู่บนจอหรืออยู่ลึกถึงบทความยาว ๆ ล่าง ๆ ผลคือหน้าเว็บที่มีรูป 30 รูปจะยิง request 30 ครั้งตั้งแต่วินาทีแรก แย่ง bandwidth กับไฟล์ที่สำคัญกว่า เช่น CSS และรูป hero

Lazy loading เปลี่ยนพฤติกรรมนี้เป็น defer until needed — เลื่อนการโหลดออกไปจนกว่ารูปจะจำเป็นต้องแสดง โดย native implementation ในเบราว์เซอร์ทำงานประมาณนี้:

  • เบราว์เซอร์คำนวณ distance threshold หรือระยะห่างจาก viewport ถ้ารูปอยู่ไกลกว่านั้นจะยังไม่ยิง request ระยะนี้แต่ละเบราว์เซอร์ตั้งไม่เหมือนกัน และพอเครือข่ายช้าจะขยายระยะให้โหลดล่วงหน้ามากขึ้น
  • เมื่อผู้ใช้เลื่อนเข้าใกล้ เบราว์เซอร์ค่อยเริ่มดาวน์โหลด โดยพยายามให้รูปโหลดเสร็จก่อนที่ผู้ใช้จะเลื่อนมาเห็นจริง ๆ
  • Chrome ยิง range request เอาแค่ 2 KB แรกของไฟล์ก่อน เพื่ออ่านขนาดภาพจาก header ของไฟล์ แล้วสร้าง placeholder กัน layout กระโดด (CLS) โดยที่ยังไม่ต้องโหลดไฟล์เต็ม

จุดสำคัญที่คนพลาดบ่อยคือ preload scanner – ชิ้นส่วนของเบราว์เซอร์ที่อ่าน HTML ล่วงหน้าแล้วส่งรูปทุกรูปที่เจอใน <img src> เข้าคิวโหลดทันที แต่รูปที่มี loading="lazy" จะถูกข้าม ทำให้การเริ่มโหลดของรูป lazy ช้ากว่าปกติเพราะต้องรอ layout เกิดก่อน นี่คือเหตุผลที่รูปใน first viewport ห้าม lazy เด็ดขาด

แผนภาพเทียบการโหลดรูปแบบ Eager โหลดทุกรูปทันทีแล้วแย่ง bandwidth กับ Lazy โหลดเฉพาะรูปบนจอและเลื่อนถึงค่อยโหลด

4 วิธีเขียนโค้ด Lazy Load เรียงจากง่ายสุด

1. ใช้ loading=”lazy” — native attribute บรรทัดเดียว

<img
  src="product-photo.jpg"
  alt="รูปสินค้า"
  width="1200"
  height="800"
  loading="lazy"
>

attribute รองรับ 2 ค่าหลัก: lazy คือเลื่อนการโหลดจนกว่ารูปเข้าใกล้ viewport และ eager ซึ่งเป็นพฤติกรรม default เหมือนไม่ใส่อะไรเลย ใส่เมื่ออยากประกาศชัด ๆ ว่ารูปนี้ต้องโหลดทันที ทุกเบราว์เซอร์หลักรองรับแล้ว ทั้ง Chrome, Firefox, Safari และ Edge ดังนั้นในปี 2026 นี้แทบไม่มีเหตุผลต้องเขียน lazy loader เองสำหรับ <img> ธรรมดาอีกต่อไป

อย่าลืมว่า width และ height ควรใส่คู่กันเสมอ เพื่อให้เบราว์เซอร์คำนวณ aspect-ratio สร้างพื้นที่รอไว้ก่อนรูปมา ช่วย CLS ตั้งแต่ยังไม่โหลด

2. WordPress ทำ lazy load ให้อัตโนมัติอยู่แล้ว

ถ้าเว็บรัน WordPress 5.5 ขึ้นไป ระบบจะเพิ่ม loading="lazy" ให้รูปในเนื้อหาอัตโนมัติโดยไม่ต้องแตะโค้ดเลย และตั้งแต่ WordPress 6.1 ตรรกะยิ่งฉลาดขึ้น — รูปแรกของเนื้อหาจะถูกงด lazy เพื่อไม่ให้กระทบ LCP และรูปใหญ่รูปแรกจะได้ fetchpriority="high" ติดมาให้ด้วย

Developer ที่อยากคุมละเอียดกว่านั้นใช้ filter ของ WordPress ได้ เช่นบังคับไม่ให้ lazy รูปจาก class ที่กำหนด:

add_filter( 'wp_img_loading_optimization_att', function( $attr_value, $attr_name, $image ) {
    if ( 'loading' === $attr_name && false !== strpos( (string) ( $image['class'] ?? '' ), 'no-lazy' ) ) {
        return false; // ไม่ใส่ loading="lazy" ให้รูปที่มี class no-lazy
    }
    return $attr_value;
}, 10, 3 );

ถ้าใช้ cache หรือ optimization plugin อยู่แล้ว เช็คด้วยว่า plugin ไม่ไป override พฤติกรรมนี้จนกลายเป็น lazy ทุกรูป รวมถึงรูป hero

3. IntersectionObserver สำหรับ background-image

Native loading="lazy" ใช้กับ CSS background-image ไม่ได้ เพราะ background ไม่ใช่ element ที่มี attribute โหลดของตัวเอง ต้องใช้ JavaScript ผ่าน IntersectionObserver API แทน:

<div class="lazy-bg" data-bg="hero-banner.jpg"></div>
const observer = new IntersectionObserver((entries) => {
  entries.forEach((entry) => {
    if (entry.isIntersecting) {
      entry.target.style.backgroundImage =
        `url(${entry.target.dataset.bg})`;
      observer.unobserve(entry.target);
    }
  });
}, { rootMargin: '200px' }); // เผื่อระยะโหลดล่วงหน้า 200px

document.querySelectorAll('.lazy-bg').forEach((el) => observer.observe(el));

หลักการคือเก็บ URL ไว้ใน data-bg ก่อน (เบราว์เซอร์จะไม่โหลดอะไรเลย) แล้วค่อยย้ายไปใส่ background-image เมื่อ element เข้าใกล้ viewport พารามิเตอร์ rootMargin ทำหน้าที่คล้าย distance threshold ของ native คือสั่งโหลดล่วงหน้าก่อนผู้ใช้เลื่อนมาถึงตัวจริง

4. ใช้ library เมื่อไรจึงจำเป็น

Library อย่าง lazysizes หรือ vanilla-lazyload ยุคนี้มีที่ยืนเฉพาะกรณีที่ native ไม่ครอบ เช่นต้องรองรับเบราว์เซอร์เก่า ๆ จริง ๆ ต้อง lazy ทั้ง <video>, <iframe> และ background พร้อมกันด้วยระบบเดียว หรืออยากได้ LQIP (placeholder เบลอ ๆ โหลดเร็วก่อนรูปจริง) ถ้างานคือ lazy รูป <img> ธรรมดา library คือตัวเกินจำเป็น — เพิ่ม JavaScript ลงหน้าเปล่า ๆ และยิ่งเสี่ยงต่อ bug แบบ lazy ทับรูป hero

ถ้ากำลังวางระบบเว็บที่มีรูปและ media หนาแน่น เช่น ระบบสินค้า ระบบสมาชิก หรือพวก พัฒนา Web Application ตามระบบงาน การเลือกจุด lazy ให้ถูกตั้งแต่ต้นจะช่วยประหยัดงาน performance tuning รอบหลังได้เยอะ

Fetch Priority คืออะไร และช่วย LCP อย่างไร

fetchpriority คือ attribute ที่บอก “ลำดับความสำคัญ” ของ resource ให้เบราว์เซอร์รู้ว่าตัวไหนควรได้ bandwidth ก่อน ค่าที่ใช้คือ high, low และ auto โดยละไว้เท่ากับ default

ใช้งานจริงคือบนรูป hero หรือรูปที่เป็น LCP element ของหน้า:

<!-- รูป hero: ห้าม lazy, ใส่ fetchpriority="high" -->
<img
  src="hero.webp"
  alt="แบนเนอร์หลัก"
  width="1200"
  height="600"
  fetchpriority="high"
  decoding="async"
>

<!-- รูป below the fold: lazy ปกติ ไม่ต้องแตะ fetchpriority -->
<img
  src="gallery-1.jpg"
  alt="รูปที่ 1"
  width="800"
  height="600"
  loading="lazy"
>

กฎที่ต้องถือ 3 ข้อ:

  • ใส่ fetchpriority="high" ได้แค่ 1–2 รูปต่อหน้า ถ้าใส่ทุกรูป priority จะถูกกลืนหมด เท่ากับไม่ได้ช่วยอะไร
  • ห้ามใช้ fetchpriority="high" คู่กับ loading="lazy" เพราะ lazy สั่งเลื่อนการโหลดซึ่งขัดกับ high โดยตรง
  • อย่าใช้ loading="auto" เพราะค่านี้ถูกถอดออกจาก browser แล้ว

ผลของมันวัดได้จริง มีการทดสอบเปรียบเทียบรูปเดียวกันบน Slow 4G พบว่ารูปที่เป็น <img> พร้อม fetchpriority="high" ให้ LCP ประมาณ 2.0 วินาที ขณะที่รูปเดียวกันถ้าใส่ loading="lazy" LCP พุ่งไปราว 3.6 วินาที ส่วนทางฝั่ง Chrome เองรายงานว่าการ tune priority ช่วย LCP ได้ราว 30% ในบางเว็บ เช่น Google Flights นี่คือเหตุผลที่ Lighthouse ตรวจเจอ “รูป LCP ถูก lazy load” แล้วจะต้องแจ้งเตือนทุกครั้ง

Srcset กับ Lazy Load ทำงานร่วมกันยังไง

srcset กับ sizes คือระบบ responsive images ที่ให้เบราว์เซอร์เลือกไฟล์ขนาดพอดีกับหน้าจอ ทั้งสองอย่างทำงานเป็นชั้น ๆ กับ lazy load อย่างไม่ขัดแย้งกัน — เบราว์เซอร์ใช้ srcset “เลือกว่าจะโหลดไฟล์ไหน” แล้วค่อยใช้ loading attribute ตัดสิน “จะโหลดเมื่อไร”

<img
  src="photo-800.jpg"
  srcset="photo-400.jpg 400w,
          photo-800.jpg 800w,
          photo-1600.jpg 1600w"
  sizes="(max-width: 600px) 100vw, 800px"
  alt="รูปประกอบบทความ"
  width="800"
  height="500"
  loading="lazy"
>

ข้อควรรู้สองจุด: หนึ่ง ถ้าใช้ <picture> ให้ใส่ loading="lazy" ที่แท็ก <img> ลูกด้านในเท่านั้น ไม่ใช่ที่ <picture> เอง เพราะ <picture> เป็นแค่ container สอง รูปที่ lazy อยู่ใต้จอจะไม่กิน bandwidth ตอนโหลดหน้า แต่พอเลื่อนถึงก็ยังเลือกไฟล์จาก srcset ตามปกติ อีกนัยคือ lazy load ไม่ลดคุณภาพ responsive images ลงเลย ทำงานร่วมกันได้เต็ม 100%

เคล็ดลับก่อนใช้ srcset คือเตรียมไฟล์ขนาดต่าง ๆ ให้เรียบร้อย และบีบอัดทุกไฟล์ โดยใช้เครื่องมือ ย่อและครอบรูปออนไลน์ฟรี ช่วยก่อนอัปโหลดได้

ผลต่อ Google PageSpeed และ Core Web Vitals

Lazy load ที่วางถูกที่ช่วย PageSpeed ผ่าน 3 กลไก:

  • ลด bandwidth contention: รูปใต้จอไม่แย่ง bandwidth กับ CSS, font และรูป hero ตอนโหลดหน้า ทำให้ LCP ของหน้าเร็วขึ้น โดยเฉพาะเครือข่ายมือถือที่ bandwidth จำกัด
  • ลดจำนวน request ตอนเริ่ม: หน้ายาวที่มีรูป 40 รูปอาจยิงแค่ 5–10 request ตอนเปิดครั้งแรก ที่เหลือเลื่อนไปตามการใช้งานจริง
  • ประหยัด data ผู้ใช้: คนที่เปิดแล้วเลื่อนอ่านแค่ครึ่งเดียวก็ไม่ต้องจ่าย data ให้รูปครึ่งล่าง

แต่ใช้ผิดก็ทำคะแนนแย่ลงได้ ข้อผิดพลาดที่เจอบ่อยคือ:

  1. Lazy รูป hero / LCP element — รูป first viewport ที่ถูก lazy จะเริ่มโหลดช้าลงเพราะต้องรอ layout ก่อน บนมือถือค่าเฉลี่ยรูป LCP ที่ถูก lazy เริ่มดาวน์โหลดช้ากว่าประมาณ 190 มิลลิวินาที และถ้าใช้ lazy load แบบ JavaScript ที่ย้าย URL ไปเก็บใน data-src preload scanner จะมองไม่เห็นรูปเลย ผลคือ load delay ยาวขึ้นอีกหลายร้อยมิลลิวินาที
  2. Blanket lazy loading ทั้งหน้า — script ที่วน loop ใส่ loading="lazy" ให้ทุก <img> รวมถึงรูปบนจอ คือ bug คลาสสิกของ lazy load plugin บางตัว
  3. Lazy หน้าที่รูปน้อย — หน้าที่มีรูปใต้จอแค่ 2–3 รูป ประโยชน์แทบไม่มี แต่เพิ่ม complexity เข้ามาแทน

ถ้าอยากไล่ต่อในเชิงลึกว่าคะแนนหน้าเว็บมาจากอะไร อ่านต่อจากบทความ เว็บไซต์ WordPress ช้าแก้ด้วย 4 วิธีนี้ และวิธีอ่านคะแนนให้เป็นจาก คู่มือใช้ Google PageSpeed Insights ทั้งสองบทความเขียนครอบภาพรวมไว้แล้ว ส่วนบทนี้จับเฉพาะงานรูปภาพ

เช็คผลหลังใส่ Lazy Load 3 จุด

การวางโค้ดเสร็จไม่ใช่จบ ต้องยืนยันว่ามันทำงานตามที่ตั้งใจ:

  1. DevTools → Network tab: reload หน้าแล้วดูคอลัมน์ Waterfall รูปใต้จอต้องไม่โหลดตั้งแต่ตอนแรก แล้วเลื่อนลงไป รูปควรเริ่มโหลดตอนเข้าใกล้ viewport ถ้ารูปโหลดหมดตั้งแต่ต้นแปลว่า lazy ไม่ทำงาน
  2. รูป hero ยัง eager: เช็ค <img> รูปแรกใน DevTools → Elements ว่าไม่มี loading="lazy" และมี fetchpriority="high" ถ้าเว็บเป็น WordPress เช็คด้วยว่า optimization plugin ไม่ได้แอบ lazy มันทับ
  3. PageSpeed Insights: รันผลแล้วดูหัวข้อ LCP request discovery รูป LCP ต้องโดนค้นเจอจาก HTML ตั้งแต่แรก ไม่ติดคำเตือนว่าถูก lazy load และยิ่งถ้าได้คำแนะนำให้ apply fetchpriority ก็แปลว่ายังใส่ไม่ครบ

สรุปสั้น ๆ สำหรับกลับมาอ่าน: lazy load เฉพาะรูปใต้จอด้วย loading="lazy", รูป hero ใช้ fetchpriority="high" แทน, ใส่ width/height ทุกรูป แล้วเช็คซ้ำด้วย Network tab และ PageSpeed เสมอ

สรุป

Lazy load รูปภาพในปี 2026 คืองานบรรทัดเดียวด้วย native loading="lazy" โดยไม่ต้องพึ่ง JavaScript หรือ library ตัวเติมแบบเก่า สิ่งที่ต้องจริงจังกว่าคือการวางมันให้ถูกตำแหน่ง — lazy เฉพาะรูปใต้ viewport, คงรูป hero ไว้ eager พร้อม fetchpriority="high", และใช้ srcset คุมขนาดไฟล์ตามจอ ผลต่อ PageSpeed จะเห็นทาง LCP และค่า data ที่ประหยัดได้ชัดเจน เมื่อวางโครงถูกตั้งแต่ต้น

ขั้นถัดไปที่ทำได้ทันที: เปิด PageSpeed Insights วัดหน้าเว็บของคุณตอนนี้ แล้วดูว่ารูป LCP ของหน้าติดคำเตือน lazy load อยู่หรือเปล่า ถ้าติด แก้ตามโค้ดในบทความนี้แล้ววัดใหม่ใน 5 นาที

FAQ

ทำ lazy load แล้วมีผลเสียต่อ SEO ไหม

ไม่มีผลเสีย ถ้าใช้ native loading="lazy" เพราะ Googlebot ใช้ Chromium จึงเข้าใจ attribute นี้และ render รูปได้เหมือนผู้ใช้ทั่วไป ความเสี่ยงจริง ๆ อยู่ที่ lazy load แบบ JavaScript เก่าที่รูปไม่มี src จริงจน crawler มองไม่เห็น หรือใช้ lazy จนเนื้อหาโหลดเฉพาะเมื่อ scroll ซึ่งอาจทำให้บาง crawler เก็บรูปไม่ครบ

WordPress ทำ lazy load ให้อัตโนมัติจริงไหม

จริง ตั้งแต่ WordPress 5.5 รูปในเนื้อหาจะได้ loading="lazy" อัตโนมัติ และตั้งแต่ 6.1 ระบบจะงด lazy รูปแรกของเนื้อหาและใส่ fetchpriority="high" ให้รูปใหญ่รูปแรกเพื่อปกป้อง LCP ดังนั้นถ้าเว็บ WordPress ทั่วไป lazy load ถูกจัดการให้แล้ว งานที่เหลือคือตรวจว่า theme หรือ plugin ไม่ไปทับพฤติกรรมนี้

ควรใส่ lazy load กับรูปทุกรูปไหม

ไม่ควร รูปใน first viewport เช่น hero, โลโก้บนเฮดเดอร์ หรือแบนเนอร์แรก ต้องโหลดทันทีเพราะผู้ใช้เห็นมันก่อนรูปอื่น การ lazy รูปพวกนี้ทำให้ LCP ช้าลงโดยตรง กฎง่าย ๆ คือรูปที่ต้องเลื่อนลงไปจึงจะเห็น ให้ lazy ส่วนรูปที่อยู่บนจอตอนเปิดหน้า ให้ eager พร้อม fetchpriority="high" เฉพาะตัวที่สำคัญที่สุดรูปเดียว

Scroll to Top