Search in VS Code for multiple terms

Question

Suppose I search on VS Code the terms 'word1 word2'. Then it finds all the occurrences where 'word1' is followed by 'word2'. In reality I want to find all the files where word1 and word2 occur, but they don't have to be consecutive. How can I do it?

Answer 1

To search for multiple terms ordered you can use the pattern word1.*word2.

The search will find the files containing both words in this order.

Answer 2

The original question asked to do a single search for files containing two separate words in the same file. Below is what I do to search for two (or more) words in the same file by using multiple searches.:

1. Search Like you normally do
2. Click on "Open in editor"
3. Adjust the context line count. (The higher the context count the more you can search for that second term, but the more non relevant searches you bring in)
4. Hit Cmd + F (or equivalent if not on mac) and search there. In the image below I have narrowed it down to 53 hits. I can manually skip through until I find it.

Need even more Fine tuning?

1. Same Steps as 1 - 3
2. Copy the contents to a file. (In the image below I saved it to a file called haystack.ts)
3. Search there for a third word. (In the image below I have now narrowed it down to 7 searches.)

Answer 3

This extension: Find and Transform, I am the author, makes it quite easy to do any number of sequential searches across files only using the files from previous search results for future searches.

There is a variable ${resultsFiles} that resolves to those previous search results files and can be used in the "filesToInclude" argument. Here is a sample keybinding

{
  "key": "alt+b",
  "command": "runInSearchPanel",
  "args": {
    
    "find": ["first", "second"],
    "delay": 2000,              // necessary to allow results to populate
    // delay may need to be longer if you are searching a lot of files 

    "replace": ["", "knuckles"],   // optional
    
    "filesToInclude": ["", "${resultsFiles}"],
    "filesToExclude": "Users\\Mark\\AppData\\Roaming\\Code\\User\\keybindings.json",
    
    "isRegex": true,

    // so that the first search will be triggered and produce results
    "triggerSearch": true,

    "triggerReplaceAll": [false, true]   // optional
  }
}

1. "find": ["first", "second"], : search for first and then search for second
2. "filesToInclude": ["", "${resultsFiles}"], : clear the filesToInclude on the first search, on second search use the resultFiles from the first search
3. You can do as many sequential searches as you like
4. The finds can be regex's and as complex as you wish

Answer 4

To apply logical and (?=.*word1)(?=.*word2)(?=.*word3)

To apply logical or (word1)|(word2)|(word3)

Answer 5

This is now supported, you can search for the term then open in editor and use ctrl + f to search the search results thanks @pushkin

Answer 6

Try Open new Search Editor command, through command pallete, You can map it to any keybinding you'd like in the Keybindings Editor. I mapped to cmd+shift+i

This is helpful for me!

There is one more way, using up/ down arrow key in search editor, moves us across our search history, even this is useful,

It needs a little bent of mind to accept that it is equivalent to having multiple search editors (what IntelliJ etc provides) but without persistence!

Answer 7

Use regex flag and search for (word1[\s\S\n]*word2)|(word2[\s\S\n]*word1)

---

Made a small extension based on @tonix regex:

https://marketplace.visualstudio.com/items?itemName=usernamehw.search

Answer 8

Here is also a simple way for simple needs - use this as regex

(word1)|(word2)|(word3)  

It may not cover some cases, but has been working fine for me, and easy to remember to type it in.

Answer 9

For you guys,

if you want to search for multiple words (more than 2) at once in a single file and all the words must appear in the file at least once (logical AND), you can use the following regex which leverages lookahead assertions:

^(?=[\s\S\n]*(word1))(?=[\s\S\n]*(word2))(?=[\s\S\n]*(word3))(?=[\s\S\n]*(word4))[\s\S\n]*$

A global search with this pattern will only return all the files that contain word1 AND word2 AND word3 AND word4 in any order (e.g. word4 may appear at the beginning and/or word2 may appear at the end of the file).

I also wrote a little Python CLI helper which creates the regex automatically for you given the patterns you want to AND (though creating the regex by hand is pretty straightforward).

Copy the following code, paste it in a new file and save it somewhere on your machine (I've called it regex_and_lookahead.py). Then make the file executable with chmod +x ./regex_and_lookahead.py (important, I used Python 3.6, the literal prefix f -> f'(?=[\s\S\\n]*({arg}))' won't work in previous versions):

#!/usr/bin/env python
from sys import argv

args = argv[1:]
regex = '^'
for arg in args:
    regex += f'(?=[\s\S\\n]*({arg}))'
regex += '[\s\S\\n]*$'

print(regex)

Usage:

./regex_and_lookahead.py word1 word2 word3 word4

Will generate the above regex. You can also use it to generate more complex regexes cause each parameter can have regex characters in it!

As an example:

./regex_and_lookahead.py "pattern with space" "option1|option2" "\bword3\b" "(repeated pattern\.){6}"

Will generate the following regex:

^(?=[\s\S\n]*(pattern with space))(?=[\s\S\n]*(option1|option2))(?=[\s\S\n]*(\bword3\b))(?=[\s\S\n]*((repeated pattern\.){6}))[\s\S\n]*$

Which will match a file if and only if all of the following conditions are true:

• There's at least one occurrence of the string pattern with space;
• There's at least one occurrence of either option1 or option2;
• There's at least one occurrence of the word word3 delimited by word boundary assertions;
• There is at least one occurrence of the string repeated pattern. repeated 6 times (i.e.: repeated pattern.repeated pattern.repeated pattern.repeated pattern.repeated pattern.repeated pattern.).

As you can see, the sky is the only limit. Have fun!

Answer 10

VSCode has an open issue to support multiple searches. You may want to get on there and push them a little.