How to check if character is a letter in Javascript?

Question

I am extracting a character in a Javascript string with:

var first = str.charAt(0);

and I would like to check whether it is a letter. Strangely, it does not seem like such functionality exists in Javascript. At least I cannot find it.

How can I test this?

Create a number and test against `NaN`? Or just `isNan(first)` I guess. — Marc, Mar 25 '12 at 18:24
@Marc If this character was '-' for example, your test would not indicate that it is a letter... — Jérôme Verstrynge, Mar 25 '12 at 18:25
Define "letter"? English alpha only, or something else? Do you want to "blacklist" or "whitelist"? — Wesley Murch, Mar 25 '12 at 18:26
Something like in Java (if possible): http://docs.oracle.com/javase/6/docs/api/java/lang/Character.html#isLetter%28char%29 — Jérôme Verstrynge, Mar 25 '12 at 18:27
@JVerstry not everybody knows Java. Can't you just tell us what characters will be allowed? — PeeHaa, Mar 25 '12 at 18:29
@PeeHaa True, but in the case of a real letter, his test would return false, exactly like if it was '-'. So, the info provided by his test would still be incomplete. — Jérôme Verstrynge, Mar 25 '12 at 18:30
duplicate? http://stackoverflow.com/questions/10707972/detecting-if-a-character-is-a-letter — Adriano, Sep 15 '14 at 12:55
you may want to remove accents & then do a simple [a-z] check. see http://stackoverflow.com/questions/990904/javascript-remove-accents-in-strings — Adriano, Sep 15 '14 at 13:37
@JVerstry I added my answer: it addresses the issue of special characters (used, in Spanish, German, French, Italian, & many more) — Adriano, Sep 15 '14 at 14:48
This is a great way for testing if a character is a number or not, but not necessarily a letter (due to Unicode, etc). If all you need is to do a numeric digit check, this should work. Though for special cases it may benefit from some checks for characters that may be valid "numbers", like NaN, INF, -INF, 1.0E+2, etc. I'm actually surprised "-" isn't considered a number in JS since the language is so loose. For example, it could be interpreted as "-0" or "0", like how an empty string can be compared against "0". — Beejor, May 11 '15 at 19:50
I see a lot of people calling JS Java here. JS and Java are not the same thing, not even close. One is a essentially a toy, the other is for making websites. — Ian Wise, Jan 10 '18 at 09:44
Please, if you’re reading the answers to this question (or writing one), do consider that there is a whole world outside “a-z”: diacritics, ligatures, non-Latin scripts. Assuming your code will only have to deal with (a subset of) English characters is bad practice and paves the way for broken software in the long term. Note that even in English you may encounter “é”, “ë”, “æ”, “&”, “ﬃ”, etc. — Philippe-André Lorin, Sep 04 '20 at 08:58

score 210 · Answer 1 · answered Mar 25 '12 at 18:26

210

I don't believe there is a built-in function for that. But it's easy enough to write with a regex

function isLetter(str) {
  return str.length === 1 && str.match(/[a-z]/i);
}

answered Mar 25 '12 at 18:26

JaredPar

733,204
149
1,241
1,454

64

The code only tests whether the character is one of the basic letter from a to z (very few languages are written using only those letters). This is very different from the Java function that was mentioned. – Jukka K. Korpela Mar 25 '12 at 19:19
13

You can still use a regex and just add more detail as you need it: str.match(/[A-Z|a-z|ü|é]/i); //etc – Eli Jun 22 '15 at 21:54
maybe this is works? `var char=str.toLowerCase(); return (char.length==1 && char>='a' && char<='z')` – Yibo Yang Feb 04 '16 at 23:26
2

@YiboYang - nope, went to the jsbin link above, changed it to yours and ran it, and got this: "is 'u' is a letter? true" "is 'ü' is a letter? false" "is 'à' is a letter? false" With your code. – Julix Sep 05 '16 at 06:38
4

It should be noted this doesn't actually return true || false as one might expect. If `str` is a value from a-z it returns that value. Otherwise it returns null. If you need it to return true / false use this. `isLetter: function (str) { if (str.length !== 1 && str.match(/[a-z]/i)) { return true; } return false; },` – Regis Jan 20 '18 at 01:23
Just refactored it to return true or false: `function isLetter(str) { return (/^[a-z]{1}$/i).test(str); }` – Chen Dachao Feb 26 '20 at 13:43
This one worked for me for simple cases of just checking if alphabets. Thanks – cherucole Apr 29 '20 at 18:31
3

Soooooo the results of this didn't return a true or false value, which is all I cared about... which can be accomplished simply by changing `return str.length === 1 && str.match(/[a-z]/i);` to `return str.length === 1 && !!str.match(/[a-z]/i);`. If this is something you'd like to incorporate into your answer. Upvoted nonetheless. – Shmack Sep 09 '20 at 06:24

score 168 · Answer 2 · edited Mar 06 '17 at 14:46

168

With respect to those special characters not being taken into account by simpler checks such as /[a-zA-Z]/.test(c), it can be beneficial to leverage ECMAScript case transformation (toUpperCase). It will take into account non-ASCII Unicode character classes of some foreign alphabets.

function isLetter(c) {
  return c.toLowerCase() != c.toUpperCase();
}

NOTE: this solution will work only for most Latin, Greek, Armenian and Cyrillic scripts. It will NOT work for Chinese, Japanese, Arabic, Hebrew and most other scripts.

edited Mar 06 '17 at 14:46

mik01aj

11,928
15
76
119

answered Sep 14 '15 at 14:48

filip

3,542
1
26
23

22

Clever. But based on my very limited understand, it doesn't work with alphabets that don't have upper and lower case, like Chinese or Japanese – Notre Feb 17 '16 at 23:55
7

great (and clever) code. Works with all Latin based alphabets. – fvlinden Apr 09 '16 at 07:58
4

Personally I love functions like this as it's so much easier to glance at and understand than the regex functions – Djave May 17 '16 at 15:00
4

brilliant solution. In case of c = '1a', simply split your string into array and loop, e.g., ` function isLetters(arr) { for (var i = 0; i < arr.length; i++) { if(arr[i].toLowerCase() != arr[i].toUpperCase()){ } else { return false; } } return true; } ` – Ronnie Royston Aug 21 '16 at 20:14
"is 'u' is a letter? true" "is 'ü' is a letter? true" "is 'à' is a letter? true" Seems to work! :) – Julix Sep 05 '16 at 06:40
1

Clever, but wrong. :) From [Unicode Case Mappings & Names FAQ](http://unicode.org/faq/casemap_charprop.html): Q: Do all scripts have an uppercase and a lowercase? A: No (...) The vast majority of scripts do not have case distinctions. – mik01aj Mar 06 '17 at 14:42
8

Compared to the solution based on a `/[a-z]/i` pattern, this trick will accept the complete range of Latin characters. Compared to the other solution containing a complete Latin Unicode upper-lower mapping, you save 99.2% in code size. It is misleading to call this solution "wrong", because it depends on your problem. If your scope is the Latin character set, this is a lean and elegant way to solve it. – filip Mar 08 '17 at 16:31
1

@ToniMichelCaubet the samples you gave, c = '1a' or 'a1' are not single letters! This algorithm is strictly for single characters. – revelt Aug 24 '18 at 14:40
This does work for Chinese and Japanese, as they don’t use letters. – Philippe-André Lorin Sep 04 '20 at 08:33
Very cleaver. It works with latin based alphabet and it is very clear. Good job – Lixt Sep 26 '22 at 20:34

Sumer · Answer 3 · 2020-06-23T02:35:49.610

52

if( char.toUpperCase() != char.toLowerCase() )

Will return true only in case of letter

As point out in below comment, if your character is non English, High Ascii or double byte range then you need to add check for code point.

if( char.toUpperCase() != char.toLowerCase() || char.codePointAt(0) > 127 )

edited Jun 23 '20 at 02:35

answered Aug 14 '18 at 02:37

Sumer

2,687
24
24

1

just to add twopence, if turning it into a function, add a check is it string and enforce the length to be one or make sure length is one. That's to prevent `1a` for example. – revelt Aug 24 '18 at 14:42
1

@AnchovyLegend It works because there aren't uppercase and lowercase versions of numbers, punctuation, and other non-alphabetic characters. In other words, the upper and lower case of them will be the same, whereas the upper and lower case of letters will differ. Personally, I like this technique because it's independent of the language (it works with languages with diacritical marks). I haven't run any benchmarks, but I would guess that this is more efficient than building a regex. (But I could be wrong, since regex are amazingly fast.) – Daniel 'Dang' Griffith Feb 02 '20 at 21:28
5

This fails for scripts that don’t discriminate between upper and lower case, like Chinese. – Michael Schmid May 26 '20 at 22:32
@MichaelSchmid, We can add code point check say "a".codePointAt(0).toString(16). The code point should be greater than 127. – Sumer Jun 23 '20 at 02:32
3

@Sumer, why would that help? Just because the code point is above 127 doesn’t mean it’s a letter. – Michael Schmid Jun 23 '20 at 07:24
All symbols are scattered in code point till 128, rest all are charaters. Some logic can be used for that. – Sumer Jun 24 '20 at 14:53
@Sumer, Unicode currently has 248’966 assigned code points. Only 100’520 of them are letters. – Michael Schmid Aug 13 '20 at 08:04
@michael , can you give one example, one Unicode code point that's not a letter – Sumer Aug 14 '20 at 09:04
@Sumer, “¡” (inverted exclamation mark, codepoint 161). It’s a punctuation mark used in Spanish. – Michael Schmid Aug 14 '20 at 10:27
Totally agreed @michael, is there any solution to separate out such symbols? I guess in this case current solution will work for English and other languages where all characters have corresponding capital letters – Sumer Aug 16 '20 at 23:26
@MichaelSchmid Chinese characters are not letters, so returning false for them is right. – Philippe-André Lorin Sep 04 '20 at 08:14
This method fails with small caps (e.g. “ᴀ”). – Philippe-André Lorin Sep 04 '20 at 08:21
This method fails for any unicameral script, such as Hebrew or Arabic (e.g. “ل”). See https://en.wikipedia.org/wiki/Unicase – Philippe-André Lorin Sep 04 '20 at 08:24

Michael Schmid · Answer 4 · 2020-05-26T23:15:04.310

ES6 supports unicode-aware regular expressions.

RegExp(/^\p{L}/,'u').test(str)

This works for all alphabets.

Unfortunately, there is a bug in Firefox (will be fixed in version 78) that prevents this from being used universally. But if you can control your runtime environment and it supports it (e.g. Node.js), this is a straightforward, comprehensive solution.

Atlernatively, XRegExp provides a polyfill of modern regular expression to all browsers.

bezmax · Accepted Answer · 2014-09-15T13:06:26.373

15

I believe this plugin has the capabilities you seek: http://xregexp.com/plugins/ (github link: https://github.com/slevithan/xregexp)

With it you can simply match all unicode letters with \p{L}.

Read the header of this source file to see which categories it supports: http://xregexp.com/plugins/xregexp-unicode-categories.js

edited Sep 15 '14 at 13:06

answered Mar 25 '12 at 21:21

bezmax

25,562
10
53
84

1

Have you got experience in using this plugin on projects you worked on? (just wondering how reliable this library is) – Adriano Sep 17 '14 at 07:17
downvoting as this is certainly a poor answer for 2019 – Peter Dec 04 '19 at 16:05
11

@Peter Could you please link an answer you consider suitable for 2019? I would add a link to it as an edit to my answer as long as the other solution works with all Unicode characters. – bezmax Dec 05 '19 at 18:34
If you don't want to use a plugin and need the solution to work in any version of JavaScript please consider my answer. – Adam Gawne-Cain Dec 13 '21 at 15:19

fmg · Answer 6 · 2019-06-26T15:17:15.013

10

How about using ASCII codes?

let n = str.charCodeAt(0);
let strStartsWithALetter = (n >= 65 && n < 91) || (n >= 97 && n < 123);

edited Jun 26 '19 at 15:17

answered Jun 25 '19 at 03:13

fmg

813
8
18

3

Works perfectly for the unlikely case that you are processing only English texts. (An assumption that is wrong for almost every system.) – Michael Schmid Aug 14 '20 at 10:32
When characters are easy to read (as is the case here), writing Ascii or Unicode codes (e.g. 65 instead of 'A') is bad practice, because it’s unreadable. See other answers for how to write this properly. – Philippe-André Lorin Sep 04 '20 at 08:40

score 3 · Answer 7 · edited Mar 02 '20 at 13:23

This solution works with special characters too, for instance é, è, ê, ü, ö, à

2 steps:

Remove the accents, based on this answer: Remove accents/diacritics in a string in JavaScript
Check if a to z character, using regex or unicode (your choice)

Live demos of my solution:

Note: I posted the solution that uses global functions as it's probably the simplest to understand. But do look into "javascript module pattern" if you want better code (cleaner, easier to maintain and extend), see impressivewebs.com/my-current-javascript-design-pattern and also this YouTube video (presentation by Paul Irish).

var defaultDiacriticsRemovalap = [
    {'base':'A', 'letters':'\u0041\u24B6\uFF21\u00C0\u00C1\u00C2\u1EA6\u1EA4\u1EAA\u1EA8\u00C3\u0100\u0102\u1EB0\u1EAE\u1EB4\u1EB2\u0226\u01E0\u00C4\u01DE\u1EA2\u00C5\u01FA\u01CD\u0200\u0202\u1EA0\u1EAC\u1EB6\u1E00\u0104\u023A\u2C6F'},
    {'base':'AA','letters':'\uA732'},
    {'base':'AE','letters':'\u00C6\u01FC\u01E2'},
    {'base':'AO','letters':'\uA734'},
    {'base':'AU','letters':'\uA736'},
    {'base':'AV','letters':'\uA738\uA73A'},
    {'base':'AY','letters':'\uA73C'},
    {'base':'B', 'letters':'\u0042\u24B7\uFF22\u1E02\u1E04\u1E06\u0243\u0182\u0181'},
    {'base':'C', 'letters':'\u0043\u24B8\uFF23\u0106\u0108\u010A\u010C\u00C7\u1E08\u0187\u023B\uA73E'},
    {'base':'D', 'letters':'\u0044\u24B9\uFF24\u1E0A\u010E\u1E0C\u1E10\u1E12\u1E0E\u0110\u018B\u018A\u0189\uA779'},
    {'base':'DZ','letters':'\u01F1\u01C4'},
    {'base':'Dz','letters':'\u01F2\u01C5'},
    {'base':'E', 'letters':'\u0045\u24BA\uFF25\u00C8\u00C9\u00CA\u1EC0\u1EBE\u1EC4\u1EC2\u1EBC\u0112\u1E14\u1E16\u0114\u0116\u00CB\u1EBA\u011A\u0204\u0206\u1EB8\u1EC6\u0228\u1E1C\u0118\u1E18\u1E1A\u0190\u018E'},
    {'base':'F', 'letters':'\u0046\u24BB\uFF26\u1E1E\u0191\uA77B'},
    {'base':'G', 'letters':'\u0047\u24BC\uFF27\u01F4\u011C\u1E20\u011E\u0120\u01E6\u0122\u01E4\u0193\uA7A0\uA77D\uA77E'},
    {'base':'H', 'letters':'\u0048\u24BD\uFF28\u0124\u1E22\u1E26\u021E\u1E24\u1E28\u1E2A\u0126\u2C67\u2C75\uA78D'},
    {'base':'I', 'letters':'\u0049\u24BE\uFF29\u00CC\u00CD\u00CE\u0128\u012A\u012C\u0130\u00CF\u1E2E\u1EC8\u01CF\u0208\u020A\u1ECA\u012E\u1E2C\u0197'},
    {'base':'J', 'letters':'\u004A\u24BF\uFF2A\u0134\u0248'},
    {'base':'K', 'letters':'\u004B\u24C0\uFF2B\u1E30\u01E8\u1E32\u0136\u1E34\u0198\u2C69\uA740\uA742\uA744\uA7A2'},
    {'base':'L', 'letters':'\u004C\u24C1\uFF2C\u013F\u0139\u013D\u1E36\u1E38\u013B\u1E3C\u1E3A\u0141\u023D\u2C62\u2C60\uA748\uA746\uA780'},
    {'base':'LJ','letters':'\u01C7'},
    {'base':'Lj','letters':'\u01C8'},
    {'base':'M', 'letters':'\u004D\u24C2\uFF2D\u1E3E\u1E40\u1E42\u2C6E\u019C'},
    {'base':'N', 'letters':'\u004E\u24C3\uFF2E\u01F8\u0143\u00D1\u1E44\u0147\u1E46\u0145\u1E4A\u1E48\u0220\u019D\uA790\uA7A4'},
    {'base':'NJ','letters':'\u01CA'},
    {'base':'Nj','letters':'\u01CB'},
    {'base':'O', 'letters':'\u004F\u24C4\uFF2F\u00D2\u00D3\u00D4\u1ED2\u1ED0\u1ED6\u1ED4\u00D5\u1E4C\u022C\u1E4E\u014C\u1E50\u1E52\u014E\u022E\u0230\u00D6\u022A\u1ECE\u0150\u01D1\u020C\u020E\u01A0\u1EDC\u1EDA\u1EE0\u1EDE\u1EE2\u1ECC\u1ED8\u01EA\u01EC\u00D8\u01FE\u0186\u019F\uA74A\uA74C'},
    {'base':'OI','letters':'\u01A2'},
    {'base':'OO','letters':'\uA74E'},
    {'base':'OU','letters':'\u0222'},
    {'base':'OE','letters':'\u008C\u0152'},
    {'base':'oe','letters':'\u009C\u0153'},
    {'base':'P', 'letters':'\u0050\u24C5\uFF30\u1E54\u1E56\u01A4\u2C63\uA750\uA752\uA754'},
    {'base':'Q', 'letters':'\u0051\u24C6\uFF31\uA756\uA758\u024A'},
    {'base':'R', 'letters':'\u0052\u24C7\uFF32\u0154\u1E58\u0158\u0210\u0212\u1E5A\u1E5C\u0156\u1E5E\u024C\u2C64\uA75A\uA7A6\uA782'},
    {'base':'S', 'letters':'\u0053\u24C8\uFF33\u1E9E\u015A\u1E64\u015C\u1E60\u0160\u1E66\u1E62\u1E68\u0218\u015E\u2C7E\uA7A8\uA784'},
    {'base':'T', 'letters':'\u0054\u24C9\uFF34\u1E6A\u0164\u1E6C\u021A\u0162\u1E70\u1E6E\u0166\u01AC\u01AE\u023E\uA786'},
    {'base':'TZ','letters':'\uA728'},
    {'base':'U', 'letters':'\u0055\u24CA\uFF35\u00D9\u00DA\u00DB\u0168\u1E78\u016A\u1E7A\u016C\u00DC\u01DB\u01D7\u01D5\u01D9\u1EE6\u016E\u0170\u01D3\u0214\u0216\u01AF\u1EEA\u1EE8\u1EEE\u1EEC\u1EF0\u1EE4\u1E72\u0172\u1E76\u1E74\u0244'},
    {'base':'V', 'letters':'\u0056\u24CB\uFF36\u1E7C\u1E7E\u01B2\uA75E\u0245'},
    {'base':'VY','letters':'\uA760'},
    {'base':'W', 'letters':'\u0057\u24CC\uFF37\u1E80\u1E82\u0174\u1E86\u1E84\u1E88\u2C72'},
    {'base':'X', 'letters':'\u0058\u24CD\uFF38\u1E8A\u1E8C'},
    {'base':'Y', 'letters':'\u0059\u24CE\uFF39\u1EF2\u00DD\u0176\u1EF8\u0232\u1E8E\u0178\u1EF6\u1EF4\u01B3\u024E\u1EFE'},
    {'base':'Z', 'letters':'\u005A\u24CF\uFF3A\u0179\u1E90\u017B\u017D\u1E92\u1E94\u01B5\u0224\u2C7F\u2C6B\uA762'},
    {'base':'a', 'letters':'\u0061\u24D0\uFF41\u1E9A\u00E0\u00E1\u00E2\u1EA7\u1EA5\u1EAB\u1EA9\u00E3\u0101\u0103\u1EB1\u1EAF\u1EB5\u1EB3\u0227\u01E1\u00E4\u01DF\u1EA3\u00E5\u01FB\u01CE\u0201\u0203\u1EA1\u1EAD\u1EB7\u1E01\u0105\u2C65\u0250'},
    {'base':'aa','letters':'\uA733'},
    {'base':'ae','letters':'\u00E6\u01FD\u01E3'},
    {'base':'ao','letters':'\uA735'},
    {'base':'au','letters':'\uA737'},
    {'base':'av','letters':'\uA739\uA73B'},
    {'base':'ay','letters':'\uA73D'},
    {'base':'b', 'letters':'\u0062\u24D1\uFF42\u1E03\u1E05\u1E07\u0180\u0183\u0253'},
    {'base':'c', 'letters':'\u0063\u24D2\uFF43\u0107\u0109\u010B\u010D\u00E7\u1E09\u0188\u023C\uA73F\u2184'},
    {'base':'d', 'letters':'\u0064\u24D3\uFF44\u1E0B\u010F\u1E0D\u1E11\u1E13\u1E0F\u0111\u018C\u0256\u0257\uA77A'},
    {'base':'dz','letters':'\u01F3\u01C6'},
    {'base':'e', 'letters':'\u0065\u24D4\uFF45\u00E8\u00E9\u00EA\u1EC1\u1EBF\u1EC5\u1EC3\u1EBD\u0113\u1E15\u1E17\u0115\u0117\u00EB\u1EBB\u011B\u0205\u0207\u1EB9\u1EC7\u0229\u1E1D\u0119\u1E19\u1E1B\u0247\u025B\u01DD'},
    {'base':'f', 'letters':'\u0066\u24D5\uFF46\u1E1F\u0192\uA77C'},
    {'base':'g', 'letters':'\u0067\u24D6\uFF47\u01F5\u011D\u1E21\u011F\u0121\u01E7\u0123\u01E5\u0260\uA7A1\u1D79\uA77F'},
    {'base':'h', 'letters':'\u0068\u24D7\uFF48\u0125\u1E23\u1E27\u021F\u1E25\u1E29\u1E2B\u1E96\u0127\u2C68\u2C76\u0265'},
    {'base':'hv','letters':'\u0195'},
    {'base':'i', 'letters':'\u0069\u24D8\uFF49\u00EC\u00ED\u00EE\u0129\u012B\u012D\u00EF\u1E2F\u1EC9\u01D0\u0209\u020B\u1ECB\u012F\u1E2D\u0268\u0131'},
    {'base':'j', 'letters':'\u006A\u24D9\uFF4A\u0135\u01F0\u0249'},
    {'base':'k', 'letters':'\u006B\u24DA\uFF4B\u1E31\u01E9\u1E33\u0137\u1E35\u0199\u2C6A\uA741\uA743\uA745\uA7A3'},
    {'base':'l', 'letters':'\u006C\u24DB\uFF4C\u0140\u013A\u013E\u1E37\u1E39\u013C\u1E3D\u1E3B\u017F\u0142\u019A\u026B\u2C61\uA749\uA781\uA747'},
    {'base':'lj','letters':'\u01C9'},
    {'base':'m', 'letters':'\u006D\u24DC\uFF4D\u1E3F\u1E41\u1E43\u0271\u026F'},
    {'base':'n', 'letters':'\u006E\u24DD\uFF4E\u01F9\u0144\u00F1\u1E45\u0148\u1E47\u0146\u1E4B\u1E49\u019E\u0272\u0149\uA791\uA7A5'},
    {'base':'nj','letters':'\u01CC'},
    {'base':'o', 'letters':'\u006F\u24DE\uFF4F\u00F2\u00F3\u00F4\u1ED3\u1ED1\u1ED7\u1ED5\u00F5\u1E4D\u022D\u1E4F\u014D\u1E51\u1E53\u014F\u022F\u0231\u00F6\u022B\u1ECF\u0151\u01D2\u020D\u020F\u01A1\u1EDD\u1EDB\u1EE1\u1EDF\u1EE3\u1ECD\u1ED9\u01EB\u01ED\u00F8\u01FF\u0254\uA74B\uA74D\u0275'},
    {'base':'oi','letters':'\u01A3'},
    {'base':'ou','letters':'\u0223'},
    {'base':'oo','letters':'\uA74F'},
    {'base':'p','letters':'\u0070\u24DF\uFF50\u1E55\u1E57\u01A5\u1D7D\uA751\uA753\uA755'},
    {'base':'q','letters':'\u0071\u24E0\uFF51\u024B\uA757\uA759'},
    {'base':'r','letters':'\u0072\u24E1\uFF52\u0155\u1E59\u0159\u0211\u0213\u1E5B\u1E5D\u0157\u1E5F\u024D\u027D\uA75B\uA7A7\uA783'},
    {'base':'s','letters':'\u0073\u24E2\uFF53\u00DF\u015B\u1E65\u015D\u1E61\u0161\u1E67\u1E63\u1E69\u0219\u015F\u023F\uA7A9\uA785\u1E9B'},
    {'base':'t','letters':'\u0074\u24E3\uFF54\u1E6B\u1E97\u0165\u1E6D\u021B\u0163\u1E71\u1E6F\u0167\u01AD\u0288\u2C66\uA787'},
    {'base':'tz','letters':'\uA729'},
    {'base':'u','letters': '\u0075\u24E4\uFF55\u00F9\u00FA\u00FB\u0169\u1E79\u016B\u1E7B\u016D\u00FC\u01DC\u01D8\u01D6\u01DA\u1EE7\u016F\u0171\u01D4\u0215\u0217\u01B0\u1EEB\u1EE9\u1EEF\u1EED\u1EF1\u1EE5\u1E73\u0173\u1E77\u1E75\u0289'},
    {'base':'v','letters':'\u0076\u24E5\uFF56\u1E7D\u1E7F\u028B\uA75F\u028C'},
    {'base':'vy','letters':'\uA761'},
    {'base':'w','letters':'\u0077\u24E6\uFF57\u1E81\u1E83\u0175\u1E87\u1E85\u1E98\u1E89\u2C73'},
    {'base':'x','letters':'\u0078\u24E7\uFF58\u1E8B\u1E8D'},
    {'base':'y','letters':'\u0079\u24E8\uFF59\u1EF3\u00FD\u0177\u1EF9\u0233\u1E8F\u00FF\u1EF7\u1E99\u1EF5\u01B4\u024F\u1EFF'},
    {'base':'z','letters':'\u007A\u24E9\uFF5A\u017A\u1E91\u017C\u017E\u1E93\u1E95\u01B6\u0225\u0240\u2C6C\uA763'}
];

var diacriticsMap = {};
for (var i=0; i < defaultDiacriticsRemovalap.length; i++){
    var letters = defaultDiacriticsRemovalap[i].letters.split("");
    for (var j=0; j < letters.length ; j++){
        diacriticsMap[letters[j]] = defaultDiacriticsRemovalap[i].base;
    }
}

function removeDiacriticFromChar (char) {
    return diacriticsMap[char] || char; 
}


/*
 *  [1] Remove the accent, based on answer of https://stackoverflow.com/questions/990904/javascript-remove-accents-in-strings
 *  [2] Check if a to z character, using regex or unicode (your choice, here using regex)
 *
 */
function isLetter(char) {
  var charWithoutAccent = removeDiacriticFromChar(char);  /* [1] */
  return charWithoutAccent.match(/[a-z]/i);               /* [2] */
}

console.log( "is 'u' is a letter? " + (isLetter('u') ? 'true' : 'false') );
console.log( "is 'ü' is a letter? " + (isLetter('ü') ? 'true' : 'false') );
console.log( "is 'à' is a letter? " + (isLetter('à') ? 'true' : 'false') );
console.log( "is 'ö' is a letter? " + (isLetter('ö') ? 'true' : 'false') );
console.log( "is 'ù' is a letter? " + (isLetter('ù') ? 'true' : 'false') );
console.log( "is 'é' is a letter? " + (isLetter('é') ? 'true' : 'false') );
console.log( "is 'é' is a letter? " + (isLetter('é') ? 'true' : 'false') );
console.log( "is 'ê' is a letter? " + (isLetter('ê') ? 'true' : 'false') );

It doesn't appear to work with Chinese or Japanese characters — Notre, Feb 17 '16 at 23:51

score 3 · Answer 8 · edited Feb 17 '22 at 12:42

3

So we got a first character using charAt() function then try to match it using regular expression to check if there is a letter lowercased starting from a to z and return its results as a boolean

Boolean('#Foo'.charAt(0).match(/[a-zA-Z]/)) // false
Boolean('Foo'.charAt(0).match(/[a-zA-Z]/)) // true

edited Feb 17 '22 at 12:42

GramThanos

3,572
1
22
34

answered May 22 '20 at 08:13

FDisk

8,493
2
47
52

1

Letter isn't just a to z. English is a rather important language, yes, and even English doesn't ONLY use a to z. – Gábor Jan 11 '21 at 14:13

score 2 · Answer 9 · answered Jun 04 '20 at 03:52

2

We can check also in simple way as:

function isLetter(char){
    return ( (char >= 'A' &&  char <= 'Z') ||
             (char >= 'a' &&  char <= 'z') );
}


console.log(isLetter("a"));
console.log(isLetter(3));
console.log(isLetter("H"));

answered Jun 04 '20 at 03:52

ganesh phirke

471
1
3
12

1

Thanks for the short, clear and fast answer, `&&` (priority: 6) evaluates before `||` (priority: 5), so I think you can drop the parenthesis. – kungfooman Nov 03 '21 at 11:02

Adam Gawne-Cain · Answer 10 · 2021-12-13T08:23:09.617

Here is a solution that works for all Unicode letters and works in all versions of JavaScript:

function isLetter(c) {
    if (c.length != 1 || c == '_' || c == '$')
        return false;
    if (c.toUpperCase() != c.toLowerCase())
        return true; // Speed up accepting latin letters
    if (c.charCodeAt(0) < 128)
        return false; // Speed up rejecting non-letter ASCII characters
    try {
        eval("function " + c + "(){}");
        return true;
    } catch {
        return false;
    }
}

The above code uses the fact that the first character of a JavaScript identifier must be a Unicode letter or _ or $, and cannot be anything else.

Here are some unit tests for the above function:

    assertTrue(isLetter('A'));
    assertTrue(isLetter('a'));
    assertTrue(isLetter('é'));
    assertFalse(isLetter('2'));
    assertFalse(isLetter('_'));
    assertTrue(isLetter('わ'));

Carlos Aleman · Answer 11 · 2022-03-13T06:49:49.063

2

You can use a combination of regex and test() to check if the first character is a letter

/^[a-z]/i.test(str.charAt(0))

edited Mar 13 '22 at 06:49

answered Mar 12 '22 at 18:43

Carlos Aleman

101
3
11

score 0 · Answer 12 · edited Mar 02 '20 at 13:24

I`m posting here because I didn't want to post a new question. Assuming there aren't any single character declarations in the code, you can eval() the character to cause an error and check the type of the character. Something like:

function testForLetter(character) {
  try {
    //Variable declarations can't start with digits or operators
    //If no error is thrown check for dollar or underscore. Those are the only nonletter characters that are allowed as identifiers
    eval("let " + character + ";");
    let regExSpecial = /[^\$_]/;
    return regExSpecial.test(character);
  } catch (error) {
    return false;
  }
}

console.log(testForLetter("!")); //returns false;
console.log(testForLetter("5")); //returns false;
console.log(testForLetter("ن")); //returns true;
console.log(testForLetter("_")); //returns false;

If your test returns true for underscores, then it is not useful. — Jérôme Verstrynge, Jul 30 '18 at 16:45
This introduces a potential security threat of code injection. Use only with care, if at all. — Michael Schmid, Aug 13 '20 at 08:09

score 0 · Answer 13 · answered Apr 05 '21 at 13:52

Another possibility is using the library unicode-properties. The library supports Unicode version 12. In this example the library returns the character category for a given string. And then checks if the first character of the category equals to 'L' (which obviously stands for letter).

var unicode = require("unicode-properties");
let str = "E";
console.log(unicode.getCategory(str.charCodeAt(0)).charAt(0) === "L"); // True

score -1 · Answer 14 · answered Dec 11 '19 at 05:23

-1

// to check if the given string contain alphabets    
function isPangram(sentence){
        let lowerCased = sentence.toLowerCase();
        let letters = "abcdefghijklmnopqrstuvwxyz";
        // traditional for loop can also be used
        for (let char of letters){
            if (!lowerCased.includes(char)) return false;
        }
        return true;
    }

answered Dec 11 '19 at 05:23

Roshan Rijal

17
3

2

Unicode currently has 128 000 characters covering 135 alphabets. Those 26 are a really small subset of them. – Michael Schmid May 26 '20 at 22:37

score -1 · Answer 15 · answered Apr 05 '20 at 11:41

I made a function to do this:

var isLetter = function (character) {
  if( (character.charCodeAt() >= 65 && character.charCodeAt() <= 90) || (character.charCodeAt() >= 97 && character.charCodeAt() <= 122) ) {
    return true;
  }
  else{
    return false;
  }
}

This basically verifies in the ASCII table if the code of the character refers to a Letter.

You can see the ASCII table on this link and compare columns DEC (where is the code) and symbol: https://www.ascii-code.com/

Note: My function is true only to "simple" letters (things like "Á", "é", "ç", "Ü" it will return false... but if you needed you can adapt this function to de other conditions).

score -1 · Answer 16 · answered May 01 '20 at 16:51

-1

It's possible to know if the character is a letter or not by using a standard builtin function isNaN or Number.isNaN() from ES6:

isNaN('s') // true
isNaN('-') // true
isNaN('32') // false, '32' is converted to the number 32 which is not NaN

It retruns true if the given value is not a number, otherwise false.

answered May 01 '20 at 16:51

Alexa-905

60
2

Clever, but I'm not sure it's a sufficient answer... Also, Marc suggested this in the comments... – Garrett Motzner May 01 '20 at 17:14
var sn ="string indijf &"; var nn = isNaN(sn) document.getElementById("demo").innerHTML = nn; I am passing numbers or special characters still return true. can you please add more details answers – Mr Coder May 18 '20 at 17:42
1

In which alphabet is “-” a letter? – Michael Schmid Aug 14 '20 at 10:34

score -1 · Answer 17 · answered Nov 17 '21 at 11:57

-1

You can simply use built in function isNaN , like this:

var char = 'a'; // can try '123', 'abc'
var checkNo =isNaN(char);
console.log(checkNo); // true

answered Nov 17 '21 at 11:57

Mr Nano

11
4

This is the same solution as in [this other answer](https://stackoverflow.com/a/61546897/2227743). *When answering older questions that already have answers, please make sure you provide either a novel solution or a significantly better explanation than existing answers.* – Eric Aya Nov 17 '21 at 13:46

How to check if character is a letter in Javascript?

17 Answers17

Linked

Related