Here's an example of how the method works on the string "My text" with a start value of 3 and a length value of 2:

Transcription

1 CS 1251 Page 1 Friday Friday, October 31, :36 AM Finding patterns in text A smaller string inside of a larger one is called a substring. You have already learned how to make substrings in the spreadsheet using the spreadsheet formulas =left(), =right(), and =mid(). Javascript has two swiss army knife functions for manipulating text. They are called.substr() and.substring(). The functionality of all three of those spreadsheet functions can be reproduced by using either of those methods-- but the exact details are different between the two. The string method.substr() The first argument is where to start. This method is 0-based. It can accept negative numbers which determine a location based upon how far it is from the end. The second argument is optional. If it not included then the method will return everything from the starting index to the end of the string. This makes it easy to replicate the behavior of =right(). If the second argument is included then it stand for how far to go. It is a measure of length. Here's an example of how the method works on the string "My text" with a start value of 3 and a length value of 2: "My text".substr(3,2) The result is "te" My text My text start length of 2 at index 3 Let's look at how we can use.substr() to emulate the spreadsheet functions: =right("my text",3) "My text".substr(-3) Displays the last 3 characters in the string =left("my text",3) =mid("my text",4,5) "My text".substr(0,3) Displays the first 3 characters in the string "My text".substr(3,2) Displays the substring "te" The string method.substring() The first argument is where to start. This method is 0-based. It does not accept negative numbers (it treats them as if they were a 0). The second argument is optional and indicates where to stop. Think about the function as walking through the characters one by one-- start argument tells the program when to start recording characters, and the stop argument tells it where to stop-- and the computer responds instantly-- before it records that location. "My text".substr(3,5) My text My text My text * * start at stop at index 3 index 5

2 CS 1251 Page 2 The result is "te" =right("my text",3) str="my text"; str.substring(str.length-3) Displays the last 3 characters in the string =left("my text",3) "My text".substring(0,3) Displays the first 3 characters in the string =mid("my text",4,5) "My text".substring(3,5) Displays the substring "te" In computer descriptions of funtions it is common to use [ ] to indicate an optional argument. With that in mind we can summarize the information this way: =right(text, n) =left(text,n) =mid(start,stop).substr(start,[n]).substring(start,[stop]) Returns the last n characters from text Returns the first n characters from text Returns the substring starting at index start and going to index stop Returns the substring starting at index start and of length n Returns the substring starting at index start and stoping at index stop Neither 1 nor 0 based-- it's based on length Neither 1 nor 0 based-- it's based on length Both arguments are 1-based The first argument start is 0- based. The second argument n is a length Both arguments are 0-based The string method.search() We have just observed how to use numbers to extract a substring from a longer string. We can also try go in the opposite direction and find the location (a number) of a substring located inside of a longer string. On the spreadsheet side we used the function =search(<substring>,<text>) for this task. There's an equivalent on the javascript side called.search(<substring>) For example "Hello".search("ll") will return 2 (the index at which the match was found.the method.search() is case sensitive AND 0-based: Hello location that match begins It turns out that.search() can do far more than just search for a substring it can search for patterns of text. These patterns of text are called regular expressions and they are EXTREMELY useful. Regular Expressions Regular expressions are used to describe patterns. As we experiment with them you may find it very helpful to try the examples out using the tools at Some uses: Verify that entered data is in correct format

3 CS 1251 Page 3 Find a complicated text pattern Reformat text Regular expressions describe patterns of text. They are specified similarly to a string, but instead of using quotes we will use forward slashes. For example /\d/ The above is a regular expression that matches a single digit. Regular expressions are fairly similar to searches with wild cards, but there are a lot more characters with a special meaning. For example the character. Stands for ANY character (don't try to interpret it as the period). We tell.search() to use regular expressions by using the forward slashes instead of quotes: "Hello".search(/ll/); Will return the same value as "Hello".search("ll") And, "hello".search(/l./); Will look for any l followed by another character. So in this example, we'll get the same result, but consider "hello".search(/o/); which will return a 4 and "hello".search(/o./); which will return a -1 (meaning no matches). One of the cool things about regular expressions (regex's if you're friends), is that they can be STORED in a variable: var pattern=/o/; "hello".search(pattern); Will return a 4! Here are some other special characters, and combinations of characters: \d stands for any digit (0,1,2,3,4,5,6,7,8,9) So "The other day I looked for 23 pumpkins".search(/\d\d/); Will return 27, while "The other day I looked for 23 pumpkins".search(/\d\d\d/); Will return -1 because there's no place where 3 digits appear in a row. Here are some of the special characters:. Any character except newline Beginning of the string (anchor) $ End of the string (anchor) Most normal characters Same meaning \r, \n, \t carriage return newline tab \d Any digit \D Any NON-digit \s white space \S anything BUT whitespace \w any alphanumeric character [a-za-z0-9_] \W Any NON-word character Notice the back slash '\'? It changes the meaning of the symbols so \n doesn't try to search for "\n",

4 CS 1251 Page 4 instead it looks for a newline, and \s doesn't try to search for "\s", instead it tries to look for ANY single example of whitespace. Notice the lower-case/upper-case pattern in the table above. The backslash is called "escape", and it means that you "escape the normal interpretation". Escaping a special character (preceding it by \) makes it normal so if you want to match the period you can use \. Notice that some of the characters are called anchors-- these don't use up characters-- they match a condition (like being at the beginning of a string) Let's suppose we have a customer spreadsheet with phone numbers. We expect the phone number to be of the form (xxx)xxx-xxxx So how could we look for it? Let's write a function that takes the current active selection, and changes the background color of any cell that does NOT have an entry in this format: function findbadphonenumbers(){ var activerange=spreadsheetapp.getactiverange(); var numrows=activerange.getnumrows(); var phonepattern=/\(\d\d\d\)\d\d\d-\d\d\d\d$/; // Nasty isn't it? var cell; for(row =1;row<=numRows;row++){ //remember that.getcell() is 1- based! cell=activerange.getcell(row,1); var tmp = cell.getvalue(); if(typeof(tmp)=="string"){ if(tmp.search(phonepattern)==-1){ cell.setbackgroundcolor("red"); Let me explain that regular expression by putting each unit on a separate line: / beginning of regular expression start of the string \( An honest parenthesis-- could have used [(] as well \d first digit in area code \d second digit in area code \d third digit in area code \) another honest parenthesis-- could have used [)] \d First digit in the prefix \d second digit in the prefix \d final digit in the prefixt - the dash \d beginning digit of the last bit \d next digit \d next digit \d final digit $ end of the string / end of the regular expression In addition you can use "character classes" to match a collection of characters: [<put characters here>] [acgt] will match a, c, g, or t ONCE. You can INVERT the meaning by putting a at the beginning: [acgt] will match anything that is NOT an a, c, g, or t.

5 CS 1251 Page 5 metacharacters Some characters are used to control HOW the matching occurs: * 0-or more instances + 1-or more instances {n {n,m {n, {,m exactly n instances n or more, but m or less n or more no more than m Parenthesis can be used to group data at the metacharacters above, apply to them. Parenthesis can also be used to CAPTURE data. Okay some of today's lecture will be a bit redundant, but it's good to be reminded how these things work. I want to add two more anchors. Here is a review (again) of the special characters that we have: Special Characters (mostly involving backslash) Anchors:. Any character except newline \r, \n, \t carriage return newline tab \d Any digit \D Any NON-digit \s white space \S anything BUT whitespace \w any alphanumeric character [a-za-z0-9_] \W any non-alphanumeric character \( \) \\ \ \$ \. \[ \] Beginning of the string (anchor) $ End of the string (anchor) \b word boundary (this is an anchor) \B nonword boundary * 0-or more instances + 1-or more instances? 0 or 1 instances {n {n,m {n, {,m exactly n instances n or more, but m or less n or more no more than m Literal versions Metacharacters (control the matching) (we will learn a few more later on) Grouping and alternation ( left parenthesis for grouping and capture ) right parenthesis for grouping and capture

6 CS 1251 Page 6 alternation (acts like an 'or' from logic) Character Classes: [characters] characters Matches one character The characters to match When the first character in a character class it looks for the opposite - When NOT the first character it acts as a range [A-E0-3] is the same as [ABCDE0123] Subexpressions captured by parenthesis \n n is the number of the left parenthesis that defines the group. Let's do a bit more practice. Go to (If you get done early go work on Enter the string: "Jerry had 10 little lambs and 30 slices of pizza. Mary had gold bullion and a violin." Now come up with regular expressions that do the following: 1. Match a number with two digits (in this case the match should be Match a complete number of any length-- even if you don't know how many digits 3. Go to javascript console and redo 1 and 2 in javascript use a..search() to find the location of the match b..match() to find the value of the match 4. Back to the webpage and find a regular expression that matches an entire word 5. Matches a word that starts with l 6. Matches a word that start with m OR M (use a character class) 7. Matches a word that start with m OR M (use a alternation ) 8. Matches a word that starts with a capital letter 9. Matches a word that start with a capital letter but has no other capital letters 10. Match a word that is preceded by a space and starts with a capital letter 11. Match a word that is preceded by one or more spaces and starts with a capital letter 12. Matches an entire sentence 13. Matches a monetary amount of the form $3.00 or $20.00 or $ Putting it together: Let's suppose that we have a list of names, but we want to make certain that all the first letters are capitalized, unfortunately we don't know how many words are in any particular name. This is more subtle than you might think. Matching something that starts with a capital letter and is followed by lowercase letters (optionally-- we want to match I): /[A-Z][a-z]*/ But what if we want ALL our words to be of this form. This will find a word that is preceded by a space /([A-Z][a-z]*)+/ This will fail. It matches patterns like "MaryHadALittleLamb" (try it on the webpage). And since it is not anchored at the beginning it will also match a pattern like this: "so lots of lower case stuff and then MaryHadALittleLamb will be found" Try this in the inspector And the contents the array are: Do you see what happened? Index 0 shows the total match and the following indices show the

7 CS 1251 Page 7 subexpressions that matched (remember how the parenthesis are numbered?) Okay, let's make a function that looks at each word in the current selection and highlights any cell that has a word in the wrong form. function findbadnames(){ var activerange=spreadsheetapp.getactiverange(); var numrows=activerange.getnumrows(); var namepattern=/[ ]*[A-Z]([a-z])*([ ]+[A-Z]([a-z])*)*[ ]*$/; var cell; for(row =1;row<=numRows;row++){ //remember that.getcell() is 1- based! cell=activerange.getcell(row,1); var tmp = cell.getvalue(); if(typeof(tmp)=="string"){ if(tmp.search(namepattern)==-1){ cell.setbackgroundcolor("red"); So this is tricky, but not impossible to understand let's look at the regular expression: /[ ]*[A-Z]([a-z])*([ ]+[A-Z]([a-z])*)*[ ]*$/ Start of string optional collection of spaces capital letter option collection of lower case strings one or more spaces followed by a capital letter, followed by optional lower case optional spaces ignored at the end Here's what we will try it on: And here are the results: greedy versus lazy matching The symbol? can be a bit tricky. It can MODIFY another metacharacter: *? 0 or more-- lazy * 0 or more-- greedy +? 1 or more-- lazy + 1 or more--greedy? 0 or 1-- greedy

8 CS 1251 Page 8?? 0 or 1-- lazy Greedy matches eat as much as they possibly can: Lazy matches as little as possible. Let's see why this might be useful by trying to match data between parenthesis. First we need a pattern: To get the stuff inside the parenthesis: /\(.+\)/ Try using it with.match() in the console window. On an expression like this: "example (parenthesis stuff) blah" Spiffy isn't it? However there is a problem "example (parenthesis stuff) blah (more parens) blah" What happened? [have them explain] Try this modification: /\(.+?\)/ (see the difference between greedy and lazy?) There is another way to make sure the pattern matches the way that you expect: /\([)]+\)/ Greedy or lazy, we get the same result (try it) Some string methods that work with regular expressions are:.test(<regexp>) // Returns boolean (true if the string has a match, false otherwise).match<regexp).search(<regexp>) // Returns index of match.replace(<regexp>,<replacement>) // Allows for replacements flags &.match() You can modify some things about how a regexp matches by following it with some letters: /<regexp>/g /<regexp>/i global case insensitive (ignore difference between lower case and upper case) /<regexp>/m multiline (we won't cover this) the.search() function FINDS the location of the pattern and it ignores /g "hello, world".search(/l./) will return 2. "hello, world".search(/l./g) will also return 2. The.match() function returns the actual match and the parenthesis matches: "hello, world".match(/l./) will return "ll" But the global flag causes.match() to return ALL matches but to NOT return the parenthesis matches: "hello, world".match(/l./g) returns ["ll","ld"] <discuss why "lo" isnt found this has to do with HOW the pattern is found-- the simple version of the answer is that matches can't, by default, overlap> Search and Replace You can use.replace(<regexp>,<string>) to find a pattern (or more than one pattern) and replace it So, for example, let's write a function that finds every occurrence of the word "red" and replaces it with "blue" function redtoblue(mystr){ return(mystr.replace("red","blue")); function redtoblue2(mystr){

9 CS 1251 Page 9 return(mystr.replace(/red/i,"blue")); function redtoblue3(mystr){ return(mystr.replace(/red/ig,"blue")); And now consider a function that acts the same way as left trim function regexlefttrim(mystr){ return(mystr.replace(/\s+/,'')); How about a function that replaces multiple spaces with just a single space function collapsespaces(mystr){ return(mystr.replace(/[ ]+/g,' ')); [Do examples in the console] Okay. now things get cool. You can use BACK REFERENCES in the replacement string of the form $n: Let's look for a pattern of the form blah blah blah (first thing in parens) blah blah blah (second thing in parens) blah blah blah And swap the contents of the parenthesis! Recall we can find the contents of parenthesis like this: /\(.+?\)/ note the lazy matching +? Now we want to capture: /(\(.+?\))/ Next we want to find the next set of parens and capture their contents too: /(\(.+?\))(.*?)(\(.+?\))/ Now lets try a replace.replace(/(\(.+?\))(.*?)(\(.+?\))/,"$3$2$1") The best basic tutorial I found is at: We can also use to stand for "or". Let's try the regexcrossword: