Enter this in a file:
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Hello
A
Hello
B
And then search for this using /:
\(Hello\n\)\#<=A
On my version of Vim (7.4, included patches: 1-582), the A underneath Hello is matched as expected, B is not, but also the 446th A on the first line is matched.
There is also some weird behaviour with this, if I make the line longer with more As, the 632nd A is highlighted. If I introduce 16 spaces at the beginning of the line, the 447th and the 632nd characters on the line are matched.
My question is, does this affect anyone else, and is it really a bug or is my search erroneous?
Yes, this looks like a bug. I can reproduce with Vim 7.4.608, but only with the default :set regexpengine=0 automatic selection.
To avoid the problem, you can either change the global option, or explicitly specify an engine inside the pattern:
\%#=1\(Hello\n\)\#<=A
\%#=2\(Hello\n\)\#<=A
Please report this bug, either to the vim_dev mailing list, or its issue tracker.
Related
I have long text files (.srt subtitle files, actually) - which unfortunately include a lot of irrelevant/distracting information.
All irrelevant text is enclosed within identical pairs of pilcrow (paragraph) characters: ¶
So for example, some text would look like this:
This is important, and ¶junk trash garbage rubbish¶ I would like to
keep it.
Obviously, I want to remove everything between the ¶ characters and keep the rest. It doesn't matter whether the ¶ characters themselves are stripped or retained: if they're retained, it's trivial just to remove them directly with a subsequent search/replace - so I just need whatever pattern match is easiest.
Note that the ¶ symbols come in identical pairs, so it's not as simple as, for example, stripping out everything between [asymetrical characters].
I'm not working on any particular platform. In fact, I was hoping to use a web-based tool to do it like this one.
I just need the regex - if anyone can assist! Alternatively, if there are better ways than regex, I'd be grateful for suggestions.
Edit: It has been suggested that this question (Remove text in-between delimiters in a string (using a regex?)) answers what I'm looking for. Thanks, but unfortunately it doesn't. That relates to using it in C# (which I don't know), and the answers to that question do not explain exactly how to replicate what I want. I want it to work in the online tool to which I linked.
Update: A good answer works, but only if the unwanted text appears in-line. I also need it to remove text where the entire line is unwanted:
779 00:35:52,216 --> 00:35:54,784
I miss him already.
780 00:36:00,291 --> 00:36:03,727
¶ If you ever need someone ¶
665
00:30:21,821 --> 00:30:25,589
¶ Feels like
sometimes you want to ¶
So I want to remove everything which appears between the ¶ symbols, regardless of where they appeal in the line, and regardless of the presence of line breaks.
Second Update
Subsequent to the accepted answer, it seems it's not entirely working. In the example here, the regex provided does not work in the first multi-line instance. I have no clue what's wrong. I just want line breaks (or any other characters) to be irrelevant in the consideration. The request is simply to delete everything between pairs of ¶ characters, regardless of where they appear, and regardless of what else lies between.
Final (hopefully) update
For reference, and thanks to user MDR, we have the solution: (¶[\S\s]*?¶)
Updated because of new information in question and comments below this answer.
That online tool you quoted seems to extract text (perhaps not what you want here - you want to remove the bit found). Maybe instead use a local text editor (xed, Gedit, Textedit, TextWrangler, Visual Code Studio, Atom, NotePad++ on Windows etc.) that has find and replace but with a regex option and find...
(¶[\S\s]*?¶)
...and replace with nothing. Demo: https://regex101.com/r/4v9gXj/8
If I may suggest regexr.com. Use as pattern ¶.*?¶ and then switch to Replace section as the screenshot shows.
I'm doing little replace job: I want to remove some double quotes that should not be there for correct syntax, in image below.
therefore I built a regex that captures such a pattern into double-quoteless one, namely
however, when I run "replace all",
double quotes are removed as expected, but upper- and lower-case are affected weirdly, as you can see. What am I doing wrong? Is this expected result?
Sorry, I found it myself - if Preserve case(Alt+A in windows) is turned on, it will show such a behaviour. Turning off that solved the problem.
I have lines like
SC2268,Registration lauch causes a menu of what the user wants to do
I need to change this to
[SC2268]:Registration lauch causes a menu of what the user wants to do
I have tried the following things:
1.%s/\(\w\+\),\(\w\+\)/\[1]:\2/gi
2.%s/\(SC[0-9]*\)/\[1]/gi
But no luck.
:%s/^\([^,]*\),/[\1]:/
looks reasonable to me (EDIT: Thanks #Sven for pointing out I needed to change the , into :)
You're close. The symbol to insert the first match is \1; the backslash must be directly before the number:
:%s/\(SC[0-9]*\)/[\1]/gi
The escaping and syntax of the {pattern} and {replacement} parts in :s/{pattern}/{replacement}/ are different! When in doubt, please consult the help:
:help pattern
:help s/\1
Also note that there are shorter ways for this particular one; see (and try to understand) #bobbogo's answer.
I am trying to write a regular expression which finds all the comments in text.
For example all between /* */.
Example:
/* Hello */
When I do this:/\*.*\*/, it behaves odd and nothing is shown. What is wrong with it?
EDIT: The comments can be spread across multiple lines
Unlike the example posted above, you were trying to match comments that spanned multiple lines. By default, . does not match a line break. Thus you have to enable multi-line mode in the regex to match multi-line comments.
Also, you probably need to use .*? instead of .*. Otherwise it will make the largest match possible, which will be everything between the first open comment and the last close comment.
I don't know how to enable multi-line matching mode in Sublime Text 2. I'm not sure it is available as a mode. However, you can insert a line break into the actual pattern by using CTRL + Enter. So, I would suggest this alternative:
/\*(.|\n)*?\*/
If Sublime Text 2 doesn't recognize the \n, you could alternatively use CTRL + Enter to insert a line break in the pattern, in place of \n.
I encountered this problem several years ago and wrote an entire article about it.
If you don't have access to non-greedy matching (not all regex libraries support non-greedy) then you should use this regex:
/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+/
If you do have access to non-greedy matching then you can use:
/\*(.|[\r\n])*?\*/
Also, keep in mind that regular expressions are just a heuristic for this problem. Regular expressions don't support cases in which something appears to be a comment to the regular expression but actually isn't:
someString = "An example comment: /* example */";
// The comment around this code has been commented out.
// /*
some_code();
// */
Just want to add for HTML Comments is is this
\<!--(.|\n)*?-->
Just an additionnal note about using regex to remove comments inside a programming language file.
Warning!
Doing this you must not forget the case where you have the string /* or */ inside a string in the code - like var string = "/*"; - (we never know if you parse a huge code that is not yours)!
So the best is to parse the document with a programming language and have a boolean to save the state of an open string (and ignore any match inside open string).
Again a string delimited by " can contain a \" so pay attention with the regex!
You cannot write a regular expression that would be able to correctly find all comments, or even one type of comments - single-line or multiline.
Regular expressions can only provide a partial match, one that would would cover perhaps 90% of all cases, but that's it.
The syntax for regular expression is so complex, it is only possible to identify them correctly in 100% of cases by doing a full expression evaluation, which in turn is based on tokenizing the code. The latter is a huge task, which is implemented by all AST parsers today. See AST Explorer
Only a proper-written AST parser can tell you precisely where all regular expressions are located in your code. You would have to write a parser then based on that.
Or, you could use one of the existing libraries that already do all that, like decomment.
RegEx examples where any head-on approach is going to stumble, being unable to tell a regular expression from a comment block:
/\// - it will think this reg-ex is a single-line comment
/\/*/ - it will think this reg-ex opens a multi-line comment
The answer which user1919238 wrote works. Just corroborating that here, although the many upvotes probably do give you a clue.
It got rid of all these annoying block comments, put here just to show the usefulness/thank user1919238 for saving time:
/*# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIndlYnBhY2s6Ly9zdHlsZXMvZ2xvYmFscy5jc3MiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0VBRUUsVUFBVTtFQUNWLFNBQVM7RUFDVDt3RUFDc0U7QUFDeEU7O0FBRUE7RUFDRSxjQUFjO0VBQ2QscUJBQXFCO0FBQ3ZCOztBQUVBO0VBQ0Usc0JBQXNCO0FBQ3hCIiwic291cmNlc0NvbnRlbnQiOlsiaHRtbCxcbmJvZHkge1xuICBwYWRkaW5nOiAwO1xuICBtYXJnaW46IDA7XG4gIGZvbnQtZmFtaWx5OiAtYXBwbGUtc3lzdGVtLCBCbGlua01hY1N5c3RlbUZvbnQsIFNlZ29lIFVJLCBSb2JvdG8sIE94eWdlbixcbiAgICBVYnVudHUsIENhbnRhcmVsbCwgRmlyYSBTYW5zLCBEcm9pZCBTYW5zLCBIZWx2ZXRpY2EgTmV1ZSwgc2Fucy1zZXJpZjtcbn1cblxuYSB7XG4gIGNvbG9yOiBpbmhlcml0O1xuICB0ZXh0LWRlY29yYXRpb246IG5vbmU7XG59XG5cbioge1xuICBib3gtc2l6aW5nOiBib3JkZXItYm94O1xufVxuIl0sInNvdXJjZVJvb3QiOiIifQ== */
/*# sourceMappingURL=data:application/json;base64,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 */
/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["webpack://styles/custom.module.css"],"names":[],"mappings":"AAAA;EACE,UAAU;EACV,SAAS;EACT;wEACsE;EACtE,kBAAkB;EAClB,kBAAkB;AACpB;AACA;EACE,UAAU;EACV,SAAS;EACT,cAAc;EACd,eAAe;AACjB;AACA;EACE,UAAU;EACV,SAAS;EACT,eAAe;EACf,cAAc;AAChB;AACA;EACE,eAAe;EACf,YAAY;AACd;AACA;;;EAGE,eAAe;EACf,cAAc;AAChB;AACA;EACE,kBAAkB;EAClB,YAAY;AACd;AACA;;;EAGE,eAAe;EACf,cAAc;AAChB;AACA;EACE,gBAAgB;EAChB,mBAAmB;AACrB;AACA;EACE,eAAe;EACf,4CAA4C;AAC9C;AACA;EACE,eAAe;EACf,4CAA4C;AAC9C;AACA;EACE,kBAAkB;EAClB,oBAAoB;EACpB,cAAc;EACd,0BAA0B;AAC5B;AACA;EACE,kBAAkB;EAClB,eAAe;AACjB;;AAEA;EACE,YAAY;EACZ,eAAe;EACf,eAAe;EACf,gBAAgB;EAChB,cAAc;EACd,qBAAqB;EACrB,yBAAyB;EACzB,mBAAmB;EACnB,qDAAqD;AACvD;;AAEA;EACE,kBAAkB;EAClB,iBAAiB;AACnB;;AAEA;EACE,SAAS;EACT,kBAAkB;EAClB,gBAAgB;AAClB;;AAEA;EACE,YAAY;EACZ,eAAe;EACf,eAAe;EACf,gBAAgB;EAChB,cAAc;EACd,qBAAqB;EACrB,yBAAyB;EACzB,mBAAmB;EACnB,qDAAqD;AACvD;AACA;;;EAGE,cAAc;EACd,qBAAqB;AACvB;AACA;EACE,YAAY;EACZ,mBAAmB;AACrB;AACA;;;EAGE,cAAc;EACd,qBAAqB;EACrB,eAAe;AACjB;AACA;EACE,aAAa;EACb,mBAAmB;EACnB,uBAAuB;EACvB,eAAe;EACf,gBAAgB;EAChB,gBAAgB;AAClB;AACA;EACE,mBAAmB;EACnB,mBAAmB;EACnB,uBAAuB;EACvB,iBAAiB;EACjB,gBAAgB;EAChB,gBAAgB;AAClB;AACA;EACE,iBAAiB;EACjB,mBAAmB;EACnB,uBAAuB;EACvB,iBAAiB;EACjB,gBAAgB;EAChB,gBAAgB;AAClB;AACA;EACE,mBAAmB;EACnB,mBAAmB;EACnB,uBAAuB;EACvB,iBAAiB;EACjB,gBAAgB;EAChB,gBAAgB;AAClB;AACA;EACE,iBAAiB;EACjB,iBAAiB;EACjB,aAAa;EACb,sBAAsB;EACtB,uBAAuB;EACvB,mBAAmB;AACrB;;AAEA;EACE,eAAe;EACf,SAAO;EACP,aAAa;EACb,sBAAsB;EACtB,uBAAuB;EACvB,mBAAmB;AACrB;;AAEA;EACE,WAAW;EACX,aAAa;EACb,6BAA6B;EAC7B,aAAa;EACb,uBAAuB;EACvB,mBAAmB;AACrB;;AAEA;EACE,mBAAmB;AACrB;;AAEA;EACE,aAAa;EACb,uBAAuB;EACvB,mBAAmB;AACrB;;AAEA;EACE,cAAc;EACd,qBAAqB;AACvB;;AAEA;;;EAGE,0BAA0B;AAC5B;;AAEA;EACE,SAAS;EACT,iBAAiB;EACjB,eAAe;AACjB;;AAEA;;EAEE,kBAAkB;AACpB;AACA;EACE,gBAAgB;EAChB,iBAAiB;AACnB;AACA;EACE,eAAe;EACf,gBAAgB;EAChB,iBAAiB;EACjB,kBAAkB;AACpB;AACA;EACE,mBAAmB;EACnB,kBAAkB;EAClB,gBAAgB;EAChB,iBAAiB;EACjB;oDACkD;AACpD;;AAEA;EACE,aAAa;EACb,mBAAmB;EACnB,uBAAuB;EACvB,eAAe;EACf,gBAAgB;EAChB,gBAAgB;AAClB;AACA;EACE,YAAY;EACZ,eAAe;EACf,eAAe;EACf,gBAAgB;EAChB,cAAc;EACd,qBAAqB;EACrB,2BAAmB;UAAnB,mBAAmB;EACnB,4BAA4B;EAC5B,mBAAmB;EACnB,qDAAqD;AACvD;AACA;;;EAGE,YAAY;EACZ,mBAAmB;AACrB;AACA;EACE,kBAAkB;EAClB,iBAAiB;AACnB;;AAEA;EACE,SAAS;EACT,kBAAkB;EAClB,gBAAgB;AAClB;AACA;EACE,YAAY;EACZ,eAAe;EACf,eAAe;EACf,gBAAgB;EAChB,cAAc;EACd,qBAAqB;EACrB,2BAAmB;UAAnB,mBAAmB;EACnB,wBAAwB;EACxB,mBAAmB;EACnB,qDAAqD;AACvD;AACA;;;EAGE,aAAa;EACb,oBAAoB;AACtB;AACA;EACE,kBAAkB;EAClB,iBAAiB;AACnB;;AAEA;EACE,SAAS;EACT,kBAAkB;EAClB,gBAAgB;AAClB;;AAEA;EACE,YAAY;EACZ,eAAe;EACf,eAAe;EACf,gBAAgB;EAChB,cAAc;EACd,qBAAqB;EACrB,yBAAyB;EACzB,mBAAmB;EACnB,qDAAqD;AACvD;;AAEA;;;EAGE,cAAc;EACd,qBAAqB;AACvB;AACA;EACE,kBAAkB;EAClB,iBAAiB;AACnB;;AAEA;EACE,SAAS;EACT,kBAAkB;EAClB,gBAAgB;AAClB;;AAEA;EACE,WAAW;AACb;AACA;EACE,aAAa;AACf;AACA;EACE,aAAa;EACb,kBAAkB;EAClB,kBAAkB;AACpB;AACA;EACE,UAAU;AACZ;AACA;EACE,aAAa;AACf;AACA;EACE,WAAW;AACb;AACA;EACE,SAAS;AACX;AACA;EACE,iBAAiB;AACnB;AACA;EACE;AACF;AACA;EACE,kBAAkB;AACpB;AACA;EACE,aAAa;AACf;AACA;EACE,UAAU;AACZ;;;;;AAKA;EACE;IACE,WAAW;IACX,sBAAsB;EACxB;AACF","sourcesContent":[".linklink {\n  padding: 0;\n  margin: 0;\n  font-family: -apple-system, BlinkMacSystemFont, Segoe UI, Roboto, Oxygen,\n    Ubuntu, Cantarell, Fira Sans, Droid Sans, Helvetica Neue, sans-serif;\n  font-style: italic;\n  font-size: inherit;\n}\n.linklink:hover {\n  padding: 1;\n  margin: 0;\n  color: #0070f3;\n  font-size: 110%;\n}\n.linklink:active {\n  padding: 1;\n  margin: 0;\n  font-size: 115%;\n  color: #ffac33;\n}\n.pagesymbol {\n  font-size: 3rem;\n  color: white;\n}\n.pagesymbol:hover,\n.pagesymbol:focus,\n.pagesymbol:active {\n  font-size: 6rem;\n  color: #0070f3;\n}\n.pagesymbol text {\n  font-size: 0.0005%;\n  color: white;\n}\n.pagesymbol text:hover,\n.pagesymbol text:focus,\n.pagesymbol text:active {\n  font-size: 2rem;\n  color: #ffac33;\n}\n.gigantic{\n  font-size: 200px;\n  text-align: inherit;\n}\n.workscited {\n  font-size: 12pt;\n  font-family: \"Times New Roman\", Times, serif;\n}\n.workscited pp {\n  font-size: 12pt;\n  font-family: \"Times New Roman\", Times, serif;\n}\n.href {\n  font-size: inherit;\n  font-weight: inherit;\n  color: #0070f3;\n  text-decoration: underline;\n}\n.scansion {\n  font-family: Menlo;\n  font-size: 11pt;\n}\n\n.checkboxcard {\n  margin: 1rem;\n  flex-basis: 45%;\n  padding: 1.5rem;\n  text-align: left;\n  color: inherit;\n  text-decoration: none;\n  border: 1px solid #eaeaea;\n  border-radius: 10px;\n  transition: color 0.15s ease, border-color 0.15s ease;\n}\n\n.checkboxcard h3 {\n  margin: 0 0 1rem 0;\n  font-size: 1.5rem;\n}\n\n.checboxcard p {\n  margin: 0;\n  font-size: 1.25rem;\n  line-height: 1.5;\n}\n\n.checkboxcard checkbox {\n  margin: 1rem;\n  flex-basis: 45%;\n  padding: 0.3rem;\n  text-align: left;\n  color: inherit;\n  text-decoration: none;\n  border: 1px solid #eaeaea;\n  border-radius: 10px;\n  transition: color 0.15s ease, border-color 0.15s ease;\n}\n.checkboxcard checkbox:hover,\n.checkboxcard checkbox:focus,\n.checkboxcard checkbox:active {\n  color: #0070f3;\n  border-color: #0070f3;\n}\n.checkboxcard oppositebox {\n  color: white;\n  border-color: white;\n}\n.checkboxcard oppositebox:hover,\n.checkboxcard oppositebox:focus,\n.checkboxcard oppositebox:active {\n  color: #0070f3;\n  border-color: #0070f3;\n  font-size: 2rem;\n}\n.grid {\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  flex-wrap: wrap;\n  max-width: 800px;\n  margin-top: 3rem;\n}\n.stack {\n  display: -moz-stack;\n  align-items: center;\n  justify-content: center;\n  flex-wrap: nowrap;\n  max-width: 800px;\n  margin-top: 3rem;\n}\n.box {\n  display: -moz-box;\n  align-items: center;\n  justify-content: center;\n  flex-wrap: nowrap;\n  max-width: 800px;\n  margin-top: 3rem;\n}\n.popup {\n  display: -moz-popup;\n  align-items: center;\n  justify-content: center;\n  flex-wrap: nowrap;\n  max-width: 800px;\n  margin-top: 3rem;\n}\n.container {\n  min-height: 100vh;\n  padding: 0 0.5rem;\n  display: flex;\n  flex-direction: column;\n  justify-content: center;\n  align-items: center;\n}\n\n.main {\n  padding: 5rem 0;\n  flex: 1;\n  display: flex;\n  flex-direction: column;\n  justify-content: center;\n  align-items: center;\n}\n\n.footer {\n  width: 100%;\n  height: 100px;\n  border-top: 1px solid #eaeaea;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n}\n\n.footer img {\n  margin-left: 0.5rem;\n}\n\n.footer a {\n  display: flex;\n  justify-content: center;\n  align-items: center;\n}\n\n.title a {\n  color: #0070f3;\n  text-decoration: none;\n}\n\n.title a:hover,\n.title a:focus,\n.title a:active {\n  text-decoration: underline;\n}\n\n.title {\n  margin: 0;\n  line-height: 1.15;\n  font-size: 4rem;\n}\n\n.title,\n.description {\n  text-align: center;\n}\n.description {\n  line-height: 1.5;\n  font-size: 1.5rem;\n}\n.descriptleft {\n  line-height:1.5;\n  font-size:1.5rem;\n  text-align:center;\n  text-justify: left;\n}\n.code {\n  background: #fafafa;\n  border-radius: 5px;\n  padding: 0.75rem;\n  font-size: 1.1rem;\n  font-family: Menlo, Monaco, Lucida Console, Liberation Mono, DejaVu Sans Mono,\n    Bitstream Vera Sans Mono, Courier New, monospace;\n}\n\n.grid {\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  flex-wrap: wrap;\n  max-width: 800px;\n  margin-top: 3rem;\n}\n.correct {\n  margin: 1rem;\n  flex-basis: 45%;\n  padding: 1.5rem;\n  text-align: left;\n  color: inherit;\n  text-decoration: none;\n  text-emphasis: bold;\n  border: 1px solid lightgreen;\n  border-radius: 10px;\n  transition: color 0.15s ease, border-color 0.15s ease;\n}\n.correct:hover,\n.correct:focus,\n.correct:active {\n  color: green;\n  border-color: green;\n}\n.correct h3 {\n  margin: 0 0 1rem 0;\n  font-size: 1.5rem;\n}\n\n.correct p {\n  margin: 0;\n  font-size: 1.25rem;\n  line-height: 1.5;\n}\n.ok {\n  margin: 1rem;\n  flex-basis: 45%;\n  padding: 1.5rem;\n  text-align: left;\n  color: inherit;\n  text-decoration: none;\n  text-emphasis: bold;\n  border: 1px solid yellow;\n  border-radius: 10px;\n  transition: color 0.15s ease, border-color 0.15s ease;\n}\n.ok:hover,\n.ok:focus,\n.ok:active {\n  color: orange;\n  border-color: orange;\n}\n.ok h3 {\n  margin: 0 0 1rem 0;\n  font-size: 1.5rem;\n}\n\n.ok p {\n  margin: 0;\n  font-size: 1.25rem;\n  line-height: 1.5;\n}\n\n.card {\n  margin: 1rem;\n  flex-basis: 45%;\n  padding: 1.5rem;\n  text-align: left;\n  color: inherit;\n  text-decoration: none;\n  border: 1px solid #eaeaea;\n  border-radius: 10px;\n  transition: color 0.15s ease, border-color 0.15s ease;\n}\n\n.card:hover,\n.card:focus,\n.card:active {\n  color: #0070f3;\n  border-color: #0070f3;\n}\n.card h3 {\n  margin: 0 0 1rem 0;\n  font-size: 1.5rem;\n}\n\n.card p {\n  margin: 0;\n  font-size: 1.25rem;\n  line-height: 1.5;\n}\n\n.logo {\n  height: 1em;\n}\n.space2 {\n  line-height:2;\n}\n._215 {\n  line-height:2;\n  font-size: 1.25rem;\n  text-align: center;\n}\n.cyan {\n  color:cyan;\n}\n.magenta {\n  color:magenta;\n}\n.green {\n  color:green;\n}\n.red {\n  color:red;\n}\n.lcoral {\n  color: lightcoral;\n}\n.lsalmon{\n  color: lightsalmon\n}\n.greenyellow{\n  color: greenyellow;\n}\n.skyblue {\n  color:skyblue;\n}\n.blue {\n  color:blue;\n}\n\n\n\n\n@media (max-width: 600px) {\n  .grid {\n    width: 100%;\n    flex-direction: column;\n  }\n}\n"],"sourceRoot":""} */
if you want to replace the obnoxious comment from flutter main.dart,
Press cmd +r on mac or cntrl+ r on windows,
type //.* into the box above, leave the box below empty
click .* on the replace dialog, to activate regex,
then click on replace all. this will remove all your comments, you can do this if you want to remove all comments in any file in a flutter.
Additional, to reformat the main.dart
press cmd+a on mac and cntrl+a on windows,
then press cmd+alt(option)+l or cntrl+alt+l, this will reformat the code.
I will attach a picture of the main. dart, the green .* at the top of the page is what you will press to activate the regex.
We have a large solution with many projects in it, and throughout the project in forms, messages, etc we have a reference to a company name. For years this company name has been the same, so it wasn't planned for it to change, but now it has.
The application is specific to one state in the US, so localizations/string resource files were never considered or used.
A quick Find All instances of the word pulled up 1309 lines, but we only need to change lines that actually end up being displayed to the user (button text, message text, etc).
Code can be refactored later to make it more readable when we have time to ensure nothing breaks, but for time being we're attempting to find all visible instances and replace them.
Is there any way to easily find these "instances"? Perhaps a type of Regex that can be used in the Find All functionality in Visual Studio to only pull out the word when it's wrapped inside quotes?
Before I go down the rabbit hole of trying to make my job easier and spending far more time than it would have taken to just go line by line, figured I would see if anyone has done something like this before and has a solution.
You can give this a try. (I hope your code is under source control!)
Foobar{[^"]*"([^"]*"[^"]*")*[^"]*}$
And replace with
NewFoobar\1
Explanation
Foobar the name you are searching for
[^"]*" a workaround for the missing non greedy modifier. [^"] means match anything but " that means this matches anything till the first ".
([^"]*"[^"]*")* To ensure that you are matching only inside quotes. This ensures that there are only complete sets of quotes following.
[^"]* ensures that there is no quote anymore till the end of the line $
{} the curly braces buts all this stuff following your companies name into a capturing group, you can refer to it using \1
The VS regex capability is quite stripped down. It perhaps represents 20% of what can be done with full-powered regular expressions. It won't be sufficient for your needs. For example, one way to solve this quote-delimited problem is to use non-greedy matching, which VS regex does not support.
If I were in your shoes, I would write a perl script or a C# assembly that runs outside of Visual Studio, and simply races through all files (having a particular file extension) and fixes everything. Then reload into Visual Studio, and you are done. Well, if all went well with the regex anway.
Ultimately what you really must watch out for is code like this:
Log.WriteLine("Hello " + m_CompanyName + " There");
In this case, regex will think that "m_CompanyName" appears between two quotes - but it is not what you meant. In this case you need even more sophistication, and I think you'll find the answer with a special .net regular expression extension.