FreeCode, Example Code,Free Programming Source Code: The FreeCode-FreeCode blog is the largest collection of free Internet related source code. Free programs are available in the following languages: C/C++, Java, Javascript, Ajax and Perl...
<html>
<body>
<script type="text/javascript">
function check_time()
{
var elem = document.getElementById('timeStr');
var orig_str = elem.value;
//24 hour
var _reg = new RegExp(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
alert(_reg.test(orig_str));
}
</script>
<input type="text" id="timeStr">
<input type="button" value="test" onclick="check_time()" />
</body>
</html>
...
<script type="text/javascript">
var str = " java script ";
str = str.replace(/^\s+/g,"");//remove heading whitespace
str = str.replace(/\s+$/g,"");//remove trailing whitespace
alert("|"+str+"|");
</script>
...
// : c12:TheReplacements.java
// From 'Thinking in Java, 3rd ed.' (c) Bruce Eckel 2002
// www.BruceEckel.com. See copyright notice in CopyRight.txt.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
* ! Here's a block of text to use as input to the regular expression matcher.
* Note that we'll first extract the block of text by looking for the special
* delimiters, then process the extracted block. !
*/
public class TheReplacements {
public static void main(String[] args) throws Exception {
String s = TextFile.read("TheReplacements.java");
// Match the specially-commented block of text above:
Matcher mInput = Pattern.compile("/\\*!(.*)!\\*/", Pattern.DOTALL)
.matcher(s);
if (mInput.find())
s = mInput.group(1); // Captured by parentheses
// Replace two or more spaces with a single space:
s = s.replaceAll(" {2,}", " ");
// Replace one or more spaces at the beginning of each
// line with no spaces. Must enable MULTILINE mode:
s = s.replaceAll("(?m)^ +", "");
System.out.println(s);
s = s.replaceFirst("[aeiou]", "(VOWEL1)");
StringBuffer sbuf = new StringBuffer();
Pattern p = Pattern.compile("[aeiou]");
Matcher m = p.matcher(s);
// Process the find information as you
// perform the replacements:
while (m.find())
m.appendReplacement(sbuf, m.group().toUpperCase());
// Put in the remainder of the text:
m.appendTail(sbuf);
System.out.println(sbuf);
}
} ///:~
class TextFile extends ArrayList {
// Tools to read and write files as single strings:
public static String read(String fileName) throws IOException {
StringBuffer sb = new StringBuffer();
BufferedReader in = new BufferedReader(new FileReader(fileName));
String s;
while ((s = in.readLine()) != null) {
sb.append(s);
sb.append("\n");
}
in.close();
return sb.toString();
}
public static void write(String fileName, String text) throws IOException {
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(
fileName)));
out.print(text);
out.close();
}
public TextFile(String fileName) throws IOException {
super(Arrays.asList(read(fileName).split("\n")));
}
public void write(String fileName) throws IOException {
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(
fileName)));
for (int i = 0; i < size(); i++)
out.println(get(i));
out.close();
}
// Simple test:
public static void main(String[] args) throws Exception {
String file = read("TextFile.java");
write("test.txt", file);
TextFile text = new TextFile("test.txt");
text.write("test2.txt");
}
} ///:~
...
String inputStr = "abbabcd";
String patternStr = "(a(?:b*))+(c*)";
// (?:b*) is a non-capturing group
// Compile and use regular expression
Pattern pattern = Pattern.compile(patternStr);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.find();
if (matchFound) {
// Get all groups for this match
for (int i=0; i<=matcher.groupCount(); i++) {
String groupStr = matcher.group(i);
}
// group 0: abbabc
// group 1: ab
// group 2: c
}
...
A group is a pair of parentheses used to group subpatterns. For example, h(a|i)t matches hat or hit. A group also captures the matching text within the parentheses. For example,
input: abbc
pattern: a(b*)c
causes the substring bb to be captured by the group (b*). A pattern can have more than one group and the groups can be nested. For example,
pattern: (a(b*))+(c*)
contains three groups:
group 1: (a(b*))
group 2: (b*)
group 3: (c*)
The groups are numbered from left to right, outside to inside. There is an implicit group 0, which contains the entire match. Here is an example of what is captured in groups. Notice that group 1 was applied twice, once to the input abb and then to the input ab. Only the most recent match is captured. Note that when using * on a group and the group matches zero times, the group will not be cleared. In particular, it will hold the most recently captured text. For example,
input: aba
pattern: (a(b)*)+
group 0: aba
group 1: a
group 2: b
Group 1 first matched ab capturing b in group 2. Group 1 then matched the a with group 2 matching zero bs, therefore leaving intact the previously captured b.
Note: If it is not necessary for a group to capture text, you should use a non-capturing group since it is more efficient. For more information, see Using a Non-Capturing Group in a Regular Expression.
This example demonstrates how to retrieve the text in a group.
CharSequence inputStr = "abbabcd";
String patternStr = "(a(b*))+(c*)";
// Compile and use regular expression
Pattern pattern = Pattern.compile(patternStr);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.find();
if (matchFound) {
// Get all groups for this match
for (int i=0; i<=matcher.groupCount(); i++) {
String groupStr = matcher.group(i);
}
}
...
import java.util.regex.*;
public class BasicMatch {
public static void main(String[] args) {
// Compile regular expression
String patternStr = "b";
Pattern pattern = Pattern.compile(patternStr);
// Determine if pattern exists in input
CharSequence inputStr = "a b c b";
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.find(); // true
// Get matching string
String match = matcher.group(); // b
// Get indices of matching string
int start = matcher.start(); // 2
int end = matcher.end(); // 3
// the end is index of the last matching character + 1
// Find the next occurrence
matchFound = matcher.find(); // true
}
}
...my $string = ' Mary had a little lamb. '; $string =~ s/^\\s+//; #remove leading spaces $string =~ s/\\s+$//; #remove trailing spaces print $string;...
A line from a flat-file is typically formatted using a separator character to separate the fields. If the separator is simply a comma, tab, or single character, the StringTokenizer class can be used to parse the line into fields. If the separator is more complex (e.g., a space after a comma), a regular expression is needed. String.split() conveniently parses a line using a regular expression to specify the separator.
String.split() returns only the nondelimiter strings. To obtain the delimiter strings, see Parsing a String into Tokens Using a Regular Expression.
Note: The StringTokenizer does not conveniently handle empty fields properly. For example, given the line a,,b, rather than return three fields (the second being empty), the StringTokenizer returns two fields, discarding the empty field. String.split() properly handles empty fields.
// Parse a comma-separated string String inputStr = "a,,b"; String patternStr = ","; String[] fields = inputStr.split(patternStr); // ["a", "", "b"] // Parse a line whose separator is a comma followed by a space inputStr = "a, b, c,d"; patternStr = ", "; fields = inputStr.split(patternStr, -1); // ["a", "b", "c,d"] // Parse a line with and's and or's inputStr = "a, b, and c"; patternStr = "[, ]+(andor)*[, ]*"; fields = inputStr.split(patternStr, -1); // ["a", "b", "c"]...
CharSequence inputStr = "a 1 2 b c 3 4";
String patternStr = "[a-z]";
// Set to false if only the tokens that match the pattern are to be returned.
// If true, the text between matching tokens are also returned.
boolean returnDelims = true;
// Create the tokenizer
Iterator tokenizer = new RETokenizer(inputStr, patternStr, returnDelims);
// Get the tokens (and delimiters)
for (; tokenizer.hasNext(); ) {
String tokenOrDelim = (String)tokenizer.next();
}
// "", "a", " 1 2 ", "b", " ", "c"
class RETokenizer implements Iterator {
// Holds the original input to search for tokens
private CharSequence input;
// Used to find tokens
private Matcher matcher;
// If true, the String between tokens are returned
private boolean returnDelims;
// The current delimiter value. If non-null, should be returned
// at the next call to next()
private String delim;
// The current matched value. If non-null and delim=null,
// should be returned at the next call to next()
private String match;
// The value of matcher.end() from the last successful match.
private int lastEnd = 0;
// patternStr is a regular expression pattern that identifies tokens.
// If returnDelims delim is false, only those tokens that match the
// pattern are returned. If returnDelims true, the text between
// matching tokens are also returned. If returnDelims is true, the
// tokens are returned in the following sequence - delimiter, token,
// delimiter, token, etc. Tokens can never be empty but delimiters might
// be empty (empty string).
public RETokenizer(CharSequence input, String patternStr, boolean returnDelims) {
// Save values
this.input = input;
this.returnDelims = returnDelims;
// Compile pattern and prepare input
Pattern pattern = Pattern.compile(patternStr);
matcher = pattern.matcher(input);
}
// Returns true if there are more tokens or delimiters.
public boolean hasNext() {
if (matcher == null) {
return false;
}
if (delim != null || match != null) {
return true;
}
if (matcher.find()) {
if (returnDelims) {
delim = input.subSequence(lastEnd, matcher.start()).toString();
}
match = matcher.group();
lastEnd = matcher.end();
} else if (returnDelims && lastEnd < input.length()) {
delim = input.subSequence(lastEnd, input.length()).toString();
lastEnd = input.length();
// Need to remove the matcher since it appears to automatically
// reset itself once it reaches the end.
matcher = null;
}
return delim != null || match != null;
}
// Returns the next token (or delimiter if returnDelims is true).
public Object next() {
String result = null;
if (delim != null) {
result = delim;
delim = null;
} else if (match != null) {
result = match;
match = null;
}
return result;
}
// Returns true if the call to next() will return a token rather
// than a delimiter.
public boolean isNextToken() {
return delim == null && match != null;
}
// Not supported.
public void remove() {
throw new UnsupportedOperationException();
}
}
...
