MongoDB $ltrim Operator

What Is $ltrim?

$ltrim is a MongoDB aggregation expression that removes characters from the left (start) of a string. Default: leading whitespace. Optional chars: a set of characters to strip instead.

$ltrim = trim from the left only

{ $ltrim: { input: <string> } }
{ $ltrim: { input: <string>, chars: <string> } }

default chars → whitespace (incl. null)
custom chars  → each character is a trim candidate (a set, not one substring)

{ $ltrim: { input: "  hello" } }           → "hello"
{ $ltrim: { input: "00042", chars: "0" } } → "42"

null / missing input → null
right side untouched

How to Use $ltrim in MongoDB

Point at a string field, optionally set chars, then store the cleaned value in a stage.

1. Choose an expression stage ($addFields or $project).
2. Pass the string: { $ltrim: { input: "$label" } }.
3. For custom leading characters, add chars (for example "0").
4. Remember: trimming stops at the first character not listed in chars.

Pseudocode

s = evaluate(input)
if s is null or missing:
    result = null
else:
    set = chars if provided else whitespace
    while s starts with a character in set:
        remove that leading character
    result = s
emit { ..., field: result }

Cheat Sheet

Keep these facts handy while cleaning leading characters.

Live Preview

Watch $ltrim remove leading spaces or leading zeros.

input = "  hello"
chars = whitespace (default)

$ltrim → "hello"

Worked Walkthrough — Leading Spaces

A label is stored as " hello" (two leading spaces). We want "hello".

input: "  hello"

$ltrim default (whitespace):
  char[0] = ' ' → trim
  char[1] = ' ' → trim
  char[2] = 'h' → stop (not whitespace)

Result:
  "hello"

Trailing spaces (if any) would stay — $ltrim only touches the left.

MongoDB Examples

We use one document with a padded label and a zero-padded code. First we store it, then we trim spaces, then we trim leading zeros. Run these in mongosh after inserting the sample data once.

db.labels.insertOne({
  _id: 1,
  label: "  hello",
  code: "00042"
});

db.labels.find()

{
  _id: 1,
  label: "  hello",
  code: "00042"
}

"  hello"  --$ltrim-->  "hello"
"00042"    --$ltrim chars "0"-->  "42"

db.labels.aggregate([
  {
    $addFields: {
      cleanLabel: {
        $ltrim: { input: "$label" }
      }
    }
  }
]);

{
  _id: 1,
  label: "  hello",
  code: "00042",
  cleanLabel: "hello"
}

db.labels.aggregate([
  {
    $project: {
      code: 1,
      cleanCode: {
        $ltrim: {
          input: "$code",
          chars: "0"
        }
      }
    }
  }
]);

{
  _id: 1,
  code: "00042",
  cleanCode: "42"
}

Performance Notes

Trimming is inexpensive compared with large sorts or joins. Clean early when later stages depend on exact string matches.

Key Takeaways