Add code for workshop

Author: bonnie

README.md

@@ -0,0 +1,3 @@
+# jsnation-regex-workshop
+
+Code for the [JSNation Live](https://live.jsnation.com/workshops-3h) Regular Expressions workshop, June 14, 2021

exercises/1-regexp-methods.js

@@ -0,0 +1,25 @@
+const assert = require("assert");
+
+// Exercise 1 ///////////////////////////////////////////////////////////////////////
+// Return true if the input string contains a word starting with
+// q (case insensitive), false otherwise
+const hasQWord = (inputString) => {
+  const regex = /\bq\w+\b/i;
+  // write function here
+};
+assert(hasQWord("I adore quails.") === true);
+assert(hasQWord("Quinn left her job! No way!") === true);
+assert(hasQWord("This exquisite string has no matching words.") === false);
+
+// Exercise 2 ///////////////////////////////////////////////////////////////////////
+// Return the first full word of the input string. Could be preceded or
+// followed by a space, newline, punctuation, etc.
+const findFirstWord = (inputString) => {
+  const regex = /^\W*\w+\b/;
+  // write funtion here
+};
+assert(
+  findFirstWord("I, a JavaScript fan, am at the JSNation regex workshop!"),
+  "I"
+);
+assert(findFirstWord("\nWhat is that newline doing there?\n"), "What");

exercises/2-string-methods.js

@@ -0,0 +1,50 @@
+const assert = require("assert");
+
+// Exercise 1 ///////////////////////////////////////////////////////////////////////
+// Return the punchline of the joke, assuming the punchline starts after a ? and any
+// number of space characters, using a string method.
+// Note: later we will do this same exercise using string splitting.
+const getPunchline = (joke) => {
+  const regex = /[^\?]\?\s*/;
+  // write function here
+};
+
+const joke1 =
+  "What's the difference between Java and JavaScript? Java is like JavaScript the way car is like carpet.";
+const punchline1 = "Java is like JavaScript the way car is like carpet.";
+assert.strictEqual(getPunchline(joke1), punchline1);
+
+const joke2 =
+  "Why do Javascript developers prefer dark mode? Because light attracts bugs.";
+const punchline2 = "Because light attracts bugs.";
+assert.strictEqual(getPunchline(joke2), punchline2);
+
+// Exercise 2 ///////////////////////////////////////////////////////////////////////
+// Return an array of words in the input string that start with the letter j (case
+// insensitive) and end with the letter t (also case insensitive).
+const getJTwords = (inputString) => {
+  const regex = /\bj\w+t\b/gi;
+  // write function here
+};
+
+const JTstring1 = "JavaScript just makes me jump for joy.";
+assert.deepStrictEqual(getJTwords(JTstring1), ["JavaScript", "just"]);
+
+const JTstring2 = "James and Justine went for a walk";
+assert.deepStrictEqual(getJTwords(JTstring2), null);
+
+// Exercise 3 ///////////////////////////////////////////////////////////////////////
+// Find all of the amounts in USD and return them in an array (hint: use capture groups)
+const getUSDamounts = (string) => {
+  const regex = /^USD: \$([\d\.]+)/gm;
+  // write function here
+};
+
+const currencyString = `
+AUD: $6.09
+USD: $5.70
+JPY: ¥117.84
+EUR: €36.12
+USD: $12.89
+`;
+assert.deepStrictEqual(getUSDamounts(currencyString), ["5.70", "12.89"]);

exercises/3-capture-groups.js

@@ -0,0 +1,53 @@
+const assert = require("assert");
+
+// EXERCISE 1 ///////////////////////////////////////////////////////////////////////
+// Return true if string has the first word repeated in the string (case insensitive),
+// false otherwise
+const stringRepeatsFirstWord = (inputString) => {
+  // note, you will have to adjust this regex so that it finds strings that start
+  // and end with the same word
+  // const regexToFindFirstWord = /^(\b\w+\b)/i;
+  //
+  // write function here
+};
+
+const stringWithBookends = "Which witch is which?";
+assert(stringRepeatsFirstWord(stringWithBookends) === true);
+
+const stringWithRepeats = "To know her is to love her";
+assert(stringRepeatsFirstWord(stringWithRepeats) === true);
+
+const averageString = "This is just your average string.";
+assert(stringRepeatsFirstWord(averageString) === false);
+
+// EXERCISE 2 ///////////////////////////////////////////////////////////////////////
+// Given data shaped like this:
+// 28may2021 04:55:38 This is a message
+// 03jun2021 23:44:01 This is another message
+// Extract the month and day as a group named “date”, the year into a group named "year",
+// the time as a group named “time” and the message as a group named “message”
+
+const parseLineIntoObj = (logLine) => {
+  // you will have to separate this regex into named groups!
+  const regex = /^\d{2}[a-z]{3}\d{4} \d{2}:\d{2}:\d{2} .+$/;
+
+  // write the function here
+};
+
+const logLine1 = "28may2021 04:55:38 Something happened here";
+const result1 = {
+  date: "28may",
+  year: "2021",
+  time: "04:55:38",
+  message: "Something happened here",
+};
+assert.deepStrictEqual(parseLineIntoObj(logLine1), result1);
+
+const logLine2 = "03jun2021 23:44:01 Nothing happened here";
+const result2 = {
+  date: "03jun",
+  year: "2021",
+  time: "23:44:01",
+  message: "Nothing happened here",
+};
+assert.deepStrictEqual(parseLineIntoObj(logLine2), result2);

exercises/4-split-replace.js

@@ -0,0 +1,81 @@
+const assert = require("assert");
+
+// Exercise 1 ///////////////////////////////////////////////////////////////////////
+// EXAMPLE: Replace any email address (using the simplified regex below)
+// with the text "<<redacted>>"
+const redactEmails = (text) => {
+  const regex = /\b[\w\.]+@[\w\.]+\.[\w]+\b/g;
+
+  // write function here
+};
+
+const emailString1 = "[email protected]";
+assert.strictEqual(redactEmails(emailString1), "<<redacted>>");
+
+const emailString2 =
+  "Please send to [email protected], [email protected] and [email protected]. Thanks!";
+const redactedString2 =
+  "Please send to <<redacted>>, <<redacted>> and <<redacted>>. Thanks!";
+assert.strictEqual(redactEmails(emailString2), redactedString2);
+
+const emailString3 = "This string has no emails!!";
+assert.strictEqual(redactEmails(emailString3), emailString3);
+
+// Exercise 2 ///////////////////////////////////////////////////////////////////////
+// EXAMPLE: Strip off any whitespace characters from the beginning or end of a string,
+// but let the spaces in the middle stand.
+const stripWhitespace = (inputString) => {
+  // you'll have to add groups in the following regex to make this one work
+  const regex = /^\s*.*\s*$/;
+
+  // write function here
+};
+
+const input1 = "   that's some unnecessary whitespace    \n\n";
+const output1 = "that's some unnecessary whitespace";
+assert.deepEqual(stripWhitespace(input1), output1);
+
+const input2 = '\n"Get to the back of the ship!" Tom said sternly.\n';
+const output2 = '"Get to the back of the ship!" Tom said sternly.';
+assert.deepEqual(stripWhitespace(input2), output2);
+
+const noOuterSpaceString = "Do not launch me out of the atmosphere please!";
+assert.deepEqual(stripWhitespace(noOuterSpaceString), noOuterSpaceString);
+
+// Exercise 3 ///////////////////////////////////////////////////////////////////////
+// Remember this one? Return the punchline of the joke, assuming the punchline starts
+// after a ? and any number of space characters, this time using string splitting.
+const getPunchline = (joke) => {
+  const regex = /\?\s*/;
+
+  // write function here
+};
+
+const joke1 =
+  "What's the difference between Java and JavaScript? Java is like JavaScript the way car is like carpet.";
+const punchline1 = "Java is like JavaScript the way car is like carpet.";
+assert.deepStrictEqual(getPunchline(joke1), punchline1);
+
+const joke2 =
+  "Why do Javascript developers prefer dark mode? Because light attracts bugs.";
+const punchline2 = "Because light attracts bugs.";
+assert.deepStrictEqual(getPunchline(joke2), punchline2);
+
+// Exercise 4 ///////////////////////////////////////////////////////////////////////
+// Capitalize first letter of every word in a string, and lowercase the rest
+const toTitleCase = (inputString) => {
+  // Note: you can add groups here to make your job easier later ;-)
+  const regex = /\b\w\S*\b/g;
+
+  // write function here
+};
+
+const title1 = "of mice and MEN";
+const outputTitle1 = "Of Mice And Men";
+assert.deepEqual(toTitleCase(title1), outputTitle1);
+
+const title2 =
+  "knitting with dog hair: better a sweater from a dog you KNOW and LOVE than from a sheep you’ll NEVER meet";
+const outputTitle2 =
+  "Knitting With Dog Hair: Better A Sweater From A Dog You Know And Love Than From A Sheep You’ll Never Meet";
+assert.deepEqual(toTitleCase(title2), outputTitle2);

exercises/5-regex-obj.js

@@ -0,0 +1,25 @@
+const assert = require("assert");
+
+// Exercise 1 ///////////////////////////////////////////////////////////////////////
+// Write a function that creates a regular expression that checks for
+// every instance of the input string surrounded by word boundaries (\b)
+const myFavoriteStringRegex = (favoriteString) => {
+  // write the function here
+};
+
+// assert has trouble comparing regexes; hence the "toString()"
+assert.strictEqual(
+  myFavoriteStringRegex("regex").toString(),
+  /\bregex\b/g.toString()
+);
+
+// Exercise 2 ///////////////////////////////////////////////////////////////////////
+// Return the input regular expression with the 'm' flag removed.
+// If there is no 'm' flag, just return the regular expression unaltered.
+const removeMultilineFlag = (inputRegex) => {
+  // write the function here
+};
+
+// assert has trouble comparing regexes; hence the "toString()"
+assert.strictEqual(removeMultilineFlag(/^a+/m).toString(), /^a+/.toString());
+assert.strictEqual(removeMultilineFlag(/^a+/).toString(), /^a+/.toString());

exercises/6-free-for-all.js

@@ -0,0 +1,115 @@
+const assert = require("assert");
+
+// Exercise 1 ///////////////////////////////////////////////////////////////////////
+// Return all sentences of the string. Ignore space between sentences. Assume a sentence
+// ends with . ? or !
+const getSentences = (inputString) => {
+  // I'm not writing the regex for you here because there are a couple possibilities
+  // for how to do this and I don't want to sway you one way or the other! Discuss with
+  // your breakout room. :-)
+};
+const input1 =
+  "Some people, when confronted with a problem, think, I know, I'll use regular expressions. Now they have two problems.";
+const input1sentence1 =
+  "Some people, when confronted with a problem, think, I know, I'll use regular expressions.";
+const input1sentence2 = "Now they have two problems.";
+assert.deepStrictEqual(getSentences(input1), [
+  input1sentence1,
+  input1sentence2,
+]);
+
+const input2 = "I did it! I found the bug! Now to find the next 99.";
+const input2sentences = [
+  "I did it!",
+  "I found the bug",
+  "Now to find the next 99.",
+];
+assert.deepStrictEqual(getSentences(input2), input2sentences);
+
+// Exercise 2 ///////////////////////////////////////////////////////////////////////
+// Given an array of files in a directory, identify which files have a vi swap file (.filename.swp -- for example: .favorite_regexes.txt.swp)
+const findFilesWithViSwap = (fileArray) => {
+  // you may find it useful to add a group to the following regex
+  const regex = /^\.[\w\.]+\.swp$/;
+
+  // write function here
+};
+
+const directoryFiles = [
+  "resume.txt",
+  ".resume.txt.swp",
+  "cover_letter.txt",
+  ".cover_letter.txt.swp",
+  "signed_offer_letter.txt",
+  "robot_to_reply_to_job_postings.js",
+  ".robot_to_reply_to_job_postings.js.swp",
+];
+assert.deepStrictEqual(findFilesWithViSwap[directoryFiles], [
+  "resume.txt",
+  "cover_letter.txt",
+  "robot_to_reply_to_job_postings.js",
+]);
+
+// Exercise 3 ///////////////////////////////////////////////////////////////////////
+// Strip html tags out of text
+const stripHtmlTags = (inputString) => {
+  const regex = /<[^<>]*>/gm;
+
+  // write function here
+};
+
+const html1 = "<span>This is a span</span>";
+const stripped1 = "This is a span";
+assert.strictEqual(stripHtmlTags(html1), stripped1);
+
+const html2 =
+  "<h1>Regular Expressions</h1>\n<h2>Quantifiers</h2>\n<p>Quantifiers tell you how many of the preceding token are allowed.</p>";
+const stripped2 =
+  "Regular Expressions\nQuantifiers\nQuantifiers tell you how many of the preceding token are allowed.";
+assert.strictEqual(stripHtmlTags(html2), stripped2);
+
+const html3 = "No tags. Absolutely none.";
+assert.strictEqual(stripHtmlTags(html3), html3);
+
+// Exercise 4 ///////////////////////////////////////////////////////////////////////
+// Given an input array, return an array only with strings that contain no numbers
+const filterOutNumberUsernames = (inputArray) => {
+  const regex = /^\D+$/;
+
+  // write function here
+};
+
+const usernameArray = [
+  "githubFan98",
+  "loves2code",
+  "dadJokesOnly",
+  "javascript4ever",
+  "son!cTheHedgehog",
+];
+const filteredUsernameArray = ["dadJokesOnly", "son!cTheHedgehog"];
+assert.deepStrictEqual(
+  filterOutNumberUsernames(usernameArray),
+  filteredUsernameArray
+);
+
+// Exercise 5 ///////////////////////////////////////////////////////////////////////
+// Make sure the first word of every sentence is capitalized
+// For simplicity, you can assume the first word of the string is already capitalized
+const capitalizeFirstWordOfSentence = (inputString) => {
+  // you'll probably want to add groups here
+  const regex = /[\.\?\!]\s+\w/gs;
+
+  // write function here
+};
+
+const sentences1 =
+  "We are just an advanced breed of monkeys on a minor planet of a very average star. but we can understand the Universe. that makes us something very special. ― Stephen Hawking";
+const capitalized1 =
+  "We are just an advanced breed of monkeys on a minor planet of a very average star. But we can understand the Universe. That makes us something very special. ― Stephen Hawking";
+assert.strictEqual(capitalizeFirstWordOfSentence(sentences1), capitalized1);
+
+const sentences2 =
+  "Why was the JavaScript developer sad? because they didn't Node how to Express themself";
+const capitalized2 =
+  "Why was the JavaScript developer sad? Because they didn't Node how to Express themself";
+assert.strictEqual(capitalizeFirstWordOfSentence(sentences2), capitalized2);