RegEX CheatSheet

Short for regular expression, a regex is a string of text that allows you to create patterns that help match, locate, and manage text. Perl is a great example of a programming language that utilizes regular expressions. However, it's only one of the many places you can find regular expressions. Regular expressions can also be used from the command line and in-text editors to find text within a file.

Python has a built-in package called re, which can be used to work with Regular Expressions.

Import the re module:

---

    
        import re
    

re.search()

>>> sentence = 'This is a sample string'
>>> bool(re.search(r'this', sentence, flags=re.I))
True
>>> bool(re.search(r'xyz', sentence))
False

---

re.findall()

>>> re.findall(r'\bs?pare?\b', 'par spar apparent spare part pare')
['par', 'spar', 'spare', 'pare']
>>> re.findall(r'\b0*[1-9]\d{2,}\b', '0501 035 154 12 26 98234')
['0501', '154', '98234']

---

re.finditer()

>>> m_iter = re.finditer(r'[0-9]+', '45 349 651 593 4 204')
>>> [m[0] for m in m_iter if int(m[0]) < 350]
['45', '349', '4', '204']

---

re.split()

>>> re.split(r'\d+', 'Sample123string42with777numbers')
['Sample', 'string', 'with', 'numbers']

---

re.sub()

>>> ip_lines = "catapults\nconcatenate\ncat"
>>> print(re.sub(r'^', r'* ', ip_lines, flags=re.M))
* catapults
* concatenate
* cat

---

re.compile()

>>> pet = re.compile(r'dog')
>>> type(pet)

>>> bool(pet.search('They bought a dog'))
True
>>> bool(pet.search('A cat crossed their path'))
False

const str = 'table football';


const regex = new RegExp('foo*');
const globalRegex = new RegExp('foo*', 'g');


console.log(regex.test(str));
// Output: true

console.log(globalRegex.lastIndex);
// Output: 0

console.log(globalRegex.test(str));
// Output: true

console.log(globalRegex.lastIndex);
// Output: 9

console.log(globalRegex.test(str));
// Output: false

let text = 'I like APPles very much';
let regexA = /apples/;
let regexB = /apples/i;
 

console.log(text.search(regexA));
// Output: -1


console.log(text.search(regexB));
// Output: 7

let text = 'Do you like apples?';
let regex= /apples/;
 

console.log(regex.exec(text)[0]);
// Output: apples 


console.log(regex.exec(text).input);
// Output: Do you like apples?

const paragraph = 'The quick brown fox jumps over the lazy dog. It barked.';
const regex = /[A-Z]/g;
const found = paragraph.match(regex);


console.log(found);
// Output: Array ["T", "I"]

let text = 'This 593 string will be brok294en at places where d1gits are.';
let regex = /\d+/g
console.log(text.split(regex))
// Put Result: [ "This ", " string will be brok", "en at places where d", "gits are." ]



const str = 'The quick brown fox jumps over the lazy dog.';

const words = str.split(' ');
console.log(words[3]);
// Output: "fox"

const chars = str.split('');
console.log(chars[8]);
// Output: "k"

const strCopy = str.split();
console.log(strCopy);
// Output: Array ["The quick brown fox jumps over the lazy dog."]

let regex = /t(e)(st(\d?))/g;
let text = 'test1test2';
let array = [...text.matchAll(regex)];


// Output: ["test1", "e", "st1", "1"]
console.log(array[0]);


// Output: ["test2", "e", "st2", "2"]
console.log(array[1]);

let text = 'Do you like aPPles?';
let regex = /apples/i
 

let result = text.replace(regex, 'mangoes');
console.log(result);
// Output: Do you like mangoes?

const p = 'The quick brown fox jumps over the lazy dog. If the dog reacted, was it really lazy?';
console.log(p.replaceAll('dog', 'monkey'));
// Output: "The quick brown fox jumps over the lazy monkey. If the monkey reacted, was it really lazy?"


// global flag required when calling replaceAll with regex
const regex = /Dog/ig;
console.log(p.replaceAll(regex, 'ferret'));
// Output: "The quick brown fox jumps over the lazy ferret. If the ferret reacted, was it really lazy?"


let regex = /apples/gi;
let text = 'Here are apples and apPleS';
let result = text.replaceAll(regex, "mangoes");
console.log(result);
// Output: Here are mangoes and mangoes

$str = "Visit Samsung!";
$regex = "/samsung/i";


echo preg_replace($regex, "cheatsheet.com", $str); 
// Output: Visit cheatsheet.com!

$str = "Visit cheatsheet";
$regex = "#cheatsheet#i";
echo preg_match($regex, $str);
// Output: 1


// Declare a variable and initialize it 
$str = "Check For Testing."; 
// case-Insensitive search for the word "Check" 
if (preg_match("/\bCheck\b/i", $str, $match))  
    echo "Matched String!"; 
else
    echo "Not matched for String";   
// Output : Matched String!

<!-- Example 1 -->
$regex = "/[a-zA-Z]+ (\d+)/";
$input_str = "June 24, August 13, and December 30";
if (preg_match_all($regex, $input_str, $matches_out)) {

    echo count($matches_out);
    // Output: 2

    echo count($matches_out[0]);
    // Output: 3

    print_r($matches_out[0]);
    // Output: Array("June 24", "August 13", "December 30")

    print_r($matches_out[1]);
    // Output: Array("24", "13", "30")
}


<!-- Example 2 -->
$str = "abc ABC";
$pattern = "/((a)b)(c)/i";
if(preg_match_all($pattern, $str, $matches, PREG_PATTERN_ORDER)) {
  print_r($matches);
}

$arr = ["Jane", "jane", "Joan", "JANE"];
$regex = "/Jane/";

echo preg_grep($regex, $arr);
// Output: Jane


$input = ["Red", "Pink", "Green", "Blue", "Purple"];
$result = preg_grep("/^p/i", $input);
print_r($result);
// Output: 
    Array (
        [1] => Pink
        [4] => Purple
    )

<!-- Example 1 -->
$str = "Jane\tKate\nLucy Marion";
$regex = "@\s@";

print_r(preg_split($regex, $str));
// Output: Array("Jane", "Kate", "Lucy", "Marion")


<!-- Example 2 -->
$ip = "123.456.789.000"; // some IP address
$iparr = preg_split ("/\./", $ip); 

print "$iparr[0] <br />";
print "$iparr[1] <br />" ;
print "$iparr[2] <br />"  ;
print "$iparr[3] <br />"  ;
// Output:
123 
456 
789 
000 

// The First way to use
Pattern p = Pattern.compile(".s", Pattern.CASE_INSENSITIVE);
Matcher ma = p.matcher("aS");  
boolean firstWay = m.matches();  
System.out.println(firstWay);   
// Outputs: true


// The Second way to use
boolean secondWay = Pattern.compile(".s").matcher("as").matches();  
System.out.println(secondWay);   
// Outputs: true


// The Third way to use
boolean thirdWay = Pattern.matches(".s", "BBBBB");
System.out.println(thirdWay);
// Output: false

• Pattern compile(String regex [, int flags])
• boolean matches([String regex, ] CharSequence input)
• String[] split(String regex [, int limit])
• String quote(String s)

• int start([int group | String name])
• int end([int group | String name])
• boolean find([int start])
• String group([int group | String name])
• Matcher reset()

• boolean matches(String regex)
• String replaceAll(String regex, String replacement)
• String[] split(String regex[, int limit])

// Replace sentence:
String regex = "[A-Z\n]{5}$";
String str = "I love APP\nLE";

Pattern p = Pattern.compile(regex, Pattern.MULTILINE);
Matcher m = p.matcher(str);
System.out.println(m.replaceAll("pple!"));
// Outputs: I love Apple!



// Array of all matches:
String str = "She sells seashells by the Seashore";
String regex = "\\w*se\\w*";

Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher(str);

List matches = new ArrayList<>();
while (m.find()) {
    matches.add(m.group());
}
System.out.println(matches);
// Outputs: [sells, seashells, Seashore]



// returns true if the string contains of three letters
System.out.println(Pattern.matches("[a-zA-Z][a-zA-Z][a-zA-Z]", "aPz")); 
System.out.println(Pattern.matches("[a-zA-Z][a-zA-Z][a-zA-Z]", "aAA"));
System.out.println(Pattern.matches("[a-zA-Z][a-zA-Z][a-zA-Z]", "apZx"));
// Output: true true false



boolean match1 = Pattern.compile("lin.x").matcher("linux").matches();
boolean match2 = Pattern.matches("clo..", "cloud");
System.out.println(match1);
System.out.println(match2);
// Output: true true