---
title: trim – ลบ whitespace หน้าและหลังข้อความ
url: https://www.thepexcel.com/functions/n8n/string-functions/trim-n8n/
type: function-explainer
program: n8n
syntax: string.trim()
date: 2025-12-18
scores:
  popularity: 9
  difficulty: 1
  usefulness: 9
---

# trim – ลบ whitespace หน้าและหลังข้อความ

> ลบ whitespace หน้าและหลังข้อความ

## คำอธิบาย

trim() เป็น JavaScript string method มาตรฐานที่ใช้ได้ใน n8n สำหรับลบ whitespace characters ทั้งหมดออกจากต้นและท้ายข้อความ รวมถึงช่องว่างธรรมดา tab newline carriage return และ whitespace characters อื่นๆ ตามมาตรฐาน Unicode โดยช่องว่างตรงกลางข้อความจะไม่ถูกลบออก มีเฉพาะหน้าและหลังเท่านั้น

## Syntax

```excel
string.trim()
```

**Variant**

```excel
$json.text.trim()
```

ลบ whitespace จากข้อมูล $json field

**Variant**

```excel
$json.items.map(item => item.name.trim())
```

ลบ whitespace จาก array ทั้งหมดด้วย map()

**Variant**

```excel
$json.email.trim().toLowerCase()
```

Chain กับ toLowerCase() เพื่อทำความสะอาดข้อมูลครบวงจร

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

### ทำความสะอาดข้อมูลจากฟอร์ม

ลบช่องว่างหน้า-หลังที่ผู้ใช้พิมพ์ผิดในฟอร์ม input เช่น username, email, หมายเลขโทรศัพท์

_เหมาะกับ:_ form-input-cleaning

### ปรับข้อมูล CSV และ Excel

ลบช่องว่างส่วนเกินจากข้อมูลที่ import จาก CSV หรือ Excel ก่อนนำไปใช้

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

### Validate และทำความสะอาด credentials

ป้องกันปัญหาจากช่องว่างหน้า-หลังในอีเมล, username, หรือ API keys ก่อน authentication

_เหมาะกับ:_ credential-sanitization

### ปรับข้อมูลจาก webhook และ API

ทำความสะอาดข้อมูลจาก external APIs ที่อาจส่งมาพร้อม whitespace ที่ไม่ต้องการ

_เหมาะกับ:_ api-response-cleaning

## ตัวอย่าง

### 1. ตัวอย่างที่ 1: ลบ whitespace พื้นฐาน

```excel
{{ '  Hello World  '.trim() }}
```

**ผลลัพธ์:** `Hello World`

ลบช่องว่างทั้งสองตัวที่อยู่หน้าข้อความและสองตัวที่อยู่หลังข้อความออกไป เหลือเฉพาะข้อความสะอาดคือ 'Hello World'
.
สังเกตว่าช่องว่างตรงกลางระหว่างคำว่า Hello กับ World จะไม่ถูกลบออกไปนะครับ 👌
.
**วิธีการทำงาน:**
1. ข้อมูลต้นฉบับ: '  Hello World  ' มีช่องว่างรวมสี่ตัว
2. method trim() ลบ whitespace ออกจากหน้าและหลัง
3. ผลลัพธ์: 'Hello World' โดยช่องว่างตรงกลางยังคงอยู่

### 2. ตัวอย่างที่ 2: ทำความสะอาดข้อมูลฟอร์ม

```excel
{{ $json.username.trim() }}
```

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

สมมติว่าข้อมูลที่ได้รับคือ $json.username มีค่าเป็น '  john_doe  ' ซึ่งเป็นกรณีที่ผู้ใช้พิมพ์ชื่อผู้ใช้โดยมีช่องว่างหน้าและหลังติดมาด้วย
.
**ข้อมูลต้นฉบับจากฟอร์ม:** '  john_doe  '
**ผลลัพธ์หลังใช้ trim():** 'john_doe'
.
**การใช้งานใน n8n Workflow:**
1. Webhook node รับข้อมูลจากฟอร์ม
2. Code/Set node ทำความสะอาดด้วย {{ $json.username.trim() }}
3. ส่งข้อมูลสะอาดไปยัง database หรือ API
.
**ช่วยป้องกันปัญหาเหล่านี้:**
- Query ฐานข้อมูลล้มเหลวเพราะช่องว่างไม่ตรงกัน 😭
- Authentication ผิดพลาดเพราะ username ไม่match
- Records ซ้ำใน database เพราะ whitespace ต่างกัน

### 3. ตัวอย่างที่ 3: ลบ tab และ newline

```excel
{{ $json.description.trim() }}
```

**ผลลัพธ์:** `Product description`

สมมติว่าข้อมูลที่ได้รับคือ $json.description มีค่าเป็น '
\tProduct description

'
.
**ข้อมูลต้นฉบับ:** '
\tProduct description

'
- 
 หมายถึง newline (ขึ้นบรรทัดใหม่)
- \t หมายถึง tab (เว้นวรรค)
.
**ผลลัพธ์หลัง trim():** 'Product description'
.
**ประเภท whitespace ที่ trim() ลบได้:**
✅ ช่องว่างธรรมดา (Space)
✅ การเว้นวรรค (Tab)
✅ ขึ้นบรรทัดใหม่ (Newline)
✅ กลับหัวบรรทัด (Carriage return)
✅ ตัวอักษรช่องว่าง Unicode อื่นๆ
.
**เจอบ่อยกับข้อมูลจาก:**
- ฟอร์ม Textarea ที่มีการขึ้นบรรทัด
- ไฟล์ CSV ที่มี tabs คั่นข้อมูล
- Copy-paste ข้อความจากเอกสาร

### 4. ตัวอย่างที่ 4: ทำความสะอาด array ด้วย map()

```excel
{{ $json.tags.map(tag => tag.trim()) }}
```

**ผลลัพธ์:** `["javascript", "nodejs", "n8n"]`

สมมติว่าข้อมูลที่ได้รับคือ $json.tags มีค่าเป็น [' javascript ', '  nodejs', 'n8n  ']
.
**ข้อมูล array ต้นฉบับ:**
[
  ' javascript ',  // มีช่องว่างทั้งหน้าและหลัง
  '  nodejs',       // มีช่องว่างหน้า
  'n8n  '          // มีช่องว่างหลัง
]
.
**ผลลัพธ์หลังใช้ map(tag => tag.trim()):**
['javascript', 'nodejs', 'n8n']
.
**ขั้นตอนการทำงาน:**
1. map() วนลูปผ่านแต่ละ element ใน array
2. Arrow function (tag => tag.trim()) ลบ whitespace จากแต่ละตัว
3. ได้ array ใหม่ที่สะอาดพร้อมใช้งาน ✨
.
**ใช้ได้กับ:**
- Tags จาก form input
- Columns ของไฟล์ CSV
- Multi-select dropdowns

### 5. ตัวอย่างที่ 5: Chain กับ toLowerCase() เพื่อ normalize ข้อมูล

```excel
{{ $json.email.trim().toLowerCase() }}
```

**ผลลัพธ์:** `user@example.com`

สมมติว่าข้อมูลที่ได้รับคือ $json.email มีค่าเป็น '  User@Example.COM  '
.
**ลำดับขั้นตอนการทำงาน:**
1. ข้อมูลต้นฉบับ: '  User@Example.COM  '
2. .trim() → ลบช่องว่าง → 'User@Example.COM'
3. .toLowerCase() → แปลงเป็นตัวเล็ก → 'user@example.com'
.
**กรณีที่เหมาะสม:**
✅ Normalize email ก่อนบันทึกลง database
✅ เปรียบเทียบอีเมลโดยไม่สนใจตัวพิมพ์ใหญ่เล็ก
✅ ป้องกัน duplicate accounts (User@Example.com ≠ user@example.com)
.
**ตัวอย่าง n8n Workflow:**
```
Webhook node (รับ form data)
  ↓
Code/Set node:
  email: {{ $json.email.trim().toLowerCase() }}
  ↓
HTTP Request node (บันทึกลง database)
```
.
**Best Practice:** ควรใช้ .trim().toLowerCase() ร่วมกันเสมอสำหรับ:
- Email addresses
- Usernames
- API keys
- Search queries
.
ส่วนตัวผมแนะนำให้ทำ normalization แบบนี้ทุกครั้งที่รับข้อมูลจาก user นะครับ 😎

### 6. ตัวอย่างที่ 6: ใช้กับ conditional เพื่อ validate input

```excel
{{ $json.name.trim() === '' ? 'Name is required' : $json.name.trim() }}
```

**ผลลัพธ์:** `John Smith หรือ 'Name is required'`

สมมติว่าข้อมูลที่ได้รับคือ $json.name มีค่าเป็น '   ' ซึ่งเป็นเพียงแค่ช่องว่างเท่านั้น
.
**การใช้งาน Ternary operator:**
```
$json.name.trim() === ''
  ? 'Name is required'    // ถ้าว่างหลัง trim
  : $json.name.trim()     // ถ้ามีข้อมูลจริง
```
.
**กรณีทดสอบ:**
- Input: '   ' (เฉพาะช่องว่าง)
  → หลัง trim() ได้ '' → ผลลัพธ์: 'Name is required'

- Input: '  John Smith  '
  → หลัง trim() ได้ 'John Smith' → ผลลัพธ์: 'John Smith'

- Input: '' (string ว่าง)
  → หลัง trim() ได้ '' → ผลลัพธ์: 'Name is required'
.
**ใช้ใน IF Node:**
```
{{ $json.name.trim().length > 0 }}
```
- true → มีข้อมูล → Success path
- false → ว่างเปล่า → Error path
.
**ช่วยป้องกันปัญหา:**
❌ User ส่งเฉพาะช่องว่างมาโดยไม่มีข้อมูลจริง
❌ Empty form submissions
❌ Invalid form data
.
เคยเจอมั้ยครับว่า user กด space bar แล้วกด submit... แล้ว form ก็ผ่าน validation ไปเฉยๆ 😅

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

💡 **Tips จากประสบการณ์:**
.
ส่วนตัวผมจะใส่ trim() ทุกครั้งที่รับข้อมูลจาก webhook หรือ form input เลยครับ เพราะเคยโดน bug จากช่องว่างที่มองไม่เห็นมาหลายครั้ง 😅
.
**Best Practices ที่ใช้จริง:**

1️⃣ **ใช้ร่วมกับ toLowerCase()** สำหรับ email/username:
```
{{ $json.email.trim().toLowerCase() }}
```
ป้องกันการสร้าง duplicate accounts
.
2️⃣ **Validate หลัง trim** เพื่อป้องกัน empty input:
```
{{ $json.name.trim().length > 0 }}
```
ถ้าไม่ทำแบบนี้ user สามารถส่งแค่ช่องว่างมาได้
.
3️⃣ **Clean array ทั้งก้อนด้วย map()**:
```
{{ $json.tags.map(t => t.trim()) }}
```
ใช้กับ tags, categories, หรือ multi-select values
.
4️⃣ **Chain หลาย methods** สำหรับ data normalization:
```
{{ $json.input.trim().replace(/\s+/g, ' ').toLowerCase() }}
```
ทำความสะอาดครบวงจร
.
⚠️ **Common Mistakes ที่เจอบ่อย:**

❌ ลืม trim ก่อน validation → user ส่งช่องว่างผ่าน
✅ {{ $json.name.trim() !== '' }}
.
❌ เปรียบเทียบโดยไม่ trim → 'admin' ≠ ' admin '
✅ {{ $json.role.trim() === 'admin' }}
.
❌ ลืม normalize email → duplicate accounts
✅ {{ $json.email.trim().toLowerCase() }}
.
🔧 **n8n Workflow Pattern ที่แนะนำ:**
```
Webhook node
  ↓
Code/Set node (ทำความสะอาดทันที)
  username: {{ $json.username.trim() }}
  email: {{ $json.email.trim().toLowerCase() }}
  ↓
IF node (validate ว่าไม่ว่าง)
  {{ $json.username.trim().length > 0 }}
  ↓
HTTP Request (ส่งข้อมูลสะอาดไปยัง API)
```
.
Pattern นี้ทำให้มั่นใจได้ว่าข้อมูลที่เข้า database จะสะอาดเสมอครับ 😎

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

**Q: trim() ลบ whitespace ประเภทไหนบ้าง?**

trim() ลบ whitespace ได้ทุกประเภทออกจากหน้าและท้ายข้อความครับ:
.
✅ **ที่ลบได้:**
- ช่องว่างธรรมดา (Space)
- การเว้นวรรค (Tab)
- ขึ้นบรรทัดใหม่ (Newline)
- กลับหัวบรรทัด (Carriage return)
- เลื่อนหน้ากระดาษ (Form feed)
- เว้นวรรคแนวตั้ง (Vertical tab)
- ตัวอักษรช่องว่าง Unicode ทั้งหมด
.
❌ **ที่ไม่ลบ:** ช่องว่างตรงกลางข้อความ
.
**ตัวอย่าง:**
```
'  Hello  World  '.trim()
→ 'Hello  World' (ช่องว่าง 2 ตัวตรงกลางยังอยู่)

'
\tText\r
'.trim()
→ 'Text' (tab, newline, carriage return หายหมด)
```

**Q: trim(), trimStart(), และ trimEnd() ต่างกันอย่างไร?**

แต่ละ method ลบ whitespace คนละตำแหน่งกันครับ:
.
**trim()** - ลบทั้งหน้าและหลัง
```
'  text  '.trim() → 'text'
```
.
**trimStart()** (alias: trimLeft()) - ลบเฉพาะหน้า
```
'  text  '.trimStart() → 'text  '
```
.
**trimEnd()** (alias: trimRight()) - ลบเฉพาะหลัง
```
'  text  '.trimEnd() → '  text'
```
.
**เลือกใช้ตามกรณี:**
- Form input → ใช้ trim() (ลบทั้งสองด้าน)
- Text formatting → ใช้ trimStart()/trimEnd()
- CSV parsing → ใช้ trim() (ป้องกันช่องว่างจากทั้งสองด้าน)
.
ส่วนใหญ่ผมจะใช้ trim() ธรรมดาเลยครับ เพราะปลอดภัยที่สุด 😎

**Q: trim() จะทำอะไรกับช่องว่างตรงกลาง?**

trim() จะไม่ลบช่องว่างตรงกลางข้อความครับ ลบแค่หน้าและหลังเท่านั้น
.
**ตัวอย่าง:**
```
'Hello  World'.trim() → 'Hello  World' (ช่องว่าง 2 ตัวตรงกลางยังอยู่)
'  First  Last  '.trim() → 'First  Last' (ช่องว่างตรงกลางไม่ถูกลบ)
```
.
**ถ้าต้องการลบช่องว่างตรงกลางด้วย:**
```javascript
{{ $json.text.trim().replace(/\s+/g, ' ') }}
```
.
**ขั้นตอน:**
1. trim() → ลบช่องว่างหน้าและหลัง
2. replace(/\s+/g, ' ') → แทนที่ช่องว่างหลายตัวด้วยช่องว่างเดียว
.
**ผลลัพธ์:**
```
'  Hello    World  '.trim().replace(/\s+/g, ' ')
→ 'Hello World' (เหลือช่องว่างตัวเดียว)
```
.
เทคนิคนี้ใช้ได้ดีมากเวลาทำความสะอาดข้อมูลจาก CSV หรือ textarea ครับ 💡

**Q: trim() ใช้งานใน n8n Workflow อย่างไร?**

trim() ใช้ใน n8n expressions ได้หลาย nodes ครับ:
.
**1. Code Node / Set node**
```
{{ $json.username.trim() }}
{{ $json.email.trim().toLowerCase() }}
```
.
**2. IF Node (Conditional)**
```
{{ $json.name.trim().length > 0 }}
{{ $json.input.trim() === 'admin' }}
```
.
**3. Function Node (JavaScript)**
```javascript
const cleanedData = items.map(item => ({
  ...item,
  name: item.json.name.trim(),
  email: item.json.email.trim().toLowerCase()
}));
return cleanedData;
```
.
**4. HTTP Request Node (Query parameters)**
```
Query: search={{ $json.query.trim() }}
```
.
**Common Patterns:**
- Form validation: เช็คว่า input ไม่ว่างหลัง trim
- Data cleaning: ทำความสะอาดก่อนส่ง API
- Array processing: ใช้ map() clean ทุก element
.
ส่วนตัวผมจะใส่ trim() ทุกครั้งที่รับข้อมูลจาก webhook เลยครับ ป้องกันปัญหาจากช่องว่างที่มองไม่เห็น 😎

**Q: trim() return ค่าประเภทอะไร?**

trim() return string ใหม่เสมอครับ ไม่แก้ไข string เดิม (immutable)
.
**ตัวอย่าง JavaScript:**
```javascript
const original = '  text  ';
const cleaned = original.trim();

console.log(original); // '  text  ' (ไม่เปลี่ยน)
console.log(cleaned);  // 'text' (string ใหม่)
```
.
**ใน n8n:**
```
{{ $json.name.trim() }}  // Return string ใหม่
{{ $json.name }}         // String เดิมไม่เปลี่ยน
```
.
**สิ่งที่ควรรู้:**
- trim() ไม่มี arguments (ไม่รับ parameters)
- Return type: string
- Return string ใหม่แม้ไม่มี whitespace ให้ trim
- Original string ไม่ถูกแก้ไข (immutable)
.
นี่คือเหตุผลว่าทำไม JavaScript ถึงปลอดภัย เพราะไม่ modify ข้อมูลต้นฉบับโดยไม่ตั้งใจ 👍

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

- trim-start-n8n
- trim-end-n8n
- [replace – แทนที่ข้อความหรือ pattern ตัวแรกที่พบใน string](https://www.thepexcel.com/functions/n8n/string-functions/replace-n8n/)
- [toLowerCase – ฟังก์ชันแปลงเป็นตัวเล็ก](https://www.thepexcel.com/functions/n8n/string-functions/to-lower-case-n8n/)
- [split – ฟังก์ชันแยกข้อความจากตัวคั่น](https://www.thepexcel.com/functions/n8n/string-functions/split-n8n/)
- [map – แปลงแต่ละรายการในอาร์เรย์ (transform elements)](https://www.thepexcel.com/functions/n8n/array-functions/map-n8n/)

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

- [n8n Expressions Documentation](https://docs.n8n.io/code/expressions/) _(documentation)_
- [n8n String Transformation Functions](https://docs.n8n.io/code/builtin/data-transformation-functions/strings/) _(documentation)_
- [MDN: String.prototype.trim()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim) _(documentation)_

---

_Source: [https://www.thepexcel.com/functions/n8n/string-functions/trim-n8n/](https://www.thepexcel.com/functions/n8n/string-functions/trim-n8n/)_