Node: 20
PR: [1] 1565k requests in 30.05s, 294 MB read
MAIN: [1] 1546k requests in 30.04s, 290 MB read

Node: 22
PR: [1] 1546k requests in 30.04s, 290 MB read
MAIN: [1] 1560k requests in 30.04s, 293 MB read

Node: 20
PR: [1] 1367k requests in 30.05s, 257 MB read
MAIN: [1] 1357k requests in 30.04s, 255 MB read

Node: 22
PR: [1] 1380k requests in 30.04s, 259 MB read
MAIN: [1] 1392k requests in 30.05s, 261 MB read

We currently don't have this:

For example, the following media types are equivalent in describing HTML text data encoded in the UTF-8 character encoding scheme, but the first is preferred for consistency (the "charset" parameter value is defined as being case-insensitive in [RFC2046], Section 4.1.2):

text/html;charset=utf-8
Text/HTML;Charset="utf-8"
text/html; charset="utf-8"
text/html;charset=UTF-8

cant we avoid somehow toLowerCase?

cant we avoid somehow toLowerCase?

We already call toLowerCase in add and hasParser, I think its ok to have it in run as well

I would say we should do something like this. The intention is that we cache both any-case header and lowercase header.
So, most of the time it hit the cache with original header and check only once by lowercase header.

Please be aware multipart/form-data always pollute the cache (spammed with all useless cache record) since the boundary part may not be the same for all time.
But most of the case, the full lookup should only run one time.

ContentTypeParser.prototype.getParser = function (contentType) {
  // fast-path for remembered content-type (incoming as lowercase)
  let parser = this.customParsers.get(contentType)
  if (parser !== undefined) return parser
  parser = this.cache.get(contentType)
  if (parser !== undefined) return parser
  // case-incensitive cache check
  const lowercaseContentType = contentType.toLowerCase()
  let parser = this.customParsers.get(lowercaseContentType)
  if (parser !== undefined) return parser
  parser = this.cache.get(lowercaseContentType)
  if (parser !== undefined) return parser


  // eslint-disable-next-line no-var
  for (var i = 0; i !== this.parserList.length; ++i) {
    const parserListItem = this.parserList[i]
    if (
      lowercaseContentType.slice(0, parserListItem.length) === parserListItem &&
      (lowercaseContentType.length === parserListItem.length || lowercaseContentType.charCodeAt(parserListItem.length) === 59 /* `;` */ || lowercaseContentType.charCodeAt(parserListItem.length) === 32 /* ` ` */)
    ) {
      parser = this.customParsers.get(parserListItem)
      this.cache.set(contentType, parser)
      // cache for both lowercase and original header
      this.cache.set(lowercaseContentType, parser)
      return parser
    }
  }
  // eslint-disable-next-line no-var
  for (var j = 0; j !== this.parserRegExpList.length; ++j) {
    const parserRegExp = this.parserRegExpList[j]
    // regexp should use the original header in all case
    // it allows the user to choose whether they want case-sensitive or case-insensitive
    if (parserRegExp.test(contentType)) {
      parser = this.customParsers.get(parserRegExp.toString())
      this.cache.set(contentType, parser)
      // cache for both lowercase and original header
      this.cache.set(lowercaseContentType, parser)
      return parser
    }
  }
  return this.customParsers.get('')
}

@climba03003 wdyt? I like this approach!

Every string Content-Type parser is lowercase , so:

If we miss the original cache checks, then we lowercase and try to match manually like before

If we match there, then we save the original version to the cache for future matches

Note that this only applies to string content-type parsers

Like you said, RegExp offers more freedom in how a user would want to match

This pull request has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.