UCS-2 - Revision history

Dan Tobias at 02:35, 21 May 2019

2019-05-21T02:35:57Z

Dan Tobias at 16:18, 19 May 2019

2019-05-19T16:18:46Z

Jsummers at 22:24, 4 March 2016

2016-03-04T22:24:28Z

Jsummers at 17:21, 8 November 2013

2013-11-08T17:21:45Z

Jsummers at 23:34, 24 September 2013

2013-09-24T23:34:03Z

Jsummers at 00:24, 12 September 2013

2013-09-12T00:24:52Z

Jsummers at 21:49, 11 September 2013

2013-09-11T21:49:32Z

Jsummers: Surrogate pairs

2013-09-11T01:16:20Z

Surrogate pairs

Dan Tobias at 23:33, 14 February 2013

2013-02-14T23:33:17Z

Jsummers: Created page with "{{FormatInfo |formattype=electronic |subcat=Character Encodings }} '''UCS-2''' is the trivial 16-bit Unicode encoding. It is considered to be obsolete. It was at one time..."

2013-02-14T17:20:59Z

Created page with "{{FormatInfo |formattype=electronic |subcat=Character Encodings }} '''UCS-2''' is the trivial 16-bit Unicode encoding. It is considered to be obsolete. It was at one time..."

New page

{{FormatInfo
|formattype=electronic
|subcat=Character Encodings
}}
'''UCS-2''' is the trivial 16-bit [[Unicode]] encoding. It is considered to be obsolete.

It was at one time the only popular Unicode encoding, so there was little need to distinguish between the terms ''Unicode'' and ''UCS-2''. If an old format specification says that text is encoded in "Unicode", it probably means UCS-2.

UCS-2 encodes a sequence of Unicode code points in a sequence of unsigned 16-bit integers, one code point per integer, in the obvious way (U+0000=0x0000, U+0001=0x0001, ..., U+FFFF=0xffff). It is only capable of encoding code points up to U+FFFF, and does not support the higher code points (U+10000 through U+10FFFF).

Since it is often necessary to encode code points into bytes, instead of 16-bit integers, there are two flavors of UCS-2 which do that: USC-2BE (big-[[Endianness|endian]]) and UCS-2LE (little-endian).

== See also ==

* [[UTF-16]]
* [[Byte Order Mark]]

@@ Line 2: / Line 2: @@
 |formattype=electronic
 |subcat=Character encoding
 |charset=ISO-10646-UCS-2
 |charsetaliases=csUnicode

@@ Line 2: / Line 2: @@
 |formattype=electronic
 |subcat=Character encoding
 }}
-'''UCS-2''' is the trivial 16-bit [[Unicode]] encoding. It was defined in versions of Unicode prior to 2.0, and is now considered to be obsolete.
+'''UCS-2''' is the trivial 16-bit [[Unicode]] encoding. It was defined in versions of Unicode prior to 2.0, and is now considered to be obsolete. It was standardized as part of ISO 10646.
 UCS-2 was at one time the only popular Unicode encoding, so there was little need to distinguish between the terms ''Unicode'' and ''UCS-2''. If an old format specification says that text is encoded in "Unicode", it probably means UCS-2.

@@ Line 19: / Line 19: @@
 ''[Note: This is not the orthodox way of explaining surrogate pairs.]''
-Although UCS-2 does not support code points beyond U+FFFF, a hack called ''surrogate pairs'' was invented to allow such code points to safely pass through UCS-2 systems (e.g. file formats, databases, programming languages) in many cases.
+Although UCS-2 does not support code points beyond U+FFFF, a hack called ''surrogate pairs'' was invented to allow such code points to safely pass through UCS-2 systems (e.g. file formats, databases, strings in some programming languages) in many cases.
 When using this hack, a code point beyond U+FFFF is encoded as two code points in the reserved range U+D800 through U+DFFF. Each of these code points is then called a ''surrogate'', and together they form a ''surrogate pair''. Assuming that the reserved code points are not used in any other way, this format is identical to [[UTF-16]].

@@ Line 3: / Line 3: @@
 |subcat=Character Encodings
 }}
-'''UCS-2''' (as originally formulated) is the trivial 16-bit [[Unicode]] encoding. It is considered to be obsolete.
+'''UCS-2''' is the trivial 16-bit [[Unicode]] encoding. It was defined in versions of Unicode prior to 2.0, and is now considered to be obsolete.
-−
-The terms ''UCS-2'' and ''[[UTF-16]]'' are sometimes used interchangeably, because the data formats end up being identical in most real-world situations.
 UCS-2 was at one time the only popular Unicode encoding, so there was little need to distinguish between the terms ''Unicode'' and ''UCS-2''. If an old format specification says that text is encoded in "Unicode", it probably means UCS-2.
 == Original format ==

@@ Line 17: / Line 17: @@
 ''[Note: This is not the orthodox way of explaining surrogate pairs.]''
-Although UCS-2 does not support codepoints beyond U+FFFF, a hack called ''surrogate pairs'' was invented to allow such codepoints to safely pass through UCS-2 systems (e.g. file formats, databases, programming languages) in many cases.
+Although UCS-2 does not support code points beyond U+FFFF, a hack called ''surrogate pairs'' was invented to allow such code points to safely pass through UCS-2 systems (e.g. file formats, databases, programming languages) in many cases.
-When using this hack, a codepoint beyond U+FFFF is encoded as two codepoints in the reserved range U+D800 through U+DFFF. Each of these codepoints is then called a ''surrogate'', and together they form a ''surrogate pair''. Assuming that the reserved codepoints are not used in any other way, this format is identical to [[UTF-16]].
+When using this hack, a code point beyond U+FFFF is encoded as two code points in the reserved range U+D800 through U+DFFF. Each of these code points is then called a ''surrogate'', and together they form a ''surrogate pair''. Assuming that the reserved code points are not used in any other way, this format is identical to [[UTF-16]].
 When converting from UCS-2 to another encoding, it is a good idea to be aware of this hack. In most cases, sequences that look like surrogate pairs should be interpreted as such. One should keep in mind that UCS-2 systems generally aren't aware of UTF-16's rules, so it might be a bad idea to blindly interpret UCS-2 data as if it were UTF-16. For example, a string containing only the single code unit 0xDFFF is valid UCS-2, but invalid UTF-16.

@@ Line 5: / Line 5: @@
 '''UCS-2''' is the trivial 16-bit [[Unicode]] encoding. It is considered to be obsolete.
-It was at one time the only popular Unicode encoding, so there was little need to distinguish between the terms ''Unicode'' and ''UCS-2''. If an old format specification says that text is encoded in "Unicode", it probably means UCS-2.
+The term ''UCS-2'' is sometimes used as a synonym for [[UTF-16]], but this article describes UCS-2 as it was originally defined.
 UCS-2 encodes a sequence of Unicode code points in a sequence of unsigned 16-bit integers, one code point per integer, in the obvious way (U+0000=0x0000, U+0001=0x0001, ..., U+FFFF=0xffff). It is only capable of encoding code points up to U+FFFF, and does not support the higher code points (U+10000 through U+10FFFF).
@@ Line 11: / Line 13: @@
 Since it is often necessary to encode code points into bytes, instead of 16-bit integers, there are two flavors of UCS-2 which do that: USC-2BE (big-[[Endianness|endian]]) and UCS-2LE (little-endian).
-== See also ==
+== Surrogate pairs ==
 * [[UTF-16]]
 * [[Byte Order Mark]]
 == External links ==
 * [http://www.unicode.org/faq/basic_q.html#14 Unicode FAQ: What is the difference between UCS-2 and UTF-16?]

← Older revision		Revision as of 23:33, 14 February 2013
Line 15:		Line 15:
	* [[UTF-16]]		* [[UTF-16]]
	* [[Byte Order Mark]]		* [[Byte Order Mark]]
		+
		+	== External links ==
		+
		+	* [http://www.unicode.org/faq/basic_q.html#14 Unicode FAQ: What is the difference between UCS-2 and UTF-16?]