Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Summer 2008/wiki1 1 rapodraz

2008-06-10T14:53:47Z

Rapodraza:

=Regular Expressions in Ruby vs. Java=
Ruby and Java both support Regular Expressions, but generally speaking, Ruby's dynamic typing and native regular expression support allow for performing equivalent or similar functions more simply and with less code.

==General Differences==
Ruby can perform most regular expression related functions using a combination of the String and Regexp classes. The String class has several methods that take a Regexp as a parameter, and similarly the Regexp class has methods that take a String as a parameter. Ruby also provides a shorthand for defining regular expressions, a string surrounded by forward slashes: Regexp.new('test') and /test/ are equivalent.

Mostly, Java does not have native support for regular expressions. While the String class has a few methods that can perform related functions, they do not necessarily follow the conventional rules of regular expressions. Proper regular expression support is available in Java through several packages, most notably java.util.regex, which is Sun's standard package available in Java 1.4+. This package provides two classes, Pattern and Matcher, which are respectively used to define and operate on regular expressions. These classes work in conjunction with the String class to perform regular expression functions.

==Code Example: find a regular expression match within a String==
In Ruby, there are 2 simple ways to do this, the main difference between them being that one is a String method and one is a Regexp method.
First the String method, the [http://www.ruby-doc.org/core/classes/String.html#M000792 =~] operator, which returns the index in the string at which the pattern first matches.

"This is a string" =~ /is/
>> 2
"This is a string" =~ /hello/
>> nil

An equivalent way to do this is with the Regexp method match(). Note that match() returns a [http://www.ruby-doc.org/core/classes/MatchData.html MatchData] object if successful.

/is/.match("This is a string")
>> #<MatchData:0x5e1715c>
/hello/.match("This is a string")
>> nil

In Java, it is possible to do a simple version of this using only the String.matches() method, however this is a boolean method so we will miss out on the extra index information that Ruby's =~ will give.

String str = "This is a string";
str.matches("is"); // does not do what you expect. This will return false.
str.matches(".*is.*"); // will return true

In the above code, it is important to realize that matches() will only return true if the entire string from beginning to end is a match. In other words, it behaves as if the input regular expression "regexp" is actually "^regexp$". For matching a subsring or the entire string, a workaround such as the third line above must be used.

==Code Example: collecting regular expression matches within a String in an array of Strings==
In Ruby, a simple way to collect regular expression matches from a String is to use the String.scan() method, which takes a regular expression as a parameter, and returns a String array.

matches = "This is a string".scan(/is/)
>> ["is", "is"]

A slightly more complex regular expression:

matches = "This is a string".scan(/\w*i\w*/) # match any word with an i in it
>> ["This", "is", "string"]

In Java, it is a bit more complicated. There are no shortcut methods as part of the String class to help us do what we want, and we need to make use of the Pattern and Matcher classes.

String myString = new String("This is a string");
Pattern myPattern = Pattern.compile("is");
Matcher myMatcher = myPattern.matcher(myString);
Vector results = new Vector(); // to store the resulting matches 
while (myMatcher.find()) { // find() finds the next match, evaluates to false if not found
results.add(myMatcher.group()); // group() returns the matched string
}

=Links=
http://www.regular-expressions.info/ruby.html 
http://www.regular-expressions.info/java.html 
http://www.javaworld.com/javaworld/jw-07-2001/jw-0713-regex.html?page=3 
http://regex.info/java.html 
http://www.blueskyonmars.com/2003/10/31/14-stringmatches-is-dumb/ 
http://www.ruby-doc.org/core/classes/MatchData.html 

[[CSC/ECE 517 Summer 2008/wiki1 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-06-10T12:22:01Z

Rapodraza:

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-06-10T12:21:43Z

Rapodraza:

=Regular Expressions in Ruby vs. Java=
Ruby and Java both support Regular Expressions, but generally speaking, Ruby's dynamic typing and native regular expression support allow for performing equivalent or similar functions more simply and with less code. hello hy

==General Differences==
Ruby can perform most regular expression related functions using a combination of the String and Regexp classes. The String class has several methods that take a Regexp as a parameter, and similarly the Regexp class has methods that take a String as a parameter. Ruby also provides a shorthand for defining regular expressions, a string surrounded by forward slashes: Regexp.new('test') and /test/ are equivalent.

Mostly, Java does not have native support for regular expressions. While the String class has a few methods that can perform related functions, they do not necessarily follow the conventional rules of regular expressions. Proper regular expression support is available in Java through several packages, most notably java.util.regex, which is Sun's standard package available in Java 1.4+. This package provides two classes, Pattern and Matcher, which are respectively used to define and operate on regular expressions. These classes work in conjunction with the String class to perform regular expression functions.

==Code Example: find a regular expression match within a String==
In Ruby, there are 2 simple ways to do this, the main difference between them being that one is a String method and one is a Regexp method.
First the String method, the [http://www.ruby-doc.org/core/classes/String.html#M000792 =~] operator, which returns the index in the string at which the pattern first matches.

"This is a string" =~ /is/
>> 2
"This is a string" =~ /hello/
>> nil

An equivalent way to do this is with the Regexp method match(). Note that match() returns a [http://www.ruby-doc.org/core/classes/MatchData.html MatchData] object if successful.

/is/.match("This is a string")
>> #<MatchData:0x5e1715c>
/hello/.match("This is a string")
>> nil

In Java, it is possible to do a simple version of this using only the String.matches() method, however this is a boolean method so we will miss out on the extra index information that Ruby's =~ will give.

String str = "This is a string";
str.matches("is"); // does not do what you expect. This will return false.
str.matches(".*is.*"); // will return true

In the above code, it is important to realize that matches() will only return true if the entire string from beginning to end is a match. In other words, it behaves as if the input regular expression "regexp" is actually "^regexp$". For matching a subsring or the entire string, a workaround such as the third line above must be used.

==Code Example: collecting regular expression matches within a String in an array of Strings==
In Ruby, a simple way to collect regular expression matches from a String is to use the String.scan() method, which takes a regular expression as a parameter, and returns a String array.

matches = "This is a string".scan(/is/)
>> ["is", "is"]

A slightly more complex regular expression:

matches = "This is a string".scan(/\w*i\w*/) # match any word with an i in it
>> ["This", "is", "string"]

In Java, it is a bit more complicated. There are no shortcut methods as part of the String class to help us do what we want, and we need to make use of the Pattern and Matcher classes.

String myString = new String("This is a string");
Pattern myPattern = Pattern.compile("is");
Matcher myMatcher = myPattern.matcher(myString);
Vector results = new Vector(); // to store the resulting matches 
while (myMatcher.find()) { // find() finds the next match, evaluates to false if not found
results.add(myMatcher.group()); // group() returns the matched string
}

=Links=
http://www.regular-expressions.info/ruby.html 
http://www.regular-expressions.info/java.html 
http://www.javaworld.com/javaworld/jw-07-2001/jw-0713-regex.html?page=3 
http://regex.info/java.html 
http://www.blueskyonmars.com/2003/10/31/14-stringmatches-is-dumb/ 
http://www.ruby-doc.org/core/classes/MatchData.html 

[[CSC/ECE 517 Summer 2008/wiki1 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-06-10T12:21:27Z

Rapodraza:

=Regular Expressions in Ruby vs. Java=
Ruby and Java both support Regular Expressions, but generally speaking, Ruby's dynamic typing and native regular expression support allow for performing equivalent or similar functions more simply and with less code. hello

==General Differences==
Ruby can perform most regular expression related functions using a combination of the String and Regexp classes. The String class has several methods that take a Regexp as a parameter, and similarly the Regexp class has methods that take a String as a parameter. Ruby also provides a shorthand for defining regular expressions, a string surrounded by forward slashes: Regexp.new('test') and /test/ are equivalent.

Mostly, Java does not have native support for regular expressions. While the String class has a few methods that can perform related functions, they do not necessarily follow the conventional rules of regular expressions. Proper regular expression support is available in Java through several packages, most notably java.util.regex, which is Sun's standard package available in Java 1.4+. This package provides two classes, Pattern and Matcher, which are respectively used to define and operate on regular expressions. These classes work in conjunction with the String class to perform regular expression functions.

==Code Example: find a regular expression match within a String==
In Ruby, there are 2 simple ways to do this, the main difference between them being that one is a String method and one is a Regexp method.
First the String method, the [http://www.ruby-doc.org/core/classes/String.html#M000792 =~] operator, which returns the index in the string at which the pattern first matches.

"This is a string" =~ /is/
>> 2
"This is a string" =~ /hello/
>> nil

An equivalent way to do this is with the Regexp method match(). Note that match() returns a [http://www.ruby-doc.org/core/classes/MatchData.html MatchData] object if successful.

/is/.match("This is a string")
>> #<MatchData:0x5e1715c>
/hello/.match("This is a string")
>> nil

In Java, it is possible to do a simple version of this using only the String.matches() method, however this is a boolean method so we will miss out on the extra index information that Ruby's =~ will give.

String str = "This is a string";
str.matches("is"); // does not do what you expect. This will return false.
str.matches(".*is.*"); // will return true

In the above code, it is important to realize that matches() will only return true if the entire string from beginning to end is a match. In other words, it behaves as if the input regular expression "regexp" is actually "^regexp$". For matching a subsring or the entire string, a workaround such as the third line above must be used.

==Code Example: collecting regular expression matches within a String in an array of Strings==
In Ruby, a simple way to collect regular expression matches from a String is to use the String.scan() method, which takes a regular expression as a parameter, and returns a String array.

matches = "This is a string".scan(/is/)
>> ["is", "is"]

A slightly more complex regular expression:

matches = "This is a string".scan(/\w*i\w*/) # match any word with an i in it
>> ["This", "is", "string"]

In Java, it is a bit more complicated. There are no shortcut methods as part of the String class to help us do what we want, and we need to make use of the Pattern and Matcher classes.

String myString = new String("This is a string");
Pattern myPattern = Pattern.compile("is");
Matcher myMatcher = myPattern.matcher(myString);
Vector results = new Vector(); // to store the resulting matches 
while (myMatcher.find()) { // find() finds the next match, evaluates to false if not found
results.add(myMatcher.group()); // group() returns the matched string
}

=Links=
http://www.regular-expressions.info/ruby.html 
http://www.regular-expressions.info/java.html 
http://www.javaworld.com/javaworld/jw-07-2001/jw-0713-regex.html?page=3 
http://regex.info/java.html 
http://www.blueskyonmars.com/2003/10/31/14-stringmatches-is-dumb/ 
http://www.ruby-doc.org/core/classes/MatchData.html 

[[CSC/ECE 517 Summer 2008/wiki1 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-06-10T12:20:39Z

Rapodraza:

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-06-10T12:20:18Z

Rapodraza:

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-06-02T13:53:29Z

Rapodraza:

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-06-02T13:52:55Z

Rapodraza:

=Regular Expressions in Ruby vs. Java=
Ruby and Java both support Regular Expressions, but generally speaking, Ruby's dynamic typing and native regular expression support allow for performing equivalent or similar functions more simply and with less code.

==General Differences==
Ruby can perform most regular expression related functions using a combination of the String and Regexp classes. The String class has several methods that take a Regexp as a parameter, and similarly the Regexp class has methods that take a String as a parameter. Ruby also provides a shorthand for defining regular expressions, a string surrounded by forward slashes: Regexp.new('test') and /test/ are equivalent.

Mostly, Java does not have native support for regular expressions. While the String class has a few methods that can perform related functions, they do not necessarily follow the conventional rules of regular expressions. Proper regular expression support is available in Java through several packages, most notably java.util.regex, which is Sun's standard package available in Java 1.4+. This package provides two classes, Pattern and Matcher, which are respectively used to define and operate on regular expressions. These classes work in conjunction with the String class to perform regular expression functions.

==Code Example: find a regular expression match within a String==
In Ruby, there are 2 simple ways to do this, the main difference between them being that one is a String method and one is a Regexp method.
First the String method, the [http://www.ruby-doc.org/core/classes/String.html#M000792 =~] operator, which returns the index in the string at which the pattern first matches.

"This is a string" =~ /is/
>> 2
"This is a string" =~ /hello/
>> nil

An equivalent way to do this is with the Regexp method match(). Note that match() returns a [http://www.ruby-doc.org/core/classes/MatchData.html MatchData] object if successful.

/is/.match("This is a string")
>> #<MatchData:0x5e1715c>
/hello/.match("This is a string")
>> nil

In Java, it is possible to do a simple version of this using only the String.matches() method, however this is a boolean method so we will miss out on the extra index information that Ruby's =~ will give.

String str = "This is a string";
str.matches("is"); // does not do what you expect. This will return false.
str.matches(".*is.*"); // will return true

In the above code, it is important to realize that matches() will only return true if the entire string from beginning to end is a match. In other words, it behaves as if the input regular expression "regexp" is actually "^regexp$". For matching a subsring or the entire string, a workaround such as the third line above must be used.

==Code Example: collecting regular expression matches within a String in an array of Strings==
In Ruby, a simple way to collect regular expression matches from a String is to use the String.scan() method, which takes a regular expression as a parameter, and returns a String array.

matches = "This is a string".scan(/is/)
>> ["is", "is"]

A slightly more complex regular expression:

matches = "This is a string".scan(/\w*i\w*/) # match any word with an i in it
>> ["This", "is", "string"]

In Java, it is a bit more complicated. There are no shortcut methods as part of the String class to help us do what we want, and we need to make use of the Pattern and Matcher classes.

String myString = new String("This is a string");
Pattern myPattern = Pattern.compile("is");
Matcher myMatcher = myPattern.matcher(myString);
Vector results = new Vector(); // to store the resulting matches 
while (myMatcher.find()) { // find() finds the next match, evaluates to false if not found
results.add(myMatcher.group()); // group() returns the matched string
}

=Links=
http://www.regular-expressions.info/ruby.html
http://www.regular-expressions.info/java.html
http://www.javaworld.com/javaworld/jw-07-2001/jw-0713-regex.html?page=3
http://regex.info/java.html
http://www.blueskyonmars.com/2003/10/31/14-stringmatches-is-dumb/
http://www.ruby-doc.org/core/classes/MatchData.html

[[CSC/ECE 517 Summer 2008/wiki1 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-06-02T13:51:44Z

Rapodraza:

=Regular Expressions in Ruby vs. Java=
Ruby and Java both support Regular Expressions, but generally speaking, Ruby's dynamic typing and native regular expression support allow for performing equivalent or similar functions more simply and with less code.

==General Differences==
Ruby can perform most regular expression related functions using a combination of the String and Regexp classes. The String class has several methods that take a Regexp as a parameter, and similarly the Regexp class has methods that take a String as a parameter. Ruby also provides a shorthand for defining regular expressions, a string surrounded by forward slashes: Regexp.new('test') and /test/ are equivalent.

Mostly, Java does not have native support for regular expressions. While the String class has a few methods that can perform related functions, they do not necessarily follow the conventional rules of regular expressions. Proper regular expression support is available in Java through several packages, most notably java.util.regex, which is Sun's standard package available in Java 1.4+. This package provides two classes, Pattern and Matcher, which are respectively used to define and operate on regular expressions. These classes work in conjunction with the String class to perform regular expression functions.

==Code Example: find a regular expression match within a String==
In Ruby, there are 2 simple ways to do this, the main difference between them being that one is a String method and one is a Regexp method.
First the String method, the [http://www.ruby-doc.org/core/classes/String.html#M000792 =~] operator, which returns the index in the string at which the pattern first matches.

"This is a string" =~ /is/
>> 2
"This is a string" =~ /hello/
>> nil

An equivalent way to do this is with the Regexp method match(). Note that match() returns a [http://www.ruby-doc.org/core/classes/MatchData.html MatchData] object if successful.

/is/.match("This is a string")
>> #<MatchData:0x5e1715c>
/hello/.match("This is a string")
>> nil

In Java, it is possible to do a simple version of this using only the String.matches() method, however this is a boolean method so we will miss out on the extra index information that Ruby's =~ will give.

String str = "This is a string";
str.matches("is"); // does not do what you expect. This will return false.
str.matches(".*is.*"); // will return true

In the above code, it is important to realize that matches() will only return true if the entire string from beginning to end is a match. In other words, it behaves as if the input regular expression "regexp" is actually "^regexp$". For matching a subsring or the entire string, a workaround such as the third line above must be used.

==Code Example: collecting regular expression matches within a String in an array of Strings==
In Ruby, a simple way to collect regular expression matches from a String is to use the String.scan() method, which takes a regular expression as a parameter, and returns a String array.

matches = "This is a string".scan(/is/)
>> ["is", "is"]

A slightly more complex regular expression:

matches = "This is a string".scan(/\w*i\w*/) # match any word with an i in it
>> ["This", "is", "string"]

In Java, it is a bit more complicated. There are no shortcut methods as part of the String class to help us do what we want, and we need to make use of the Pattern and Matcher classes.

String myString = new String("This is a string");
Pattern myPattern = Pattern.compile("is");
Matcher myMatcher = myPattern.matcher(myString);
Vector results = new Vector(); // to store the resulting matches 
while (myMatcher.find()) { // find() finds the next match, evaluates to false if not found
results.add(myMatcher.group()); // group() returns the matched string
}

=Links=
[http://www.regular-expressions.info/ruby.html]
[http://www.regular-expressions.info/java.html]
[http://www.javaworld.com/javaworld/jw-07-2001/jw-0713-regex.html?page=3]
[http://regex.info/java.html]
[http://www.blueskyonmars.com/2003/10/31/14-stringmatches-is-dumb/]
[http://www.ruby-doc.org/core/classes/MatchData.html]

[[CSC/ECE 517 Summer 2008/wiki1 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-06-02T13:49:13Z

Rapodraza:

=Regular Expressions in Ruby vs. Java=
Ruby and Java both support Regular Expressions, but generally speaking, Ruby's dynamic typing and native regular expression support allow for performing equivalent or similar functions more simply and with less code.

==General Differences==
Ruby can perform most regular expression related functions using a combination of the String and Regexp classes. The String class has several methods that take a Regexp as a parameter, and similarly the Regexp class has methods that take a String as a parameter. Ruby also provides a shorthand for defining regular expressions, a string surrounded by forward slashes: Regexp.new('test') and /test/ are equivalent.

Mostly, Java does not have native support for regular expressions. While the String class has a few methods that can perform related functions, they do not necessarily follow the conventional rules of regular expressions. Proper regular expression support is available in Java through several packages, most notably java.util.regex, which is Sun's standard package available in Java 1.4+. This package provides two classes, Pattern and Matcher, which are respectively used to define and operate on regular expressions. These classes work in conjunction with the String class to perform regular expression functions.

==Code Example: find a regular expression match within a String==
In Ruby, there are 2 simple ways to do this, the main difference between them being that one is a String method and one is a Regexp method.
First the String method, the [http://www.ruby-doc.org/core/classes/String.html#M000792 =~] operator, which returns the index in the string at which the pattern first matches.

"This is a string" =~ /is/
>> 2
"This is a string" =~ /hello/
>> nil

An equivalent way to do this is with the Regexp method match(). Note that match() returns a [http://www.ruby-doc.org/core/classes/MatchData.html MatchData] object if successful.

/is/.match("This is a string")
>> #<MatchData:0x5e1715c>
/hello/.match("This is a string")
>> nil

In Java, it is possible to do a simple version of this using only the String.matches() method, however this is a boolean method so we will miss out on the extra index information that Ruby's =~ will give.

String str = "This is a string";
str.matches("is"); // does not do what you expect. This will return false.
str.matches(".*is.*"); // will return true

In the above code, it is important to realize that matches() will only return true if the entire string from beginning to end is a match. In other words, it behaves as if the input regular expression "regexp" is actually "^regexp$". For matching a subsring or the entire string, a workaround such as the third line above must be used.

==Code Example: collecting regular expression matches within a String in an array of Strings==
In Ruby, a simple way to collect regular expression matches from a String is to use the String.scan() method, which takes a regular expression as a parameter, and returns a String array.

matches = "This is a string".scan(/is/)
>> ["is", "is"]

A slightly more complex regular expression:

matches = "This is a string".scan(/\w*i\w*/) # match any word with an i in it
>> ["This", "is", "string"]

In Java, it is a bit more complicated. There are no shortcut methods as part of the String class to help us do what we want, and we need to make use of the Pattern and Matcher classes.

String myString = new String("This is a string");
Pattern myPattern = Pattern.compile("is");
Matcher myMatcher = myPattern.matcher(myString);
Vector results = new Vector(); // to store the resulting matches 
while (myMatcher.find()) { // find() finds the next match, evaluates to false if not found
results.add(myMatcher.group()); // group() returns the matched string
}

[[CSC/ECE 517 Summer 2008/wiki1 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-06-02T13:45:11Z

Rapodraza:

=Regular Expressions in Ruby vs. Java=
Ruby and Java both support Regular Expressions, but generally speaking, Ruby's dynamic typing and native regular expression support allow for performing equivalent or similar functions more simply and with less code.

==General Differences==
Ruby can perform most regular expression related functions using a combination of the String and Regexp classes. The String class has several methods that take a Regexp as a parameter, and similarly the Regexp class has methods that take a String as a parameter. Ruby also provides a shorthand for defining regular expressions, a string surrounded by forward slashes: Regexp.new('test') and /test/ are equivalent.

Mostly, Java does not have native support for regular expressions. While the String class has a few methods that can perform related functions, they do not necessarily follow the conventional rules of regular expressions. Proper regular expression support is available in Java through several packages, most notably java.util.regex, which is Sun's standard package available in Java 1.4+. This package provides two classes, Pattern and Matcher, which are respectively used to define and operate on regular expressions. These classes work in conjunction with the String class to perform regular expression functions.

==Code Example: find a regular expression match within a String==
In Ruby, there are 2 simple ways to do this, the main difference between them being that one is a String method and one is a Regexp method.
First the String method, the [http://www.ruby-doc.org/core/classes/String.html#M000792 =~] operator, which returns the index in the string at which the pattern first matches.

"This is a string" =~ /is/ 
>> 2 
"This is a string" =~ /hello/ 
>> nil 

An equivalent way to do this is with the Regexp method match(). Note that match() returns a [http://www.ruby-doc.org/core/classes/MatchData.html MatchData] object if successful.

/is/.match("This is a string") 
>> #<MatchData:0x5e1715c> 
/hello/.match("This is a string") 
>> nil 

In Java, it is possible to do a simple version of this using only the String.matches() method, however this is a boolean method so we will miss out on the extra index information that Ruby's =~ will give.

String str = "This is a string"; 
str.matches("is"); // does not do what you expect. This will return false. 
str.matches(".*is.*"); // will return true 

In the above code, it is important to realize that matches() will only return true if the entire string from beginning to end is a match. In other words, it behaves as if the input regular expression "regexp" is actually "^regexp$". For matching a subsring or the entire string, a workaround such as the third line above must be used.

==Code Example: collecting regular expression matches within a String in an array of Strings==
In Ruby, a simple way to collect regular expression matches from a String is to use the String.scan() method, which takes a regular expression as a parameter, and returns a String array.

matches = "This is a string".scan(/is/) 
>> ["is", "is"] 

A slightly more complex regular expression:

matches = "This is a string".scan(/\w*i\w*/) # match any word with an i in it 
>> ["This", "is", "string"] 

In Java, it is a bit more complicated. There are no shortcut methods as part of the String class to help us do what we want, and we need to make use of the Pattern and Matcher classes.

String myString = new String("This is a string); 
Pattern myPattern = Pattern.compile("is"); 
Matcher myMatcher = myPattern.matcher(myString); 
Vector results = new Vector(); // to store the resulting matches 

while (myMatcher.find()) { // find() finds the next match, evaluates to false if not found 
results.add(myMatcher.group()); // group() returns the matched string 
} 

[[CSC/ECE 517 Summer 2008/wiki1 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-05-30T18:37:49Z

Rapodraza:

=Regular Expressions in Ruby vs. Java=
Ruby and Java both support Regular Expressions, but generally speaking, Ruby's dynamic typing and native regular expression support allow for performing equivalent or similar functions more simply and with less code.

==General Differences==
Ruby can perform most regular expression related functions using a combination of the String and Regexp classes. The String class has several methods that take a Regexp as a parameter, and similarly the Regexp class has methods that take a String as a parameter. Ruby also provides a shorthand for defining regular expressions, a string surrounded by forward slashes: Regexp.new('test') and /test/ are equivalent.

Mostly, Java does not have native support for regular expressions. While the String class has a few methods that can perform related functions, they do not necessarily follow the conventional rules of regular expressions. Proper regular expression support is available in Java through several packages, most notably java.util.regex, which is Sun's standard package available in Java 1.4+. This package provides two classes, Pattern and Matcher, which are respectively used to define and operate on regular expressions. These classes work in conjunction with the String class to perform regular expression functions.

==Code Example: find a regular expression match within a String==
In Ruby, there are 2 simple ways to do this, the main difference between them being that one is a String method and one is a Regexp method.
First the String method, the [http://www.ruby-doc.org/core/classes/String.html#M000792 =~] operator, which returns the index in the string at which the pattern first matches.

"This is a string" =~ /is/ 
>> 2 
"This is a string" =~ /hello/ 
>> nil 

An equivalent way to do this is with the Regexp method match(). Note that match() returns a [http://www.ruby-doc.org/core/classes/MatchData.html MatchData] object if successful.

/is/.match("This is a string") 
>> #<MatchData:0x5e1715c> 
/hello/.match("This is a string") 
>> nil 

In Java, it is possible to do a simple version of this using only the String.matches() method, however this is a boolean method so we will miss out on the extra index information that Ruby's =~ will give.

String str = "This is a string"; 
str.matches("is"); // does not do what you expect. This will return false. 
str.matches(".*is.*"); // will return true 

In the above code, it is important to realize that matches() will only return true if the entire string from beginning to end is a match. In other words, it behaves as if the input regular expression "regexp" is actually "^regexp$". For matching a subsring or the entire string, a workaround such as the third line above must be used.

==Code Example: collecting regular expression matches within a String in an array of Strings==
In Ruby, a simple way to collect regular expression matches from a String is to use the String.scan() method, which takes a regular expression as a parameter, and returns a String array.

matches = "This is a string".scan(/is/)
>> ["is", "is"]

A slightly more complex regular expression:

matches = "This is a string".scan(/\w*i\w*/) # match any word with an i in it
>> ["This", "is", "string"]

In Java,

[[CSC/ECE 517 Summer 2008/wiki1 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-05-30T14:05:57Z

Rapodraza:

=Regular Expressions in Ruby vs. Java=
Ruby and Java both support Regular Expressions, but generally speaking, Ruby's dynamic typing and native regular expression support allow for performing equivalent or similar functions more simply and with less code.

==General Differences==
Ruby can perform most regular expression related functions using a combination of the String and Regexp classes. The String class has several methods that take a Regexp as a parameter, and similarly the Regexp class has methods that take a String as a parameter. Ruby also provides a shorthand for defining regular expressions, a string surrounded by forward slashes: Regexp.new('test') and /test/ are equivalent.

Mostly, Java does not have native support for regular expressions. While the String class has a few methods that can perform related functions, they do not necessarily follow the conventional rules of regular expressions. Proper regular expression support is available in Java through several packages, most notably java.util.regex, which is Sun's standard package available in Java 1.4+. This package provides two classes, Pattern and Matcher, which are respectively used to define and operate on regular expressions. These classes work in conjunction with the String class to perform regular expression functions.

==Code Example: find a regular expression match within a String==
In Ruby, there are 2 simple ways to do this, the main difference between them being that one is a String method and one is a Regexp method.
First the String method, the [http://www.ruby-doc.org/core/classes/String.html#M000792 =~] operator, which returns the index in the string at which the pattern first matches.

"This is a string" =~ /is/ 
>> 2 
"This is a string" =~ /hello/ 
>> nil 

An equivalent way to do this is with the Regexp method match(). Note that match() returns a [http://www.ruby-doc.org/core/classes/MatchData.html MatchData] object if successful.

/is/.match("This is a string") 
>> #<MatchData:0x5e1715c> 
/hello/.match("This is a string") 
>> nil 

In Java, it is possible to do a simple version of this using only the String.matches() method, however this is a boolean method so we will miss out on the extra index information that Ruby's =~ will give.

String str = "This is a string"; 
str.matches("is"); // does not do what you expect. This will return false. 
str.matches(".*is.*"); // will return true 

In the above code, it is important to realize that matches() will only return true if the entire string from beginning to end is a match. In other words, it behaves as if the input regular expression "regexp" is actually "^regexp$". For matching a subsring or the entire string, a workaround such as the third line above must be used.

==Code Example: collecting regular expression matches within a String in an array of Strings==
[[CSC/ECE 517 Summer 2008/wiki1 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-05-30T12:43:24Z

Rapodraza:

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-05-29T15:35:08Z

Rapodraza: /* Regular Expressions in Ruby vs. Java */

== Regular Expressions in Ruby vs. Java ==
Ruby and Java both support Regular Expressions, but generally speaking, Ruby's dynamic typing and native regular expression support allow for equivalent or similar functions to be performed more simply and with less code.

Ruby can perform most regular expression related functions using a combination of the String and Regexp classes. The String class has several methods that take a Regexp as a parameter, and similarly the Regexp class has methods that take a String as a parameter. Ruby also provides a shorthand for defining regular expressions, a string surrounded by forward slashes: Regexp.new('test') and /test/ are equivalent.

Mostly, Java does not have native support for regular expressions. While the String class has a few methods that can perform related functions, they do not necessarily follow the conventional rules of regular expressions. Proper regular expression support is available in Java through several packages, most notably java.util.regex, which is Sun's standard package available in Java 1.4+. This package provides two classes, Pattern and Matcher, which are respectively used to define and operate on regular expressions. These classes work in conjunction with the String class to perform regular expression functions.

add code examples

[[CSC/ECE 517 Summer 2008/wiki1 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-05-29T13:27:05Z

Rapodraza: /* Regular Expressions in Ruby vs. Java */

== Regular Expressions in Ruby vs. Java ==
Ruby and Java both support Regular Expressions, but generally speaking, Ruby's dynamic typing and native regular expression support allow for equivalent or similar functions to be performed more simply and with less code.

Ruby can perform most regular expression related functions using a combination of the String and Regexp classes. The String class has several methods that take a Regexp as a parameter, and similarly the Regexp class has methods that take a String as a parameter. Ruby also provides a shorthand for defining regular expressions, a string surrounded by forward slashes: Regexp.new('test') and /test/ are equivalent.

Mostly, Java does not have native support for regular expressions. While the String class has a few methods that can perform related functions, they do not necessarily follow the conventional rules of regular expressions. Proper regular expression support is available in Java through several packages, most notably java.util.regex, which is Sun's standard package available in Java 1.4+. This package provides two classes, Pattern and Matcher, which are respectively used to define and operate on regular expressions. These classes work in conjunction with the String class to perform regular expression functions.

[[CSC/ECE 517 Summer 2008/wiki1 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-05-29T12:49:37Z

Rapodraza:

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-05-29T12:45:35Z

Rapodraza:

== Regular Expressions in Ruby vs. Java ==

Back to the assignment page: [[CSC/ECE 517 Summer 2008/wiki1 Assignment]]

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-05-28T13:45:54Z

Rapodraza:

test text to see if I made the page right

Back to the assignment page: [[CSC/ECE 517 Summer 2008/wiki1 Assignment]]

CSC/ECE 517 Summer 2008/wiki1 Assignment

2008-05-28T13:44:51Z

Rapodraza:

'''Topics'''

1. Regular-expression support 
[[CSC/ECE_517_Summer_2008/wiki1_1_rp]]
2. Iterators and generators 
3. Reflection 
4. Threads 
5. Hooks 
6. Arrays and hashes 
7. Eval 
[[CSC/ECE_517_Summer_2008/wiki1_7_ev]]
8. Prototype-based programming 

----
[[CSC/ECE 517 Summer 2008]]

CSC/ECE 517 Summer 2008/wiki1 1 rp

2008-05-28T13:42:58Z

Rapodraza:

test text to see if I made the page right