JIS
Unsupported (not recognized)Category: Text · Last tested 2026-09-01
Real compatibility results for the JIS function: executed in Excel for the web, Google Sheets and LibreOffice Calc, with desktop Excel behavior from Microsoft’s official documentation (we do not run desktop Excel — Excel for the web is a different application and is executed separately). Syntax and links to that documentation are below.
Support matrix
| Engine | Documented | Live-tested | Verdict |
|---|---|---|---|
| Excel (desktop) | Yes | No — documented only | n/a |
| Excel for the web | — | Yes (recalc, 2026-09-01) | Unsupported (not recognized) |
| Google Sheets | No | Yes (Drive import, 2026-08-31) | Unsupported (not recognized) |
| LibreOffice Calc | Yes | Yes (25.8.7.3, 2026-08-31) | Supported, behaves as documented |
LibreOffice version history
We executed the same test cases under each LibreOffice release to show exactly when JIS’s support changed — not documentation claims, real results.
| LibreOffice version | Verdict | Tested |
|---|---|---|
| 24.2.0.3 | Supported, behaves as documented | 2026-08-31 |
| 24.8.7.2 | Supported, behaves as documented | 2026-08-31 |
| 25.2.0.3 | Supported, behaves as documented | 2026-08-31 |
| 25.8.7.3 | Supported, behaves as documented | 2026-08-31 |
Why isn’t JIS working in Google Sheets?
Google Sheets does not implement JIS: we imported the formula into
Sheets on 2026-08-31 and every case came back #NAME?
(unrecognized function). Sheets is a rolling service with no version to pin, so this is a
statement about the service on that date, and Google’s own
function list does not document it either. Rewrite the formula with a documented
Sheets equivalent — see the
Excel ↔ Sheets equivalents table.
Discovered quirks
-
=JIS("EXCEL") on
Excel for the web returned
#NAME?, but the documented/expected
result is EXCEL.
Provenance
Derived from the documented rule rather than from the broken example: E X C E L map to U+FF25 U+FF38 U+FF23 U+FF25 U+FF2C (FULLWIDTH LATIN CAPITAL E, X, C, E, L). That is exactly the mapping batch A's ASC cases assert in the opposite direction, and exactly the value batch C asserted for DBCS("EXCEL") on the other Windows-named half of this pair. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page.; MISMATCH vs expected: expected 'EXCEL', got '#NAME?'
-
=JIS("EXCEL") on
Excel for the web returned
#NAME?, but the documented/expected
result is EXCEL.
Provenance
The Text argument description ends: "If text does not contain any half-width English letters or katakana, text is not changed." Full-width input contains no half-width letters, so the documented answer is the argument itself -- which also makes JIS idempotent, since this string is the output of the previous case. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page.; MISMATCH vs expected: expected 'EXCEL', got '#NAME?'
-
=JIS("カナ") on
Excel for the web returned
#NAME?, but the documented/expected
result is カナ.
Provenance
The page names two classes of convertible characters: "half-width (single-byte) English letters or katakana". This case covers the second. U+FF76 HALFWIDTH KATAKANA LETTER KA and U+FF85 HALFWIDTH KATAKANA LETTER NA map to U+30AB KATAKANA LETTER KA and U+30CA KATAKANA LETTER NA. Latin-only tests would never exercise this branch, and it is the branch the function is actually named after. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page.; MISMATCH vs expected: expected 'カナ', got '#NAME?'
-
=LEN(JIS("EXCEL")) on
Excel for the web returned
#NAME?, but the documented/expected
result is 5.
Provenance
"Half-width" and "full-width" describe how many BYTES a character occupied in a legacy double-byte encoding, not how many characters there are: the conversion replaces each character with one other character. So LEN is invariant under JIS even though LENB is not -- on all four builds LENB of the full-width result is 10 against LENB 5 for the argument. Asserting LEN here separates "converted the characters" from "inserted padding". Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page.; MISMATCH vs expected: expected 5, got '#NAME?'
-
=ASC(JIS("EXCEL")) on
Excel for the web returned
#NAME?, but the documented/expected
result is EXCEL.
Provenance
ASC is documented as the inverse operation ("changes full-width (double-byte) English letters or katakana within a character string to half-width (single-byte) characters"), and batch A already executed ASC's own cases. Composing the two must return the original string. This is the strongest single check in the file: it depends on nothing but the two documented rules being inverses, and it would fail if JIS converted the wrong character class, converted only some characters, or changed the length. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page.; MISMATCH vs expected: expected 'EXCEL', got '#NAME?'
-
=JIS("EXCEL") on
Google Sheets returned
#NAME?, but the documented/expected
result is EXCEL.
Provenance
Derived from the documented rule rather than from the broken example: E X C E L map to U+FF25 U+FF38 U+FF23 U+FF25 U+FF2C (FULLWIDTH LATIN CAPITAL E, X, C, E, L). That is exactly the mapping batch A's ASC cases assert in the opposite direction, and exactly the value batch C asserted for DBCS("EXCEL") on the other Windows-named half of this pair. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page.; MISMATCH vs expected: expected 'EXCEL', got '#NAME?'
-
=JIS("EXCEL") on
Google Sheets returned
#NAME?, but the documented/expected
result is EXCEL.
Provenance
The Text argument description ends: "If text does not contain any half-width English letters or katakana, text is not changed." Full-width input contains no half-width letters, so the documented answer is the argument itself -- which also makes JIS idempotent, since this string is the output of the previous case. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page.; MISMATCH vs expected: expected 'EXCEL', got '#NAME?'
-
=JIS("カナ") on
Google Sheets returned
#NAME?, but the documented/expected
result is カナ.
Provenance
The page names two classes of convertible characters: "half-width (single-byte) English letters or katakana". This case covers the second. U+FF76 HALFWIDTH KATAKANA LETTER KA and U+FF85 HALFWIDTH KATAKANA LETTER NA map to U+30AB KATAKANA LETTER KA and U+30CA KATAKANA LETTER NA. Latin-only tests would never exercise this branch, and it is the branch the function is actually named after. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page.; MISMATCH vs expected: expected 'カナ', got '#NAME?'
-
=LEN(JIS("EXCEL")) on
Google Sheets returned
#NAME?, but the documented/expected
result is 5.
Provenance
"Half-width" and "full-width" describe how many BYTES a character occupied in a legacy double-byte encoding, not how many characters there are: the conversion replaces each character with one other character. So LEN is invariant under JIS even though LENB is not -- on all four builds LENB of the full-width result is 10 against LENB 5 for the argument. Asserting LEN here separates "converted the characters" from "inserted padding". Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page.; MISMATCH vs expected: expected 5, got '#NAME?'
-
=ASC(JIS("EXCEL")) on
Google Sheets returned
#NAME?, but the documented/expected
result is EXCEL.
Provenance
ASC is documented as the inverse operation ("changes full-width (double-byte) English letters or katakana within a character string to half-width (single-byte) characters"), and batch A already executed ASC's own cases. Composing the two must return the original string. This is the strongest single check in the file: it depends on nothing but the two documented rules being inverses, and it would fail if JIS converted the wrong character class, converted only some characters, or changed the length. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page.; MISMATCH vs expected: expected 'EXCEL', got '#NAME?'
Executed test cases
Excel for the web (executed 2026-09-01 via OneDrive recalculation)
These values come from Excel for the web, not from desktop Excel. They are two different implementations of the calculation engine, and this run measured only the web one: the corpus was uploaded to OneDrive as .xlsx, recalculated by Excel for the web on open, and downloaded again for readback. Excel for the web is a rolling service with no pinnable version, so the run is identified by its date. Where a value here disagrees with the Expected column — which is Microsoft’s documentation of the desktop product — we cannot tell you whether the web engine diverges from the desktop one or the documentation is wrong about both, because we do not run desktop Excel.
| Formula | Description | Result | Expected | Verdict |
|---|---|---|---|---|
| =JIS("EXCEL") | The page's own example argument: five half-width English letters converted to full-width | #NAME? | EXCELProvenanceDerived from the documented rule rather than from the broken example: E X C E L map to U+FF25 U+FF38 U+FF23 U+FF25 U+FF2C (FULLWIDTH LATIN CAPITAL E, X, C, E, L). That is exactly the mapping batch A's ASC cases assert in the opposite direction, and exactly the value batch C asserted for DBCS("EXCEL") on the other Windows-named half of this pair. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Mismatch |
| =JIS("EXCEL") | Text that is already full-width, which the page says is left alone | #NAME? | EXCELProvenanceThe Text argument description ends: "If text does not contain any half-width English letters or katakana, text is not changed." Full-width input contains no half-width letters, so the documented answer is the argument itself -- which also makes JIS idempotent, since this string is the output of the previous case. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Mismatch |
| =JIS("カナ") | Half-width katakana, the other character class the page names explicitly | #NAME? | カナProvenanceThe page names two classes of convertible characters: "half-width (single-byte) English letters or katakana". This case covers the second. U+FF76 HALFWIDTH KATAKANA LETTER KA and U+FF85 HALFWIDTH KATAKANA LETTER NA map to U+30AB KATAKANA LETTER KA and U+30CA KATAKANA LETTER NA. Latin-only tests would never exercise this branch, and it is the branch the function is actually named after. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Mismatch |
| =LEN(JIS("EXCEL")) | The conversion is character-for-character, so the character count is unchanged | #NAME? | 5Provenance"Half-width" and "full-width" describe how many BYTES a character occupied in a legacy double-byte encoding, not how many characters there are: the conversion replaces each character with one other character. So LEN is invariant under JIS even though LENB is not -- on all four builds LENB of the full-width result is 10 against LENB 5 for the argument. Asserting LEN here separates "converted the characters" from "inserted padding". Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Mismatch |
| =ASC(JIS("EXCEL")) | Round trip: full-width conversion followed by the documented inverse | #NAME? | EXCELProvenanceASC is documented as the inverse operation ("changes full-width (double-byte) English letters or katakana within a character string to half-width (single-byte) characters"), and batch A already executed ASC's own cases. Composing the two must return the original string. This is the strongest single check in the file: it depends on nothing but the two documented rules being inverses, and it would fail if JIS converted the wrong character class, converted only some characters, or changed the length. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Mismatch |
Google Sheets (executed 2026-08-31 via Drive import)
Google Sheets is a rolling service with no pinnable version, so this run is identified by its date. The corpus was imported to Drive as .xlsx, recalculated by Sheets, and exported back for readback.
| Formula | Description | Result | Expected | Verdict |
|---|---|---|---|---|
| =JIS("EXCEL") | The page's own example argument: five half-width English letters converted to full-width | #NAME? | EXCELProvenanceDerived from the documented rule rather than from the broken example: E X C E L map to U+FF25 U+FF38 U+FF23 U+FF25 U+FF2C (FULLWIDTH LATIN CAPITAL E, X, C, E, L). That is exactly the mapping batch A's ASC cases assert in the opposite direction, and exactly the value batch C asserted for DBCS("EXCEL") on the other Windows-named half of this pair. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Mismatch |
| =JIS("EXCEL") | Text that is already full-width, which the page says is left alone | #NAME? | EXCELProvenanceThe Text argument description ends: "If text does not contain any half-width English letters or katakana, text is not changed." Full-width input contains no half-width letters, so the documented answer is the argument itself -- which also makes JIS idempotent, since this string is the output of the previous case. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Mismatch |
| =JIS("カナ") | Half-width katakana, the other character class the page names explicitly | #NAME? | カナProvenanceThe page names two classes of convertible characters: "half-width (single-byte) English letters or katakana". This case covers the second. U+FF76 HALFWIDTH KATAKANA LETTER KA and U+FF85 HALFWIDTH KATAKANA LETTER NA map to U+30AB KATAKANA LETTER KA and U+30CA KATAKANA LETTER NA. Latin-only tests would never exercise this branch, and it is the branch the function is actually named after. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Mismatch |
| =LEN(JIS("EXCEL")) | The conversion is character-for-character, so the character count is unchanged | #NAME? | 5Provenance"Half-width" and "full-width" describe how many BYTES a character occupied in a legacy double-byte encoding, not how many characters there are: the conversion replaces each character with one other character. So LEN is invariant under JIS even though LENB is not -- on all four builds LENB of the full-width result is 10 against LENB 5 for the argument. Asserting LEN here separates "converted the characters" from "inserted padding". Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Mismatch |
| =ASC(JIS("EXCEL")) | Round trip: full-width conversion followed by the documented inverse | #NAME? | EXCELProvenanceASC is documented as the inverse operation ("changes full-width (double-byte) English letters or katakana within a character string to half-width (single-byte) characters"), and batch A already executed ASC's own cases. Composing the two must return the original string. This is the strongest single check in the file: it depends on nothing but the two documented rules being inverses, and it would fail if JIS converted the wrong character class, converted only some characters, or changed the length. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Mismatch |
LibreOffice Calc 25.8.7.3 (tested 2026-08-31)
| Formula | Description | Result | Expected | Verdict |
|---|---|---|---|---|
| =JIS("EXCEL") | The page's own example argument: five half-width English letters converted to full-width | EXCEL | EXCELProvenanceDerived from the documented rule rather than from the broken example: E X C E L map to U+FF25 U+FF38 U+FF23 U+FF25 U+FF2C (FULLWIDTH LATIN CAPITAL E, X, C, E, L). That is exactly the mapping batch A's ASC cases assert in the opposite direction, and exactly the value batch C asserted for DBCS("EXCEL") on the other Windows-named half of this pair. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Matched |
| =JIS("EXCEL") | Text that is already full-width, which the page says is left alone | EXCEL | EXCELProvenanceThe Text argument description ends: "If text does not contain any half-width English letters or katakana, text is not changed." Full-width input contains no half-width letters, so the documented answer is the argument itself -- which also makes JIS idempotent, since this string is the output of the previous case. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Matched |
| =JIS("カナ") | Half-width katakana, the other character class the page names explicitly | カナ | カナProvenanceThe page names two classes of convertible characters: "half-width (single-byte) English letters or katakana". This case covers the second. U+FF76 HALFWIDTH KATAKANA LETTER KA and U+FF85 HALFWIDTH KATAKANA LETTER NA map to U+30AB KATAKANA LETTER KA and U+30CA KATAKANA LETTER NA. Latin-only tests would never exercise this branch, and it is the branch the function is actually named after. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Matched |
| =LEN(JIS("EXCEL")) | The conversion is character-for-character, so the character count is unchanged | 5 | 5Provenance"Half-width" and "full-width" describe how many BYTES a character occupied in a legacy double-byte encoding, not how many characters there are: the conversion replaces each character with one other character. So LEN is invariant under JIS even though LENB is not -- on all four builds LENB of the full-width result is 10 against LENB 5 for the argument. Asserting LEN here separates "converted the characters" from "inserted padding". Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Matched |
| =ASC(JIS("EXCEL")) | Round trip: full-width conversion followed by the documented inverse | EXCEL | EXCELProvenanceASC is documented as the inverse operation ("changes full-width (double-byte) English letters or katakana within a character string to half-width (single-byte) characters"), and batch A already executed ASC's own cases. Composing the two must return the original string. This is the strongest single check in the file: it depends on nothing but the two documented rules being inverses, and it would fail if JIS converted the wrong character class, converted only some characters, or changed the length. Microsoft's JIS page states the rule twice: "converts half-width (single-byte) letters within a character string to full-width (double-byte) characters", and "For Japanese, this function changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters". It also warns that "The name of the function (and the characters that it converts) depends upon your language settings"; this harness runs under LC_ALL=en_US.UTF-8, a non-DBCS default language, which is stated here rather than assumed away. THE PAGE'S PUBLISHED EXAMPLES ARE UNUSABLE AS WRITTEN, so no figure is copied from them. The first reads, in the raw page source, '=JIS("EXCEL") equals "EXCEL"' -- both sides identical ASCII, i.e. the argument coming back unchanged, which directly contradicts the page's own rule since "EXCEL" is five half-width English letters. (The full-width result appears to have been flattened to ASCII somewhere in publishing; the identical defect sits on the DBCS page, which batch C recorded, and the ASC page carries the same line as its CORRECT behaviour.) The second example is rendered entirely as inline GIF images (media/fe337.gif and siblings), so no literal argument or result can be read out of it at all. Every value in this file is therefore derived from the stated rule and from the Unicode halfwidth/fullwidth block, not copied from the page. |
Matched |
Docs & syntax
- Excel (desktop): official documentation
- LibreOffice Calc: official documentation
Where JIS behaves differently
- When the documentation is wrong: 29 vendor doc defects found by execution
Independent derivation across 586 executed functions found 29 places where a vendor's own page is contradicted by its own inputs, its own table, or the live engine: 23 Microsoft, 5 Google, 1 LibreOffice. Includes T.INV.2T's doubly-wrong Remark, DISC's stale figure, ISDATE's page against the live engine, and RAWSUBTRACT's help against LibreOffice's own result.