---
title: Text.StartsWith – ตรวจสอบว่าข้อความขึ้นต้นด้วยคำที่กำหนด
url: https://www.thepexcel.com/functions/power-query/text-functions/text-startswith/
type: function-explainer
program: Power Query
syntax: "Text.StartsWith(text as nullable text, substring as text, optional comparer as nullable function) as nullable logical"
date: 2025-12-03
updated: 2025-12-23
scores:
  popularity: 7
  difficulty: 3
  usefulness: 7
---

# Text.StartsWith – ตรวจสอบว่าข้อความขึ้นต้นด้วยคำที่กำหนด

> Text.StartsWith ตรวจสอบว่าข้อความหลักขึ้นต้นด้วยข้อความย่อยที่กำหนดหรือไม่ โดยคืนค่า true หรือ false

## คำอธิบาย

Text.StartsWith ตรวจสอบว่าข้อความหลักขึ้นต้นด้วยข้อความย่อยที่กำหนดหรือไม่ โดยคืนค่า true หรือ false สามารถระบุ Comparer เพื่อเลือกว่าจะให้ตรวจสอบแบบ Case Sensitive (ไว) หรือ Case Insensitive (ไม่ไว) ได้

## Syntax

```excel
Text.StartsWith(text as nullable text, substring as text, optional comparer as nullable function) as nullable logical
```

## Arguments

| Name | Required | Type | Default | Description |
| --- | --- | --- | --- | --- |
| text | Yes | text |  | ข้อความหลักที่ต้องการตรวจสอบว่าขึ้นต้นด้วยข้อความย่อยหรือไม่ สามารถเป็น null ได้ |
| substring | Yes | text |  | ข้อความย่อยที่ต้องการตรวจสอบว่าข้อความหลักขึ้นต้นด้วยข้อความนี้หรือไม่ |
| comparer | No | function | Comparer.Ordinal | ฟังก์ชัน Comparer สำหรับการเปรียบเทียบ เช่น Comparer.Ordinal (case-sensitive) หรือ Comparer.OrdinalIgnoreCase (case-insensitive) หากไม่ระบุจะใช้ Comparer.Ordinal เป็นค่าเริ่มต้น |

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

### กรองข้อมูลตามรหัสสินค้า

เลือกเฉพาะรายการสินค้าที่รหัสขึ้นต้นด้วย "PROD" หรือ "SKU"

### จัดกลุ่มข้อมูลตามหมวดหมู่

ถ้าข้อความในคอลัมน์ขึ้นต้นด้วย "Fruits" ให้จัดอยู่ในหมวดหมู่ผลไม้

## ตัวอย่าง

### 1. ตัวอย่างที่ 1: ตรวจสอบการขึ้นต้นแบบ Case Sensitive

```excel
Text.StartsWith("Hello World", "Hello")
```

**ผลลัพธ์:** `true`

ข้อความ "Hello World" ขึ้นต้นด้วย "Hello" ตรงทุกตัว (รวมตัวพิมพ์ใหญ่ H) ดังนั้นจึงคืนค่า true
.
ส่วนตัวผมใช้ example นี้เป็นการตรวจสอบพื้นฐาน เพราะการแยกตัวพิมพ์เล็ก-ใหญ่เป็นจริงใน Power Query

### 2. ตัวอย่างที่ 2: ตรวจสอบแล้วคืนค่า false

```excel
Text.StartsWith("Hello World", "hello")
```

**ผลลัพธ์:** `false`

ข้อความ "Hello World" ไม่ได้ขึ้นต้นด้วย "hello" (ตัวพิมพ์เล็ก h) เพราะมันขึ้นต้นด้วย "Hello" (ตัวพิมพ์ใหญ่ H) ดังนั้นคืนค่า false
.
นี่คือสาเหตุทั่วไปของเหตุการณ์ที่ unexpected ครับ เพราะบางคนลืมว่า Power Query เป็น case-sensitive 😅

### 3. ตัวอย่างที่ 3: ใช้ Comparer.OrdinalIgnoreCase สำหรับ Case Insensitive

```excel
Text.StartsWith("Apple Pie", "apple", Comparer.OrdinalIgnoreCase)
```

**ผลลัพธ์:** `true`

ด้วยการใช้ Comparer.OrdinalIgnoreCase ฟังก์ชันจะไม่สนใจความแตกต่างของตัวพิมพ์เล็ก-ใหญ่ ดังนั้น "Apple Pie" ถือว่าขึ้นต้นด้วย "apple" จึงคืนค่า true
.
ที่ต้องระวังคือ Comparer.OrdinalIgnoreCase จะทำการเปรียบเทียบแบบ ordinal (ตามลำดับไบต์) ไม่ใช่ culturally aware ถ้าต้องการ culture-aware comparison ให้ใช้ Comparer.FromCulture("th-TH") แทน

### 4. ตัวอย่างที่ 4: ใช้ในตาราง Power Query เพื่อกรองข้อมูล

```excel
let
    Products = Table.FromRecords({
        [ProductCode = "PROD-001", ProductName = "Apple"],
        [ProductCode = "PROD-002", ProductName = "Banana"],
        [ProductCode = "SERV-001", ProductName = "Consulting"],
        [ProductCode = "PROD-003", ProductName = "Cherry"]
    }),
    OnlyProductCodes = Table.SelectRows(
        Products,
        each Text.StartsWith([ProductCode], "PROD-")
    )
in
    OnlyProductCodes
```

**ผลลัพธ์:** `Table with 3 rows:
[ProductCode="PROD-001", ProductName="Apple"]
[ProductCode="PROD-002", ProductName="Banana"]
[ProductCode="PROD-003", ProductName="Cherry"]`

ตัวอย่างนี้แสดงการใช้ Text.StartsWith ร่วมกับ Table.SelectRows ในสถานการณ์จริง โดยสร้างตาราง Products แล้วกรองเฉพาะสินค้าที่มีรหัส (ProductCode) ขึ้นต้นด้วย "PROD-"
.
โดยใช้เงื่อนไข each Text.StartsWith([ProductCode], "PROD-") ซึ่ง 'each' วนลูปตรวจสอบทุกแถว และ [ProductCode] คือการอ้างอิงคอลัมน์ ProductCode ในแถวปัจจุบัน
.
ผลลัพธ์จะได้เฉพาะแถวสินค้า 3 รายการ (PROD-001, PROD-002, PROD-003) ส่วน SERV-001 ถูกกรองออก เพราะมันขึ้นต้นด้วย "SERV-" ไม่ใช่ "PROD-" ส่วนตัวผมชอบใช้ pattern นี้มากครับ เพราะทำให้โค้ด readable และ maintainable ได้ดี 💡

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

- 💡 **Tip 1**: Text.StartsWith เป็นฟังก์ชันที่ใช้บ่อยในการกรองข้อมูลตามรูปแบบรหัส (code pattern) เช่นการกรองสินค้า ลูกค้า หรือหมวดหมู่ตามตัวอักษรแรก ส่วนตัวผมมักใช้มันคู่กับ Table.SelectRows เพื่อสร้าง filter condition ที่อ่านง่ายและ maintainable ได้

- .

- 💡 **Tip 2**: ถ้าต้องการตรวจสอบหลายรูปแบบขึ้นต้น เช่นกรองข้อมูลที่ขึ้นต้นด้วย "PROD-" หรือ "SERV-" สามารถใช้ 'or' ได้ดังนี้ each Text.StartsWith([Code], "PROD-") or Text.StartsWith([Code], "SERV-") หรือเขียนแบบสั้นๆ ได้ด้วยการ refactor เป็นเงื่อนไขที่ซับซ้อนมากขึ้น

- .

- 💡 **Tip 3**: เมื่อทำการ filter บน data source ที่มีขนาดใหญ่ ใช้ Text.StartsWith คู่กับ Table.SelectRows มักสามารถ leverage Query Folding ได้ บางครั้ง ขึ้นอยู่กับ data source ว่าสนับสนุนหรือไม่ ช่วยให้ประสิทธิภาพดีขึ้นอย่างมาก 😎

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

**Q: Text.StartsWith เป็น Case Sensitive โดยค่าเริ่มต้นหรือไม่?**

ใช่ครับ เป็น Case Sensitive เมื่อไม่ระบุ Comparer parameter ดังนั้น Text.StartsWith("Apple", "apple") จะคืนค่า false เพราะมันขึ้นต้นด้วย "A" ตัวพิมพ์ใหญ่ ไม่ใช่ "a" ตัวพิมพ์เล็ก
.
ถ้าต้องการให้ case-insensitive ต้องเพิ่มพารามิเตอร์ที่สามดังนี้ Text.StartsWith("Apple", "apple", Comparer.OrdinalIgnoreCase) หรือสามารถแปลงข้อความก่อนเปรียบเทียบได้เช่น Text.StartsWith(Text.Lower("Apple"), Text.Lower("apple")) ครับ

**Q: ต่างจาก Text.Contains อย่างไร?**

Text.StartsWith ตรวจสอบเฉพาะว่าข้อความขึ้นต้นด้วยข้อความย่อยที่กำหนดหรือไม่ ส่วน Text.Contains ตรวจสอบว่าข้อความใดจะมีข้อความย่อยนั้นอยู่ที่ไหนก็ได้ (ต้น กลาง ท้าย)
.
เช่น Text.StartsWith("Hello World", "World") จะคืนค่า false เพราะ "World" ไม่ได้อยู่ที่ต้น แต่ Text.Contains("Hello World", "World") จะคืนค่า true เพราะ "World" อยู่ในข้อความ 😎

**Q: ถ้า text parameter เป็น null จะคืนค่าอะไร?**

ถ้า text parameter (ตัวแรก) เป็น null ฟังก์ชันจะคืนค่า null โดยไม่คืนค่า true หรือ false
.
ดังนั้นถ้าต้องการตรวจสอบและจัดการกรณี null ต้องเขียนเงื่อนไขพิเศษ เช่น each [Column]  null and Text.StartsWith([Column], "Prefix") เพื่อให้แน่ใจว่า [Column] ไม่เป็น null ก่อนทำการเปรียบเทียบ

**Q: Comparer.OrdinalIgnoreCase กับ Comparer.FromCulture ต่างกันอย่างไร?**

Comparer.OrdinalIgnoreCase ทำการเปรียบเทียบแบบ ordinal (ตามลำดับไบต์) โดยไม่สนใจตัวพิมพ์เล็ก-ใหญ่ แต่ไม่ได้พิจารณา cultural differences
.
ส่วน Comparer.FromCulture("th-TH") ทำการเปรียบเทียบแบบ culture-aware ซึ่งอาจให้ผลลัพธ์ต่างกันเมื่อจัดการกับภาษาอื่น เช่น ภาษาไทย ส่วนตัวผมแนะนำให้ใช้ Comparer.OrdinalIgnoreCase สำหรับการเปรียบเทียบทั่วไป และ Comparer.FromCulture เมื่อต้องจัดการข้อมูลที่มีความสำคัญทางวัฒนธรรม 💡

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

- [Microsoft Learn: Text.StartsWith official documentation](https://learn.microsoft.com/en-us/powerquery-m/text-startswith) _(official)_
- [Microsoft Learn: Text functions in Power Query M](https://learn.microsoft.com/en-us/powerquery-m/text-functions) _(official)_
- [Microsoft Learn: Comparer functions and case sensitivity](https://learn.microsoft.com/en-us/powerquery-m/comparer-ordinal) _(official)_
- [PowerQuery.how: Text.StartsWith guide and examples](https://powerquery.how/text-startswith/) _(article)_

---

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