blocks|key|3057126|text|if+(substr(strtolower($text),+0,+3)+!=+'xml')+&&+(1+===+preg_match('/%5E\w[%5E<>]%2B$/',+$text)))
{
++++//+valid;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3057127|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>if (substr(strtolower($text), 0, 3) != 'xml') &amp;&amp; (1 === preg_match('/^\w[^&lt;&gt;]+$/', $text)))
{
 // valid;
}
</code></pre>

blocks|key|1296046|text|假设您正在使用Unicode，这将大致满足您的需要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1296047|(注意：这是完全未经测试的。)|offset|length|style|BOLD|1296048|[%5E\p{P}xX0-9][%5EmMlL\s]{2}[\w\p{P}0-9-]|code-block|syntax|javascript|1296049|\p{P}是PHP正则表达式语法中的Unicode标点符号语法。|CODE|1296050|entityMap|0|LINK|mutability|MUTABLE|url|http://www.php.net/manual/en/regexp.reference.unicode.php|1^0|0|1|3|0|0|0|5|0|5|0|I|B|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|13|8|@$D|14|E|15|F|O]]|9|@$D|16|E|17|1|18]|$D|19|E|1A|1|1B]]|A|$]]|$1|P|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]|X|$5|S|T|U|A|$V|W]]]]

This should give you roughly what you need [Assuming you are using Unicode]: 
(Note: This is completely untested.)

<pre><code>[^\p{P}xX0-9][^mMlL\s]{2}[\w\p{P}0-9-]
</code></pre>

<a href="http://www.php.net/manual/en/regexp.reference.unicode.php" rel="nofollow noreferrer"><code>\p{P}</code></a> is the syntax for <a href="http://www.php.net/manual/en/regexp.reference.unicode.php" rel="nofollow noreferrer">Unicode Punctuation marks</a> in PHP's regular expression syntax.

blocks|key|3057178|text|怎么样|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3057179|/\A(?!XML)[a-z][\w0-9-]*/i|code-block|syntax|javascript|3057180|用法：|3057181|if+(preg_match('/\A(?!XML)[a-z][\w0-9-]*/i',+$subject))+{
++++#+valid+name
}+else+{
++++#+invalid+name
}|3057182|解释：|3057183|\A++Beginning+of+the+string
(?!XML)++Negative+lookahead+(assert+that+it+is+impossible+to+match+"XML")
[a-z]++Match+a+non-digit,+non-punctuation+character
[\w0-9-]*++Match+an+arbitrary+number+of+allowed+characters
/i++make+the+whole+thing+case-insensitive|3057184|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

How about

<pre><code>/\A(?!XML)[a-z][\w0-9-]*/i
</code></pre>

Usage:

<pre><code>if (preg_match('/\A(?!XML)[a-z][\w0-9-]*/i', $subject)) {
 # valid name
} else {
 # invalid name
}
</code></pre>

Explanation:

<pre><code>\A Beginning of the string
(?!XML) Negative lookahead (assert that it is impossible to match "XML")
[a-z] Match a non-digit, non-punctuation character
[\w0-9-]* Match an arbitrary number of allowed characters
/i make the whole thing case-insensitive
</code></pre>

blocks|key|1533070|text|如果要创建有效XML，请使用DOM扩展。这样你就不用担心任何Regex了。如果您试图将一个无效的名称输入到一个DomElement中，您将得到一个错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1533071|function+isValidXmlName($name)
{
++++try+{
++++++++new+DOMElement($name);
++++++++return+TRUE;
++++}+catch(DOMException+$e)+{
++++++++return+FALSE;
++++}
}|code-block|syntax|javascript|1533072|这会给|1533073|var_dump(+isValidXmlName('foo')+);++++++//+true+++valid+localName
var_dump(+isValidXmlName(':foo')+);+++++//+true+++valid+localName
var_dump(+isValidXmlName(':b:c')+);+++++//+true+++valid+localName
var_dump(+isValidXmlName('b:c')+);++++++//+false++assumes+QName|1533074|很可能对你想做的事来说已经足够了。|1533075|书呆子音符1|1533076|注意localName和QName之间的区别。ext/dom假设您使用的是名称空间元素，如果冒号前面有前缀，这将为名称的形成添加约束。从技术上讲，b:b是一个有效的本地名称，因为NameStartChar是NameChar的一部分。如果要包含这些内容，请将该函数更改为|1533077|function+isValidXmlName($name)
{
++++try+{
++++++++new+DOMElement(
++++++++++++$name,
++++++++++++null,
++++++++++++strpos($name,+':')+>=+1+?+'http://example.com'+:+null
++++++++);
++++++++return+TRUE;
++++}+catch(DOMException+$e)+{
++++++++return+FALSE;
++++}
}|1533078|书呆子音符2|1533079|请注意，元素可以以"xml“开头。W3schools+(他不属于W3c)显然搞错了这个部分(不会是第一次)。如果确实希望排除以xml开头的元素，请添加|1533080|if(stripos($name,+'xml')+===+0)+return+false;|1533081|在try/catch之前。|style|CODE|1533082|entityMap|0|LINK|mutability|MUTABLE|url|http://www.w3.org/TR/REC-xml/|1|http://php.net/manual/en/book.dom.php|2|http://www.w3.org/TR/REC-xml-names/#NT-QName|3|http://www.w3.org/TR/REC-xml/#NT-NameChar|4|http://w3fools.com/^0|5|5|0|E|5|1|0|0|0|0|0|0|C|5|2|2H|Q|3|0|0|0|1A|6|4|0|0|1|9|0^^$0|@$1|2|3|4|5|6|7|1K|8|@]|9|@$A|1L|B|1M|1|1N]|$A|1O|B|1P|1|1Q]]|C|$]]|$1|D|3|E|5|F|7|1R|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1S|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1T|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1U|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1V|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1W|8|@]|9|@$A|1X|B|1Y|1|1Z]|$A|20|B|21|1|22]]|C|$]]|$1|S|3|T|5|F|7|23|8|@]|9|@]|C|$G|H]]|$1|U|3|V|5|6|7|24|8|@]|9|@]|C|$]]|$1|W|3|X|5|6|7|25|8|@]|9|@$A|26|B|27|1|28]]|C|$]]|$1|Y|3|Z|5|F|7|29|8|@]|9|@]|C|$G|H]]|$1|10|3|11|5|6|7|2A|8|@$A|2B|B|2C|12|13]]|9|@]|C|$]]|$1|14|3|-4|5|6|7|2D|8|@]|9|@]|C|$]]]|15|$16|$5|17|18|19|C|$1A|1B]]|1C|$5|17|18|19|C|$1A|1D]]|1E|$5|17|18|19|C|$1A|1F]]|1G|$5|17|18|19|C|$1A|1H]]|1I|$5|17|18|19|C|$1A|1J]]]]

If you want to create <a href="http://www.w3.org/TR/REC-xml/" rel="noreferrer">valid XML</a>, use the <a href="http://php.net/manual/en/book.dom.php" rel="noreferrer">DOM Extension</a>. This way you don't have to bother about any Regex. If you try to put in an invalid name to a DomElement, you'll get an error.

<pre><code>function isValidXmlName($name)
{
 try {
 new DOMElement($name);
 return TRUE;
 } catch(DOMException $e) {
 return FALSE;
 }
}
</code></pre>

This will give

<pre><code>var_dump( isValidXmlName('foo') ); // true valid localName
var_dump( isValidXmlName(':foo') ); // true valid localName
var_dump( isValidXmlName(':b:c') ); // true valid localName
var_dump( isValidXmlName('b:c') ); // false assumes QName
</code></pre>

and is likely good enough for what you want to do.

<h3>Pedantic note 1</h3>

Note the distinction between localName and <a href="http://www.w3.org/TR/REC-xml-names/#NT-QName" rel="noreferrer">QName</a>. ext/dom assumes you are using a namespaced element if there is a prefix before the colon, which adds constraints to how the name may be formed. Technically, b:b is a valid local name though because <a href="http://www.w3.org/TR/REC-xml/#NT-NameChar" rel="noreferrer">NameStartChar is part of NameChar</a>. If you want to include these, change the function to 

<pre><code>function isValidXmlName($name)
{
 try {
 new DOMElement(
 $name,
 null,
 strpos($name, ':') &gt;= 1 ? 'http://example.com' : null
 );
 return TRUE;
 } catch(DOMException $e) {
 return FALSE;
 }
}
</code></pre>

<h3>Pedantic note 2</h3>

Note that elements may start with "xml". W3schools (who is not affiliated with the W3c) apparently got this part wrong (<a href="http://w3fools.com" rel="noreferrer">wouldn't be the first time</a>). If you really want to exclude elements starting with xml add

<pre><code>if(stripos($name, 'xml') === 0) return false;
</code></pre>

before the <code>try/catch</code>.

blocks|key|1296117|text|使用这个正则表达式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1296118|%5E_?(?!(xml%7C_\d\W))(\w.-%2B)$|blockquote|offset|length|style|BOLD|1296119|这将匹配所有四点，并允许unicode字符。|1296120|entityMap^0|0|0|Q|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@$E|O|F|P|G|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|Q|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|L|$]]

Use this regex: 

<blockquote>
 ^_?(?!(xml|[_\d\W]))([\w.-]+)$
</blockquote>

This matches all your four points and allows unicode characters.

blocks|key|3057235|text|如果您正在使用DotNet框架，请尝试XmlConvert.VerifyName。它将告诉您名称是否有效，或使用XmlConvert.EncodeName将无效名称实际转换为有效名称.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3057236|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If you are using the DotNet framework try XmlConvert.VerifyName. It will tell you if the name is valid, or use XmlConvert.EncodeName to actually convert an invalid name into a valid one...

blocks|key|1533118|text|下面的表达式应该匹配有效的unicode元素名称，但xml除外。以xml开头或结尾的名称仍将被允许。这是通过@toscho's+passes的。我唯一搞不懂的就是扩展器。xml元素名称规范说：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1533119|4+NameChar+::=+-字母
5名::=+(英文字母“_”)：‘)+(NameChar)*|blockquote|1533120|但是，对于包含扩展程序的unicode类别或类没有明确的定义。|1533121|%5E[\p{L}_:][\p{N}\p{L}\p{Mc}.\-%7C:]*((?<!xml)%7Cxml)$|code-block|syntax|javascript|1533122|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|O|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|Q|8|@]|9|@]|A|$J|K]]|$1|L|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|M|$]]

The expression below should match valid unicode element names excepting xml. Names that start or end with xml will still be allowed. This passes @toscho's äøñ test. The one thing I could not figure out a regex for was extenders. The xml element name spec says:

<blockquote>
 [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
 CombiningChar | Extender
 
 [5] Name ::= (Letter | '_' | ':') (NameChar)*
</blockquote>

But there's no clear definition for a unicode category or class containing extenders.

<pre><code>^[\p{L}_:][\p{N}\p{L}\p{Mc}.\-|:]*((?&lt;!xml)|xml)$
</code></pre>

blocks|key|1297640|text|到目前为止，这一点已经被忽略了，尽管问题是旧的:通过PHP的pcre函数进行名称验证，这些函数是用XML规范简化的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1297641|XML的定义非常清楚地说明了它的规范(可扩展标记语言(XML)+1.0+(第五版))中的元素名称：|offset|length|1297642|[4]++NameStartChar++::=+++":"+%7C+[A-Z]+%7C+"_"+%7C+[a-z]+%7C+[#xC0-#xD6]+%7C+[#xD8-#xF6]+%7C+[#xF8-#x2FF]+%7C+[#x370-#x37D]+%7C+[#x37F-#x1FFF]+%7C+[#x200C-#x200D]+%7C+[#x2070-#x218F]+%7C+[#x2C00-#x2FEF]+%7C+[#x3001-#xD7FF]+%7C+[#xF900-#xFDCF]+%7C+[#xFDF0-#xFFFD]+%7C+[#x10000-#xEFFFF]
[4a]+NameChar+++++++::=+++NameStartChar+%7C+"-"+%7C+"."+%7C+[0-9]+%7C+#xB7+%7C+[#x0300-#x036F]+%7C+[#x203F-#x2040]
[5]++Name+++++++++++::=+++NameStartChar+(NameChar)*|code-block|syntax|javascript|1297643|可以将此表示法转换为与preg_match兼容的UTF-8正则表达式，这里作为单引号的PHP字符串逐字复制：|style|CODE|1297644|'~%5E[:A-Z_a-z\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\x{2FF}\\x{370}-\\x{37D}\\x{37F}-\\x{1FFF}\\x{200C}-\\x{200D}\\x{2070}-\\x{218F}\\x{2C00}-\\x{2FEF}\\x{3001}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFFD}\\x{10000}-\\x{EFFFF}][:A-Z_a-z\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\x{2FF}\\x{370}-\\x{37D}\\x{37F}-\\x{1FFF}\\x{200C}-\\x{200D}\\x{2070}-\\x{218F}\\x{2C00}-\\x{2FEF}\\x{3001}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFFD}\\x{10000}-\\x{EFFFF}.\\-0-9\\xB7\\x{0300}-\\x{036F}\\x{203F}-\\x{2040}]*$~u'|1297645|或者作为另一个以更易读的方式命名子模式的变体：|1297646|'~
#+XML+1.0+Name+symbol+PHP+PCRE+regex+<http://www.w3.org/TR/REC-xml/#NT-Name>
(?(DEFINE)
++++(?<NameStartChar>+[:A-Z_a-z\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\x{2FF}\\x{370}-\\x{37D}\\x{37F}-\\x{1FFF}\\x{200C}-\\x{200D}\\x{2070}-\\x{218F}\\x{2C00}-\\x{2FEF}\\x{3001}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFFD}\\x{10000}-\\x{EFFFF}])
++++(?<NameChar>++++++(?&NameStartChar)+%7C+[.\\-0-9\\xB7\\x{0300}-\\x{036F}\\x{203F}-\\x{2040}])
++++(?<Name>++++++++++(?&NameStartChar)+(?&NameChar)*)
)
%5E(?&Name)$
~ux'|1297647|请注意，此模式包含冒号:，您可能希望排除它(第一种模式中的两种形式，第二种模式中的一种)，因为XML验证原因(例如，对NCName的测试)。|1297648|用法示例：|1297649|$name++++=+'::...';
$pattern+=+'~
#+XML+1.0+Name+symbol+PHP+PCRE+regex+<http://www.w3.org/TR/REC-xml/#NT-Name>
(?(DEFINE)
++++(?<NameStartChar>+[:A-Z_a-z\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\x{2FF}\\x{370}-\\x{37D}\\x{37F}-\\x{1FFF}\\x{200C}-\\x{200D}\\x{2070}-\\x{218F}\\x{2C00}-\\x{2FEF}\\x{3001}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFFD}\\x{10000}-\\x{EFFFF}])
++++(?<NameChar>++++++(?&NameStartChar)+%7C+[.\\-0-9\\xB7\\x{0300}-\\x{036F}\\x{203F}-\\x{2040}])
++++(?<Name>++++++++++(?&NameStartChar)+(?&NameChar)*)
)
%5E(?&Name)$
~ux';

$valid+=+1+===+preg_match($pattern,+$name);+#+bool(true)|1297650|以XML开头的元素名称(小写或大写字母)是不可能的，这是不正确的。<XML/>是一个格式非常好的XML，而XML是一个格式非常好的元素名称。|1297651|只是这些名称位于格式良好的元素名称的子集中，这些元素名称是为标准化而保留的(XMLVersion1.0和更高版本)。很容易测试(格式良好的)元素名称是否通过字符串比较保留：|1297652|$reserved+=+$valid+&&+0+===+stripos($name,+'xml'));|1297653|或者另一个正则表达式：|1297654|$reserved+=+$valid+&&+1+===+preg_match('~%5E[Xx][Mm][Ll]~',+$name);|1297655|DOMDocument不能测试保留的名称，至少我不知道怎么做，我一直在寻找。|1297656|一个有效的元素名称需要一个唯一的元素类型声明，这个声明似乎不在这里讨论的范围之内，因为没有提供这样的声明。因此，答案并没有考虑到这一点。如果有一个元素类型声明，您只需要根据所有(区分大小写的)名称的白列表进行验证，因此这将是一个简单的区分大小写的字符串比较。|1297657|游走：DOMDocument与正则表达式有什么不同？|1297658|与DOMDocument+/+DOMElement相比，对有效元素名的限定有一些不同之处。DOM扩展处于某种混合模式，这使得它无法预测它验证的内容。下面的偏移说明了这种行为，并说明了如何控制它。|1297659|让我们接受$name并实例化一个元素：|1297660|$element+=+new+DOMElement($name);|1297661|结果取决于：|1297662|如果第一个字符是冒号，它只验证符号。|unordered-list-item|1297663|如果第一个字符不是冒号，它将验证符号。|1297664|因此，第一个字符决定比较模式。|1297665|正则表达式专门编写了要检查的内容，这里是XML1.0+Name符号。|1297666|您可以通过用冒号前缀名称来实现DOMElement的相同目标：|1297667|function+isValidXmlName($name)
{

++++try+{
++++++++new+DOMElement(":$name");
++++++++return+TRUE;
++++}+catch+(DOMException+$e)+{
++++++++return+FALSE;
++++}
}|1297668|要显式检查QName，可以通过将其转换为PrefixedName来实现，以防它是UnprefixedName|1297669|function+isValidXmlnsQname($qname)
{
++++$prefixedName+=+(!strpos($qname,+':')+?+'prefix:'+:+'')+.+$qname;

++++try+{
++++++++new+DOMElement($prefixedName,+NULL,+'uri:ns');
++++++++return+TRUE;
++++}+catch+(DOMException+$e)+{
++++++++return+FALSE;
++++}
}|1297670|entityMap|0|LINK|mutability|MUTABLE|url|http://www.w3.org/TR/2008/REC-xml-20081126/#NT-Name|1|http://php.net/preg_match|2|http://www.w3.org/TR/REC-xml-names/#NT-NCName|3|http://php.net/DOMDocument|4|http://www.w3.org/TR/REC-xml/#NT-Name|5|http://www.w3.org/TR/REC-xml-names/#NT-QName^0|0|J|M|0|0|0|B|A|B|A|1|0|0|0|0|B|1|1N|6|1N|6|2|0|0|0|1|3|X|6|1H|3|0|0|0|0|0|0|B|0|B|3|0|0|3|B|0|1|B|F|A|0|5|5|0|0|0|F|2|4|0|G|2|5|0|0|R|4|0|F|A|0|0|5|5|K|C|14|E|0|0^^$0|@$1|2|3|4|5|6|7|2N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|2O|8|@]|9|@$D|2P|E|2Q|1|2R]]|A|$]]|$1|F|3|G|5|H|7|2S|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|2T|8|@$D|2U|E|2V|M|N]]|9|@$D|2W|E|2X|1|2Y]]|A|$]]|$1|O|3|P|5|H|7|2Z|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|30|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|31|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|32|8|@$D|33|E|34|M|N]|$D|35|E|36|M|N]]|9|@$D|37|E|38|1|39]]|A|$]]|$1|W|3|X|5|6|7|3A|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|H|7|3B|8|@]|9|@]|A|$I|J]]|$1|10|3|11|5|6|7|3C|8|@$D|3D|E|3E|M|N]|$D|3F|E|3G|M|N]|$D|3H|E|3I|M|N]]|9|@]|A|$]]|$1|12|3|13|5|6|7|3J|8|@]|9|@]|A|$]]|$1|14|3|15|5|H|7|3K|8|@]|9|@]|A|$I|J]]|$1|16|3|17|5|6|7|3L|8|@]|9|@]|A|$]]|$1|18|3|19|5|H|7|3M|8|@]|9|@]|A|$I|J]]|$1|1A|3|1B|5|6|7|3N|8|@$D|3O|E|3P|M|N]]|9|@$D|3Q|E|3R|1|3S]]|A|$]]|$1|1C|3|1D|5|6|7|3T|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|3U|8|@$D|3V|E|3W|M|N]]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|3X|8|@$D|3Y|E|3Z|M|N]|$D|40|E|41|M|N]]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|42|8|@$D|43|E|44|M|N]]|9|@]|A|$]]|$1|1K|3|1L|5|H|7|45|8|@]|9|@]|A|$I|J]]|$1|1M|3|1N|5|6|7|46|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|1Q|7|47|8|@]|9|@$D|48|E|49|1|4A]]|A|$]]|$1|1R|3|1S|5|1Q|7|4B|8|@]|9|@$D|4C|E|4D|1|4E]]|A|$]]|$1|1T|3|1U|5|6|7|4F|8|@]|9|@]|A|$]]|$1|1V|3|1W|5|6|7|4G|8|@$D|4H|E|4I|M|N]]|9|@]|A|$]]|$1|1X|3|1Y|5|6|7|4J|8|@$D|4K|E|4L|M|N]]|9|@]|A|$]]|$1|1Z|3|20|5|H|7|4M|8|@]|9|@]|A|$I|J]]|$1|21|3|22|5|6|7|4N|8|@$D|4O|E|4P|M|N]|$D|4Q|E|4R|M|N]|$D|4S|E|4T|M|N]]|9|@]|A|$]]|$1|23|3|24|5|H|7|4U|8|@]|9|@]|A|$I|J]]|$1|25|3|-4|5|6|7|4V|8|@]|9|@]|A|$]]]|26|$27|$5|28|29|2A|A|$2B|2C]]|2D|$5|28|29|2A|A|$2B|2E]]|2F|$5|28|29|2A|A|$2B|2G]]|2H|$5|28|29|2A|A|$2B|2I]]|2J|$5|28|29|2A|A|$2B|2K]]|2L|$5|28|29|2A|A|$2B|2M]]]]

This has been missed so far despite the fact the question is that old: Name validation via PHP's pcre functions that are streamlined with the XML specification.

XML's definition is pretty clear about the element name in it's specs (<a href="http://www.w3.org/TR/2008/REC-xml-20081126/#NT-Name">Extensible Markup Language (XML) 1.0 (Fifth Edition)</a>):

<pre><code>[4] NameStartChar ::= ":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
[4a] NameChar ::= NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
[5] Name ::= NameStartChar (NameChar)*
</code></pre>

This notation can be transposed into a UTF-8 compatible regular expression to be used with <a href="http://php.net/preg_match"><code>preg_match</code></a>, here as single-quoted PHP string to be copied verbatim:

<pre><code>'~^[:A-Z_a-z\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\x{2FF}\\x{370}-\\x{37D}\\x{37F}-\\x{1FFF}\\x{200C}-\\x{200D}\\x{2070}-\\x{218F}\\x{2C00}-\\x{2FEF}\\x{3001}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFFD}\\x{10000}-\\x{EFFFF}][:A-Z_a-z\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\x{2FF}\\x{370}-\\x{37D}\\x{37F}-\\x{1FFF}\\x{200C}-\\x{200D}\\x{2070}-\\x{218F}\\x{2C00}-\\x{2FEF}\\x{3001}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFFD}\\x{10000}-\\x{EFFFF}.\\-0-9\\xB7\\x{0300}-\\x{036F}\\x{203F}-\\x{2040}]*$~u'
</code></pre>

Or as another variant with named subpatterns in a more readable fashion:

<pre><code>'~
# XML 1.0 Name symbol PHP PCRE regex &lt;http://www.w3.org/TR/REC-xml/#NT-Name&gt;
(?(DEFINE)
 (?&lt;NameStartChar&gt; [:A-Z_a-z\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\x{2FF}\\x{370}-\\x{37D}\\x{37F}-\\x{1FFF}\\x{200C}-\\x{200D}\\x{2070}-\\x{218F}\\x{2C00}-\\x{2FEF}\\x{3001}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFFD}\\x{10000}-\\x{EFFFF}])
 (?&lt;NameChar&gt; (?&amp;NameStartChar) | [.\\-0-9\\xB7\\x{0300}-\\x{036F}\\x{203F}-\\x{2040}])
 (?&lt;Name&gt; (?&amp;NameStartChar) (?&amp;NameChar)*)
)
^(?&amp;Name)$
~ux'
</code></pre>

Note that this pattern contains the colon <code>:</code> which you might want to exclude (two appereances in the first pattern, one in the second) for XML Namespace validation reasons (e.g. a test for <a href="http://www.w3.org/TR/REC-xml-names/#NT-NCName"><code>NCName</code></a>).

Usage Example:

<pre><code>$name = '::...';
$pattern = '~
# XML 1.0 Name symbol PHP PCRE regex &lt;http://www.w3.org/TR/REC-xml/#NT-Name&gt;
(?(DEFINE)
 (?&lt;NameStartChar&gt; [:A-Z_a-z\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\x{2FF}\\x{370}-\\x{37D}\\x{37F}-\\x{1FFF}\\x{200C}-\\x{200D}\\x{2070}-\\x{218F}\\x{2C00}-\\x{2FEF}\\x{3001}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFFD}\\x{10000}-\\x{EFFFF}])
 (?&lt;NameChar&gt; (?&amp;NameStartChar) | [.\\-0-9\\xB7\\x{0300}-\\x{036F}\\x{203F}-\\x{2040}])
 (?&lt;Name&gt; (?&amp;NameStartChar) (?&amp;NameChar)*)
)
^(?&amp;Name)$
~ux';

$valid = 1 === preg_match($pattern, $name); # bool(true)
</code></pre>

<hr>

The saying that an element name starting with <code>XML</code> (in lower or uppercase letters) would not be possible is not correct. <code>&lt;XML/&gt;</code> is a perfectly well-formed XML and <code>XML</code> is a perfectly well-formed element name.

It is just that such names are in the subset of well-formed element names that are reserved for standardization (XML version 1.0 and above). It is easy to test if a (well-formed) element name is reserved with a string comparison:

<pre><code>$reserved = $valid &amp;&amp; 0 === stripos($name, 'xml'));
</code></pre>

or alternatively another regular expression:

<pre><code>$reserved = $valid &amp;&amp; 1 === preg_match('~^[Xx][Mm][Ll]~', $name);
</code></pre>

<a href="http://php.net/DOMDocument">PHP's <code>DOMDocument</code></a> can not test for reserved names at least I don't know any way how to do that and I've been looking a lot.

A valid element name needs a Unique Element Type Declaration which seems to be out of the scope of the question here as no such declaration has been provided. Therefore the answer does not take care of that. If there would be an element type declaration, you would only need to validate against a white-list of all (case-sensitive) names, so this would be a simple case-sensitive string-comparison.

<hr>

Excursion: What does <code>DOMDocument</code> do different to the Regular Expression?

In comparison with a <code>DOMDocument</code> / <code>DOMElement</code>, there are some differences what qualifies a valid element name. The DOM extension is in some kind of mixed-mode which makes it less predictable what it validates. The following excursion illustrates the behavior and shows how to control it.

Let's take <code>$name</code> and instantiate an element:

<pre><code>$element = new DOMElement($name);
</code></pre>

The outcome depends:

<ul>
<li>if the first character is a colon, it just validates the <a href="http://www.w3.org/TR/REC-xml/#NT-Name">XML 1.0 <code>Name</code> symbol</a>.</li>
<li>if the first character is not a colon, it validates the <a href="http://www.w3.org/TR/REC-xml-names/#NT-QName">XMLNS 1.0 <code>QName</code> symbol</a></li>
</ul>

So the first character decides about the comparison mode.

A regular expression is specifically written what to check for, here the XML 1.0 <code>Name</code> symbol.

You can achieve the same with <code>DOMElement</code> by prefixing the name with a colon:

<pre><code>function isValidXmlName($name)
{

 try {
 new DOMElement(":$name");
 return TRUE;
 } catch (DOMException $e) {
 return FALSE;
 }
}
</code></pre>

To explicitly check for the <code>QName</code> this can be achieved by turning it into a <code>PrefixedName</code> in case it is a <code>UnprefixedName</code>:

<pre><code>function isValidXmlnsQname($qname)
{
 $prefixedName = (!strpos($qname, ':') ? 'prefix:' : '') . $qname;

 try {
 new DOMElement($prefixedName, NULL, 'uri:ns');
 return TRUE;
 } catch (DOMException $e) {
 return FALSE;
 }
}
</code></pre>

blocks|key|1533264|text|XML、xml等都是有效的标记，它们只是“为本规范或本规范的未来版本中的标准化而保留的”，这种情况很可能永远不会发生。请查一下https://www.w3.org/TR/REC-xml/的实际标准。w3school的文章是不准确的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1533265|entityMap|0|LINK|mutability|MUTABLE|url|https://www.w3.org/TR/REC-xml/^0|1R|U|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

XML, xml and etc are valid tags, they are just "reserved for standardization in this or future versions of this specification" which likely will never happen. Please check the real standard at <a href="https://www.w3.org/TR/REC-xml/" rel="nofollow">https://www.w3.org/TR/REC-xml/</a>. The w3school article is inaccurate.

I need a regex or a function in PHP that will validate a string to be a good XML element name.

Form w3schools:

<blockquote>
 XML elements must follow these naming
 rules:
 
 <ol>
 <li>Names can contain letters, numbers, and other characters</li>
 <li>Names cannot start with a number or punctuation character</li>
 <li>Names cannot start with the letters xml (or XML, or Xml, etc)</li>
 <li>Names cannot contain spaces</li>
 </ol>
</blockquote>

I can write a basic regex that will check for rules 1,2 and 4, but it won't account for all punctuation allowed and won't account for 3rd rule

<pre><code>\w[\w0-9-]
</code></pre>

<h3>Friendly Update</h3>

Here is the more authoritative source for <a href="http://www.w3.org/TR/REC-xml/#NT-NameChar" rel="noreferrer">well-formed XML Element names</a>:

Names and Tokens

<pre><code>NameStartChar ::=
 ":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] |
 [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | 
 [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | 
 [#x10000-#xEFFFF]

NameChar ::=
 NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]

Name ::=
 NameStartChar (NameChar)*
</code></pre>

Also a separate non-tokenized rule is specified:

<blockquote>
 Names beginning with the string "xml", or with any string which would match (('X'|'x') ('M'|'m') ('L'|'l')), are reserved for standardization in this or future versions of this specification.
</blockquote>

How to check if string is a valid XML element name?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我需要PHP中的regex或函数来验证字符串是一个好的XML元素名称。表格w3schools：XML元素必须遵循以下命名规则：名称可以包含字母、数字和其他字符。名称不能以数字或标点符号开头。名称不能以字母XML (或Xml或xml等)开头。名称不能包含空格我可以编写一个基本的正则表达式，它将检查规则1、2和4，但它不会...

问如何检查字符串是否是有效的XML元素名称？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何检查字符串是否是有效的XML元素名称？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何检查字符串是否是有效的XML元素名称？
EN