We create a macro to delete the first word of the current sentence without needing to move the insertion point. This version better utilizes VBA tools to accomplish the task and also naturally handles typical sentence beginning of sentence punctuation.
Thanks for your interest
This content is part of a paid plan.
Delete the first word of a sentence
What happens when we find a tool we didn't know we wanted? The task under consideration sounds so simple, maybe even unnecessary—delete the first word of the current sentence without moving the insertion point (or changing the selection).
Why bother?
This macro was the result of a “productive procrastination” work session. I didn’t want to write at the time, so I tricked myself into creating another macro to take care of a menial task that had been annoying me. At least I wasn’t “researching” writing videos, but this one has surprised me perhaps more than many others. It’s not my most productive macro, but I use it often. It provides yet another (small) tool to alleviate a menial editing task.
The version extends the previous more manual macro, and it also partially overlaps a related member article to capitalize the first word of a sentence.
Create the empty macro
Open the VBA editor and create the following empty macro. If you prefer a more visual approach, a previous post shows how to create an empty macro, but we'll end up in the VBA editor either way.
The single quote tells VBA the rest of the text on that line is a comment meant for human readers. This macro includes a longer description since we add more functionality over the previous version which requires some extra explanation. We start our macro steps on the empty line.
What are the manual steps?
What manual steps would we use to delete the first word of a sentence?
- Use the keyboard or mouse to move to the beginning of the sentence (mouse is slower than it feels)
- Press Function+Command+Delete on a Mac (or Control+Delete in Windows) to delete the word
- Delete and then capitalize the first letter of the new first word of the sentence
- Move back to the original editing location to keep working
We could also double click the first word, but the steps are similar enough (and still require four steps) that the distinction is irrelevant for this version of the macro. Word does not include a standard keyboard shortcut to navigate between sentences, but a we previously covered how to assign shortcuts to some (almost hidden) Word commands to navigate between or selection partial sentences.
Why bother thinking more like VBA?
VBA can do essentially anything we can do with a keyboard and mouse, so we could, in principle, always implement the manual steps in our macros, just as VBA. As we familiarize ourselves with how VBA works, the manual steps provide more of a logical starting point than a potential sequence of macro steps. A more typical VBA approach identifies relevant document elements which we reference to accomplish the necessary subtasks.
Why does thinking more like VBA matter if we can accomplish all the same tasks?
Emulating manual steps can be an issue in some circumstances since the relative element positions could change compared to what we were expecting when we created the macro. It's not a deal breaker because we can often account for most cases, but it's cumbersome to make sure every little tweak works for every use case.
Instead, we just refer to the relevant document element(s) and give the appropriate commands. We'll still occasionally move range variables (or the Selection) around the document to accomplish the overall task, but thinking in terms of the document element thingies often results in fewer and clearer macro steps. The macros will likely be a little safer—avoiding some unintended side effects—and also save us some time and effort when testing our macros.
What are objects in VBA?
Who ever thought of computer world object thingies?
Representing real-world things as virtual (in the colloquial sense) objects was around a few decades before VBA was released for Word. The point is to make working with them easier since they more closely mimic how a human thinks about it.
Toward that goal, VBA generalizes document element concepts as "objects." Most of them are obvious like a Paragraph or Document, but some are more utilitarian like a document Range. In computer world, such objects include various actions (called "methods") and data (called "properties") that allow us to manipulate them or the related document content. Most VBA objects are named as expected only with the first letter capitalized.
What is the Selection?
The Selection is how VBA encapsulates and allows us to control the selection we see on the screen. Since it represents the author's current edit location in a document, only one exists per document. Moreover, an insertion point is effectively an empty selection, so it is also represented by the same object. At a root level, the Selection is like a Range, but it contains more methods and properties tailored to it's specialized purpose in a document plus some extra just for convenience. A separate article goes into more detail about the Selection.
What is a Range?
A Range is a span of document content that acts much like an invisible Selection. Both are VBA generalizations of the respective concepts as we imagine them in a document. A Range includes methods and properties that allow us to change the range or the associated content. For example, we can move the range around, extend or contract it in the document, insert or delete text, etc.
We can declare VBA variables to store a document range and then access (usually stated as "call") the necessary methods or (re)assign any properties necessary to carry out the macro task. Using range variables is common in VBA since we can avoid changing the on-screen selection or insertion point (unless we want to do so) as we perform the macro steps. See a separate article for a brief introduction to Ranges.
VBA-like approach to delete the first word
For simple macros, we might follow the manual steps more directly just phrasing the actions in VBA. The previous delete first word macro worked in this mode except it used a Range variable to avoid manipulating the insertion point on screen for added convenience. While it was fully functional, it nevertheless acted more like a human using a keyboard and tapping it out, but … we can create clearer, more concise macros if we take advantage of other tools VBA offers.
Declare a working range
While not required in regular VBA, we can avoid some silly mistakes (like variable spelling errors causing problems) if we explicitly tell VBA what variables we plan to use in the macro. This almost always includes specifying the type of data it will store.
Dim is a VBA keyword to declare a variable, and "As Range" tells it what data type to use. We can declare multiple variables on the same line if we separate them with a comma and add a type for each variable (otherwise the variable will be a generic type).
I usually give the variable a descriptive name to make using it easier. In this macro, we're working with a sentence and a word range, so we use variables rSentence and rWord. This macro technically only manipulates one range at a time, but naming them separately improves the clarity. The preceding r in the variable names is a personal reminder that they store document range information, but VBA does not care as long as it is a valid name (only including alphanumeric characters or an underscore and not a VBA keyword).
Store the current sentence range
We need to store the current sentence at the insertion point (or the first one in a selection). The Selection includes a Sentences collection.
This collection includes all sentences fully or even partially spanned by the Selection. We want the first sentence, so we use the First property.
We finally assign the identified sentence range to our rSentence variable.
We use Set since a Range is an object in VBA not just a value. Other than this extra keyword, we include an equals "=" sign just like any other assignment.
The First property returns the requested sentence as a document range (it works a little differently with the Paragraphs collection, for example). In this assignment, the left side of the assignment is a Range variable, and the right side is a valid range, so they match as they must (although VBA can automatically convert some data types like numbers).
Allow beginning of sentence punctuation
Double quotes are valid characters for novel dialog, and non-fiction manuscripts might have some parenthetical text, so it would be nice if the current macro properly accounts for these characters. To accomplish this goal, we trim any double quotes or parentheses from the left side of the sentence range.
Trim punctuation from the Start
We want to trim certain characters from the beginning of the range, and the MoveStartWhile method is made for this task.
The command requires a set of characters which is stored in an option named Cset. It specifies any characters to trim from the beginning of the range (or extend over them if moving backward). Most characters are assigned in a plain text like "abc" (called a "string"), but special characters are a little more complicated.
The command will trim any of the characters included in Cset from the beginning of the range, but it stops immediately when it finds any character not in the set. It is not looking for the text sequence "abc" since Find does general text searches in VBA. The order of the characters assigned to Cset does not matter.
Trim parentheses
In VBA we define a string using double quotes. For example, we can make a string consisting of a left parenthesis and a left square bracket just by putting them together in double quotes like "([". We then assign this string to the Cset option in our MoveStartWhile command.
All command options are assigned using a colon equals := symbol. We further included a left square bracket along with an open parenthesis to be a little more general.
Trim double quotes
Modern keyboards type a straight double quote, and Word automatically converts them to a left curly double quote on the left side of a word (or the converse on the right side of a word). Even with the automatic conversions, we still need to include a straight double quote in the trim step because one might be stranded in a document. We might have unintentionally tapped undo and reversed the AutoCorrect change, or more likely, we pasted in some plain text from another app.
Problem with a straight double quote
Unfortunately for the current macro, a left double quote and a straight double quote are both special characters for purposes of the Cset option. That may sound a little strange since we can just type a straight double quote with the keyboard (Shift+tap right pinky finger), but … we have a problem when trying to create a string with the character that defines a string.
Huh?
We use straight double quote to define a text string as in "abc", so it's troublesome to also put it inside double quotes to also represent a double quote.
What do we do? Use """? Or maybe it's """"?
All that to include a double quote character?
Yuck. VBA includes a messy notation like this (the latter one when no other text is included), but we'll ignore it in favor of the clearer special character approach below.
Including special characters with ChrW
VBA includes a standard function ChrW(…) to get the plain text of many special characters that our keyboard cannot reproduce directly. We simply give it the correct number from an extensive Unicode character table (almost 155,000 of characters are in the standard).
- Left double quote “ → ChrW(8220)
- Straight double quote " → ChrW(34)
The straight double quote character is also defined in an older standard ascii table, but the Unicode table includes all ascii characters as a subset.
We just need to add these two characters together with the grouping symbol string above using a plus + sign. The plus sign just smooshes or "concatenates" the strings together into a single longer string.
This particular Cset string is four characters long.
Trim relevant punctuation marks
Putting the different characters together, our trim command is:
After this command, the Start of the range may not be at the literal beginning of the sentence, but assuming the sentence contains some regular text, the range is likely positioned at the first English word of the sentence. This distinction has some implications for the case assignment later.
Get the first word range
The sentence range contains a Words collection.
We want the first word in the sentence range, so we refer to its First property.
Assign this word range to our rWord variable.
Like the Sentences collection, the First property of the Words collection returns a document range which matches the variable data type on the left side of the assignment.
Punctuation as words?
It is important to remove the punctuation before trying to assign the first word range because Word considers individual punctuation marks to be separate words. That is, a single double quote is counted as a "word" in Word which carries through into how VBA interprets a document.
Punctuation issues?
In some strange cases such as only punctuation and spaces in a paragraph, VBA can get a little confused about what constitutes the first word even after the range is trimmed (perhaps as it tries to apply various internal rules defining sentences in real text), but this works in the vast majority of cases.
What about a comma?
I like my macros to handle obvious special cases naturally. It is not uncommon for a comma to follow the first word of a sentence. If so, we would need to run the macro again to remove the comma since Word treats punctuation as individual words. That's a little annoying, so let's check for it and delete it also if so.
Does a comma exist?
We need to check whether a comma follows the first word. A rough conditional statement looks like:
Get the Next character
How do we identify the character immediately after the range?
This is a tad complicated in general, but the quick answer is every range includes a Next method that will return the next unit of document content after the range.
The default unit size is a character, and the default number of units is one (the immediate next unit). Since we're checking for a single comma just after the rWord range, a single character works for our macro. The available Unit constants include most of the common ones we think about when creating documents (e.g., words, sentences, paragraphs, etc.).
Next gives us the range of the next character, but we need the plain text for the upcoming comparison, so we refer to its Text property.
Check whether the character is a comma
Now, we want to check whether that next character is a comma. A comma is just ",", but the double quotes are necessary because it's a string one character in length. The comparison condition between the two individual characters just uses an equals = sign.
All by itself, this looks like we're assigning a comma "," character to the Text property, but when we put it inside a conditional statement, VBA will interpret it as a True or False (Boolean) value.
Extend range over the comma
If a comma is present, we simply need to extend the right side of the word range over the comma and any spaces. The MoveEnd method is perfect for this subtask since it literally moves the End position of a range by a specified unit.
Word treats a comma as a separate word, so we use assign the word unit wdWord to the Unit option. When using a word unit, MoveEnd will automatically include any trailing space(s), but it will exclude any paragraph mark(s).
A character unit would technically work here since a comma is just one character, but it's convenient to let VBA automatically include the trailing space(s) without any extra work on our part.
Word and sentence extension gotcha
Details, details …
The MoveEnd method still works as expected even if a comma ends the current paragraph (a little strange, but just thinking about a potential gotcha). Extending the End of a range by a word unit will not automatically extend over a paragraph mark like it would when extending the range over a sentence unit.
What does that mean?
It basically saves us some extra troubleshooting later, so we don't accidentally delete a paragraph mark which would merge neighboring paragraphs.
Putting the conditional statement together
We only extend the range if a comma exists immediately after the word, so we put the above condition and this action together into the earlier conditional statement.
Since we're only taking a single action if the comma is present, we can condense it into one line and still be clear with the potential action.
Alternative range extension
If you don't like conditional statements, we could just let VBA do the character checks under the hood. The MoveEndWhile method will handle this nicely as long as we give it a set of characters to include in the range. This methods extends the End position forward in the document over the specified characters.
Without a lot of extra explanation, we specify the character set Cset as a comma and a space ", ".
This seems simpler, but in this case, I like the explicit test with the MoveEnd extension above. Only one version is necessary.
Delete the first word
We can finally delete the first word of the sentence (and maybe a comma). The range already spans the word, so we delete it using the Delete method.
Our rWord range spans the desired word, so we just delete the whole range. No unit option is necessary. This method acts similar to the keyboard’s Delete key [or Function (Globe)+Delete on a Mac]. If a selection exists in a document, and we tap Delete, it will delete the range contents and nothing else.
If the range does not contain any text, the method will still (forward) delete a character by default which is not what is intended in the macro. We handle two gotchas below that should catch and avoid most empty word range situations.
Capitalize the new first word
After the above Delete action, our current working range rWord spans no document text. In typical cases, the range is now positioned at the beginning of the new first word of the sentence, so we can capitalize that word using the Case property.
The Case property is stored as a value, so we just use a regular equals = sign for the assignment. The word title constant wdTitleWord comes from a standard table of Case constants. The constant does exactly what we want here. In general, wdTitleWord capitalizes every significant word in the range. In this macro, the range is empty but positioned just in front of the new first word, so it can only act on that word.
Sentence case may not work here
The sentence constant wdTitleSentence would not work for this macro if any punctuation were present in the sentence (which would be to the left of the rWord range at this point in the macro). The internal Case logic applied by Word when using wdTitleSentence would consider the current word to be the (mostly likely) second word in the sentence since a punctuation mark counts as a word. Since a typical (non-proper noun) second word of a sentence is not supposed to be capitalized, nothing would happen.
Any gotchas?
Authors probably don't need much admonition to be careful when deleting content, but we should think a little harder about potential problems when our macros delete any text automatically. The potential gotchas in this macro are simple in principle but messy in practice. On the bright side, at worst we lose an unintended word, so we're mostly safe given the simplicity of the steps.
Do we really have to think about all this?
If you don't mind a few minor missteps popping up causing you to tap Undo every once in a while, then the main macro will probably work most of the time. I prefer my macros to handle most reasonable special cases automatically, but if you're not interested in any of the wormy details, skip to the final macros below.
Does a starting selection exist?
In most text-oriented macros, we should consider whether a starting selection exists when the macro runs. Does it matter here?
In this macro, we specifically isolate the first sentence range early in the macro. If the initial selection spans more than one sentence, we only use the first one, and the rest of the macro logic carries through without a problem.
What happens with an empty paragraph?
A less obvious issue could pop up if the Selection starts at an empty paragraph when the macro runs. One could argue an author simply wouldn't run the macro in that case, but accidents happen. We might tap the wrong shortcut key, for example.
Without explaining all the details about how issues pop up through the individual macro steps, let's imagine a few examples → along with their unintended consequence(s).
- If the initial paragraph is empty and the insertion point is positioned there → The first word of last sentence of the previous paragraph is deleted.
- If the initial paragraph contains only spaces or tabs → The first group of spaces is deleted up to the first tab or the end of paragraph mark if no tabs exist.
- If the initial paragraph contains a double quote (or left parenthesis) punctuation mark and maybe some spaces or tabs → Punctuation mark is deleted.
Uhhh … those are strange. Overall, the issues are more annoying than horrible, but can we do anything about them? Is it worth the effort to catch and correct them?
Why do I need to worry about it?
If we don't detect the errors and exit the macro, then the Delete method near the end will still work similar to pressing the Delete key on the keyboard. It defaults to (forward) deleting a single character or whatever is selected, so it's not a big risk, but as written, something will happen on the Delete step.
Was the "wrong" word deleted?
Problem 1 is a little perplexing when it occurs. We see the text change … in the wrong paragraph. Our eyes must roam back through the previous paragraph text to determine what happened. We might even tap Undo just to see what changes. Wasted time.
Why was the wrong word deleted?
Well, it's not really the wrong word, just the unexpected one. Word considers any trailing paragraph mark(s) to be part of the previous sentence. Since the current empty paragraph contains no text, it is technically part of the last sentence of the previous paragraph. I don't think this is an intuitive definition, but we must nevertheless work around it.
The steps to fix problem 1 are unsightly but reasonably short (see below). We check for an empty paragraph and just exit the macro if we find it empty since that means no sentence exists in the current paragraph.
What if the starting paragraph is only whitespace?
A similar issue pops up with problem 2 above if the initial paragraph contains only whitespace (basically spaces or tabs).
Unfortunately, solving or at least avoiding this issue is messier than what was needed to sidestep problem 1. Given the length, we cover it in separate articles on detecting an empty document range or an empty paragraph. Both functions work, but they tackle the question a little differently.
After implementing the respective functions, the error checks are almost trivial as seen in the last macro below.
What if the paragraph only contains a punctuation mark?
Now we're splitting hairs.
In problem 3 above, the initial paragraph contains only punctuation or whitespace. Unfortunately, VBA may get extra confused about what the "first word" of the non-existent is. Depending on the specific circumstances, it may delete either the punctuation or a paragraph mark.
In this macro, we can detect this issue by looking at the sentence range after the punctuation is trimmed. If that range is somehow empty or just filled with whitespace characters, we just exit the macro and do nothing else.
Sidestepping some of the gotchas
We can't catch everything, but we can make some progress. Let's consider a two precautions even if it just presents the overall idea of how we can make the macro more robust and general.
Detect an empty paragraph
We can avoid most issues with problem 1 by detecting a strictly empty paragraph. We go into much more detail in a separate article, but let's do a whirlwind review of two simpler aspects of the validation.
Get the first paragraph text
The first paragraph is probably the current one where the user is editing. We reference all paragraphs in the Selection using the Paragraphs collections. Then use the First property to get the initial paragraph.
As an aside, we can't just use Selection.Text since it only stores the text spanned by the initial selection. Selection.Text does not span the full paragraph content, and we can't assume the whole paragraph is selected if we want to be general.
Check for an empty paragraph
An empty paragraph contains only a paragraph mark, so we need the first paragraph text for comparison.
In VBA, a paragraph mark is defined as the special character constant vbCr.
The condition tests whether the plain text of the paragraph is exactly a single paragraph mark. No more and no less.
Just exit the macro
If the above condition is True, then we just exit the macro. The command to exit a macro (a.k.a., Sub which is short for Subroutine) is:
This command ends the macro ends immediately. We combine the condition and the exit command into an If-Then statement to make the decision.
Since this is a short step, we condensed it into a one-line If-Then statement. Technically, this is only checking the first paragraph, but let's not get into extra details here.
Detect a paragraph of whitespace?
Unfortunately, catching problem 2 requires more work, so it is relegated to separate articles covering functions designed to detect an empty document range or an empty paragraph. Although, this gotcha is innocuous in that it just deletes the spaces.
Detect an empty sentence range?
Problem 3 was related to whether the sentence range is empty before allowing the macro to delete anything. We can partly avoid this issue by focusing on a strictly empty range, but a more thorough treatment allowing whitespace after the punctuation mark is mostly clearly implemented using a separate function to detect an empty document range.
Is the range empty?
A range is empty if the Start and End positions are the same. Our sentence range was called rSentence. Checking whether the two positions are the same is just a regular condition.
With limited explanation, the conditional statement to exit the macro when the sentence range is empty is:
How was that?
Did that whip your hair into a bird's nest? It was a tornader in a trailer park tour for fixin some of the gotchas, but at least it gives some idea of how we can be a little more careful.
Would I include this validation check in my own macro?
I definitely would, but not everyone likes enduring tropical storm winds. If you prefer more detailed explanations or want to incorporate detecting whitespace, two other member articles cover detecting an empty document range or an empty paragraph.
Final delete first word macro
Here is the revised macro to delete the first word of a sentence while allowing for some common sentence punctuation. It also takes better advantage of VBA tools to get the job done.
This more VBA-like approach is cleaner with a little extra functionality compared to the previous version. I assigned my version of this macro to Command+Option+W in Word for Mac or Control+Alt+W on Windows.
Include whitespace validation checks
To make the macro more robust, we can enhance the two validation checks (see the gotchas above) by allowing an "empty" paragraph or sentence range to also contain whitespace characters. Without much explanation, the improved version is:
These improved whitespace validations are messier and longer than would work for this article. To use this version of the macro, the IsRangeWhitespace function in that article must be included as well.
After including it, the validation checks are almost trivial in this macro reading almost like English. The two distinct validations may seem redundant, but both are necessary. For example, if the initial paragraph is empty (as in just a paragraph mark), the following sentence range assignment would still automatically span a sentence back into the previous paragraph.
Further improvements?
We don't want to enter an never-ending improvements loop (gotta get some writing done sometime), but if you like macros and efficiency, it's hard not to at least toy with the ideas.
Add an undo record?
The macro makes two separate changes, so we might consider grouping them into a single action using an undo record, so they are reversed as one step not two. I will sometimes include undo records in small macros. They're a nice touch, but tread with caution since they can cause significant problems (not exaggerating) with the undo action chain if they are not correctly implemented.
Others ideas?
One thing I like about VBA, is how we can customize our macros specifically for our own workflow. You might want to restrict your version to not work on chapter or scene headings or whatever. Almost anything is possible. It's more a matter of whether it fits into your own workflow (and is practical).
