电影文件名的C#Regex

我一直试图使用C#Regex从电影名称中删除某些字符串，但没有成功

我使用的文件名示例有：

欧洲旅行社（2004）[SD]

事件视界（1997）[720]

快速与狂暴（2009）[1080p]

星际迷航（2009）[未知]

我想删除方括号或括号中的任何内容（包括括号本身）

到目前为止，我正在使用：

movieTitleToFetch = Regex.Replace(movieTitleToFetch, "([*\\(\\d{4}\\)])", "");

这似乎删除了年份和括号，但我就是不知道如何删除方括号和内容而不影响其他部分。。。我得到了各种各样的结果，但最接近的结果是：

movieTitleToFetch = Regex.Replace(movieTitleToFetch, "([?\\[+A-Z+\\]])", "");

这给我留下了：

urorip（2004）

而不是：

欧洲旅行社（2004）[SD]

在末尾留下的任何空白都可以，因为我将只执行

movieTitleToFetch = movieTitleToFetch.Trim();

最后

提前感谢,

---

Alex

此正则表达式模式应该可以正常工作。。。也许需要一些调整

"[\[\(].+?[\]\)]"

Regex.Replace(movieTitleToFetch, @"[\[\(].+?[\]\)]", "");

这应该与“[”或“（“直到下一次出现“]”或“）之间的任何内容匹配

如果这不起作用，请尝试删除括号的转义字符，如下所示

Regex.Replace(movieTitleToFetch, @"[\[(].+?[\])]", "");

---

这个正则表达式模式应该可以正常工作。。。也许需要一些调整

"[\[\(].+?[\]\)]"

Regex.Replace(movieTitleToFetch, @"[\[\(].+?[\]\)]", "");

这应该与“[”或“（“直到下一次出现“]”或“）之间的任何内容匹配

如果这不起作用，请尝试删除括号的转义字符，如下所示

Regex.Replace(movieTitleToFetch, @"[\[(].+?[\])]", "");

---

我们不能用这个来代替：-

if(movieTitleToFetch.Contains("("))
         movieTitleToFetch=movieTitleToFetch.Substring(0,movieTitleToFetch.IndexOf("("));

以上代码肯定会返回这些字符串的完美电影标题：-

欧洲旅行社（2004）[SD]

事件视界（1997）[720]

快速与愤怒（2009）[1080p]

《星际迷航》（2009）[未知]

如果发生以下情况，您将没有年份，但只有类型，即：-

欧洲旅行社[SD]

事件视界[720]

快速与愤怒[1080p]

星际迷航[未知]

那就用这个

if(movieTitleToFetch.Contains("("))
         movieTitleToFetch=movieTitleToFetch.Substring(0,movieTitleToFetch.IndexOf("("));
else if(movieTitleToFetch.Contains("["))
         movieTitleToFetch=movieTitleToFetch.Substring(0,movieTitleToFetch.IndexOf("["));

---

我们不能用这个来代替：-

if(movieTitleToFetch.Contains("("))
         movieTitleToFetch=movieTitleToFetch.Substring(0,movieTitleToFetch.IndexOf("("));

以上代码肯定会返回这些字符串的完美电影标题：-

欧洲旅行社（2004）[SD]

事件视界（1997）[720]

快速与愤怒（2009）[1080p]

《星际迷航》（2009）[未知]

如果发生以下情况，您将没有年份，但只有类型，即：-

欧洲旅行社[SD]

事件视界[720]

快速与愤怒[1080p]

星际迷航[未知]

那就用这个

if(movieTitleToFetch.Contains("("))
         movieTitleToFetch=movieTitleToFetch.Substring(0,movieTitleToFetch.IndexOf("("));
else if(movieTitleToFetch.Contains("["))
         movieTitleToFetch=movieTitleToFetch.Substring(0,movieTitleToFetch.IndexOf("["));

这就是诀窍：

@"(\[[^\]]*\])|(\([^\)]*\))"

它删除“[”到下一个“]”和“（“到下一个”）”中的任何内容

这就做到了：

@"(\[[^\]]*\])|(\([^\)]*\))"

---

它删除“[”到下一个“]”和“（“到下一个”）”中的任何内容

@Craigt非常合适，但它可能更干净，以确保支架匹配

([\[].*?[\]]|[\(].*?[\)]) 

---

@Craigt非常合适，但它可能更干净，以确保支架匹配

([\[].*?[\]]|[\(].*?[\)]) 

你能用一下吗

string MovieTitle="Star Trek (2009) [Unknown]";
movieTitleToFetch= MovieTitle.IndexOf('(')>MovieTitle.IndexOf('[')?
                    MovieTitle.Substring(0,MovieTitle.IndexOf('[')):
                    MovieTitle.Substring(0,MovieTitle.IndexOf('('));

你能用一下吗

string MovieTitle="Star Trek (2009) [Unknown]";
movieTitleToFetch= MovieTitle.IndexOf('(')>MovieTitle.IndexOf('[')?
                    MovieTitle.Substring(0,MovieTitle.IndexOf('[')):
                    MovieTitle.Substring(0,MovieTitle.IndexOf('('));

我提出了

+\s（？\（\d{4}\）\s（？\[\w+\]）

，它与您的任何示例都匹配，并包含年份和命名为捕获组的格式，以帮助您替换它们

这种模式可以翻译为：

任何字符、一个或多个表示
空白
文字'（'后接4位数字，后接文字'）（年份）
空白
文字'['后跟字母数字，一个或多个表示，后跟文字']'（格式）

我想出了

+\s（？\（\d{4}\）\s（？\[\w+\]）

，它与您的任何示例都匹配，并将年份和格式作为命名的捕获组来帮助您替换它们

这种模式可以翻译为：

任何字符、一个或多个表示
空白
文字'（'后接4位数字，后接文字'）（年份）
空白

---

文字'['后跟字母数字，一个或多个表示，后跟文字']'（格式）

我知道我在这个线程上迟到了，但我写了一个简单的算法来清理下载的电影文件名

这将运行以下步骤：

删除括号中的所有内容（如果查找年份，则尝试保留该信息）

删除常用词列表（720p、bdrip、h264等…）

假设可以是标题中的语言信息，并在剩余字符串末尾（特殊单词之前）删除它们

如果在括号中找不到年份，则查看剩余字符串的结尾（对于语言）

这样做将替换点和空格，以便标题可以作为搜索api的查询

以下是XUnit的测试（我使用了大多数意大利语标题来测试它）

和代码的第一个版本

using System;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions; 

namespace Grappachu.Movideo.Core.Helpers.TitleCleaner
{
    public class MovieTitleCleanerResult
    {
        public string Title { get; set; }
        public int? Year { get; set; }
        public string SubTitle { get; set; }
    }

    public class MovieTitleCleaner
    {
        private const string SpecialMarker = "§=§";
        private static readonly string[] ReservedWords;
        private static readonly string[] SpaceChars;
        private static readonly string[] Languages;

        static MovieTitleCleaner()
        {
            ReservedWords = new[]
            {
                SpecialMarker, "hevc", "bdrip", "Bluray", "x264", "h264", "AC3", "DTS", "480p", "720p", "1080p"
            };
            var cultures = CultureInfo.GetCultures(CultureTypes.AllCultures);
            var l = cultures.Select(x => x.EnglishName).ToList();
            l.AddRange(cultures.Select(x => x.ThreeLetterISOLanguageName));
            Languages = l.Distinct().ToArray();


            SpaceChars = new[] {".", "_", " "};
        }


        public static MovieTitleCleanerResult Clean(string filename)
        {
            var temp = Path.GetFileNameWithoutExtension(filename);
            int? maybeYear = null;

            // Remove what's inside brackets trying to keep year info.
            temp = RemoveBrackets(temp, '{', '}', ref maybeYear);
            temp = RemoveBrackets(temp, '[', ']', ref maybeYear);
            temp = RemoveBrackets(temp, '(', ')', ref maybeYear);

            // Removes special markers (codec, formats, ecc...)
            var tokens = temp.Split(SpaceChars, StringSplitOptions.RemoveEmptyEntries);
            var title = string.Empty;
            for (var i = 0; i < tokens.Length; i++)
            {
                var tok = tokens[i];
                if (ReservedWords.Any(x => string.Equals(x, tok, StringComparison.OrdinalIgnoreCase)))
                {
                    if (title.Length > 0)
                        break;
                }
                else
                {
                    title = string.Join(" ", title, tok).Trim();
                }
            }
            temp = title;

            // Remove languages infos when are found before special markers (should not remove "English" if it's inside the title)
            tokens = temp.Split(SpaceChars, StringSplitOptions.RemoveEmptyEntries);
            for (var i = tokens.Length - 1; i >= 0; i--)
            {
                var tok = tokens[i];
                if (Languages.Any(x => string.Equals(x, tok, StringComparison.OrdinalIgnoreCase)))
                    tokens[i] = string.Empty;
                else
                    break;
            }
            title = string.Join(" ", tokens).Trim();


            // If year is not found inside parenthesis try to catch at the end, just after the title
            if (!maybeYear.HasValue)
            {
                var resplit = title.Split(SpaceChars, StringSplitOptions.RemoveEmptyEntries);
                var last = resplit.Last();
                if (LooksLikeYear(last))
                {
                    maybeYear = int.Parse(last);
                    title = title.Replace(last, string.Empty).Trim();
                }
            }


            // TODO: review this. when there's one dash separates main title from subtitle 
            var res = new MovieTitleCleanerResult();
            res.Year = maybeYear;
            if (title.Count(x => x == '-') == 1)
            {
                var sp = title.Split('-');
                res.Title = sp[0];
                res.SubTitle = sp[1];
            }
            else
            {
                res.Title = title;
            }


            return res;
        }

        private static string RemoveBrackets(string inputString, char openChar, char closeChar, ref int? maybeYear)
        {
            var str = inputString;
            while (str.IndexOf(openChar) > 0 && str.IndexOf(closeChar) > 0)
            {
                var dataGraph = str.GetBetween(openChar.ToString(), closeChar.ToString());
                if (LooksLikeYear(dataGraph))
                {
                    maybeYear = int.Parse(dataGraph);
                }
                else
                {
                    var parts = dataGraph.Split(SpaceChars, StringSplitOptions.RemoveEmptyEntries);
                    foreach (var part in parts)
                        if (LooksLikeYear(part))
                        {
                            maybeYear = int.Parse(part);
                            break;
                        }
                }
                str = str.ReplaceBetween(openChar, closeChar, string.Format(" {0} ", SpecialMarker));
            }
            return str;
        }

        private static bool LooksLikeYear(string dataRound)
        {
            return Regex.IsMatch(dataRound, "^(19|20)[0-9][0-9]");
        }
    }


    public static class StringUtils
    {
        public static string GetBetween(this string src, string a, string b,
            StringComparison comparison = StringComparison.Ordinal)
        {
            var idxStr = src.IndexOf(a, comparison);
            var idxEnd = src.IndexOf(b, comparison);
            if (idxStr >= 0 && idxEnd > 0)
            {
                if (idxStr > idxEnd)
                    Swap(ref idxStr, ref idxEnd);
                return src.Substring(idxStr + a.Length, idxEnd - idxStr - a.Length);
            }
            return src;
        }

        private static void Swap<T>(ref T idxStr, ref T idxEnd)
        {
            var temp = idxEnd;
            idxEnd = idxStr;
            idxStr = temp;
        }

        public static string ReplaceBetween(this string s, char begin, char end, string replacement = null)
        {
            var regex = new Regex(string.Format("\\{0}.*?\\{1}", begin, end));
            return regex.Replace(s, replacement ?? string.Empty);
        }
    }
}

使用系统；
利用制度全球化；
使用System.IO；
使用System.Linq；
使用System.Text.RegularExpressions；
命名空间graphpachu.Movideo.Core.Helpers.TitleCleaner
{
公共级电影
{
公共字符串标题{get；set；}
公共整数？年份{get；set；}
公共字符串字幕{get；set；}
}
公共级电影剪辑师
{
private const string SpecialMarker=“§=§”；
私有静态只读字符串[]保留字；
私有静态只读字符串[]空格字符；
私有静态只读字符串[]语言；
静态电影清洁器（）
{
ReservedWords=new[]
{
特别营销员，“hevc”、“bdrip”、“Bluray”、“x264”、“h264”、“AC3”、“DTS”、“480p”、“720p”、“1080p”
};
var cultures=CultureInfo.GetCultures（CultureTypes.AllCultures）；
var l=cultures.Select（x=>x.EnglishName.ToList（）；
l、 AddRange（cultures.Select（x=>x.ThreeLetterIsLanguageName））；
语言=l.Distinct（）.ToArray（）；
SpaceChars=new[]{“.”、“”、”}；
}
公共静态MovietItleLeanerResult Clean（字符串文件名）
{
var temp=Path.GetFileNameWithoutExtension（文件名）；
int？maybeYear=null；
//雷莫