What is the range of Unicode Printable Characters?

Asked 22/9, 2010 at 14:14 Answered 2/9, 2021 at 4:49

Solved unicode character-encoding unicode-string

Can anybody please tell me what is the range of Unicode printable characters? [e.g. Ascii printable character range is \u0020 - \u007f]

Rambow answered 22/9, 2010 at 14:14 Comment(5)

\u0000 - \u0020 are also unprintable in Unicode – Foothold 22/9, 2010 at 14:22

More like \u0020 - \u007e – Vinegarroon 26/8, 2013 at 12:57

You sure got a lot of hate for this question. I like the idea. – Voltmeter 7/1, 2016 at 8:52

It's a bit odd to use a programming language notation for UTF-16 code units to give a range of ASCII codepoints (but numerically and character-wise, it does work out). – Distrait 24/11, 2018 at 21:34

The question is extremely straightforward, but the answer is not. So naturally everyone will claim the question is invalid. This is a question about Unicode, not about fonts (afaik), so all that matters is if the symbol could conceptually be drawn. Control characters, zero width characters, and modifiers are clearly excluded from this list. \u0020 and other spaces (?) are an edge case, but that does not make the question unanswerable. Anyway, I recommend visiting en.wikipedia.org/wiki/List_of_Unicode_characters to further your investigation on this matter. – Doge 2/5, 2021 at 15:58

See, http://en.wikipedia.org/wiki/Unicode_control_characters

You might want to look especially at C0 and C1 control character http://en.wikipedia.org/wiki/C0_and_C1_control_codes

The wiki says, the C0 control character is in the range U+0000—U+001F and U+007F (which is the same range as ASCII) and C1 control character is in the range U+0080—U+009F

other than C-control character, Unicode also has hundreds of formatting control characters, e.g. zero-width non-joiner, which makes character spacing closer, or bidirectional text control. This formatting control characters are rather scattered.

More importantly, what are you doing that requires you to know Unicode's non-printable characters? More likely than not, whatever you're trying to do is the wrong approach to solve your problem.

Turbit answered 22/9, 2010 at 14:27 Comment(7)

I want to create a random unicode string generator which will generate printable characters. – Rambow 22/9, 2010 at 14:29

Printable by whom? Do you want to include eg. all the Chinese characters? Many users won't have fonts for them, so ‘printing’ them would give you nothing, a blank box, or some other useless replacement character. – Leading 22/9, 2010 at 20:29

One good reason is to avoid security exploits: bugzilla.mozilla.org/show_bug.cgi?id=968576 – Sherburne 7/4, 2015 at 20:46

@Leading My browser can display Chinese characters. Not sure if that was the case in 2010 though. – Schematize 16/5, 2018 at 10:55

"What are you doing that requires you to know Unicode's non-printable characters?" User pastes a number from Windows calculator into a text box (e.g. ‭165063688192‬). But in reality the string will be: U+202D 165063688192 U+202C. Thus the string will be unparsable, and nobody will be able to figure out why. So thanks to a feature nobody wanted: we now need to write the TrimStrimToPrintable(String s) function. – Peritonitis 7/1, 2020 at 3:14

According to the wikipedia page you linked, 0x7F is "Not technically part of the C0 control character range". Can you clarify? – Weimaraner 21/7, 2020 at 8:46

@SOFe: Direct quote from the first link in my answer: "The control characters U+0000–U+001F and U+007F come from ASCII." You'll probably have to ask the Wikipedia author for correction/clarification on that one. Or ask that as a new separate question here on SO, as I don't know enough about Unicode to have an opinion on what you're asking. – Turbit 21/7, 2020 at 8:55

This is an old question, but it is still valid and I think there is more to usefully, but briefly, say on the subject than is covered by existing answers.

Unicode

Unicode defines properties for characters.

One of these properties is "General Category" which has Major classes and subclasses. The Major classes are Letter, Mark, Punctuation, Symbol, Separator, and Other.

By knowing the properties of your characters, you can decide whether you consider them printable in your particular context.

You must always remember that terms like "character" and "printable" are often difficult and have interesting edge-cases.

Programming Language support

Some programming languages assist with this problem.

For example, the Go language has a "unicode" package which provides many useful Unicode-related functions including these two:

func IsGraphic(r rune) bool

IsGraphic reports whether the rune is defined as a Graphic by Unicode. Such  
characters include letters, marks, numbers, punctuation, symbols, and spaces, 
from categories L, M, N, P, S, Zs. 

func IsPrint(r rune) bool

IsPrint reports whether the rune is defined as printable by Go. Such  
characters include letters, marks, numbers, punctuation, symbols, and  
the ASCII space character, from categories L, M, N, P, S and the ASCII  
space character. This categorization is the same as IsGraphic except  
that the only spacing character is ASCII space, U+0020.

Notice that it says "defined as printable by Go" not by "defined as printable by Unicode". It is almost as if there are some depths the wizards at Unicode dare not plumb.

Printable

The more you learn about Unicode, the more you realise how unexpectedly diverse and unfathomably weird human writing systems are.

In particular whether a particular "character" is printable is not always obvious.

Is a zero-width space printable? When is a hyphenation point printable? Are there characters whose printability depends on their position in a word or on what characters are adjacent to them? Is a combining-character always printable?

Footnotes

ASCII printable character range is \u0020 - \u007f

No it isn't. \u007f is DEL which is not normally considered a printable character. It is, for example, associated with the keyboard key labelled "DEL" whose earliest purpose was to command the deletion of a character from some medium (display, file etc).

In fact many 8-bit character sets have many non-consecutive ranges which are non-printable. See for example C0 and C1 controls.

Ceballos answered 23/11, 2018 at 16:19 Comment(1)

DEL was funnier when it was labeled RUBOUT (on the TTYs I used when starting out long ago). – Radiosensitive 1/3, 2021 at 19:42

First, you should remove the word 'UTF8' in your question, it's not pertinent (UTF8 is just one of the encodings of Unicode, it's something orthogonal to your question).

Second: the meaning of "printable/non printable" is less clear in Unicode. Perhaps you mean a "graphical character" ; and one can even dispute if a space is printable/graphical. The non-graphical characters would consist, basically, of control characters: the range 0x00-0x0f plus some others that are scattered.

Anyway, the vast majority of Unicode characters (more than 200.000) are "graphical". But this certainly does not imply that they are printable in your environment.

It seems to me a bad idea, if you intend to generate a "random printable" unicode string, to try to include all "printable" characters.

Cangue answered 22/9, 2010 at 14:55 Comment(0)

What you should do is pick a font, and then generate a list of which Unicode characters have glyphs defined for your font. You can use a font library like freetype to test glyphs (test for FT_Get_Char_Index(...) != 0).

Rouvin answered 3/5, 2011 at 17:48 Comment(0)

What characters are valid?

At present, Unicode is defined as starting from U+0000 and ending at U+10FFFF. The first block, Basic Latin, spans U+0000 to U+007F and the last block, Supplementary Private Use Area-B, spans U+100000 to 10FFFF. If you want to see all of these blocks, see here: Wikipedia.org: Unicode Block; List of Blocks.

Let's break down what's valid/invalid in the Latin Block1.

The Latin Block: TLDR

If you're interested in filtering out either invisible characters, you'll want to filter out:

U+0000 to U+0008: Control
U+000E to U+001F: Device (i.e., Control)
U+007F: Delete (Control)
U+008D to U+009F: Device (i.e., Control)

The Latin Block: Full Ranges

Here's the Latin block, broken up into smaller sections...

U+0000 to U+0008: Control
U+0009 to U+000C: Space
U+000E to U+001F: Device (i.e., Control)
U+0020: Space
U+0021 to U+002F: Symbols
U+0030 to U+0039: Numbers
U+003A to U+0040: Symbols
U+0041 to U+005A: Uppercase Letters
U+005B to U+0060: Symbols
U+0061 to U+007A: Lowercase Letters
U+007B to U+007E: Symbols
U+007F: Delete (Control)
U+0080 to U+008C: Latin1-Supplement symbols.
U+008D to U+009F: Device (i.e., Control)
U+00A0: Non-breaking space. (i.e.,  )
U+00A1 to U+00BF: Symbols.
U+00C0 to U+00FF: Accented characters.

The Other Blocks

Unicode is famous for supporting non-Latin character sets, so what are these other blocks? This is just a broad overview, see the wikipedia.org page for the full, complete list.

Latin1 & Latin1-Related Blocks

U+0000 to U+007F : Basic Latin
U+0080 to U+00FF : Latin-1 Supplement
U+0100 to U+017F : Latin Extended-A
U+0180 to U+024F : Latin Extended-B

Combinable blocks

U+0250 to U+036F: 3 Blocks.

Non-Latin, Language blocks

U+0370 to U+1C7F: 55 Blocks.

Non-Latin, Language Supplement blocks

U+1C80 to U+209F: 11 Blocks.

Symbol blocks

U+20A0 to U+2BFF: 22 Blocks.

Ancient Language blocks

U+2C00 to U+2C5F: 1 Block (Glagolitic).

Language Extensions blocks

U+2C60 to U+FFEF: 66 Blocks.

Special blocks

U+FFF0 to U+FFFF: 1 Block (Specials).

Mixed answered 2/3, 2021 at 20:47 Comment(0)

Taking the opposite approach to @HoldOffHunger, it might be easier to list the ranges of non-printable characters, and use not to test if a character is printable.

In the style of Regex (so if you wanted printable characters, place a ^):

[\u0000-\u0008\u000B-\u001F\u007F-\u009F\u2000-\u200F\u2028-\u202F\u205F-\u206F\u3000\uFEFF]

Which accounts for things like separator spaces and joiners

Note that unlike their answer which is a whitelist that ignores all non-latin languages, this blacklist wont permit non-printable characters just because they're in blocks with printable characters (their answer wholly includes Non-Latin, Language Supplement blocks as 'printable', even though it contains things like 'zero-width non-joiner'..).

Be aware though, that if using this or any other solution, for sanitation for example, you may want to do something more nuanced than a blanket replace.
Arguably in that case, non-breaking spaces should change to space, not be removed, and invisible separator should be replaced with comma conditionally.

Then there's invalid character ranges, either [yet] unused or reserved for encoding purposes, and language-specific variation selectors..

NB when using regular expressions, that you enable unicode awareness if it isn't that way by default (for javascript it's via /.../u).

You can tell if you have it correct by attempting to create the regular expression with some multi-byte character ranges.
For example, the above, plus the invalid character range \u{E0100}-\u{E01EF} in javascript:

/[\u0000-\u0008\u000B-\u001F\u007F-\u009F\u2000-\u200F\u2028-\u202F\u205F-\u206F\u3000\uFEFF\u{E0100}-\u{E01EF}]/u

Without u \u{E0100}-\u{E01EF} equates to \uDB40(\uDD00-\uDB40)\uDDEF, not (\uDB40\uDD00)-(\uDB40\uDDEF), and if replacing you should always enable u even when not including multbyte unicode in the regex itself as you might break surrogate pairs that exist in the text.

Gapes answered 2/9, 2021 at 4:49 Comment(0)

One approach is to render each character to a texture and manually check if it is visible. This solution excludes spaces.

I've written such a program and used it to determine there are roughly 467241 printable characters within the first 471859 code points. I've selected this number because it covers all of the first 4 Planes of Unicode, which seem to contain all printable characters. See https://en.wikipedia.org/wiki/Plane_(Unicode)

I would much like to refine my program to produce the list of ranges, but for now here's what I am working with for anyone who needs immediate answers:

https://editor.p5js.org/SamyBencherif/sketches/_OE8Y3kS9

I am posting this tool because I think this question attracts a lot of people who are looking for slightly different applications of knowing printable ranges. Hopefully this is useful, even though it does not fully answer the question.

Doge answered 2/5, 2021 at 17:7 Comment(0)

-4

The printable Unicode character range, excluding the hex, is 32 to 126 in the int datatype.

Schwitzer answered 28/11, 2020 at 7:46 Comment(1)

This claim is clearly wrong; Unicode has nearly 150,000 printable symbols at time of writing (Unicode 13.0). See en.wikipedia.org/wiki/Unicode. – Uncounted 28/11, 2020 at 20:7

-9

Unicode, stict term, has no range. Numbers can go infinite.

What you gave is not UTF8 which has 1 byte for ASCII characters.

As for the range, I believe there is no range of printable characters. It always evolves. Check the page I gave above.

Eventempered answered 22/9, 2010 at 14:21 Comment(1)

Afaik Unicode is only defined until 0x10ffff, beyond that no codepoints will be assigned – Antione 3/12, 2010 at 6:42

Hot tags

Godot Unity Godot Help Programming Godot 4.X GUI GDScript 3D 2D Physics CSharp Godot 3.X VR XR Projects C++