---
title: Table.Group – จัดกลุ่มและสรุปผลข้อมูล (Group By)
url: https://www.thepexcel.com/functions/power-query/table-functions/table-group/
type: function-explainer
program: Power Query
syntax: "Table.Group(table as table, key as any, aggregatedColumns as list, optional groupKind as nullable number, optional comparer as nullable function) as table"
date: 2025-12-18
scores:
  popularity: 9
  difficulty: 6
  usefulness: 9
---

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

> จัดกลุ่มข้อมูลและสรุปผลด้วย aggregation functions (Group By)

## คำอธิบาย

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

## Syntax

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

**Variant**

```excel
Table.Group(table, key, aggregatedColumns)
```

รูปแบบพื้นฐาน จัดกลุ่มด้วย key เดียวหรือหลาย key พร้อมสร้างคอลัมน์สรุปผล

**Variant**

```excel
Table.Group(table, key, aggregatedColumns, groupKind)
```

ระบุ GroupKind.Local เพื่อเพิ่มประสิทธิภาพเมื่อข้อมูลเรียงลำดับตาม key แล้ว

**Variant**

```excel
Table.Group(table, key, aggregatedColumns, groupKind, comparer)
```

ระบุ comparer function สำหรับควบคุมการเปรียบเทียบค่า key ที่กำหนดเอง

## Arguments

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

## เคสการใช้งาน

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

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

_เหมาะกับ:_ data-summarization

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

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

_เหมาะกับ:_ customer-analytics

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

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

_เหมาะกับ:_ multi-dimensional-reporting

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

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

_เหมาะกับ:_ statistical-analysis

## ตัวอย่าง

### 1. ตัวอย่างที่ 1: จัดกลุ่มพื้นฐานและหาผลรวม

```excel
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
```

**ผลลัพธ์:** `Table with 2 rows:
- [Category="Electronics", TotalAmount=1300]
- [Category="Furniture", TotalAmount=1800]`

จัดกลุ่มข้อมูลการขายตาม Category และใช้ List.Sum หาผลรวมของ Amount ในแต่ละกลุ่ม ผลลัพธ์จะมี 1 row สำหรับแต่ละหมวดหมู่ที่แสดงยอดรวมทั้งหมด
.
สังเกตว่า Table.Group ใช้ each keyword เพื่ออ้างถึงแต่ละกลุ่มของข้อมูล ส่วน [Amount] จะเป็น list ของค่าทั้งหมดในคอลัมน์ Amount ภายในกลุ่มนั้น นี่เป็นจุดสำคัญที่ต้องเข้าใจครับ

### 2. ตัวอย่างที่ 2: สร้างหลายคอลัมน์สรุปผลพร้อมกัน

```excel
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
```

**ผลลัพธ์:** `Table with 2 rows:
- [CustomerID=1, TotalOrders=2, TotalValue=250, AverageValue=125, MaxValue=150]
- [CustomerID=2, TotalOrders=3, TotalValue=600, AverageValue=200, MaxValue=300]`

นี่คือจุดเด่นของ Table.Group ครับ เราสามารถสร้างคอลัมน์สรุปผลหลายคอลัมน์ในคราวเดียวได้เลย 😎
.
สังเกตว่าเราใช้ Table.RowCount(_) เพื่อนับจำนวนคำสั่งซื้อ โดย _ หมายถึง table ของกลุ่มนั้นทั้งหมด จากนั้นก็ใช้ List.Sum สำหรับผลรวม List.Average สำหรับค่าเฉลี่ย และ List.Max สำหรับค่าสูงสุด
.
การรวม aggregation functions หลายตัวแบบนี้ช่วยให้เราวิเคราะห์ข้อมูลได้ครอบคลุมในขั้นตอนเดียว ไม่ต้องมาทำทีละคอลัมน์

### 3. ตัวอย่างที่ 3: จัดกลุ่มด้วยหลายคอลัมน์พร้อมกัน

```excel
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
```

**ผลลัพธ์:** `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]`

การจัดกลุ่มตามหลายคอลัมน์พร้อมกันเป็นเทคนิคที่ใช้บ่อยมากครับ เราแค่ใส่ list ของชื่อคอลัมน์ {"Region", "Product"} แทนที่จะใส่คอลัมน์เดียว
.
ผลลัพธ์ที่ได้จะแยกตามทั้งภูมิภาคและสินค้า ซึ่งเป็นรูปแบบ multi-dimensional grouping ที่เจอบ่อยในการวิเคราะห์ข้อมูล ส่วนตัวผมใช้เทคนิคนี้เวลาต้องทำรายงานยอดขายแยกตามหลายมิติครับ 💡

### 4. ตัวอย่างที่ 4: ใช้ GroupKind.Local เพื่อเพิ่มประสิทธิภาพ

```excel
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
```

**ผลลัพธ์:** `Table with 2 rows:
- [Status="Active", Total=450]
- [Status="Inactive", Total=125]`

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

### 5. ตัวอย่างที่ 5: ใช้ร่วมกับ Table.SelectRows และ List.Accumulate

```excel
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
```

**ผลลัพธ์:** `Table with 1 row:
- [Category="A", TotalAmount=300, RunningTotal=300]`

ตัวอย่างนี้แสดงการผสม Table.Group กับฟังก์ชันอื่นๆ ครับ
.
ก่อนอื่นเราใช้ Table.SelectRows กรองเฉพาะข้อมูลที่ต้องการก่อนจัดกลุ่ม จากนั้นภายใน aggregatedColumns เราใช้ List.Accumulate เพื่อคำนวณ running total (ผลรวมสะสม)
.
ใน case นี้ List.Sum กับ List.Accumulate ให้ผลเหมือนกัน แต่ List.Accumulate ยืดหยุ่นกว่ามากสำหรับการคำนวณที่ซับซ้อน เช่น ผลคูณสะสม หรือการคำนวณที่ขึ้นกับค่าก่อนหน้า
.
เทคนิคนี้มีประโยชน์เวลาต้องทำ custom aggregation ที่ Power Query ไม่มีฟังก์ชันสำเร็จรูปให้ครับ 💡

## หมายเหตุเพิ่มเติม

💡 **Tip**: Table.Group เป็นหนึ่งในฟังก์ชันที่ผมใช้บ่อยที่สุดใน Power Query เลยครับ เพราะมันทรงพลังมาก สามารถจัดกลุ่มและสรุปผลได้ในขั้นตอนเดียว
.
**จุดสำคัญที่ต้องเข้าใจ:** each keyword ใน aggregatedColumns หมายถึง "แต่ละกลุ่ม" ของข้อมูล ไม่ใช่ "แต่ละ row" ดังนั้น [ColumnName] จะเป็น list ของค่าทั้งหมดในคอลัมน์นั้นสำหรับกลุ่มนั้น ถ้าเข้าใจจุดนี้ จะทำให้เราเขียน aggregation ได้คล่องขึ้นเยอะ 😎
.
**Performance Trick:** ถ้าข้อมูลเรียงลำดับตาม key columns อยู่แล้ว ใส่ GroupKind.Local จะช่วยเพิ่มประสิทธิภาพได้มาก โดยเฉพาะกับชุดข้อมูลขนาดใหญ่ ส่วนตัวผมจะเช็คก่อนเสมอว่าข้อมูลเรียงอยู่แล้วหรือเปล่า
.
**เทคนิคที่ใช้บ่อย:**
- ผสมกับ Table.SelectRows เพื่อกรองข้อมูลก่อนจัดกลุ่ม
- ตามด้วย Table.Sort เพื่อเรียงลำดับผลลัพธ์ (เพราะ Table.Group ไม่รับประกันลำดับ)
- ใช้ custom function ภายใน each เพื่อทำ aggregation แบบ advanced เช่น conditional sum หรือ running total
.
ลองเอาไปใช้ดูครับ แล้วจะรู้ว่าทำไมฟังก์ชันนี้ถึงเป็น must-have ใน Power Query! 💪

## คำถามที่พบบ่อย

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

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

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

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

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

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

**Q: สามารถใช้ 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 ตามที่ต้องการเลยครับ

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

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

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

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

## ฟังก์ชันที่เกี่ยวข้อง

- [List.Sum – รวมค่าตัวเลขในรายการ](https://www.thepexcel.com/functions/power-query/list-functions/list-sum/)
- [List.Count – นับจำนวนรายการในลิสต์](https://www.thepexcel.com/functions/power-query/list-functions/list-count/)
- [List.Average – คำนวณค่าเฉลี่ยของรายการ](https://www.thepexcel.com/functions/power-query/list-functions/list-average/)
- [List.Max – หาค่าสูงสุดจากรายการ](https://www.thepexcel.com/functions/power-query/list-functions/list-max/)
- [List.Min – หาค่าต่ำสุดในลิสต์](https://www.thepexcel.com/functions/power-query/list-functions/list-min/)
- [Table.AggregateTableColumn – สรุปผลคอลัมน์ Table ย่อย](https://www.thepexcel.com/?post_type=function-explainer&p=37937)
- [Table.Distinct – ลบแถวที่ซ้ำกันออกจากตาราง](https://www.thepexcel.com/functions/power-query/table-functions/table-distinct/)
- [Table.RowCount – นับจำนวนแถวในตาราง](https://www.thepexcel.com/functions/power-query/table-functions/table-rowcount/)
- [Table.SelectRows – กรองแถวตามเงื่อนไขใน Power Query](https://www.thepexcel.com/functions/power-query/table-functions/table-selectrows/)
- [Table.Sort – เรียงลำดับข้อมูลในตาราง](https://www.thepexcel.com/functions/power-query/table-functions/table-sort/)
- [List.Accumulate – วนลูปสะสมค่าด้วย Accumulator Pattern](https://www.thepexcel.com/functions/power-query/list-functions/list-accumulate/)
- [List.Select – เลือกสมาชิกจาก List ตามเงื่อนไข](https://www.thepexcel.com/functions/power-query/list-functions/list-select/)

## แหล่งข้อมูลเพิ่มเติม

- [Microsoft Learn: Table.Group function](https://learn.microsoft.com/en-us/powerquery-m/table-group) _(documentation)_
- [PowerQuery.how: Table.Group - Table Function](https://powerquery.how/table-group/) _(guide)_
- [Microsoft Learn: Power Query M formula language - Group By](https://learn.microsoft.com/en-us/power-query/group-by) _(documentation)_
- [ExcelDemy: How to Aggregate & Summarize with Table.Group](https://www.exceldemy.com/how-to-aggregate-summarize-with-table-group-power-query-m-language/) _(tutorial)_

---

_Source: [https://www.thepexcel.com/functions/power-query/table-functions/table-group/](https://www.thepexcel.com/functions/power-query/table-functions/table-group/)_
