1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
b0VIM 8.1 �# matan matanm U3210 #"! U tp
� � � ^ � � � o � � � � � / , =
M \
j
w � �
�
� � � � � � � � � � � � !
" # $ " % ( & . ' 4 ( : ) @ * F + L , Q - V . [ / ` 0 e 1 j 2 o 3 t 4 y 5 ~ 6 � 7 � 8 � 9 � : � ; � < � = � > � ? � @ � A � B � C � D � E � F � G � H � I � J � K � L � M � N � O � P � Q � R � S � T � U V W X Y Z [ \ ] " ^ % _ ( ` + a . b 1 c 4 d 7 e : f = g @ h C i F j I k L l O m R n U o X p [ q ^ r a s d t g u j v m w p x s y v z y { | | } � ~ � � � � ad � ] � m # � � � K A �
�
�
�
T
F
� � x u B 5 � � � f W �
�
[
L
� � � � u 5 ' � � � R F
� � � { 0 $ � � � } P � � � ~ 6 ' � � � x l O B � � � � � > , � � � U J 0 # � � � statistics about the search across all files. summary **summary** - The final message emitted by ripgrep that contains was inverted. the search includes the text of the line, along with any match information if This **context** - A message that indicates a contextual line was found. and offsets of the match. includes the text **match** - A message that indicates a match was found. This file. also include summary statistics about the search for a particular This message **end** - A message the indicates a file is done being searched. least one match. contains at **begin** - A message that indicates a file is being searched and types: encoded as a JSON object, where there are five different message messages, each When this flag is provided, ripgrep will emit a sequence of Enable printing results in a JSON Lines format. --json Invert matching. Show lines that do not match the given patterns. -v, --invert-match be enabled to make ripgrep behave more like grep. default but can each file even if there were zero matches. This is disabled by matches for When used with --count or --count-matches, print the number of --include-zero --no-ignore-file-case-insensitive flag. This flag can be disabled with the file systems (such as Windows). insensitive this comes with a performance penalty and is most useful on case insensitively. Note that Process ignore files (.gitignore, .ignore, etc.) case --ignore-file-case-insensitive directly on the command line, then used -g instead. directories If you are looking for a way to include or exclude files and than later files. precedence When specifying multiple ignore files, earlier files have lower several times. ignore files can be specified by using the --ignore-file flag additional and are matched relative to the current working directory. Multiple applied are applied after the patterns found in .gitignore and .ignore are These patterns Specifies a path to one or more .gitignore format rules files. --ignore-file <PATH>... This flag overrides -s/--case-sensitive and -S/--smart-case. Unicode's "simple" case folding rules. to insensitively. The case insensitivity rules used by ripgrep conform case When this flag is provided, the given patterns will be searched -i, --ignore-case it. Globs are matched case insensitively. a ! to exclude used. Globbing rules match .gitignore globs. Precede a glob with flags may be glob. This always overrides any other ignore logic. Multiple glob the given Include or exclude files and directories for searching that match --iglob <GLOB>... This flag can be disabled with --no-hidden. provided. ignore file, then it will be searched even if this flag isn't whitelisted in an are skipped. Note that if a hidden file or a directory is and directories. By default, hidden files and directories ad � Y � � � O = � � � � ] P �
�
�
[
J
� � � � x ( ! � � � X K �
�
�
v
)
� � v k � � � < 2 � � � X J � � � � t $ � � � u B 4 � � j ] � � 2 ' � � � s 9 , � � � � This flag can be disabled with '--no-max-columns-preview'. If the '--max-columns' flag is not set, then this has no effect. of the line exceeding the limit is not shown. where the part of the line (corresponding to the limit size) is shown instead, a preview line was removed. When this flag is combined with '--max-columns', a matching replace any line that is too long with a message indicating that completely When the '--max-columns' flag is used, ripgrep will by default --max-columns-preview When this flag is omitted or is set to 0, then it has no effect. and only the number of matches in that line is printed. omitted, Don't print lines longer than this limit in bytes. Longer lines are -M, --max-columns <NUM> This overrides the --word-regexp flag. where the entire line participates in a match. prints lines ^...$ around all of the search patterns. In other words, this only to putting Only show matches surrounded by line boundaries. This is equivalent -x, --line-regexp terminal. searching in a Show line numbers (1-based). This is enabled by default when -n, --line-number the --block-buffered flag. buffering, use automatically detecting the buffering strategy. To force block behavior of using --no-line-buffered causes ripgrep to revert to its default Note that Forceful line buffering can be disabled with --no-line-buffered. 'tail -f something.log | rg foo --line-buffered | rg bar'. typically useful in shell pipelines, e.g., This is use line buffering even if it would otherwise use block buffering. ripgrep to use block buffering, which is typically faster. This flag forces ripgrep will when ripgrep's stdout is connected to a terminal, but otherwise, the default line is found, it will be flushed to stdout immediately. This is a matching When enabled, ripgrep will use line buffering. That is, whenever --line-buffered The JSON Lines format can be disabled with --no-json. https://docs.rs/grep-printer/*/grep_printer/struct.JSON.html here: A more complete description of the JSON format used can be found when --json is set. effect --only-matching, --heading, --replace, --max-columns, etc., have no Other flags that control aspects of the standard output such as concert with --json. used in ripgrep will report an error if any of the aforementioned flags are --count-matches. --files-with-matches, --files-without-match, --count or --files, be used with other flags that emit other types of output, such as It cannot The JSON Lines format is only supported for showing search results. encoded contents of the data. the base64 a normal JSON string when the data is valid UTF-8 while 'bytes' is 'bytes'. 'text' is all data elements as objects with one of two keys: 'text' or ripgrep will emit and JSON itself must be representable by a Unicode encoding, valid UTF-8 Since file paths or the contents of files are not guaranteed to be ad D � \ � � | n A � � � � < 5 �
�
�
�
�
B
5
(
� � ~ u W J � � � t N A �
�
�
�
y
l
� � � � t A 4 � � � � 8 0 � � � z 1 ! � � � � 8 4 � � � � : + � � � x B 5 � � � � | , # � � � | 2 & � � � before cannot be memory-mapped (such as stdin) will be consumed until EOF Things that (either by reading it onto the heap or by memory-mapping it). memory requires that each file it searches is laid out contiguously in ripgrep use more memory. In particular, when multiline mode is enabled, may also searches may be slower than normal line-oriented searches, and they multiline **WARNING**: Because of how the underlying regex engine works, can span. There is no limit on the number of the lines that a single match applies when multiline search is enabled. flag only flag may be passed to make the "dot all" behavior the default. This '--multiline-dotall' match any character, including '\n'. Alternatively, the where '.' will For example, both '(?s).' and '(?s:.)' have the same semantics, regex. make '.' match '\n', you must enable the "dot all" flag inside the order to character other than '\n', and this is true in ripgrep as well. In any of '.'. Namely, in most regex matchers, a '.' will by default match match semantics An important caveat is that multiline mode does not change the and regexes like '\n' are permitted. including '\n', mode is enabled, '\p{any}' will match any Unicode codepoint, when multiline and if you try to use it, ripgrep will return an error. However, forbidden, codepoint other than '\n'. Similarly, the regex '\n' is explicitly Unicode enabled (the default), then the regex '\p{any}' will match any is not cannot include a line terminator. For example, when multiline mode that a match When multiline mode is enabled, ripgrep will lift the restriction Enable matching across multiple lines. -U, --multiline This flag overrides --no-mmap. is simultaneously truncated. a file that Note that ripgrep may abort unexpectedly when --mmap if it searches will not be used. memory maps incompatible option (e.g., --context) is given with --mmap, then an Memory map searching doesn't currently support all options, so if thinks it will be faster. when ripgrep Search using memory maps when possible. This is enabled by default --mmap Examples: --max-filesize 50K or --max-filesize 80M treated as bytes. input is megabytes and gigabytes, respectively. If no suffix is provided the kilobytes, The input format accepts suffixes of K, M or G which correspond to directories. Ignore files larger than NUM in size. This does not apply to --max-filesize <NUM+SUFFIX?> 'dir'. children of descended into. 'rg --max-depth 1 dir/' will search only the direct not be For example, 'rg --max-depth 0 dir/' is a no-op because dir/ will value of zero only searches the explicitly given paths themselves. paths given. A Limit the depth of directory traversal to NUM levels beyond the --max-depth <NUM> Limit the number of matching lines per file searched to NUM. -m, --max-count <NUM> ad � [ � � _ U � � Z L �
�
�
A
8
� � � � A 3 � � � | 9 , �
�
�
{
3
$
� � � � > 0 � � i \ � � � m # � � � � S � � � S G : � � � 9 $ � � � q d & � � � s e 8 � � � � � such as git's '.git/info/exclude'. repository Don't respect ignore files that are manually configured for the --no-ignore-exclude This flag can be disabled with the --ignore-dot flag. Don't respect .ignore files. --no-ignore-dot This flag can be disabled with the --ignore flag. explicitly as a command line argument. specified This does *not* imply --no-ignore-files, since --ignore-file is --no-ignore-vcs. no-ignore-parent and --no-ignore-dot, --no-ignore-exclude, --no-ignore-global, implies Don't respect ignore files (.gitignore, .ignore, etc.). This --no-ignore This overrides the --heading flag. a terminal. every matched line. This is the default mode when not printing to a prefix for the -H/--with-filename flag, then file paths will be printed as addition to Don't group matches by each file. If --no-heading is provided in --no-heading This flag overrides --with-filename. ripgrep is explicitly instructed to search one file or stdin. default when Never print the file path with the matched lines. This is the -I, --no-filename behavior as well. pre-defined locations, then this flag will also disable that files in If ripgrep ever grows a feature to automatically read configuration respect the RIPGREP_CONFIG_PATH environment variable. will not Never read configuration files. When this flag is present, ripgrep --no-config This flag can be disabled with --no-multiline-dotall. all" whereas '(?-s:.)' always disables "dot all". enables "dot inline flags in the regex pattern itself, e.g., '(?s:.)' always controlled via whether this flag is used, "dot all" semantics can still be regardless of file if you prefer "dot all" semantics by default. Note that ripgrep config This flag is generally intended to be used in an alias or your By default, the multiline mode runs without this flag. -U/--multiline flag. most one line), this can be useful when searching with the can span at typically isn't relevant for line-oriented matching (since matches this behavior Normally, a '.' will match any character except newlines. While multiline searching isn't enabled with the --multiline flag. effect if newlines when multiline searching is enabled. This flag has no to match This flag enables "dot all" in your regex pattern, which causes '.' --multiline-dotall This flag can be disabled with --no-multiline. is always better to disable multiline mode. line, then it Nevertheless, if you only care about matches spanning at most one searching it. will automatically avoid reading each file into memory before ripgrep does not contain patterns that would match '\n' characters, then the regex necessary. Specifically, if the --multiline flag is provided but when searching can begin. In general, ripgrep will only do these things ad + � Z � � 1 ' � � � 7 1 �
�
�
n
`
3
� � � � j \ / � � � � u H �
�
�
�
r
0
"
� � � � { N � � � � \ N ! � � � � n < / � � � � � 7 & � � z . � � � � k " � � � H � � < � � * * A large array * folding. * will use Unicode case * * Case insensitive matching * than their ASCII only versions. * and much bigger * * Classes like '\w', '\s', '\d' are all Unicode aware * '.' will only match valid UTF-8 encoded scalar values. has a number of consequences: regexes. This By default, ripgrep will enable "Unicode mode" in all of its --no-unicode This flag can be disabled with --require-git. searching in a git repository or not. whether you're ripgrep will respect all git related ignore rules regardless of that git repository. This flag allows you to relax this restriction such inside a and local exclude rules if ripgrep detects that you are searching .gitignore rules By default, ripgrep will only respect global gitignore rules, --no-require-git for --unicode. an alias This flag is now an alias for --no-unicode. And --pcre2-unicode is DEPRECATED. Use --no-unicode instead. --no-pcre2-unicode This flag overrides --mmap. Never use memory maps, even when they might be faster. --no-mmap This flag can be disabled with the --messages flag. shown. messages related to the syntax of the pattern given are still Error Suppress all error messages related to opening and reading files. --no-messages terminal. searching in a Suppress line numbers. This is enabled by default when not -N, --no-line-number This flag can be disabled with the --ignore-vcs flag. respected. continue to be --no-ignore-parent for VCS files. Note that .ignore files will implies Don't respect version control ignore files (.gitignore, etc.). This --no-ignore-vcs This flag can be disabled with the --ignore-parent flag. directories. Don't respect ignore files (.gitignore, .ignore, etc.) in parent --no-ignore-parent This flag can be disabled with the --ignore-messages flag. or .gitignore. as .ignore Suppresses all error messages related to parsing ignore files such --no-ignore-messages This flag can be disabled with the --ignore-global flag. `$HOME/.config/git/ignore`). `core.excludesFile` configuration option (which defaults to git's Don't respect ignore files that come from "global" sources such as --no-ignore-global This flag can be disabled with the --ignore-files flag. ignored. flag, are When set, any --ignore-file flags, even ones that come after this --no-ignore-files This flag can be disabled with the --ignore-exclude flag. ad m $ � ` � k �
w
'
� � , � � % �
I
� Z � o � ~ � � * � 5 � / � ( � * * that. * exactly * do * will * flag * --no-unicode * The * off. * things * these * turn * to * desirable * be * can * it * cases * some * In * * character. * a word * of * definition * Unicode * the * use * '\B') * and * ('\b' * boundaries * * Word * available. * '\p{Emoji}' are * of classes like ad � f � & �
� L � u
� B � � I � � K � � R � L � * does * PCRE2 * engine, * regex * default * the * unlike * particular, * In * ripgrep. * of * experience * user * the * in * off * trade * a critical * represents * mode * Unicode * specifically, * PCRE2 * For ad ' � N � �
0
� ]
� � 4 q � � + f � � % b � * when * searches * it * everything * that * *requires* * PCRE2 * Instead, * enabled. * features * Unicode * with * UTF-8 * invalid * possibly * search * to * ability * the * support * not ad � 2 g �
� ; n
� � 9 o � � � 9 b � * discuss * only * we * ripgrep, * of * purposes * the * for * but * UTF-16/UTF-32, * valid * (Or * UTF-8. * valid * is * enabled * is * mode * Unicode ad � 3 & O w
� � �
8 R o � � � � � 3 * invalid * search * to * attempt * you * and * enabled * mode * Unicode * PCRE2's * have * you * if * that * means * This * UTF-8.) ad � $ 8 J
Y k |
� � � � � � � $ * reason, * this * For * error. * an * print * and * halt * will * file * that * for * search * the * then * UTF-8, ad �
! "
$ ) % ) + # * replacing * by * sequences * UTF-8 * invalid * "fix" * automatically * will * ripgrep * enabled, * is * mode * Unicode * PCRE2's * when ad � 8 � �
� � �
� � � � � q ^ J 8 * the * using * when * occur * not * does * penalty * This * codepoint. * replacement * Unicode * the * with * them ad �
� �
� � |
R & � � � v I * surfaced * errors * encoding * the * see * rather * would * you * If * * engine. * regex * default ad g
� �
� R '
� � � I � � g * to * flag * --no-encoding * the * pass * then * enabled, * is * mode * Unicode * when * PCRE2 * by ad @ � � �
Q � m � � 0 � � * --unicode. * with * disabled * be * can * flag * --no-unicode * The * * transcoding. * all * disable ad � � � b
� �
9 � � ' � j � * --unicode, * and * --no-unicode * for * aliases * are * --pcre2-unicode * and * --no-pcre2-unicode * that * Note ad � �
�
�
� � u � * follow * printed, * is * path * a file * Whenever * --null * -0, * * respectively. ad Y �
~ � u � l � P � / � * before * paths * file * printing * includes * This * byte. * a NUL * with * it ad � � l � M � ' � t � * such * files * matching * of * a list * printing * when * and * matches, ad / o f � * ~ � C � o * is * option * This * --files. * and * --files-with-matches * --count, * with * as ad ^ � b � l � 4 g � * this * Enabling * --null-data * * xargs. * with * use * for * useful ad y � 5 j �
� G � � * a line * as * NUL * use * to * ripgrep * causes * option ad 0 l 1 e �
� � I l * * '\n'. * of * default * the * of * instead * terminator ad S � ( 9
L Z l } � * files * binary * large * searching * when * useful * is * This ad 3 o % 3
F Y ` f o * if * lines * long * very * have * otherwise * would * that ad � -
& - - * terminator. * line * the * as * used * were * '\n' ad � �
� � � * a minimum, * at * that, * requires * ripgrep * particular, * In ad � � �
� � � � � � * Using * memory. * into * fit * must * line * each ad e � �
� � � � � � * to * stopgap * a useful * be * can * instead * NUL ad I � �
� � � � � � * OOM * avoid * and * low * requirements * memory * keep ad � �
� � � w B * is * This * * conditions. * memory) * of * (out ad I � �
� ` % � � � * data, * delimited * NUL * processing * for * useful * also ad * b �
� c + � � b * ripgrep's * using * when * emitted * that * as * such ad < p �
y : � � p * flag. * --print0 * find's * or * flag * -0/--null ad � � �
] � O � * -a/--text. * implies * flag * this * Using * ad � ! �
� � ! * will * ripgrep * enabled, * When * --one-file-system * ad � �
� � * relative * boundaries * system * file * cross * not ad � � �
� w � * from. * started * search * the * where * to ad ' [ r
�
6 � � [ * to * applies * this * that * Note * ad E b
�
" � � E * ripgrep. * to * given * argument * path * each ad � � c
�
% | � * command * the * in * example, * For ad d � W
�
� A � * ripgrep * /quux/baz', * /foo/bar * --one-file-system * 'rg ad _ � V
�
D � * and * '/foo/bar' * both * search * will ad > n C
�
� # n * are * they * if * even * '/quux/baz' ad < l L
�
� ! l * but * systems, * file * different * on ad > J
�
� > * system * a file * cross * not * will ad � * :
x
� � * * path's * each * traversing * when * boundary ad � � 9
v
� � � * is * This * * tree. * directory ad � � #
K
o � � * or * '-xdev' * find's * to * similar ad Q � "
G
e s � * flag * This * * flag. * '-mount' ad 4
) 7 4 * --no-one-file-system. * with * disabled * be * can ad � �
� � � * only * Print * --only-matching * -o, * ad } � � � � � � * of * parts * (non-empty) * matched * the ad ~ � � � � � � * such * each * with * line, * a matching ad B r � � � � r * line. * output * a separate * on * part ad � � � O * both * Print * --passthru * ad � � � A * lines. * non-matching * and * matching ad � � � e � * to * way * Another * ad | � � P � � * is * effect * a similar * achieve ad ~ � � U � * pattern * your * modifying * by ad m � � Y � � * empty * the * match * to ad P | � > � | * if * example, * For * string. ad P | � B � | * using * searching * are * you ad T � � A � � * using * then * foo' * 'rg ad J � % � J * will * instead * "^|foo"' * 'rg ad % Q � ' � Q * in * line * every * emit ad K � ' � K * but * searched, * file * every ad � & � � & * 'foo' * of * occurrences * only ad � � � * This * highlighted. * be * will ad � �
� * same * the * enables * flag ad � � � � v � * to * needing * without * behavior ad � � z � o � * * pattern. * the * modify ad ? k [ � k * the * Set * <SEPARATOR> * --path-separator ad > j [ � j * use * to * separator * path ad : f [ �
f * paths. * file * printing * when ad > j [ � j * your * to * defaults * This ad / I � � / * which * separator, * path * platform's ad ? Q � � ? * and * Unix * / on * is ad 8 O � � 8 * flag * This * Windows. * \ on ad � Q � � * overriding * for * intended * is ad � D � � * the * when * default * the ad � < | � * (e.g., * it * demands * environment ad � � 3 h � � * is * separator * A path * cygwin). ad � � 4 m � � * byte. * a single * to * limited ad I u . U [ u * When * --pcre2 * -P, * ad : f 4 P f * present, * is * flag * this ad ; g 1 L g * the * use * will * ripgrep ad 5 a 2 J a * instead * engine * regex * PCRE2 ad C + 6 C * regex * default * its * of ad � * This * * engine. ad � � � � � * useful * generally * is ad � � � � � * want * you * when ad � � � � � * features * use * to ad � � � � � * look-around * as * such ad � � � � � * * backreferences. * or ad M u � � u * PCRE2 * that * Note ad N v � � v * optional * an * is ad I q � � q * If * feature. * ripgrep ad G o � � o * included * wasn't * PCRE2 ad 7 _ � � _ * build * your * in ad ( P � � P * then * ripgrep, * of ad ) Q � � Q * flag * this * using ad * R � � R * in * result * will ad A � � A * an * printing * ripgrep ad + � p + * and * message * error ad * � o * * may * PCRE2 * exiting. ad - � t - * worse * have * also ad * � n * * in * experience * user ad � � Z * since * cases, * some ad � � _ * fewer * has * it ad � � S * than * APIs * introspection ad � � T * regex * default * ripgrep's ad � � � B � * example, * For * engine. ad � � � G � * use * you * if ad � � � D � * a PCRE2 * in * a '\n' ad � � � @ � * the * without * regex ad � � � � * then * flag, * '-U/--multiline' ad � � � ) � * silently * will * ripgrep ad � � � . � * match * to * fail ad } � � � * of * instead * anything ad r � � � * error * an * reporting ad p � � � * it * (like * immediately ad w � � � * the * with * does ad V ~ � ~ * engine). * regex * default ad = v � = * flags: * Related * ad � X � * This * * --no-pcre2-unicode ad � � N � � * be * can * flag tp ] Y ^ \ � [ Z o $ � �
, =
M \
j
w � �
�
� � � � � � � � � � � � !
" # $ " % ( & . ' 4 ( : ) @ * F + L , Q - V . [ / ` 0 e 1 j 2 o 3 t 4 y 5 ~ 6 � 7 � 8 � 9 � : � ; � < � = � > � ? � @ � A � B � C � D � E � F � G � H � I � J � K � L � M � N � O � P � Q � R � S � T � U V W X Y Z [ \ ] " ^ % _ ( ` + a . b 1 c 4 d 7 e : f = g @ h C i F j I k L l O m R n U o X p [ q ^ r a s d t g u j v m w p x s y v z y { | | } � ~ � � � � tp � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �
� � � � � � � � � � � � " � $ � & � ( � * � , � . � 0 � 2 � 4 � 6 � 8 � : � < � > � @ � B � D � F � H � J � L � N � P � R � T � V � X � Z � \ � ^ � ` � b � d � f � h � j � l � n � p � r � t � v � x � z � | � ~ � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � ad � � J � � * --no-pcre2. * with * disabled ad c � E ^ � * When * --pcre2-version * ad a � - Z � * is * flag * this ad X � ) S � * will * ripgrep * present, ad \ � , Z � * version * the * print ad b � / [ � * in * PCRE2 * of ad F n - M n * with * along * use, ad 3 [ 9 [ * and * information, * other ad < d ! A d * If * exit. * then ad = e C e * not * is * PCRE2 ad & N < N * ripgrep * then * available, ad @ ) @ * an * print * will ad < & < * and * message * error ad A * A * an * with * exit ad 4 ( 4 * * code. * error ad � � �
� � * For * <COMMAND> * --pre ad � � �
� � * FILE, * input * each ad � � �
� � * standard * the * search ad � � �
� � * COMMAND * of * output ad � � �
� � * than * rather * FILE ad � � �
� � * of * contents * the ad � � �
� � * option * This * FILE. ad � � �
� � * COMMAND * the * expects ad � � �
� � * either * to * program ad � � �
� � * absolute * an * be ad p � �
� � * to * or * path ad k � �
� � * in * available * be ad i � �
� � * Either * PATH. * your ad k � �
� � * string * empty * an ad T | �
� | * the * or * COMMAND ad B j �
� j * will * flag * '--no-pre' ad @ h �
� h * behavior. * this * disable ad , �
x , * When * WARNING: * ad D h �
h * flag * this ad F j �
j * set, * is ad A e �
e * will * ripgrep ad 8 \ �
\ * spawn * unconditionally ad 4 X �
X * process * a ad $ H �
H * every * for ad $ H �
H * that * file ad ! E �
E * searched. * is ad B �
B * this * Therefore, ad $ H �
H * incur * can ad
1 �
1 * unnecessarily * an ad � �
* performance * large ad ' �
' * if * penalty ad ( �
( * don't * you ad � # �
# * need * otherwise ad � �
* flexibility * the ad � �
* by * offered ad � �
* flag. * this ad � �
* possible * One ad � ~
* to * mitigation ad �
�
* is * this ad � �
* use * to ad � � u
� * '--pre-glob' * the ad � � t
� * to * flag ad � � s
� * which * limit ad � � s
� * a preprocessor * files ad � � v
� * run * is ad � � s
� * * with. ad � � R
� * is * A preprocessor ad � � ]
� * run * not ad � � \
� * ripgrep * when ad � � ^
� * searching * is ad � � Z
� * * stdin. ad _ � D
� * searching * When ad d � D
� * sets * over ad e � F
� * files * of ad e � D
� * may * that ad b � A
� * one * require ad c � F
� * several * of ad V z @
z * as * decoders ad ? c .
c * COMMAND * preprocessors, ad L p 6
p * be * should ad D h 3
h * program * a wrapper ad L p :
p * script * or ad J n 7
n * first * which ad . R &
R * FILE * classifies ad 5 Y +
Y * on * based ad ( L +
L * numbers/content * magic ad 5 Y .
Y * based * or ad 7 [ .
[ * the * on ad 4 X ,
X * name * FILE ad ) M -
M * then * and ad <
< * to * dispatches ad ; "
; * appropriate * an ad 7
7 * Each * preprocessor. ad =
= * also * COMMAND ad B !
B * its * has ad � #
# * input * standard ad %
% * to * connected ad )
) * for * FILE ad �
* * convenience. ad � � � � * example, * For ad � � � � * script * a shell ad � � � � * COMMAND * for ad � � � � * look * might ad � � � � * * like: ad � � � � * "$1" * case ad � � � � * *.pdf) * in ad O s � s * pdftotext * exec ad W { � { * - * "$1" ad D � D * *) * ;; ad � � * $(file * case ad � � * in * "$1") ad � � h � * exec * *Zstandard*) ad � � W � * -cdq * pzstd ad L p B p * *) * ;; ad ) ) * cat * exec ad � � � � * esac * ;; ad v � � � * esac * ;; ad E i � i * The * ad 1 U � U * script * above ad - Q � Q * `pdftotext` * uses ad 3 W � W * convert * to ad 3 W � W * file * a PDF ad 5 Y � Y * plain * to ad 4 X � X * For * text. ad @ � @ * other * all ad ? � ? * the * files, ad > � > * uses * script ad ? � ? * `file` * the ad ? � ? * to * utility ad @ � @ * the * sniff ad B � B * of * type ad 5 � 5 * file * the tp � � � � � � �
� � �
� � � � � � � � � � � � � � � � � � � � ! � " � # � $ � % � & � ' � ( � ) � * � + � , - . / 0 1 2
3 4
5 6 7 8 9 : ; < = > ? @ A B C D E F G H ! I " J # K $ L % M & N ' O ( P ) Q * R + S , T - U . V / W 0 X 1 Y 2 Z 3 [ 4 \ 5 ] 6 ^ 7 _ 8 ` 9 a : b ; c < d = e > f ? g @ h A i B j C k D l E m F n G o H p I q J r K s L t M u N v O w P x Q y R z S { T | U } V ~ W X � Y � Z ad ) � ) * on * based ad $ � $ * contents. * its ad , � , * it * If ad � " � " * a compressed * is ad * � * * in * file ad $ � $ * Zstandard * the ad � � * then * format, ad � � * is * `pzstd` ad � � * to * used ad � � * the * decompress ad � � * to * contents ad � � * * stdout. ad � � p � * overrides * This ad � � q � * -z/--search-zip * the ad � � o � * * flag. ad w � U � * <GLOB>... * --pre-glob ad z � O � * flag * This ad { � N � * in * works ad s � H � * with * conjunction ad z � P � * --pre * the ad v � N � * Namely, * flag. ad { � O � * one * when ad | � Q � * more * or ad [ = * flags * --pre-glob ad a � D � * given, * are ad b � C � * only * then ad a � B � * that * files ad b � B � * the * match ad b � B � * set * given ad c � E � * globs * of ad L p 7 p * be * will ad J n 5 n * to * handed ad H l 8 l * command * the ad G k 2 k * by * specified ad J n 8 n * --pre * the ad J n 6 n * Any * flag. ad 5 Y / Y * files * non-matching ad 4 X + X * be * will ad + O ' O * without * searched ad 2 V * V * the * using ad & J # J * command. * preprocessor ad 6 # 6 * This * ad ( ( * is * flag ad � ' * w * useful ad � ) * s * when ad � $ * m * searching ad % % * files * many ad ' ' * the * with ad � ( * f * --pre ad � ( * N * flag. ad � ' * * Namely, ad � * it ad � * permits ad � * the ad � * ability ad � * to ad � * avoid ad � * process ad � * overhead ad � * for ad � * files ad � * that ad � * don't ad � * need ad � � � * preprocessing. ad � � � * For ad � � � * example, ad � � � * given ad � � � * the ad � � � * following ad � � � * shell ad � � � * script, ad � � � * 'pre-pdftotext': ad � � � * ad � � � * #!/bin/sh ad � � � * ad � � � * pdftotext ad � � � * "$1" ad � � � * - ad � � � * ad � � � * then ad � � � * it ad � � � * is ad � � � * possible ad � � � * to ad � � � * use ad � � � * '--pre ad � � � * pre-pdftotext ad � � � * --pre-glob ad � � � * '*.pdf'' ad � � � * to ad � � � * make ad � � � * it ad � � � * so ad | � � * ripgrep ad � � * only ad { � � * executes ad � � � * the ad t � � * 'pre-pdftotext' ad | � � * command ad � � � * on ad ~ � � * files ad � � * with ad { � � * a '.pdf' ad m � � * extension. ad k � � * ad W w w * Multiple ad U u u * --pre-glob ad Z z z * flags ad \ | | * may ad ] } } * be ad Z z z * used. ad W w w * Globbing ad Z z z * rules ad Z z z * match ad U u u * .gitignore ad Y y y * globs. ad L l l * Precede ad M m m * a glob ad O o o * with ad M m m * a ! to ad L l l * exclude ad P p p * it. ad G g g * ad 7 W W * This ad 7 W W * flag ad 8 X X * has tp � [ � \ � ] � ^ � _ � ` � a � b � c � d � e � f � g � h � i � j � k � l � m � n � o � p � q � r � s � t � u � v � w � x � y � z � { � | � } � ~ � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � ad 9 Y Y * no ad 5 U U * effect ad 9 Y Y * if ad 8 X X * the ad 6 V V * --pre ad 7 W W * flag ad 9 Y Y * is ad 8 X X * not ad 6 V V * used. ad . N N * ad ' G G * -p, ad & & * --pretty ad : : * This ad < < * is ad 1 1 * a convenience ad 9 9 * alias ad ; ; * for ad 6 6 * '--color ad 8 8 * always ad 5 5 * --heading ad / / * --line-number'. ad : : * This ad . . * flag ad 0 0 * is ad , , * useful ad . . * when ad / / * you ad
- - * still ad . . * want ad , , * pretty ad , , * output ad . . * even ad 0 0 * if ad , , * you're ad , , * piping ad + + * ripgrep ad $ $ * to ad � * another ad � * program ad $ $ * or ad ! ! * file. ad # # * For ad � * example: ad # # * 'rg ad $ $ * -p ad # # * foo ad * | less ad " " * -R'. ad � * ad � * -q, ad � � � * --quiet ad � * Do ad � * not ad � * print ad � * anything ad � * to ad � * stdout. ad � * If ad � * a match ad � * is ad � * found ad � * in ad � * a file, ad � * then ad � * ripgrep ad � � � * will ad � � � * stop ad � � � * searching. ad � � � * This ad � � � * is ad � � � * useful ad � � � * when ad � � � * ripgrep ad � � � * is ad � � � * used ad � � � * only ad � � � * for ad � � � * its ad � � � * exit ad � � � * code ad � � � * (which ad � � � * will ad � � � * be ad � � � * an ad � � � * error ad � � � * if ad � � � * no ad � � � * matches ad � � � * are ad � � � * found). ad � � � * ad � � � * When ad � � � * --files ad � � � * is ad � � � * used, ad � � � * then ad � � � * ripgrep ad � � � * will ad � � � * stop ad � � � * finding ad � � � * files ad � � � * after ad � � � * finding ad � � � * the ad � � � * first ad � � � * file ad � � � * that ad � � � * matches ad � � � * all ad � � � * ignore ad � � � * rules. ad � � � * ad � � � * --regex-size-limit ad � � � * <NUM+SUFFIX?> ad � � � * The ad � � � * upper ad � � � * size ad � � � * limit ad � � � * of ad � � � * the ad � � � * compiled ad � � � * regex. ad � � � * The ad � � � * default ad � � � * limit ad � � � * is ad � � � * 10M. tp � � � � � � �
� � �
� � � � � � � � � � � � � � � � � � � � ! � " � # � $ � % � & � ' � ( � ) * + , - . / 0 1 2 3
4 5 6
7 8 9 : ; < = > ? @ A B C D E F G H I J ! K " L # M $ N % O & P ' Q ( R ) S * T + U , V - W . X / Y 0 Z 1 [ 2 \ 3 ] 4 ^ 5 _ 6 ` 7 a 8 b 9 c : d ; e < f = g > h ? i @ j A k B l C m D n E o F p G q H r I s J t K u L v M w N x O y P z Q { R | S } T ~ U V � W � X ad � � � * ad q � � * The ad l � � * argument ad m � � * accepts ad q � � * the ad p � � * same ad p � � * size ad l � � * suffixes ad r � � * as ad m � � * allowed ad r � � * in ad q � � * the ad f � � * --max-filesize ad c � � * flag. ad [ { { * ad T t t * -e, ad O o o * --regexp ad < \ \ * <PATTERN>... ad B b b * A pattern ad I i i * to ad E e e * search ad G g g * for. ad G g g * This ad E e e * option ad H h h * can ad I i i * be ad C c c * provided ad C c c * multiple ad E e e * times, ad F f f * where ad < \ \ * all ad 7 W W * patterns ad : Z Z * given ad < \ \ * are ad 6 V V * searched. ad : Z Z * Lines ad 7 W W * matching ad = ] ] * at ad : Z Z * least ad < \ \ * one ad = ] ] * of ad < \ \ * the ad 7 W W * provided ad + K K * patterns ad 0 P P * are ad + K K * printed. ad / O O * This ad / O O * flag ad 0 P P * can ad / O O * also ad 1 Q Q * be ad / O O * used ad / O O * when ad * J J * searching ad 0 P P * for ad + K K * patterns ad # C C * that ad " B B * start ad # C C * with ad @ @ * a dash. ad ; ; * ad , , * For ad ' ' * example, ad
- - * to ad ) ) * search ad , , * for ad , , * the ad ( ( * literal ad ( ( * '-foo', ad , , * you ad , , * can ad , , * use ad + + * this ad
* * * flag: ad # # * ad � * rg ad � * -e ad � * -foo ad � * ad � � � * You ad � � � * can ad � � � * also ad � � � * use ad � � � * the ad � � � * special ad � � � * '--' ad � � � * delimiter ad � � � * to ad � � � * indicate ad � � � * that ad � � � * no ad � � � * more ad � � � * flags ad � � � * will ad � � � * be ad � � � * provided. ad � � � * Namely, ad � � � * the ad � � � * following ad � � � * is ad � � � * equivalent ad � � � * to ad � � � * the ad � � � * above: ad � � � * ad � � � * rg ad � � � * -- ad � � � * -foo ad � � � * ad � � � * -r, ad � � � * --replace ad � � � * <REPLACEMENT_TEXT> ad � � � * Replace ad � � � * every ad � � � * match ad � � � * with ad � � � * the ad � � � * text ad � � � * given ad � � � * when ad � � � * printing ad � � � * results. ad � � � * Neither ad � � � * this ad � � � * flag ad � � � * nor ad � � � * any tp � Y � Z � [ � \ � ] � ^ � _ � ` � a � b � c � d � e � f � g � h � i � j � k � l � m � n � o � p � q � r � s � t � u � v � w � x � y � z � { � | � } � ~ � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � ad � � � * other ad � � � * ripgrep ad � � � * flag ad � � � * will ad � � � * modify ad � � � * your ad � � � * files. ad ~ � � * ad k � � * Capture ad m � � * group ad k � � * indices ad l � � * (e.g., ad o � � * $5) ad o � � * and ad m � � * names ad l � � * (e.g., ad m � � * $foo) ad o � � * are ad i � � * supported ad p � � * in ad o � � * the ad [ { { * replacement ad _ * string. ad _ * Capture ad a � � * group ad _ * indices ad c � � * are ad ^ ~ ~ * numbered ad a � � * based ad d � � * on ad c � � * the ad ^ ~ ~ * position ad d � � * of ad W w w * the ad S s s * opening ad O o o * paranthesis ad X x x * of ad W w w * the ad T t t * group, ad U u u * where ad W w w * the ad R r r * leftmost ad V v v * such ad U u u * group ad X x x * is ad W w w * $1. ad W w w * The ad G g g * special ad L l l * $0 ad I i i * group ad C c c * corresponds ad L l l * to ad K k k * the ad H h h * entire ad H h h * match. ad B b b * ad 4 T T * In ad 0 P P * shells ad 2 R R * such ad 4 T T * as ad 2 R R * Bash ad 3 S S * and ad 2 R R * zsh, ad 3 S S * you ad 0 P P * should ad 2 R R * wrap ad 3 S S * the ad / O O * pattern ad 4 T T * in ad 0 P P * single ad 0 P P * quotes ad # C C * instead ad ( H H * of ad $ D D * double ad # C C * quotes. ad @ @ * Otherwise, ad # C C * capture ad % E E * group ad # C C * indices ad & F F * will ad ( H H * be ad " B B * replaced ad ( H H * by ad 6 6 * expanded ad 9 9 * shell ad 5 5 * variables ad 9 9 * which ad : : * will ad : : * most ad 8 8 * likely ad < < * be ad 8 8 * empty. ad 2 2 * ad $ $ * To ad ! ! * write ad � * a literal ad " " * '$', ad # # * use ad ! ! * '$$'. ad � * ad �
* Note ad �
* that ad � * the ad � * replacement ad � * by ad � * default ad � * replaces ad �
* each ad � * match, ad � * and ad � * NOT ad � * the ad � * entire ad � � � * line. ad � * To ad � � � * replace ad � � � * the ad � � � * entire ad � � � * line, ad � � � * you ad � � � * should ad � � � * match ad � � � * the ad � � � * entire ad � � � * line. ad � � � * ad � � � * This tp � � � � � � �
� � �
� � � � � � � � � � � � � � � � � � � � ! � " � # � $ � % � & � ' � ( � ) � * � + , - . / 0 1 2 3 4 5
6 7 8
9 : ; < = > ? @ A B C D E F G H I J K L ! M " N # O $ P % Q & R ' S ( T ) U * V + W , X - Y . Z / [ 0 \ 1 ] 2 ^ 3 _ 4 ` 5 a 6 b 7 c 8 d 9 e : f ; g < h = i > j ? k @ l A m B n C o D p E q F r G s H t I u J v K w L x M y N z O { P | Q } R ~ S T � U � V ad � � � * flag ad � � � * can ad � � � * be ad � � � * used ad � � � * with ad � � � * the ad � � � * -o/--only-matching ad � � � * flag. ad � � � * ad � � � * -z, ad � � � * --search-zip ad � � � * Search ad � � � * in ad � � � * compressed ad � � � * files. ad � � � * Currently ad � � � * gzip, ad � � � * bzip2, ad � � � * xz, ad � � � * LZ4, ad � � � * LZMA, ad � � � * Brotli ad � � � * and ad � � � * Zstd ad � � � * files ad � � � * are ad � � � * supported. ad � � � * This ad � � � * option ad � � � * expects ad � � � * the ad � � � * decompression ad � � � * binaries ad � � � * to ad � � � * be ad � � � * available ad � � � * in ad � � � * your ad � � � * PATH. ad � � � * ad y � � * This ad y � � * flag ad z � � * can ad { � � * be ad u � � * disabled ad y � � * with ad m � � * --no-search-zip. ad p � � * ad i � � * -S, ad H h h * --smart-case ad X x x * Searches ad \ | | * case ad S s s * insensitively ad ^ ~ ~ * if ad ] } } * the ad Y y y * pattern ad ^ ~ ~ * is ad ] } } * all ad V v v * lowercase. ad Z z z * Search ad \ | | * case ad I i i * sensitively ad J j j * otherwise. ad H h h * ad 8 X X * This ad 3 S S * overrides ad 9 Y Y * the ad ) I I * -s/--case-sensitive ad 9 Y Y * and ad , L L * -i/--ignore-case ad 6 V V * flags. ad / O O * ad ! A A * --sort ad
* * * <SORTBY> ad 7 7 * This ad 7 7 * flag ad 4 4 * enables ad 4 4 * sorting ad 9 9 * of ad 4 4 * results ad 9 9 * in ad 2 2 * ascending ad 5 5 * order. ad 8 8 * The ad 3 3 * possible ad 5 5 * values ad , , * for ad + + * this ad + + * flag ad + + * are: ad # # * ad � * none ad �
* (Default) ad � * Do ad � * not ad � * sort ad � * results. ad � * Fastest. ad � * Can ad � * be ad � * multi-threaded. ad � � � * path ad � � � * Sort ad � * by ad � � � * file ad � � � * path. ad � � � * Always ad � � � * single-threaded. ad � � � * modified ad � � � * Sort ad � � � * by ad � � � * the ad � � � * last ad � � � * modified ad � � � * time ad � � � * on ad � � � * a file. ad � � � * Always ad � � � * single-threaded. ad � � � * accessed ad � � � * Sort ad � � � * by ad � � � * the ad � � � * last ad � � � * accessed ad � � � * time ad � � � * on tp � W � X � Y � Z � [ � \ � ] � ^ � _ � ` � a � b � c � d � e � f � g � h � i � j � k � l � m � n � o � p � q � r � s � t � u � v � w � x � y � z � { � | � } � ~ � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � ad � � � * a file. ad � � � * Always ad � � � * single-threaded. ad � � � * created ad � � � * Sort ad � � � * by ad � � � * the ad � � � * creation ad � � � * time ad � � � * on ad � � � * a file. ad � � � * Always ad � � � * single-threaded. ad � � � * ad � � � * If ad � � � * the ad � � � * chosen ad � � � * (manually ad � � � * or ad � � � * by-default) ad � � � * sorting ad � � � * criteria ad � � � * isn't ad � � � * available ad � � � * on ad � � � * your ad � � � * system ad � � � * (for ad � � � * example, ad � � � * creation ad � � � * time ad � � � * is ad � � � * not ad � � � * available ad � � � * on ad � � � * ext4 ad � � � * file ad � � � * systems), ad � � � * then ad | � � * ripgrep ad � � * will ad | � � * attempt ad � � � * to ad } � � * detect ad ~ � � * this, ad ~ � � * print ad � � � * an ad ~ � � * error ad � � � * and ad � � * exit ad | � � * without ad y � � * searching. ad w � � * ad i � � * To ad g � � * sort ad d � � * results ad i � � * in ad d � � * reverse ad i � � * or ad a � � * descending ad e � � * order, ad h � � * use ad h � � * the ad d � � * --sortr ad f � � * flag. ad f � � * Also, ad [ { { * this ad [ { { * flag ad V v v * overrides ad W w w * --sortr. ad S s s * ad C c c * Note ad C c c * that ad @ ` ` * sorting ad @ ` ` * results ad > ^ ^ * currently ad A a a * always ad A a a * forces ad @ ` ` * ripgrep ad E e e * to ad @ ` ` * abandon ad 0 P P * parallelism ad 8 X X * and ad 8 X X * run ad 9 Y Y * in ad 3 S S * a single ad 4 T T * thread. ad . N N * ad ? ? * --sortr ad
* * * <SORTBY> ad 6 6 * This ad 6 6 * flag ad 3 3 * enables ad 3 3 * sorting ad 8 8 * of ad 3 3 * results ad 8 8 * in ad 0 0 * descending ad 4 4 * order. ad 7 7 * The ad 2 2 * possible ad 4 4 * values ad + + * for ad
* * * this ad
* * * flag ad
* * * are: ad " " * ad � * none ad � * (Default) ad � * Do ad � * not ad � * sort ad �
* results. ad �
* Fastest. ad � * Can ad � * be ad � * multi-threaded. ad � � � * path ad � � � * Sort ad � * by ad � � � * file ad � � � * path. ad � � � * Always ad � � � * single-threaded. ad � � � * modified ad � � � * Sort ad � � � * by tp � � � � � � �
� � �
� � � � � � � � � � � � � � � � � � � � ! � " � # � $ � % � & � ' � ( � ) � * � + � , � - . / 0 1 2 3 4 5 6 7
8 9 :
; < = > ? @ A B C D E F G H I J K L M N ! O " P # Q $ R % S & T ' U ( V ) W * X + Y , Z - [ . \ / ] 0 ^ 1 _ 2 ` 3 a 4 b 5 c 6 d 7 e 8 f 9 g : h ; i < j = k > l ? m @ n A o B p C q D r E s F t G u H v I w J x K y L z M { N | O } P ~ Q R � S � T ad � � � * the ad � � � * last ad � � � * modified ad � � � * time ad � � � * on ad � � � * a file. ad � � � * Always ad � � � * single-threaded. ad � � � * accessed ad � � � * Sort ad � � � * by ad � � � * the ad � � � * last ad � � � * accessed ad � � � * time ad � � � * on ad � � � * a file. ad � � � * Always ad � � � * single-threaded. ad � � � * created ad � � � * Sort ad � � � * by ad � � � * the ad � � � * creation ad � � � * time ad � � � * on ad � � � * a file. ad � � � * Always ad � � � * single-threaded. ad � � � * ad � � � * If ad � � � * the ad � � � * chosen ad � � � * (manually ad � � � * or ad � � � * by-default) ad � � � * sorting ad � � � * criteria ad � � � * isn't ad � � � * available ad � � � * on ad � � � * your ad � � � * system ad � � � * (for ad � � � * example, ad � � � * creation ad � � � * time ad � � � * is ad � � � * not ad � � � * available ad � � � * on ad � � � * ext4 ad � � � * file ad � � � * systems), ad � � � * then ad { � � * ripgrep ad ~ � � * will ad { � � * attempt ad � � � * to ad | � � * detect ad } � � * this, ad } � � * print ad � � � * an ad } � � * error ad � � * and ad ~ � � * exit ad { � � * without ad x � � * searching. ad v � � * ad h � � * To ad f � � * sort ad c � � * results ad h � � * in ad a � � * ascending ad d � � * order, ad g � � * use ad g � � * the ad d � � * --sort ad e � � * flag. ad e � � * Also, ad f � � * this ad f � � * flag ad U u u * overrides ad W w w * --sort. ad R r r * ad B b b * Note ad B b b * that ad ? _ _ * sorting ad ? _ _ * results ad = ] ] * currently ad @ ` ` * always ad @ ` ` * forces ad ? _ _ * ripgrep ad D d d * to ad ? _ _ * abandon ad / O O * parallelism ad 7 W W * and ad 7 W W * run ad 8 X X * in ad 2 R R * a single ad 3 S S * thread. ad - M M * ad ! ! * --stats ad 4 4 * Print ad 0 0 * aggregate ad / / * statistics ad 4 4 * about ad 5 5 * this ad 2 2 * ripgrep ad 2 2 * search. ad 5 5 * When ad 5 5 * this ad 5 5 * flag ad 7 7 * is ad % % * present, ad & & * ripgrep ad ) ) * will ad ( ( * print ad
* * * the ad $ $ * following ad ( ( * stats ad + + * to ad ' ' * stdout ad + + * at ad
* * * the ad
* * * end ad + + * of tp/ � U � V � W � X � Y � Z � [ � \ � ] � ^ � _ � ` � a � b � c � d � e � f � g � h � i � j � k � l � m � n � o � p � q � r � s � t � u � v � w � x � y � z � { � | � } � ~ � � � � � � � � � ad
* * * the ad � * search: ad � * number ad � * of ad � * matched ad � * lines, ad � * number ad � * of ad � * files ad � * with ad � * matches, ad � * number ad � * of ad � * files ad � * searched, ad � * and ad � * the ad � * time ad � * taken ad � * for ad � * the ad � * entire ad � * search ad � * to ad � * complete. ad � * ad � � � * This ad � � � * set ad � � � * of ad � � � * aggregate ad � � � * statistics ad � � � * may ad � � � * expand ad � � � * over ad � � � * time. ad � � � * ad � � � * Note ad � � � * that ad � � � * this ad � � � * flag ad � � � * has ad � � � * no ad � � � * effect ad � � � * if ad � � � * --files, ad � � � * --files-with-match