Check for Certain Naming Conventions in Your Code

Check Name Lengths

You can configure a minimum or maximum name length for identifiers using the following properties. The Code Analyzer displays a message if an identifier name has fewer characters than the minimum or more characters than the maximum.

"maxLength" : 12

"minLength" : 4

For example, require that the names of local and nested functions have a minimum length of 4 by specifying this code in the codeAnalyzerConfiguration.json file.

    "naming": {
        "localFunction" : {
            "minLength" : 4
        },
        "nestedFunction" : {
            "minLength" : 4
        }
    }

Check for Prefixes, Suffixes, and Phrases

You can configure required or disallowed prefixes and suffixes for identifiers using the following properties. You can also configure disallowed phrases, and the Code Analyzer displays a message if it finds the phrases anywhere in an identifier name.

"requiredPrefix" : ["prop","property"]

"disallowedPrefix" : ["get","set"]

"requiredSuffix" : "orgABC"​

"disallowedSuffix" : ["event","EVENT"]​

"disallowedPhrase" : ["enum","ENUM","class","_day"]

For example, require that the names of nested functions use certain prefixes and have a minimum length of 5 by specifying this code in the codeAnalyzerConfiguration.json file.

    "naming": {
        "nestedFunction": {
            "requiredPrefix" : ["nest","sub"],
            "minLength": 5
        }
    }

Check for Casing

You can check that identifiers conform to one or more casing standards. Specify a "casing" property containing a string scalar or string array where each element is a casing standard. If you specify more than one casing standard, then identifiers must satisfy at least one of them.

For example, this check specifies that function names must be uppercase with underscores or upper camel case.

    "naming": {
        "function": {
            "casing": ["UPPERCASE_WITH_UNDERSCORES","UpperCamelCase"]
        }
    }

Prefixes that match the requiredPrefix property and suffixes that match the requiredSuffix property are not included in casing checks. For example, this check specifies a required prefix as well as upper camel case for variable names. The check ignores the prefix when checking if the name adheres to the upper camel case rule, so a name like isEnabled is accepted.

    "naming": {
        "variable": {
            "casing": "UpperCamelCase",
            "requiredPrefix": ["init","pre","is"]
        }
    }

This table shows the values you can specify when setting casing standards.

Check for Custom Naming Conventions Using Regular Expressions

You can create a custom naming convention check by specifying the "regularExpression" property. The Code Analyzer displays a message if the identifier name does not fully match the specified regular expression. Required prefixes and suffixes are not excluded from this check. Each identifier type can have only one regular expression check.

For example, require that event names use only uppercase characters and start with the prefix "E" by specifying this code in the codeAnalyzerConfiguration.json file.

    "naming": {
        "event": {
            "regularExpression": "^([A-Z]+)$",
            "requiredPrefix": "E"
        }
    }

For more information on constructing regular expressions, see Steps for Building Expressions.

This table shows regular expressions for the casing options listed in Check for Casing.

"^[a-z0-9]+$"

"^[A-Z0-9]+$"

"^[a-z][a-zA-Z0-9]*$"

"^[A-Z][a-zA-Z0-9]*$"

"^(?!.*__)[a-z0-9_]+$"

"^(?!.*__)[A-Z0-9_]+$"

This table shows additional regular expression examples for naming conventions.

"^[A-Z][a-z0-9]*$"

"(^[a-z][a-zA-Z0-9]*$)|(^[A-Z][a-z0-9]*$)"

"^[a-z](?:[a-z0-9]+[A-Z]?[a-z0-9]*)*$"

"^[A-Z](?:[a-z0-9]+[A-Z]?[a-z0-9]*)*$"

"^(?!.*__)[a-z0-9_]+(?<!_)$"

"^(?!.*__)[A-Z0-9_]+(?<!_)$"