Hướng dẫn javascript accented characters

In JavaScript I create a string which has accented characters such as 'ò' or 'à', e.g. "ò à"

I seem to be unable to create text nodes in html which show the accented characters: if i pass them directly, i get "white question mark in black rhombus"; if i replace the accented characters by the corresponding html entities, i get the entities printed verbatim.
This function

function showAccents() {
  s1="ò à";
  s2 = s1.replace(/ò/, "ò").replace(/à/, "à");;
  var eD = document.getElementById("accent1");
  var eHT1 = document.createTextNode(s1);
  var eHT2 = document.createTextNode(s2);
  eD.appendChild(eHT1);
  eD.appendChild(eHT2);
}

Produces the following text:

� �ò à

How do I have to convert the string to get accented characters in HTML?

Hướng dẫn javascript accented characters

sdgluck

22.7k7 gold badges70 silver badges87 bronze badges

asked Feb 22, 2015 at 13:16

2

You are probably missing a page encoding. Make sure your HTML includes either this:


Or this (HTML5):


EDIT

It now seems that the problem is the encoding of your Javascript file. It too needs to be Unicode (encoded as UTF8 for example), as if it is saved in a non-Unicode encoding you are likely to have ò and à misinterpreted by the browser which might read these with a different encoding. Just open it in a text editor and save it as UTF8 (doing so will include a BOM at the start of the file that will specify its encoding, solving the problem)

answered Feb 22, 2015 at 13:20

ClafouClafou

15.1k7 gold badges56 silver badges89 bronze badges

7

It turned out my xemacs encodes with ISO-8859-1; the current version can not be easily set to UTF-8.

The solution was to change the encoding info from "utf-8" to "iso-8859-1" in the xhtml's header:


    
  

  

Groups and backreferences

Groups group multiple patterns as a whole, and capturing groups provide extra submatch information when using a regular expression pattern to match against a string. Backreferences refer to a previously captured group in the same regular expression.

Quantifiers

Indicate numbers of characters or expressions to match.

Unicode property escapes

Distinguish based on unicode character properties, for example, upper- and lower-case letters, math symbols, and punctuation.

If you want to look at all the special characters that can be used in regular expressions in a single table, see the following:

Escaping

If you need to use any of the special characters literally (actually searching for a "*", for instance), you must escape it by putting a backslash in front of it. For instance, to search for "a" followed by "*" followed by "b", you'd use /a\*b/ — the backslash "escapes" the "*", making it literal instead of special.

Similarly, if you're writing a regular expression literal and need to match a slash ("/"), you need to escape that (otherwise, it terminates the pattern). For instance, to search for the string "/example/" followed by one or more alphabetic characters, you'd use /\/example\/[a-z]+/i—the backslashes before each slash make them literal.

To match a literal backslash, you need to escape the backslash. For instance, to match the string "C:\" where "C" can be any letter, you'd use /[A-Z]:\\/ — the first backslash escapes the one after it, so the expression searches for a single literal backslash.

If using the RegExp constructor with a string literal, remember that the backslash is an escape in string literals, so to use it in the regular expression, you need to escape it at the string literal level. /a\*b/ and new RegExp("a\\*b") create the same expression, which searches for "a" followed by a literal "*" followed by "b".

If escape strings are not already part of your pattern you can add them using String.prototype.replace():

function escapeRegExp(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
}

The "g" after the regular expression is an option or flag that performs a global search, looking in the whole string and returning all matches. It is explained in detail below in Advanced Searching With Flags.

Why isn't this built into JavaScript? There is a proposal to add such a function to RegExp.

Using parentheses

Parentheses around any part of the regular expression pattern causes that part of the matched substring to be remembered. Once remembered, the substring can be recalled for other use. See Groups and backreferences for more details.

Using regular expressions in JavaScript

Regular expressions are used with the RegExp methods test() and exec() and with the String methods match(), replace(), search(), and split().

When you want to know whether a pattern is found in a string, use the test() or search() methods; for more information (but slower execution) use the exec() or match() methods. If you use exec() or match() and if the match succeeds, these methods return an array and update properties of the associated regular expression object and also of the predefined regular expression object, RegExp. If the match fails, the exec() method returns null (which coerces to false).

In the following example, the script uses the exec() method to find a match in a string.

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

If you do not need to access the properties of the regular expression, an alternative way of creating myArray is with this script:

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

(See Using the global search flag with exec() for further info about the different behaviors.)

If you want to construct the regular expression from a string, yet another alternative is this script:

const myRe = new RegExp('d(b+)d', 'g');
const myArray = myRe.exec('cdbbdbsbz');

With these scripts, the match succeeds and returns the array and updates the properties shown in the following table.

As shown in the second form of this example, you can use a regular expression created with an object initializer without assigning it to a variable. If you do, however, every occurrence is a new regular expression. For this reason, if you use this form without assigning it to a variable, you cannot subsequently access the properties of that regular expression. For example, assume you have this script:

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${myRe.lastIndex}`);

// "The value of lastIndex is 5"

However, if you have this script:

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${/d(b+)d/g.lastIndex}`);

// "The value of lastIndex is 0"

The occurrences of /d(b+)d/g in the two statements are different regular expression objects and hence have different values for their lastIndex property. If you need to access the properties of a regular expression created with an object initializer, you should first assign it to a variable.

Advanced searching with flags

Regular expressions have optional flags that allow for functionality like global searching and case-insensitive searching. These flags can be used separately or together in any order, and are included as part of the regular expression.

To include a flag with the regular expression, use this syntax:

const re = /pattern/flags;

or

const re = new RegExp('pattern', 'flags');

Note that the flags are an integral part of a regular expression. They cannot be added or removed later.

For example, re = /\w+\s/g creates a regular expression that looks for one or more characters followed by a space, and it looks for this combination throughout the string.

const re = /\w+\s/g;
const str = 'fee fi fo fum';
const myArray = str.match(re);
console.log(myArray);

// ["fee ", "fi ", "fo "]

You could replace the line:

with:

const re = new RegExp('\\w+\\s', 'g');

and get the same result.

The m flag is used to specify that a multiline input string should be treated as multiple lines. If the m flag is used, ^ and $ match at the start or end of any line within the input string instead of the start or end of the entire string.

Using the global search flag with exec()

RegExp.prototype.exec() method with the g flag returns each match and its position iteratively.

const str = 'fee fi fo fum';
const re = /\w+\s/g;

console.log(re.exec(str)); // ["fee ", index: 0, input: "fee fi fo fum"]
console.log(re.exec(str)); // ["fi ", index: 4, input: "fee fi fo fum"]
console.log(re.exec(str)); // ["fo ", index: 7, input: "fee fi fo fum"]
console.log(re.exec(str)); // null

In contrast, String.prototype.match() method returns all matches at once, but without their position.

console.log(str.match(re)); // ["fee ", "fi ", "fo "]

Using unicode regular expressions

The "u" flag is used to create "unicode" regular expressions; that is, regular expressions which support matching against unicode text. This is mainly accomplished through the use of Unicode property escapes, which are supported only within "unicode" regular expressions.

For example, the following regular expression might be used to match against an arbitrary unicode "word":

There are a number of other differences between unicode and non-unicode regular expressions that one should be aware of:

  • Unicode regular expressions do not support so-called "identity escapes"; that is, patterns where an escaping backslash is not needed and effectively ignored. For example, /\a/ is a valid regular expression matching the letter 'a', but /\a/u is not.
  • Curly brackets need to be escaped when not used as quantifiers. For example, /{/ is a valid regular expression matching the curly bracket '{', but /{/u is not — instead, the bracket should be escaped and /\{/u should be used instead.
  • The - character is interpreted differently within character classes. In particular, for Unicode regular expressions, - is interpreted as a literal - (and not as part of a range) only if it appears at the start or end of the character class. For example, /[\w-:]/ is a valid regular expression matching a word character, a -, or :, but /[\w-:]/u is an invalid regular expression, as \w to : is not a well-defined range of characters.

Unicode regular expressions have different execution behavior as well. RegExp.prototype.unicode contains more explanation about this.

Examples

Note: Several examples are also available in:

  • The reference pages for exec(), test(), match(), matchAll(), search(), replace(), split()
  • The guide articles: character classes, assertions, groups and backreferences, quantifiers, Unicode property escapes

Using special characters to verify input

In the following example, the user is expected to enter a phone number. When the user presses the "Check" button, the script checks the validity of the number. If the number is valid (matches the character sequence specified by the regular expression), the script shows a message thanking the user and confirming the number. If the number is invalid, the script informs the user that the phone number is not valid.

The regular expression looks for:

  1. the beginning of the line of data: ^
  2. followed by three numeric characters \d{3} OR | a left parenthesis \(, followed by three digits \d{3}, followed by a close parenthesis \), in a non-capturing group (?:)
  3. followed by one dash, forward slash, or decimal point in a capturing group ()
  4. followed by three digits \d{3}
  5. followed by the match remembered in the (first) captured group \1
  6. followed by four digits \d{4}
  7. followed by the end of the line of data: $

HTML

<p>
  Enter your phone number (with area code) and then click "Check".
  <br />
  The expected format is like ###-###-####.
p>
<form id="form">
  <input id="phone" />
  <button type="submit">Checkbutton>
form>
<p id="output">p>

JavaScript

const form = document.querySelector('#form');
const input = document.querySelector('#phone');
const output = document.querySelector('#output');

const re = /^(?:\d{3}|\(\d{3}\))([-/.])\d{3}\1\d{4}$/;

function testInfo(phoneInput) {
  const ok = re.exec(phoneInput.value);

  output.textContent = ok
    ? `Thanks, your phone number is ${ok[0]}`
    : `${phoneInput.value} isn't a phone number with area code!`;
}

form.addEventListener('submit', (event) => {
  event.preventDefault();
  testInfo(input);
});

Result

RegExr

An online tool to learn, build, & test Regular Expressions.

Regex tester

An online regex builder/debugger

Regex interactive tutorial

An online interactive tutorials, Cheatsheet, & Playground.

Regex visualizer

An online visual regex tester.

  • « Previous
  • Next »