/^[0-9]+$//.../.^ and the trailing $ are known
as position anchors, which match the beginning and ending of the input
string, respectively. As a result, the entire input string shall be
matched, instead of a portion of the input string. Without these
position anchors, the regex can match any part of the input string,
i.e., with leading and trailing sub-string unmatched.[...] encloses a list of characters, and matches any character in the list. [0-9] matches any character between 0 and 9 (i.e., a digit), where dash (-) denotes the range.+ indicate 1 or more occurrences of the previous sub-expression. In this case, [0-9]+ matches one or more digits.0" and "12345". It does not match with "" (empty string), "abc", "a123", etc. However, it also matches "000", "0123" and "0001"./^\d+$/, where \d is a metacharacter that matches any digit, which is identical to [0-9]./[1-9][0-9]*|0/[1-9] matches any character between 1 to 9; [0-9]* matches zero or more digits. The * is an occurrence indicator representing zero or more occurrences. Together, [1-9][0-9]* matches any number without a leading zero.| represents the OR operator; which is used to include the number 0.0" and "123"; but does not match "000" and "0123".[0-9] by metacharacter \d.^ and $ in this regex. Hence, it can match any part of the input string, instead of the whole string./[+-]?[1-9]\d*|0/, where [+-] matches either + or - sign, and ? is an occurrence indicator denoting 0 or 1 occurrence (i.e. optional)./[a-zA-Z_][0-9a-zA-Z_]*/\w (word character) for [a-zA-Z0-9_]; \d (digit) for [0-9]. Hence, it can be written as /[a-zA-Z_]\w*/./[a-zA-Z_][\w-]*/. Nonetheless, dash conflicts with subtraction and is often excluded from identifier./^\w+\.(gif|png|jpg|jpeg)$/i/.../ contains a regex.^ and trailing $ match the
beginning and the ending of the input string, respectively. That is, the
entire input string shall match with this regex, instead of a part of
the input string.\w+ matches one or more word characters (i.e., [a-zA-Z0-9_]+).\. matches the . character. We need to use \. to represent . as . has special meaning in regex. The \ is known as the escape code, which restore the original literal meaning of the following character.(gif|png|jpg|jpeg) matches either "gif", "png", "jpg" or "jpeg". The | denotes "OR" operator.i after the regex specifies case-insensitive matching. That is, it accepts "test.GIF" and "test.Gif"./^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$//.../ contains a regex.^ and trailing $ match the
beginning and the ending of the input string, respectively. That is, the
entire input string shall match with this regex, instead of a part of
the input string.\w+ matches 1 or more word characters (i.e., [a-zA-Z0-9_]).[\.-] matches character . or -. We need to use \. to represent . as . has special meaning in regex. The \ is known as the escape code, which restore the original literal meaning of the following character.[\.-]? matches 0 or 1 occurrence of [\.-].\w+ matches 1 or more word characters.([\.-]?\w+)* matches 0 or more occurrences of [\.-]?\w+.\w+([\.-]?\w+)* is used to match the username in the email, before the @ sign. It begins with at least one word character (a-z, A-Z, 0-9 and underscore), followed by more word characters or . or -. However, a . or - must follow by a word character (a-z, A-Z, 0-9 and underscore). That is, the string cannot contain "..", "--", ".-" or "-.". Example of valid string are "a.1-2-3".@ matches itself.\w+([\.-]?\w+)* is used to match the email domain name, with the same pattern as the username described above.\.\w{2,3} matches a . followed by two or three word characters, e.g., ".com", ".edu", ".us", ".uk", ".co".(\.\w{2,3})+ specifies that the above sub-expression could occur one or more times, e.g., ".com", ".co.uk", ".edu.sg" etc./^[\w\-\.\+]+\@[a-zA-Z0-9\.\-]+\.[a-zA-z0-9]{2,4}$/./^(\S+)\s+(\S+)$//.../ contain a regex.^ and $ match the beginning and ending of the input string, respectively\s (lowercase s) matches a whitespace (blank, tab \t, form-feed \f and newline \r or \n). On the other hand, the \S+ (uppercase S) matches anything that is not matched by \s, i.e., non-whitespace. In regex, the uppercase metacharacter denotes the inverse of the lowercase counterpart, for example, \w for word character and \W for non-word character.(abc)?) and to provide a so-called back-reference for capturing and extracting matches.(\S+), called parenthesized back-reference, is used to extract the matched sub-string from the input string. In this regex, there are two (\S+), match the first two words, separated by one or more whitespaces \s+. The two matched words are extracted from the input string and typically kept in special variables $1 and $2 respectively.$2 $1" (via a programming language); or substitute operator "s/(\S+)\s+(\S+)/$2 $1/" (in Perl)./^http:\/\/\S+(\/\S+)*(\/)?$/http://. Take note that / needs to be written as \/ with an escape code.\S+, one or more non-whitespaces, for the domain name.(\/\S+)*, zero or more "/...", for the sub-directories.(\/)?, an optional (0 or 1) trailing /, for directory request./.../. It consists of a sequence of characters, meta-characters (such as ., \d, \s, \S) and operators (such as +, *, ?, |, ^)| Regex | Matches |
|---|---|
| /^[1-9][0-9]*|0$/ | A positive integer |
| /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/ | An email address |
a-z and A-Z) and digits (0-9), match themselves. In other words, the regex /a/ matches the string "a"; regex /x/ matches the string "x"./Friday/ matches the string "Friday". +, *, / and \ which are regex's operators, we need to precede the character with a backslash, known as escape sequence (i.e., \+, \*, \/ and \\). For example, the regex /a\*b\+/ matches the string "a*b+".|) Operator'|'. For example, the regex /four|for|floor|4/ matches strings "four", "for", "floor" or "4".[...], [^...] and Range [ - ] Expressions[ ], also called character class. It matches any ONE character in the list. However, if the first character of the list is the caret (^), then it matches any ONE character NOT in the list. For example, the regex [02468] matches a single digit 0, 2, 4, 6, or 8; the regex [^02468] matches any single character other than 0, 2, 4, 6, or 8.-). It matches any single character that sorts between the two characters, inclusive. For example, [a-d] is the same as [abcd]. You could include a caret (^) in front of the range to invert the matching. For example, [^a-d] is equivalent to [^abcd].], place it first in the list.^, place it anywhere but first.- place it last.+, *) lose their special meaning inside bracket list, and can be used as they are.., \w, \W, \d, \D, \s, \S.) matches any single character except newline \n (same as [^\n]). For example, /.../ matches any 3 characters (including alphabets, numbers, whitespaces, but except newline); /the../ matches "there", "these", "the ", and etc.\w (word character) matches any single letter, number or underscore (same as [a-zA-Z0-9_]). The uppercase counterpart \W (non-word-character) matches any single character that doesn't match by \w (same as [^a-zA-Z0-9_]).\d (digit) matches any single digit (same as [0-9]). The uppercase counterpart \D (non-digit) matches any single character that is not a digit (same as [^0-9]).\s (space) matches any single whitespace (same as [ \t\n\r\f], blank, tab, newline, carriage-return and form-feed). The uppercase counterpart \S (non-space) matches any single character that doesn't match by \s (same as [^ \t\n\r\f])./\s\s/ # Matches two whitespaces
/\S\S\s/ # Two non-whitespaces followed by a whitespace
/\s+/ # one or more whitespaces
/\S+\s\S+/ # two words (non-whitespaces) separated by a whitespace
?: The preceding item is optional and matched at most once (i.e., occurs 0 or 1 times).*: The preceding item will be matched zero or more times.+: The preceding item will be matched one or more times.{m}: The preceding item is matched exactly m times.{m,}: The preceding item is matched m or more times.{m,n}: The preceding item is matched at least m times, but not more than n times./xy{2,4}/ ('x' followed by 2 to 4 'y') matches "xyy", "xyyy" and "xyyyy".*, +, ?, {m,n} repetition operators are greedy operators, and by default grasp as many characters as possible for a match. For example, the regex /xy{2,4}/ try to match for "xyyyy", then "xyyy", and then "xyy"./z*zzz/ is matched against the string "zzzz", the z* first matches "zzzz"; unwinds to match "zzz"; unwinds to match "zz"; and finally unwinds to match "z", such that the rest of the patterns can find a match.? after the repetition operator (*, +, ?, or {}) to curb its greediness (i.e., stop at the shortest match) in the form of *?, +?, ??, {}?. For example,input = "The <code>first</code> and <code>second</code> instances"
/<code>.*</code>/g matches "<code>first</code> and <code>second</code>".
But
/<code>.*?</code>/g produces two matches: "<code>first</code>" and "<code>second</code>".
^, $, \b, \B, \<, \>, \A, \Z^) matches the beginning of the line (or input string); and the metacharacter dollar ($) matches the end of line, excluding newline (or end of input string). These two are the most commonly used position anchors.\b matches the the edge of a word (i.e., word boundary after a whitespace); and \B matches a string provided it's not at the edge of a word. For example, the regex /\bcat\b/ matches the word "cat" in input string "This is a cat."; but does not match string "This is a catalog.".\< and \> match the empty string at the beginning and the end of a word respectively (compared with \b, which can match both the beginning and the end of a word).\A matches the beginning of the line, just like ^. \Z matches the end of the line, just like $. However, \A and \Z match only the actual beginning and ending, and ignore the embedded newlines within the string./ing$/ # ending with 'ing'
/^testing 123$/ # Matches only one pattern. Should use equality comparison instead.
$1,... , $9( ) serve two purposes in regex.( ) can be used to group sub-expressions for overriding the precedence or applying a repetition operator. For example, /(a|e|i|o|u){3,5}/ is the same as /a{3,5}|e{3,5}|i{3,5}|o{3,5}|u{3,5}/./(\S+)/ creates one back-reference (\S+), which contains the first word (consecutive non-spaces) of the input string; the regex /(\S+)\s+(\S+)/ creates two back-references: (\S+) and another (\S+), containing the first two words, separated by one or more spaces \s+.$1, $2, …, $9, where $1 contains the substring matched the first pair of parentheses, and so on. For example, /(\S+)\s+(\S+)/ creates two back-references which matched with the first two words. The matched words are stored in $1 and $2, respectively. s/(\S+) (\S+)/$2 $1/; # Swap the first and second words separated by a single space
/.../modifiers, to control the matching behavior. For example,i: case insensitive matching. The default is case-sensitive.g: global matching, i.e., search for all the matches. The default searches only the first match.
./temp and then list the files in each folder according to the name of the folder.A and B.1.txt, 2.php, 2.pdf, 3.doc, 3.pdf.1.pdf, 1.jpg, 2.png.A => List of files in A
B => List of files in BRecursiveDirectoryIterator and RecursiveIteratorIterator to iterate through all subdirectories.$array = array();
foreach ($iterator = new RecursiveIteratorIterator(
new RecursiveDirectoryIterator("./temp",
RecursiveDirectoryIterator::SKIP_DOTS),
RecursiveIteratorIterator::SELF_FIRST) as $item) {
// Note SELF_FIRST, so array keys are in place before values are pushed.
$subPath = $iterator->getSubPathName();
if($item->isDir()) {
// Create a new array key of the current directory name.
$array[$subPath] = array();
}
else {
// Add a new element to the array of the current file name.
$array[$subPath][] = $subPath;
}
}
}
LOAD DATA LOCAL INFILE 'abc.csv' INTO TABLE abc
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\r\n'
IGNORE 1 LINES
(col1, col2, col3, col4, col5...) You probably need to set the FIELDS TERMINATED BY ',' or whatever the delimiter happens to be. For a CSV file, your statement should look like this:
LOAD DATA INFILE 'data.txt' INTO TABLE tbl_name
FIELDS TERMINATED BY ',' ENCLOSED BY '"'
LINES TERMINATED BY '\r\n'
IGNORE 1 LINES;
mysql> SELECT TRIM(' bar ');
-> 'bar'
mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
-> 'barxxx'
mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
-> 'bar'
mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
-> 'barx'
Syntax:
TRIM([{BOTH | LEADING | TRAILING}[,remstr] FROM]str)TRIM([remstrFROM]str)
Definition:Remove leading and trailing spaces.
Name Description
BOTH Indicates that prefixes from both left and right are to be removed.
LEADING Indicates that only leading prefixes are to be removed.
TRAILING Indicates that only trailing prefixes are to be removed.
remstr The string to be removed.
FROM Keyword
str The actual string from where remstr is to be removed.
Posts
All Comments
![IVRAMANA](https://draft.blogger.com/img/profile_blank_gray.jpg" title="IVRAMANA)
Hello Friends! I am Ramana a part time blogger from Hyderabad.
