Method calls in Chinese grammar
Standard Chinese is S-V-O. Subject acts, verb fires, object receives. That's
the default execution order, and most sentences you'll ever write fit it.
But there's a second pattern that rearranges the same arguments into a
different shape — the 把 construction. It pulls
the object out from behind the verb and parks it in front, giving you
S 把 O V [complement].
Programmers have a clean analogy for this: it's the difference between
process(file) and file.process(). Same operation,
same arguments, but the second form foregrounds the object as the thing
being mutated. In Chinese, 把 does exactly that — the subject still acts,
but the spotlight lives on the object and its change of state.
// Default SVO — object is an argument. function process(subject, object) { return subject.apply(verb, object); } // 把 construction — object becomes the receiver. // Verb is now a method, and it MUST return a result. subject.把(object).verb(complement);
1. The basic pattern
Subject + 把 + Object + Verb + Complement 我 把 门 关 了 wǒ bǎ mén guān le "I closed the door." (idiomatic)
Notice what the complement slot is doing. A bare 把 plus a verb is almost always ungrammatical — the construction demands that something follow the verb. Aspect marker 了, a resultative, a directional, a duration, a frequency count. Something. 把 sentences need a complement. Without one, the compiler rejects the sentence.
Why? Because 把 exists to describe disposal — what the subject did to the object, and what state the object ended up in. "Just did the verb" isn't disposal. The complement is the return value of the operation.
2. SVO → 把: three transformations
The clearest way to see 把 is to watch the same meaning in both forms. In each pair, the first is plain SVO, the second reshapes it with 把.
// Pair 1 — closing the door // 我 关 了 门。 wǒ guān le mén // "I closed the door." — neutral report. I.close(door); // 我 把 门 关 了。 wǒ bǎ mén guān le // Foregrounds the door, implies a specific door // the listener knows about. I.把(door).close(); // Pair 2 — finishing the tea // 他 喝 完 了 那 杯 茶。 tā hē wán le nà bēi chá he.drinkFinish(thatCupOfTea); // 他 把 那 杯 茶 喝 完 了。 tā bǎ nà bēi chá hē wán le // The cup is now the topic. he.把(thatCupOfTea).drink("finished"); // Pair 3 — imperative // 请 关 门。 qǐng guān mén (polite generic) please(close(door)); // 请 把 门 关 上。 qǐng bǎ mén guān shàng // Specific, with resultative 上. please(door.把().close("shut"));
The pattern: SVO is a report on what happened. 把 is instructions for what should happen, or a statement about that specific thing ending up changed. It's the voice you use when the object is already on the table between you and the listener.
3. When to reach for 把
| Context | Why 把 wins | Example |
|---|---|---|
| Resultative with location | The verb moves the object to a place. SVO gets awkward; 把 keeps word order tidy. | 我 把 书 放 在 桌子 上 — wǒ bǎ shū fàng zài zhuōzi shàng — "I put the book on the table." |
| Imperative with specific object | Direct command about a known thing. 把 is the default voice. | 把 门 关 上! — bǎ mén guān shàng — "Close the door!" |
| Disposal / transfer / change-of-state | The whole point is what happened to the object. | 她 把 钱 给 我 了 — tā bǎ qián gěi wǒ le — "She gave me the money." |
Rule of thumb: if the sentence answers "what did you do with the X?" more than "what did you do?", 把 is probably the right frame.
4. When 把 is forbidden
The construction has hard type constraints. Certain objects and certain verbs simply can't be parked in the 把 slot.
| Forbidden with | Why | Wrong → Right |
|---|---|---|
| Indefinite objects | The object of 把 must be definite — a thing both speaker and listener can point to. | ✗ 我 把 一 本 书 买 了 → ✓ 我 买 了 一 本 书 — "I bought a book." |
| Perception verbs (看 见, 听 到) | Seeing and hearing don't change the object. No disposal, no 把. | ✗ 我 把 他 看 见 了 → ✓ 我 看 见 他 了 — "I saw him." |
| Mental verbs (知道, 觉得, 喜欢) | Thinking, liking, knowing — queries, not mutations. | ✗ 我 把 中文 喜欢 → ✓ 我 喜欢 中文 — "I like Chinese." |
| Stative verbs / adjectives | "Be tall", "have" — properties, not actions. | ✗ 我 把 钱 有 → ✓ 我 有 钱 — "I have money." |
5. What goes after the verb
Every 把 sentence needs something past the verb. Here are the common fillers.
| Type | Pattern | Example |
|---|---|---|
| Directional (location) | V + 在 + place | 把 书 放 在 桌子 上 — "put the book on the table" |
| Directional (motion) | V + 到 / 进 / 上 | 把 他 送 到 医院 — "send him to the hospital" |
| Resultative | V + result morpheme | 把 饭 吃 完 — "finish eating the meal" |
| Frequency | V + 了 + count + measure | 把 书 看 了 三 遍 — "read the book three times" |
| Duration | V + 了 + timespan | 把 书 读 了 两 个 小时 — "read the book for two hours" |
| Plain aspect 了 | V + 了 | 把 门 关 了 — "closed the door" |
Plain 了 is the minimum legal complement, and even that carries the "change of state" semantics the construction needs. Richer complements — resultatives, directionals, durations — slot in naturally.
6. 把 vs 被: complementary framings
把 and 被 (passive) are mirror images. Both rearrange SVO; they just rearrange it in opposite directions.
| 把 (active) | 被 (passive) | |
|---|---|---|
| Word order | S 把 O V + C | O 被 S V + C |
| Grammatical subject | Still the agent | The patient (what was acted on) |
| Foregrounds | What was done to the object | What happened to the subject |
| Voice | Active, intentional, imperative-friendly | Passive, often adversative |
| Example | 我 把 门 关 了 — "I closed the door." | 门 被 我 关 上 了 — "The door got closed by me." |
Same event, three framings. SVO is neutral. 把 keeps you in the driver's seat and draws attention to the thing you acted on. 被 hands the spotlight to the object. Both require the same kind of post-verb complement.
7. Ten sample sentences
// 1. 我 把 作业 做 完 了。 wǒ bǎ zuòyè zuò wán le // "I finished the homework." — resultative 完 // 2. 请 把 窗户 打开。 qǐng bǎ chuānghu dǎ kāi // "Please open the window." — imperative + resultative 开 // 3. 他 把 车 停 在 门口。 tā bǎ chē tíng zài ménkǒu // "He parked the car at the door." — directional 在 // 4. 我 把 钥匙 忘 在 家 里 了。 // wǒ bǎ yàoshi wàng zài jiā lǐ le // "I left the keys at home." — disposal + location + 了 // 5. 妈妈 把 饭 做 好 了。 māma bǎ fàn zuò hǎo le // "Mom finished cooking the meal." — resultative 好 // 6. 老师 把 问题 解释 得 很 清楚。 // lǎoshī bǎ wèntí jiěshì de hěn qīngchu // "The teacher explained it clearly." — complement via 得 // 7. 我 把 那 篇 文章 看 了 两 遍。 // wǒ bǎ nà piān wénzhāng kàn le liǎng biàn // "I read that article twice." — frequency // 8. 别 把 水 洒 到 地 上! bié bǎ shuǐ sǎ dào dì shàng // "Don't spill water on the floor!" — negative imperative // 9. 他 把 信 寄 给 了 朋友。 tā bǎ xìn jì gěi le péngyou // "He mailed the letter to a friend." — transfer // 10. 我们 把 房间 打扫 得 干干净净。 // wǒmen bǎ fángjiān dǎsǎo de gāngānjìngjìng // "We cleaned the room spotless." — reduplicated resultative
8. Common errors
9. Next steps
把 locks in once you stop translating it as "take" and start treating it as
a reshape operator — the thing that turns verb(object) into
object.verb(). The rest is practicing which verbs and which
objects pass the type check.
- Complements reference — the result, direction, and degree markers that 把 depends on
- 的 · 地 · 得 — the three particles that glue complements to verbs
- Module 1: The Runtime — word order, topic-comment, and where 把 fits in the execution model
- Compile Check — grammar validation drills covering 把 and 被
Next up: the passive with 被, which borrows the same complement machinery and inverts the voice. Learn 把, and 被 is half-taught already.