Newsgroup: it.comp.lang.javascript
Titolo: Istruzioni su stringhe

Raga, ho urgente bisogno di alcune istruzioni che mi svolgano alcune
operazioni su delle stringhe. Per ora sto utilizzando codice VBscript nella
mia pagina, ma mi sono accorto che non č adatto perchč Netscape non lo
riconosce, quindi devo tradurre tutto il codice in Javascript e mi servono
le istruzioni per:
1) trasformare una stringa in caretteri maiuscoli; in VBscript č
UCase(stringa)
2) contare il numero di caratteri di una stringa; in VBscript č Len(stringa)
3) estrarre parte di una stringa; in VBscript č
Mid(stringa,puntopartenza,numerodicaratteri)
4) verificare se una stringa č contenuta in un'altra; InStr(...) di VBscript
Inoltre, secondo voi, qual'č il modo piů efficace per togliere gli spazi da
una stringa?
Grazie mille!!!

http://utenti.tripod.it/sauronsw/jsreference/index.htm
In questa reference cerca l'oggetto String nell'indice di sinistra.

una stringa?
stringa.replace(" ","")
Questa funzione permette di fare anche sostituzioni molto complesse come in perl.
Ti metto la reference NS su questa funzione, che è la più interessante:
Finds a match between a regular expression and a string, and replaces the matched substring with a new substring. Method of
 String
Implemented in
 JavaScript 1.2
JavaScript 1.3: supports the nesting of a function in place of the second argument
Syntax
replace(regexp, newSubStr)
replace(regexp, function)
Versions prior to JavaScript 1.3:
replace(regexp, newSubStr)
Parameters
regexp
 The name of the regular expression. It can be a variable name or a literal.
newSubStr
 The string to put in place of the string found with regexp. This string can include the RegExp properties $1, ..., $9, lastMatch,
lastParen, leftContext, and rightContext.
function
 A function to be invoked after the match has been performed.
Description
This method does not change the String object it is called on; it simply returns a new string.
If you want to execute a global search and replace, or a case insensitive search, include the g (for global) and i (for ignore case)
flags in the regular expression. These can be included separately or together. The following two examples below show how to use
these flags with replace.
Specifying a function as a parameter. When you specify a function as the second parameter, the function is invoked after the match
has been performed. (The use of a function in this manner is often called a lambda expression.)
In your function, you can dynamically generate the string that replaces the matched substring. The result of the function call is
used as the replacement value.
The nested function can use the matched substrings to determine the new string (newSubStr) that replaces the found substring. You
get the matched substrings through the parameters of your function. The first parameter of your function holds the complete matched
substring. Other parameters can be used for parenthetical matches, remembered submatch strings. For example, the following replace
method returns XX.zzzz - XX , zzzz.
"XXzzzz".replace(/(X*)(z*)/,                   function (str, p1, p2) {                      return str + " - " + p1 + " , " +
    }                )
The array returned from the exec method of the RegExp object and the subsequent match is available to your function. You can use the
content of the array plus the input and the index (index of match in the input string) properties of the array to perform additional
tasks before the method replaces the substring.
Examples
Example 1. In the following example, the regular expression includes the global and ignore case flags which permits replace to
replace each occurrence of 'apples' in the string with 'oranges.'
<SCRIPT>re = /apples/gi;str = "Apples are round, and apples are juicy.";newstr=str.replace(re,
"oranges");document.write(newstr)</SCRIPT>
This prints "oranges are round, and oranges are juicy."
Example 2. In the following example, the regular expression is defined in replace and includes the ignore case flag.
<SCRIPT>str = "Twas the night before Xmas...";newstr=str.replace(/xmas/i, "Christmas");document.write(newstr)</SCRIPT>
This prints "Twas the night before Christmas..."
Example 3. The following script switches the words in the string. For the replacement text, the script uses the values of the $1 and
$2 properties.
<SCRIPT LANGUAGE="JavaScript1.2">re = /(\w+)\s(\w+)/;str = "John Smith";newstr = str.replace(re, "$2,
$1");document.write(newstr)</SCRIPT>
This prints "Smith, John".
Example 4. The following example replaces a Fahrenheit degree with its equivalent Celsius degree. The Fahrenheit degree should be a
number ending with F. The function returns the Celsius number ending with C. For example, if the input number is 212F, the function
returns 100C. If the number is 0F, the function returns -17.77777777777778C.
The regular expression test checks for any number that ends with F. The number of Fahrenheit degree is accessible to your function
through the parameter $1. The function sets the Celsius number based on the Fahrenheit degree passed in a string to the f2c
function. f2c then returns the Celsius number. This function approximates Perl's s///e flag.
function f2c(x) {   var s = String(x)   var test = /(\d+(\.\d*)?)F\b/g   return s.replace      (test,         myfunction ($0,$1,$2)
{            return (($1-32) * 5/9) + "C";         }      )}

ehi, un momento! Per fare molte delle operazioni che hai descritto non basta una
stringa, ci vuole un oggetto String, dico bene?
Per chi non sapesse di cosa sto parlando, mentre per una *stringa* basta var
stringa = "testo", per un *oggetto stringa* bisogna usare var stringa = new
Stringa("testo")

 wrote in message
Q4Vm4.70978$C3.7...@news.infostrada.it...

Le due sintassi sono del tutto equivalenti finché
non si inizia a pasticciare con eval:
    eval("2+1")
ritorna 3, mentre
    str=new String("2+1")
    eval(str)
ritorna invece "2+1"
che per far interpretare "correttamente" devi
usare toString() per passare dall'oggetto stringa
ad una stringa vera e propria:
    eval(str.toString())
Fortunatamente la stragrande maggioranza delle
operazioni sulle stringhe vengono correttamente
eseguite senza dover creare un oggetto String(),
e, nel caso specifico, le righe di NetFly non
implicano errori o interpretazioni ambigue su
nessuno dei
browsers.
--
Bye.
-----------------------------------------
                Ðarius.
    <- 
www.infotronica.it/darius
 ->
             ICQ# 36150792
  - Art of JavaS.T - 
www.probo.it/aoj

Se usi var, è già di per sè una dichiarazione di oggetto, senza usare new


stringa, ci vuole un oggetto String, dico bene?
No, per inciso, tutte le stringhe sono oggetti js (tranne casi particolari), anche quelle non contenute in variabili:
"stringa".toUpperCase()
---
the fly on the net
il webmaster più alto del mondo
"the Art of JavaS." 
http://www.probo.it/aoj
"the devil inside" 
http://members.tripod.com/netfly
e-mail: 
net...@netbusiness.it

 "stringa".toUpperCase()
sono daccordo. purtroppo qualche baco nel browser non lo è....
Le stringhe sono oggetti simili agli Array, non semplici variabili. A parte
che anche le variabili sono oggetti:
------------------------------
Tipo: letterale
  Sotto-tipo: numerico
    classe: intero
    classe: virgola mobile
    classe: booleano
  Sotto-tipo: stringa
------------------------------
--
N'Drillo