জাভাতে "গ্লোব" টাইপ ম্যাচ করার জন্য কি কোনও মানক (সাধারণত অ্যাপাচি কমন্স বা একইভাবে অ-ভাইরাল) লাইব্রেরি আছে? আমি যখন পার্লে একবার একইরকম কাজ করতে হয়েছিলাম, তখন আমি কেবল সমস্ত "" ."" \."," *"" .*" " "এবং" ?"" ."" এবং এই ধরণের জিনিসটি পরিবর্তন করেছি তবে আমি ভাবছি যে কেউ এটি করেছে কিনা আমার জন্য কাজ।
অনুরূপ প্রশ্ন: গ্লোব এক্সপ্রেশন থেকে রেজেক্স তৈরি করুন
উত্তর:
অন্তর্নির্মিত কিছুই নেই, তবে গ্লোব-জাতীয় কিছুকে একটি রেজেক্সে রূপান্তর করা বেশ সহজ:
public static String createRegexFromGlob(String glob)
{
String out = "^";
for(int i = 0; i < glob.length(); ++i)
{
final char c = glob.charAt(i);
switch(c)
{
case '*': out += ".*"; break;
case '?': out += '.'; break;
case '.': out += "\\."; break;
case '\\': out += "\\\\"; break;
default: out += c;
}
}
out += '$';
return out;
}
এটি আমার পক্ষে কাজ করে তবে আমি নিশ্চিত নই যে এটি বিশ্বমানের "মানক" কভার করে কিনা, যদি সেখানে থাকে তবে :)
পল টমবলিন দ্বারা আপডেট: আমি একটি পার্ল প্রোগ্রাম পেয়েছি যা গ্লোব রূপান্তর করে এবং জাভাতে এটি মানিয়ে নিয়ে আমি শেষ করি:
private String convertGlobToRegEx(String line)
{
LOG.info("got line [" + line + "]");
line = line.trim();
int strLen = line.length();
StringBuilder sb = new StringBuilder(strLen);
// Remove beginning and ending * globs because they're useless
if (line.startsWith("*"))
{
line = line.substring(1);
strLen--;
}
if (line.endsWith("*"))
{
line = line.substring(0, strLen-1);
strLen--;
}
boolean escaping = false;
int inCurlies = 0;
for (char currentChar : line.toCharArray())
{
switch (currentChar)
{
case '*':
if (escaping)
sb.append("\\*");
else
sb.append(".*");
escaping = false;
break;
case '?':
if (escaping)
sb.append("\\?");
else
sb.append('.');
escaping = false;
break;
case '.':
case '(':
case ')':
case '+':
case '|':
case '^':
case '$':
case '@':
case '%':
sb.append('\\');
sb.append(currentChar);
escaping = false;
break;
case '\\':
if (escaping)
{
sb.append("\\\\");
escaping = false;
}
else
escaping = true;
break;
case '{':
if (escaping)
{
sb.append("\\{");
}
else
{
sb.append('(');
inCurlies++;
}
escaping = false;
break;
case '}':
if (inCurlies > 0 && !escaping)
{
sb.append(')');
inCurlies--;
}
else if (escaping)
sb.append("\\}");
else
sb.append("}");
escaping = false;
break;
case ',':
if (inCurlies > 0 && !escaping)
{
sb.append('|');
}
else if (escaping)
sb.append("\\,");
else
sb.append(",");
break;
default:
escaping = false;
sb.append(currentChar);
}
}
return sb.toString();
}
আমি নিজের তৈরি করার চেয়ে এই উত্তরে সম্পাদনা করছি কারণ এই উত্তরটি আমাকে সঠিক পথে ফেলেছে।
জাভা 7 তে বাস্তবায়নের জন্যও গ্লোববিংয়ের পরিকল্পনা করা হয়েছে ।
দেখুন FileSystem.getPathMatcher(String)এবং "ফাইলগুলি অনুসন্ধান করা" টিউটোরিয়াল ।
তাদের অবদানের জন্য এখানে প্রত্যেককে ধন্যবাদ। আমি আগের উত্তরগুলির তুলনায় আরও ব্যাপক রূপান্তর লিখেছি:
/**
* Converts a standard POSIX Shell globbing pattern into a regular expression
* pattern. The result can be used with the standard {@link java.util.regex} API to
* recognize strings which match the glob pattern.
* <p/>
* See also, the POSIX Shell language:
* http://pubs.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_13_01
*
* @param pattern A glob pattern.
* @return A regex pattern to recognize the given glob pattern.
*/
public static final String convertGlobToRegex(String pattern) {
StringBuilder sb = new StringBuilder(pattern.length());
int inGroup = 0;
int inClass = 0;
int firstIndexInClass = -1;
char[] arr = pattern.toCharArray();
for (int i = 0; i < arr.length; i++) {
char ch = arr[i];
switch (ch) {
case '\\':
if (++i >= arr.length) {
sb.append('\\');
} else {
char next = arr[i];
switch (next) {
case ',':
// escape not needed
break;
case 'Q':
case 'E':
// extra escape needed
sb.append('\\');
default:
sb.append('\\');
}
sb.append(next);
}
break;
case '*':
if (inClass == 0)
sb.append(".*");
else
sb.append('*');
break;
case '?':
if (inClass == 0)
sb.append('.');
else
sb.append('?');
break;
case '[':
inClass++;
firstIndexInClass = i+1;
sb.append('[');
break;
case ']':
inClass--;
sb.append(']');
break;
case '.':
case '(':
case ')':
case '+':
case '|':
case '^':
case '$':
case '@':
case '%':
if (inClass == 0 || (firstIndexInClass == i && ch == '^'))
sb.append('\\');
sb.append(ch);
break;
case '!':
if (firstIndexInClass == i)
sb.append('^');
else
sb.append('!');
break;
case '{':
inGroup++;
sb.append('(');
break;
case '}':
inGroup--;
sb.append(')');
break;
case ',':
if (inGroup > 0)
sb.append('|');
else
sb.append(',');
break;
default:
sb.append(ch);
}
}
return sb.toString();
}
এবং ইউনিট পরীক্ষা করে এটি প্রমাণ করে:
/**
* @author Neil Traft
*/
public class StringUtils_ConvertGlobToRegex_Test {
@Test
public void star_becomes_dot_star() throws Exception {
assertEquals("gl.*b", StringUtils.convertGlobToRegex("gl*b"));
}
@Test
public void escaped_star_is_unchanged() throws Exception {
assertEquals("gl\\*b", StringUtils.convertGlobToRegex("gl\\*b"));
}
@Test
public void question_mark_becomes_dot() throws Exception {
assertEquals("gl.b", StringUtils.convertGlobToRegex("gl?b"));
}
@Test
public void escaped_question_mark_is_unchanged() throws Exception {
assertEquals("gl\\?b", StringUtils.convertGlobToRegex("gl\\?b"));
}
@Test
public void character_classes_dont_need_conversion() throws Exception {
assertEquals("gl[-o]b", StringUtils.convertGlobToRegex("gl[-o]b"));
}
@Test
public void escaped_classes_are_unchanged() throws Exception {
assertEquals("gl\\[-o\\]b", StringUtils.convertGlobToRegex("gl\\[-o\\]b"));
}
@Test
public void negation_in_character_classes() throws Exception {
assertEquals("gl[^a-n!p-z]b", StringUtils.convertGlobToRegex("gl[!a-n!p-z]b"));
}
@Test
public void nested_negation_in_character_classes() throws Exception {
assertEquals("gl[[^a-n]!p-z]b", StringUtils.convertGlobToRegex("gl[[!a-n]!p-z]b"));
}
@Test
public void escape_carat_if_it_is_the_first_char_in_a_character_class() throws Exception {
assertEquals("gl[\\^o]b", StringUtils.convertGlobToRegex("gl[^o]b"));
}
@Test
public void metachars_are_escaped() throws Exception {
assertEquals("gl..*\\.\\(\\)\\+\\|\\^\\$\\@\\%b", StringUtils.convertGlobToRegex("gl?*.()+|^$@%b"));
}
@Test
public void metachars_in_character_classes_dont_need_escaping() throws Exception {
assertEquals("gl[?*.()+|^$@%]b", StringUtils.convertGlobToRegex("gl[?*.()+|^$@%]b"));
}
@Test
public void escaped_backslash_is_unchanged() throws Exception {
assertEquals("gl\\\\b", StringUtils.convertGlobToRegex("gl\\\\b"));
}
@Test
public void slashQ_and_slashE_are_escaped() throws Exception {
assertEquals("\\\\Qglob\\\\E", StringUtils.convertGlobToRegex("\\Qglob\\E"));
}
@Test
public void braces_are_turned_into_groups() throws Exception {
assertEquals("(glob|regex)", StringUtils.convertGlobToRegex("{glob,regex}"));
}
@Test
public void escaped_braces_are_unchanged() throws Exception {
assertEquals("\\{glob\\}", StringUtils.convertGlobToRegex("\\{glob\\}"));
}
@Test
public void commas_dont_need_escaping() throws Exception {
assertEquals("(glob,regex),", StringUtils.convertGlobToRegex("{glob\\,regex},"));
}
}
এমন কয়েকটি গ্রন্থাগার রয়েছে যা গ্লোব-জাতীয় প্যাটার্ন মেলানো করে যা তালিকাগুলির চেয়ে আরও আধুনিক:
থেরেস অ্যান্টস ডিরেক্টরি স্ক্যানার এবং স্প্রিংস এন্টপ্যাথম্যাচার
আমি এন্টি স্টাইল গ্লোব্বিং জাভা বিশ্বের (হডসন, স্প্রিং, পিঁপড়া এবং আমি মনে করি মাভেন) স্ট্যান্ডার্ড গ্লোব সিনট্যাক্সে পরিণত হয়েছে যেহেতু আমি অন্যান্য সমাধানগুলির উভয়কেই সুপারিশ করি।
আমি সম্প্রতি এটা কি ছিল এবং ব্যবহৃত \Qএবং \Eউল্লিখিত glob প্যাটার্ন অব্যাহতি:
private static Pattern getPatternFromGlob(String glob) {
return Pattern.compile(
"^" + Pattern.quote(glob)
.replace("*", "\\E.*\\Q")
.replace("?", "\\E.\\Q")
+ "$");
}
globগ্লোব = প্যাটার্ন.কোয়েট (গ্লোব) এর সাথে ভেরিয়েবলটি প্রাক-প্রক্রিয়াজাতকরণের মাধ্যমে অবরুদ্ধ করতে পারেন , যা আমি বিশ্বাস করি যে এই ধরণের কেসগুলি পরিচালনা করে। সেক্ষেত্রে, আপনাকে প্রথম এবং শেষ \\ কিউ এবং \\ ই প্রিপেন্ড এবং সংযোজন করার দরকার নেই।
এটি একটি সাধারণ গ্লোব বাস্তবায়ন যা * এবং পরিচালনা করে? প্যাটার্নে
public class GlobMatch {
private String text;
private String pattern;
public boolean match(String text, String pattern) {
this.text = text;
this.pattern = pattern;
return matchCharacter(0, 0);
}
private boolean matchCharacter(int patternIndex, int textIndex) {
if (patternIndex >= pattern.length()) {
return false;
}
switch(pattern.charAt(patternIndex)) {
case '?':
// Match any character
if (textIndex >= text.length()) {
return false;
}
break;
case '*':
// * at the end of the pattern will match anything
if (patternIndex + 1 >= pattern.length() || textIndex >= text.length()) {
return true;
}
// Probe forward to see if we can get a match
while (textIndex < text.length()) {
if (matchCharacter(patternIndex + 1, textIndex)) {
return true;
}
textIndex++;
}
return false;
default:
if (textIndex >= text.length()) {
return false;
}
String textChar = text.substring(textIndex, textIndex + 1);
String patternChar = pattern.substring(patternIndex, patternIndex + 1);
// Note the match is case insensitive
if (textChar.compareToIgnoreCase(patternChar) != 0) {
return false;
}
}
// End of pattern and text?
if (patternIndex + 1 >= pattern.length() && textIndex + 1 >= text.length()) {
return true;
}
// Go on to match the next character in the pattern
return matchCharacter(patternIndex + 1, textIndex + 1);
}
}
অনুরূপ টনি Edgecombe এর উত্তর , এখানে ছোট এবং সহজ globber যে সমর্থন *এবং ?, Regex ব্যবহার করা হয় তবে কেহ এক প্রয়োজন ছাড়া।
public static boolean matches(String text, String glob) {
String rest = null;
int pos = glob.indexOf('*');
if (pos != -1) {
rest = glob.substring(pos + 1);
glob = glob.substring(0, pos);
}
if (glob.length() > text.length())
return false;
// handle the part up to the first *
for (int i = 0; i < glob.length(); i++)
if (glob.charAt(i) != '?'
&& !glob.substring(i, i + 1).equalsIgnoreCase(text.substring(i, i + 1)))
return false;
// recurse for the part after the first *, if any
if (rest == null) {
return glob.length() == text.length();
} else {
for (int i = glob.length(); i <= text.length(); i++) {
if (matches(text.substring(i), rest))
return true;
}
return false;
}
}
এটি একটি সামান্য হ্যাক পদ্ধতির হতে পারে। আমি এটি এনআইও 2 এর Files.newDirectoryStream(Path dir, String glob)কোড থেকে খুঁজে পেয়েছি । মনোযোগ দিন যে প্রতি ম্যাচের নতুন Pathঅবজেক্ট তৈরি হয়। এখনও পর্যন্ত আমি এটি কেবল উইন্ডোজ এফএসে পরীক্ষা করতে সক্ষম হয়েছি, তবে আমি বিশ্বাস করি এটি ইউনিক্সেও কাজ করা উচিত।
// a file system hack to get a glob matching
PathMatcher matcher = ("*".equals(glob)) ? null
: FileSystems.getDefault().getPathMatcher("glob:" + glob);
if ("*".equals(glob) || matcher.matches(Paths.get(someName))) {
// do you stuff here
}
আপডেট উভয় ক্ষেত্রেই কাজ করে - ম্যাক এবং লিনাক্স।
আমি একটি "স্ট্যান্ডার্ড" বাস্তবায়ন সম্পর্কে জানি না, তবে আমি বিএসডি লাইসেন্সের অধীনে প্রকাশিত এমন সোর্সফোর্জ প্রকল্পের কথা জানি যা ফাইলগুলির জন্য বিশ্বব্যাপী ম্যাচিং বাস্তবায়ন করে। এটি একটি ফাইলে প্রয়োগ করা হয়েছে , সম্ভবত আপনি এটি আপনার প্রয়োজনীয়তার জন্য মানিয়ে নিতে পারেন।
অনেক আগে আমি একটি বিশাল গ্লোব-চালিত পাঠ্য ফিল্টারিং করছিলাম তাই আমি কোডের একটি ছোট টুকরো লিখেছি (কোডের 15 লাইন, জেডিকে ছাড়িয়ে কোনও নির্ভরতা নেই)। এটি কেবল '*' (আমার পক্ষে যথেষ্ট ছিল) পরিচালনা করে তবে সহজেই '?' এর জন্য বাড়ানো যায়? এটি প্রাক-সংকলিত রেজিএক্সএক্সের চেয়ে কয়েকগুণ দ্রুত, কোনও প্রাক-সংকলন প্রয়োজন হয় না (মূলত এটি প্রতিবার প্যাটার্নটি মিলে গেলে একটি স্ট্রিং-বনাম-স্ট্রিং তুলনা)।
কোড:
public static boolean miniglob(String[] pattern, String line) {
if (pattern.length == 0) return line.isEmpty();
else if (pattern.length == 1) return line.equals(pattern[0]);
else {
if (!line.startsWith(pattern[0])) return false;
int idx = pattern[0].length();
for (int i = 1; i < pattern.length - 1; ++i) {
String patternTok = pattern[i];
int nextIdx = line.indexOf(patternTok, idx);
if (nextIdx < 0) return false;
else idx = nextIdx + patternTok.length();
}
if (!line.endsWith(pattern[pattern.length - 1])) return false;
return true;
}
}
ব্যবহার:
public static void main(String[] args) {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
try {
// read from stdin space separated text and pattern
for (String input = in.readLine(); input != null; input = in.readLine()) {
String[] tokens = input.split(" ");
String line = tokens[0];
String[] pattern = tokens[1].split("\\*+", -1 /* want empty trailing token if any */);
// check matcher performance
long tm0 = System.currentTimeMillis();
for (int i = 0; i < 1000000; ++i) {
miniglob(pattern, line);
}
long tm1 = System.currentTimeMillis();
System.out.println("miniglob took " + (tm1-tm0) + " ms");
// check regexp performance
Pattern reptn = Pattern.compile(tokens[1].replace("*", ".*"));
Matcher mtchr = reptn.matcher(line);
tm0 = System.currentTimeMillis();
for (int i = 0; i < 1000000; ++i) {
mtchr.matches();
}
tm1 = System.currentTimeMillis();
System.out.println("regexp took " + (tm1-tm0) + " ms");
// check if miniglob worked correctly
if (miniglob(pattern, line)) {
System.out.println("+ >" + line);
}
else {
System.out.println("- >" + line);
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
এখান থেকে অনুলিপি / আটকান
পূর্ববর্তী সমাধান ভিনসেন্ট রবার্ট / dimo414 দ্বারা উপর নির্ভর Pattern.quote()পরিপ্রেক্ষিতে বাস্তবায়ন হচ্ছে \Q... \E, যা API এ নথিভুক্ত নয় এবং সেজন্য অন্য / ভবিষ্যৎ জাভা বাস্তবায়নের ক্ষেত্রে দেখা নাও হতে পারে। নিম্নলিখিত সমাধানটি \Eব্যবহারের পরিবর্তে সমস্ত উপস্থিতি এড়িয়ে বাস্তবায়ন নির্ভরতা সরিয়ে দেয় quote()। স্ট্রিংয়ের সাথে নতুন লাইনের উপস্থিতি থাকলে এটি DOTALLমোড ( (?s)) সক্রিয় করে ।
public static Pattern globToRegex(String glob)
{
return Pattern.compile(
"(?s)^\\Q" +
glob.replace("\\E", "\\E\\\\E\\Q")
.replace("*", "\\E.*\\Q")
.replace("?", "\\E.\\Q") +
"\\E$"
);
}
যাইহোক, দেখে মনে হচ্ছে আপনি এটি পার্লের শক্ত উপায়ে করেছেন
এটি পার্লের কৌশলটি করে:
my @files = glob("*.html")
# Or, if you prefer:
my @files = <*.html>