Newsgroup: it.comp.lang.javascript
Titolo: sostituire gli apici

come faccio a sostituire tutti gli apici di una stringa con \'?
esempio:
l'acqua --> l\'acqua
l'ombrello --> l\'ombrello
grazie

 cerchero` un'altra donna dentro ai sogni di Tarzan...

 usa una regex (Regular Expression)
var str = "l'acqua"
str = str.replace(/'/, "\\'")
comunque ecco la documentazione MS sulle Regular Expression e su replace():
-----
REPLACE METHOD
[Description]
Returns a copy of a string with text replaced using a regular expression.
[Syntax]
stringObj.replace(rgExp, replaceText)
The replace method syntax has these parts:
stringObj (Required): The String object or literal on which to perform the
replace. This object is not modified by the replace method.
rgExp (Required): A Regular Expression object describing what to search for.
replaceText (Required): A String object or literal containing the text to
replace for every successful match of rgExp in stringObj.
[Remarks]
The result of the replace method is a copy of stringObj after all replacements
have been made.
The method updates the contents of the RegExp object.
The following example illustrates the use of the replace method:
function ReplaceDemo()
{
  var r, re;
  var s = "The quick brown fox jumped over the lazy yellow dog.";
  re = /fox/i;
  r = s.replace(re, "pig");
  return(r);
}
In addition, the replace method can also replace subexpressions in the pattern.
The following example swaps each pair of words in the string:
function ReplaceDemo()
{
  var r, re;
  var s = "The quick brown fox jumped over the lazy yellow dog.";
  re = /(\S+)(\s+)(\S+)/g;
  r = s.replace(re, "$3$2$1"); // Swap each pair of words.
  return(r);
}
-----
REGULAR EXPRESSION OBJECT
[Description]
Contains a regular expression pattern.
[Syntax 1]
var regularexpression = /pattern/[switch]
[Syntax 2]
var regularexpression = new RegExp("pattern",["switch"])
The regular expression object syntax has these parts:
 - pattern (Required): The regular expression pattern to use. If you use Syntax
1, delimit the pattern by "/" characters. If you use Syntax 2, enclose the
pattern in quotation marks.
 - switch (Optional): Enclose switch in quotation marks if you use Syntax 2.
Available switches are:
    i (ignore case)
    g (global search for all occurrences of pattern)
    gi (global search, ignore case)
[Remarks]
Regular Expression objects store patterns used when searching strings for
character combinations. After the Regular Expression object is created, it is
either passed to a string method, or a string is passed to one of the regular
expression methods. Information about the most recent search performed is stored
in the RegExp object.
Use Syntax 1 when you know the search string ahead of time. Use Syntax 2 when
the search string is changing frequently, or is unknown, such as strings taken
from user input.
The pattern argument is compiled into an internal format before use. For Syntax
1, pattern is compiled as the script is loaded. For Syntax 2, pattern is
compiled just before use, or when the compile method is called.
-----
REGULAR EXPRESSION SYNTAX
[Description]
Special characters and sequences are used in writing patterns for regular
expressions. The following table describes these characters and includes short
examples showing how the characters are used.
\  - Marks the next character as either a special character or a literal. For
example, "n" matches the character "n". "\n" matches a newline character. The
sequence "\\" matches "\" and "\(" matches "(".
^  - Matches the beginning of input.
$  - Matches the end of input.
*  - Matches the preceding character zero or more times. For example, "zo*"
matches either "z" or "zoo".
+  - Matches the preceding character one or more times. For example, "zo+"
matches "zoo" but not "z".
?  - Matches the preceding character zero or one time. For example, "a?ve?"
matches the "ve" in "never".
. - Matches any single character except a newline character.
(pattern) - Matches pattern and remembers the match. The matched substring can
be retrieved from the resulting Matches collection, using Item [0]..
[n]. To match parentheses characters ( ), use "\(" or "\)".
x|y - Matches either x or y. For example, "z|food" matches "z" or "food".
"(z|f)ood" matches "zoo" or "food".
{n} - n is a nonnegative integer. Matches exactly n times. For example, "o{2}"
does not match the "o" in "Bob," but matches the first two o's in "foooood".
{n,}- n is a nonnegative integer. Matches at least n times. For example, "o{2,}"
does not match the "o" in "Bob" and matches all the o's in "foooood". "o{1,}" is
equivalent to "o+". "o{0,}" is equivalent to "o*".
{n,m}- m and n are nonnegative integers. Matches at least n and at most m times.
For example, "o{1,3}" matches the first three o's in "fooooood". "o{0,1}" is
equivalent to "o?".
[xyz] - A character set. Matches any one of the enclosed characters. For
example, "[abc]" matches the "a" in "plain".
[^xyz] - A negative character set. Matches any character not enclosed. For
example, "[^abc]" matches the "p" in "plain".
[a-z] - A range of characters. Matches any character in the specified range. For
example, "[a-z]" matches any lowercase alphabetic character in the range "a"
through "z".
[^m-z] - A negative range characters. Matches any character not in the specified
range. For example, "[m-z]" matches any character not in the range "m" through
"z".
\b - Matches a word boundary, that is, the position between a word and a space.
For example, "er\b" matches the "er" in "never" but not the "er" in "verb".
\B - Matches a nonword boundary. "ea*r\B" matches the "ear" in "never early".
\d - Matches a digit character. Equivalent to [0-9].
\D - Matches a nondigit character. Equivalent to [^0-9].
\f - Matches a form-feed character.
\n - Matches a newline character.
\r - Matches a carriage return character.
\s - Matches any white space including space, tab, form-feed, etc. Equivalent to
"[ \f\n\r\t\v]"
\S - Matches any nonwhite space character. Equivalent to "[^ \f\n\r\t\v]".
\t  -Matches a tab character.
\v - Matches a vertical tab character.
\w - Matches any word character including underscore. Equivalent to
"[A-Za-z0-9_]".
\W - Matches any nonword character. Equivalent to "[^A-Za-z0-9_]".
\num - Matches num, where num is a positive integer. A reference back to
remembered matches. For example, "(.)\1" matches two consecutive identical
characters.
\n - Matches n, where n is an octal escape value. Octal escape values must be 1,
2, or 3 digits long. For example, "\11" and "\011" both match a tab character.
"\0011" is the equivalent of "\001" & "1". Octal escape values must not exceed
256. If they do, only the first two digits comprise the expression. Allows ASCII
codes to be used in regular expressions.
\xn - Matches n, where n is a hexadecimal escape value. Hexadecimal escape
values must be exactly two digits long. For example, "\x41" matches "A". "\x041"
is equivalent to "\x04" & "1". Allows ASCII codes to be used in regular
expressions.

 Mi sembri Hyperion, da quanto sei criptico : )
Beh, c'erano ben due 3ad in corso sul tema O:-)


 O:-)
alopecia galoppante?

 alopecia galoppante?
Aloche'? Roba che se magna? ;o)


 > > O:-)
sembra quasi sia affetta da calvizie (alopecia, appunto ;)