Thep Excel

Table.Group – จัดกลุ่มและสรุปผลข้อมูล (Group By)

Table.Group จัดกลุ่มข้อมูลตามคอลัมน์ที่กำหนดและสรุปผลในแต่ละกลุ่มด้วย aggregation functions เช่น List.Sum, List.Count, List.Average คล้ายกับ GROUP BY ใน SQL แต่ทรงพลังกว่าเพราะสามารถจัดกลุ่มหลายคอลัมน์พร้อมกันและสร้างคอลัมน์สรุปผลหลายคอลัมน์ในคำสั่งเดียว รองรับ GroupKind.Local เพื่อเพิ่มประสิทธิภาพเมื่อข้อมูลเรียงลำดับแล้ว

=Table.Group(table as table, key as any, aggregatedColumns as list, optional groupKind as nullable number, optional comparer as nullable function) as table

By ThepExcel AI Agent
18 December 2025

Function Metrics


Popularity
9/10

Difficulty
6/10

Usefulness
9/10

Syntax & Arguments

=Table.Group(table as table, key as any, aggregatedColumns as list, optional groupKind as nullable number, optional comparer as nullable function) as table

Argument Type Required Default Description
table table Yes ตารางข้อมูลต้นทางที่ต้องการจัดกลุ่ม
key any Yes ชื่อคอลัมน์ที่ใช้จัดกลุ่ม สามารถเป็น text เดี่ยว (เช่น “Category”) หรือ list ของชื่อคอลัมน์ (เช่น {“Region”, “Category”}) สำหรับจัดกลุ่มหลายระดับ
aggregatedColumns list Yes รายการของคอลัมน์ที่ต้องการสร้างจากการสรุปผล แต่ละรายการเป็น list ที่มี 3 ส่วน: {“ชื่อคอลัมน์ใหม่”, each ฟังก์ชันสรุปผล, type ชนิดข้อมูล} เช่น {{“TotalSales”, each List.Sum([Sales]), type number}}
groupKind nullable number Optional GroupKind.Global ประเภทการจัดกลุ่ม ใช้ GroupKind.Local ถ้าข้อมูลเรียงลำดับตาม key columns แล้วเพื่อเพิ่มประสิทธิภาพ (Local group = กลุ่มที่เกิดจาก row ติดกัน, Global group = กลุ่มที่รวมทุก row ที่มี key เดียวกัน) ค่าเริ่มต้นคือ GroupKind.Global
comparer nullable function Optional null ฟังก์ชันสำหรับเปรียบเทียบค่า key ที่กำหนดเอง ถ้า comparer ถือว่า key ที่ต่างกันเป็นค่าเดียวกัน row นั้นอาจถูกจัดเข้ากลุ่มที่มีค่า key แตกต่างกัน

How it works

สรุปยอดขายตามสาขา

จัดกลุ่มข้อมูลการขายตามสาขาและหาผลรวมยอดขาย ค่าเฉลี่ยต่อรายการ และจำนวนรายการในแต่ละสาขา

วิเคราะห์ข้อมูลลูกค้า

นับจำนวนคำสั่งซื้อต่อลูกค้า หามูลค่ารวมและค่าเฉลี่ยต่อคำสั่งซื้อเพื่อวิเคราะห์พฤติกรรมการซื้อ

รายงานตามหมวดหมู่และระยะเวลา

จัดกลุ่มข้อมูลตามหลายมิติพร้อมกัน เช่น หมวดหมู่สินค้าและเดือน เพื่อสร้างรายงานยอดขายแบบสรุป

หาค่าสถิติต่อกลุ่ม

คำนวณค่าสูงสุด ต่ำสุด ค่าเฉลี่ย และส่วนเบี่ยงเบนมาตรฐานของข้อมูลในแต่ละกลุ่ม

Examples

ตัวอย่างที่ 1: จัดกลุ่มพื้นฐานและหาผลรวม
let Sales = Table.FromRecords({ [Category = "Electronics", Amount = 500], [Category = "Electronics", Amount = 800], [Category = "Furniture", Amount = 1200], [Ca…
จัดกลุ่มข้อมูลการขายตาม Category และใช้ List.Sum หาผลรวมของ Amount ในแต่ละกลุ่ม ผลลัพธ์จะมี 1 row สำหรับแต่ละหมวดหมู่ที่แสดงยอดรวมทั้งหมด
.
สังเกตว่า Table.Group ใช้ each keyword เพื่ออ้างถึงแต่ละกลุ่มของข้อมูล ส่วน [Amount] จะเป็น list ของค่าทั้งหมดในคอลัมน์ Amount ภายในกลุ่มนั้น นี่เป็นจุดสำคัญที่ต้องเข้าใจครับ
Power Query Formula:

let
    Sales = Table.FromRecords({
        [Category = "Electronics", Amount = 500],
        [Category = "Electronics", Amount = 800],
        [Category = "Furniture", Amount = 1200],
        [Category = "Furniture", Amount = 600]
    }),
    GroupedSales = Table.Group(
        Sales,
        "Category",
        {{"TotalAmount", each List.Sum([Amount]), type number}}
    )
in
    GroupedSales

Result:

Table with 2 rows:
- [Category="Electronics", TotalAmount=1300]
- [Category="Furniture", TotalAmount=1800]

ตัวอย่างที่ 2: สร้างหลายคอลัมน์สรุปผลพร้อมกัน
let Orders = Table.FromRecords({ [CustomerID = 1, OrderValue = 100], [CustomerID = 1, OrderValue = 150], [CustomerID = 2, OrderValue = 200], [CustomerID = 2, Or…
นี่คือจุดเด่นของ Table.Group ครับ เราสามารถสร้างคอลัมน์สรุปผลหลายคอลัมน์ในคราวเดียวได้เลย 😎
.
สังเกตว่าเราใช้ Table.RowCount(_) เพื่อนับจำนวนคำสั่งซื้อ โดย _ หมายถึง table ของกลุ่มนั้นทั้งหมด จากนั้นก็ใช้ List.Sum สำหรับผลรวม List.Average สำหรับค่าเฉลี่ย และ List.Max สำหรับค่าสูงสุด
.
การรวม aggregation functions หลายตัวแบบนี้ช่วยให้เราวิเคราะห์ข้อมูลได้ครอบคลุมในขั้นตอนเดียว ไม่ต้องมาทำทีละคอลัมน์
Power Query Formula:

let
    Orders = Table.FromRecords({
        [CustomerID = 1, OrderValue = 100],
        [CustomerID = 1, OrderValue = 150],
        [CustomerID = 2, OrderValue = 200],
        [CustomerID = 2, OrderValue = 300],
        [CustomerID = 2, OrderValue = 100]
    }),
    CustomerSummary = Table.Group(
        Orders,
        "CustomerID",
        {
            {"TotalOrders", each Table.RowCount(_), Int64.Type},
            {"TotalValue", each List.Sum([OrderValue]), type number},
            {"AverageValue", each List.Average([OrderValue]), type number},
            {"MaxValue", each List.Max([OrderValue]), type number}
        }
    )
in
    CustomerSummary

Result:

Table with 2 rows:
- [CustomerID=1, TotalOrders=2, TotalValue=250, AverageValue=125, MaxValue=150]
- [CustomerID=2, TotalOrders=3, TotalValue=600, AverageValue=200, MaxValue=300]

ตัวอย่างที่ 3: จัดกลุ่มด้วยหลายคอลัมน์พร้อมกัน
let RegionalSales = Table.FromRecords({ [Region = "North", Product = "A", Sales = 100], [Region = "North", Product = "A", Sales = 200], [Region = "North", Produ…
การจัดกลุ่มตามหลายคอลัมน์พร้อมกันเป็นเทคนิคที่ใช้บ่อยมากครับ เราแค่ใส่ list ของชื่อคอลัมน์ {"Region", "Product"} แทนที่จะใส่คอลัมน์เดียว
.
ผลลัพธ์ที่ได้จะแยกตามทั้งภูมิภาคและสินค้า ซึ่งเป็นรูปแบบ multi-dimensional grouping ที่เจอบ่อยในการวิเคราะห์ข้อมูล ส่วนตัวผมใช้เทคนิคนี้เวลาต้องทำรายงานยอดขายแยกตามหลายมิติครับ 💡
Power Query Formula:

let
    RegionalSales = Table.FromRecords({
        [Region = "North", Product = "A", Sales = 100],
        [Region = "North", Product = "A", Sales = 200],
        [Region = "North", Product = "B", Sales = 150],
        [Region = "South", Product = "A", Sales = 300],
        [Region = "South", Product = "B", Sales = 250]
    }),
    GroupedByRegionProduct = Table.Group(
        RegionalSales,
        {"Region", "Product"},
        {
            {"TotalSales", each List.Sum([Sales]), type number},
            {"TransactionCount", each List.Count([Sales]), Int64.Type}
        }
    )
in
    GroupedByRegionProduct

Result:

Table with 3 rows:
- [Region="North", Product="A", TotalSales=300, TransactionCount=2]
- [Region="North", Product="B", TotalSales=150, TransactionCount=1]
- [Region="South", Product="A", TotalSales=300, TransactionCount=1]

ตัวอย่างที่ 4: ใช้ GroupKind.Local เพื่อเพิ่มประสิทธิภาพ
let SortedData = Table.FromRecords({ [Status = "Active", Value = 100], [Status = "Active", Value = 200], [Status = "Active", Value = 150], [Status = "Inactive",…
นี่เป็น performance trick ที่หลายคนไม่รู้จักครับ 😎
.
เมื่อข้อมูลเรียงลำดับตาม key columns แล้ว (row ที่มี key เดียวกันอยู่ติดกัน) การใช้ GroupKind.Local จะช่วยเพิ่มประสิทธิภาพได้มากเพราะ Power Query ไม่ต้องสแกนทั้ง table เพื่อหา row ที่มี key เดียวกัน
.
Local group = กลุ่มที่เกิดจาก row ติดกัน
Global group (ค่าเริ่มต้น) = รวมทุก row ที่มี key เดียวกันทั้ง table ไม่ว่าจะอยู่ตำแหน่งไหน
.
ถ้าทำงานกับข้อมูลขนาดใหญ่ เทคนิคนี้ช่วยได้เยอะครับ
Power Query Formula:

let
    SortedData = Table.FromRecords({
        [Status = "Active", Value = 100],
        [Status = "Active", Value = 200],
        [Status = "Active", Value = 150],
        [Status = "Inactive", Value = 50],
        [Status = "Inactive", Value = 75]
    }),
    // ข้อมูลเรียงลำดับตาม Status แล้ว (Active ติดกันหมด, Inactive ติดกันหมด)
    GroupedWithLocal = Table.Group(
        SortedData,
        "Status",
        {{"Total", each List.Sum([Value]), type number}},
        GroupKind.Local  // ระบุว่าข้อมูลเรียงลำดับแล้ว
    )
in
    GroupedWithLocal

Result:

Table with 2 rows:
- [Status="Active", Total=450]
- [Status="Inactive", Total=125]

ตัวอย่างที่ 5: ใช้ร่วมกับ Table.SelectRows และ List.Accumulate
let TransactionData = Table.FromRecords({ [Date = #date(2024, 1, 15), Category = "A", Amount = 100], [Date = #date(2024, 1, 20), Category = "A", Amount = 200],…
ตัวอย่างนี้แสดงการผสม Table.Group กับฟังก์ชันอื่นๆ ครับ
.
ก่อนอื่นเราใช้ Table.SelectRows กรองเฉพาะข้อมูลที่ต้องการก่อนจัดกลุ่ม จากนั้นภายใน aggregatedColumns เราใช้ List.Accumulate เพื่อคำนวณ running total (ผลรวมสะสม)
.
ใน case นี้ List.Sum กับ List.Accumulate ให้ผลเหมือนกัน แต่ List.Accumulate ยืดหยุ่นกว่ามากสำหรับการคำนวณที่ซับซ้อน เช่น ผลคูณสะสม หรือการคำนวณที่ขึ้นกับค่าก่อนหน้า
.
เทคนิคนี้มีประโยชน์เวลาต้องทำ custom aggregation ที่ Power Query ไม่มีฟังก์ชันสำเร็จรูปให้ครับ 💡
Power Query Formula:

let
    TransactionData = Table.FromRecords({
        [Date = #date(2024, 1, 15), Category = "A", Amount = 100],
        [Date = #date(2024, 1, 20), Category = "A", Amount = 200],
        [Date = #date(2024, 2, 10), Category = "B", Amount = 150],
        [Date = #date(2024, 2, 25), Category = "B", Amount = 300]
    }),
    // ขั้นตอน 1: กรองเฉพาะเดือนมกราคม
    JanuaryOnly = Table.SelectRows(
        TransactionData,
        each Date.Month([Date]) = 1
    ),
    // ขั้นตอน 2: จัดกลุ่มและสรุปผล
    GroupedByCategory = Table.Group(
        JanuaryOnly,
        "Category",
        {
            {"TotalAmount", each List.Sum([Amount]), type number},
            {"RunningTotal", each List.Accumulate([Amount], 0, (state, current) => state + current), type number}
        }
    )
in
    GroupedByCategory

Result:

Table with 1 row:
- [Category="A", TotalAmount=300, RunningTotal=300]

FAQs

ความแตกต่างระหว่าง Table.Group และ Table.AggregateTableColumn คืออะไร?

คำถามนี้เจอบ่อยมากครับ เพราะทั้งสองตัวดูคล้ายกัน 😅
.
Table.Group ใช้สำหรับจัดกลุ่มข้อมูลจาก flat table และสร้างคอลัมน์สรุปผลใหม่ในขั้นตอนเดียว
.
ส่วน Table.AggregateTableColumn ใช้เมื่อมีคอลัมน์ที่เป็น nested table อยู่แล้ว และต้องการ aggregate ข้อมูลจาก nested table นั้น
.
พูดง่ายๆ คือ Table.Group สร้างการจัดกลุ่มขึ้นมาใหม่ ขณะที่ Table.AggregateTableColumn ทำงานกับโครงสร้างที่มีอยู่แล้ว

ทำไม Table.RowCount(_) ใช้ _ แทน [ColumnName]?

นี่เป็นจุดที่หลายคนงงกันครับ 😅
.
เพราะ Table.RowCount รับ table เป็น argument ไม่ใช่ list ดังนั้น _ จึงหมายถึง table ของกลุ่มนั้นทั้งหมด
.
ส่วน [ColumnName] จะให้ list ของค่าในคอลัมน์นั้น ถ้าใช้ List.Count([ColumnName]) จะนับจำนวน element ใน list ขณะที่ Table.RowCount(_) จะนับจำนวน row ทั้งหมดใน table ของกลุ่มนั้น
.
ง่ายๆ คือ _ = table, [ColumnName] = list ครับ

GroupKind.Local ควรใช้เมื่อไหร่?

ใช้ GroupKind.Local เมื่อข้อมูลเรียงลำดับตาม key columns แล้ว (row ที่มี key เดียวกันอยู่ติดกัน) จะช่วยเพิ่มประสิทธิภาพได้มากเพราะ Power Query ไม่ต้องสแกนทั้ง table
.
แต่ถ้าข้อมูลยังไม่เรียงลำดับ ต้องใช้ค่าเริ่มต้น (GroupKind.Global) หรือเรียงลำดับด้วย Table.Sort ก่อนครับ
.
ส่วนตัวผมจะเช็คก่อนเสมอว่าข้อมูลเรียงอยู่แล้วหรือเปล่า ถ้าเรียงแล้วก็ใส่ GroupKind.Local เลย เพราะช่วยได้เยอะถ้าข้อมูลเยอะ 💡

สามารถใช้ custom function ใน aggregatedColumns ได้หรือไม่?

ได้สิครับ นี่แหละที่ทำให้ Table.Group ทรงพลัง! 😎
.
คุณสามารถเขียน custom function ภายใน each ได้ เช่น:
– each List.Sum(List.Select([Amount], each _ > 100)) → หาผลรวมเฉพาะค่าที่มากกว่า 100
– each List.Accumulate(…) → คำนวณ running total หรือผลคูณสะสม
– each List.Max([Price]) – List.Min([Price]) → หาช่วงของราคา
.
เทคนิคนี้ทำให้เราวิเคราะห์ข้อมูลได้แบบ custom ตามที่ต้องการเลยครับ

ทำไมผลลัพธ์จาก Table.Group ไม่เรียงลำดับ?

เคยเจอมั้ยครับที่ group แล้วลำดับมันไม่เป็นที่? 😅
.
ตาม Microsoft Learn ระบุไว้ว่า Table.Group ไม่รับประกันว่าผลลัพธ์จะเรียงลำดับแบบใดแบบหนึ่ง
.
ถ้าต้องการให้ผลลัพธ์เรียงลำดับ ต้องใช้ Table.Sort หลังจาก Table.Group เสมอ เช่น:
Table.Sort(GroupedTable, “Category”)
.
ผมแนะนำให้ทำเป็นนิสัยเลยครับ group แล้วก็ sort ตาม เพราะไม่งั้นลำดับมันอาจไม่เป็นที่คาดหวัง

สามารถใช้ Table.Group กับข้อมูลที่มี null values ได้ไหม?

ได้ครับ แต่ต้องระวังเรื่อง null นิดนึง 💡
.
Aggregation functions บางตัวจัดการ null แตกต่างกัน:
– List.Sum และ List.Average จะข้าม null values โดยอัตโนมัติ
– List.Count นับทุกค่า รวม null ด้วย
– List.NonNullCount นับเฉพาะค่าที่ไม่ใช่ null
.
ถ้าไม่แน่ใจว่า null จะส่งผลมั้ย แนะนำให้ใช้ List.Select กรอง null ออกก่อนทำการคำนวณจะปลอดภัยกว่าครับ

Resources & Related

Additional Notes

Table.Group เป็นฟังก์ชันที่ผมใช้บ่อยที่สุดใน Power Query เลยครับ เพราะมันทรงพลังมากกก 😎

ฟังก์ชันนี้ใช้จัดกลุ่มข้อมูลตามคอลัมน์ที่กำหนด แล้วทำการสรุปผล (Aggregation) ในแต่ละกลุ่มได้พร้อมกันเลย เช่น หาผลรวมยอดขาย นับจำนวนรายการ หาค่าเฉลี่ย หรือหาค่าสูงสุด/ต่ำสุด

.

ถ้าเคยใช้ SQL ก็คล้ายๆ กับ GROUP BY นั่นแหละ แต่ที่เจ๋งกว่าคือ… Table.Group สามารถสร้างคอลัมน์สรุปผลหลายคอลัมน์ในคำสั่งเดียวได้เลย ไม่ต้องมาทำทีละ step 💡

.

วิธีทำงานก็คือ มันจะจัดกลุ่ม row ที่มีค่าเหมือนกันในคอลัมน์ที่กำหนดเข้าด้วยกัน จากนั้นสร้าง record ใหม่สำหรับแต่ละกลุ่มที่ประกอบด้วยค่าของ key columns และคอลัมน์สรุปผลที่คำนวณจากข้อมูลในกลุ่มนั้น

.

สามารถใช้ร่วมกับฟังก์ชัน aggregation อื่นๆ ได้สารพัด:

  • List.Sum สำหรับหาผลรวม
  • List.Count สำหรับนับจำนวน
  • List.Average สำหรับหาค่าเฉลี่ย
  • List.Min และ List.Max สำหรับหาค่าต่ำสุด/สูงสุด
  • Table.RowCount สำหรับนับจำนวน row ในแต่ละกลุ่ม

.

ที่สำคัญอีกอย่างคือ… ถ้าข้อมูลเรียงลำดับตาม key columns อยู่แล้ว สามารถระบุ GroupKind.Local เพื่อเพิ่มประสิทธิภาพได้เลย ส่วนตัวผมใช้เทคนิคนี้กับข้อมูลขนาดใหญ่แล้วช่วยได้เยอะครับ ⚡

Leave a Reply

Your email address will not be published. Required fields are marked *