Newsgroup: it.comp.lang.javascript
Titolo: [!!!] LTrim, RTrim e Trim in JScript (questa è bella)

"
("Juliet ti adoro" va anche bene)
me lo fate questo favore?
baci bacini bacetti
    Juliet
konnichiwa!
^____^o <-orecchino
function lTrim(str){
return (new String(str)).replace(/^\s*/, "")
}
function rTrim(str){
return (new String(str)).replace(/\s*$/, "")
}
function trim(str){
return lTrim(rTrim(new String(str)))
}

 }
scusa la domanda, che forse č stupida, maa cosa servo queste funzioni?
ciao
ciaccio

Ciao,
ad eliminare il primo carattere e l'ultimo carattere
di una stringa se questi sono caratteri vuoti
tipo
" ciao " viene convertito in "ciao"
--
Bye
        Ro<*¿*>berto

Ciao,
posso chiamarti  JulieTrim??
mi sembra + indicato!
;-)
PS: è + bello con le RegExp
rispetto alla versione senza!


 }
sono di una complessità estrema...
quante notti non hai dormito per farle?
scusa, ma hai scoperto l'acqua tiepida... perchè ste cose bastava
inventarle...
;-)

Non proprio... la "mia" Trim toglie tutti i caratteri non stampabili a sinistra
e/o a destra di una stringa, inclusi i ritorni a capo (carriage return /r e line
feed /n), il form feed /f (non mi chiedere cosa sia), i tab /t e non vorrei dire
cazzate ma anche i non-breaking space /xA0


Allora chiamalo similTrim

Intanto c'è gente che lo chiede ancora, e io sono stata la prima ad arrivarci...
BLEEEEEEEH ;-PPPPPPPP
TI BRUCIA NON ESSERCI ARRIVATO TU, EH?
TUTTA INVIDIA ;)
ah, e già che ci sei spiegami il perchè di quel new String, e spiegami come
funziona il replace... guarda che accà nisciun'è fesso :)


> ah, e già che ci sei spiegami il perchè di quel new String
Io lo so! Io lo so! serve ad evitare "(...) is not an object"!!! Cos'ho vinto?

 " ciao " viene convertito in "ciao"
No, LTrim rimuove tutti gli spazi a sinistra ("          ciao" --> "ciao"),
RTrim rimuove tutti gli spazi a destra ("ciao          " --> "ciao"), e Trim
toglie gli spazi tutt'attorno ("            ciao            " --> "ciao")

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

Che risposta sarebbe? ^___^


è una risposta in rima!
basta essere sereni per  sentire
la poesia di quella frase ..


 la poesia di quella frase ..
:o)))
Rima a parte, le regular expression permettono molto piu` di quello.
Come justamente riportava juliet in it.comp.lang.perl le hanno detto che
"tutto si fa con le regex", e questo perche` le regex hanno possibilita`
sconfinate, che esulano la semplice sostituzione.
Esempio:
nome = 'mario ROSSI';
nome = new String(nome).replace(/([^ ])([a-zA-Z]+ ?)/g,"\u$1\L$2\E");
Ora non so bene se JS supporti il parametro "g" (globalmente) e i
simboli di sostituzione \u (uppercase nest char) e \L (lowercase till
\E), di sicuro supporta $1 e $2 (primo e secondo parametro trovati in
replace e racchiusi tra parentesi tonde).
Se tutto funziona torna 'Mario Rossi'.


\E),
non se li fuma proprio...
JS supporta :
\  Contrassegna il carattere successivo come carattere speciale. /n/
corrisponde al carattere "n". La sequenza /\n/ corrisponde a un carattere di
avanzamento riga o di nuova riga.
^  Corrisponde all'inizio dell'input o della riga.
$  Corrisponde alla fine dell'input o della riga.
*  Corrisponde a zero o più occorrenze del carattere precedente. /zo*/
individua "z" o "zoo".
+  Corrisponde a una o più occorrenze del carattere precedente. /zo+/
individua "zoo", ma non "z".
?  Corrisponde a zero occorrenze o a una sola occorrenza del carattere
precedente. /a?mp?/ individua i caratteri "mp" in "sempre".
. Corrisponde a qualsiasi carattere, ad eccezione del carattere di nuova
riga.
(criteri)  Individua la stringa criteri e memorizza la corrispondenza. La
sottostringa individuata può essere recuperata dagli elementi [1]...[n]
dell'oggetto Array risultante o dalle proprietà $1...$9 dell'oggetto RegExp.
Per individuare le parentesi ( ), è necessario specificare "\(" o "\)".
x|y Corrisponde a x o y. /c|pane?/ individua "cane" o "pane".
{n} n è un intero non negativo che corrisponde esattamente a n occorrenze.
/o{2}/ non individua la "o" in "non", mentre individua i primi due caratteri
"o" in "zooooo".
{n,}  n è un intero non negativo che individua almeno n occorrenze. /o{2,}/
non individua la "o" in "non", ma individua tutte le occorrenze del
carattere "o" in "zooooo". /o{1,}/ equivale a /o+/.
{n,m}  m e n sono interi non negativi che individuano un minimo di n e un
massimo di m occorrenze. /o{1,3}/ individua le prime tre "o" in "zoooooo".
[xyz]  Gruppo di caratteri. Individua uno dei caratteri racchiusi tra
parentesi. /[abc]/ individua la "a" in "pane".
[^xyz]  Gruppo di caratteri negativo. Individua qualsiasi carattere non
racchiuso tra le parentesi. /[^abc]/ individua la "p" in "pane".
\b  Corrisponde a un delimitatore tra parole, quale lo spazio. /ea*r\b/
individua "er" in "sera tardi".
\B  Corrisponde a un delimitatore non tra parole. /ta*r\B/ individua "tar"
in "sera tardi".
\d  Corrisponde a una cifra. Equivale a [0-9].
\D  Corrisponde a un carattere non numerico. Equivale a [^0-9].
\f  Corrisponde a un carattere di avanzamento modulo.
\n  Corrisponde a un carattere di avanzamento riga.
\r  Corrisponde a un carattere di ritorno a capo.
\s  Corrisponde a spazi vuoti, tra cui le tabulazioni, gli spazi e gli
avanzamenti modulo. Equivale a [ \f\n\r\t\v]
\S  Corrisponde a qualsiasi spazio non vuoto. Equivale a [^ \f\n\r\t\v]
\t  Corrisponde a un carattere di tabulazione.
\v  Corrisponde a un carattere di tabulazione verticale.
\w  Corrisponde a qualsiasi carattere alfabetico, compreso il carattere di
sottolineatura. Equivale a [A-Za-z0-9_].
\W  Corrisponde a qualsiasi carattere non alfabetico. Equivale a
[^A-Za-z0-9_].
\num  Corrisponde a num, dove num è un intero positivo. Fa riferimento a
corrispondenze individuate in precedenza. \1 individua quanto è memorizzato
in RegExp.$1.
/n/  Corrisponde a n, dove n è un valore ottale, esadecimale o un valore di
escape decimale. Consente l'inserimento di codice ASCII in espressioni
normali.


 non se li fuma proprio...
[snippo ma conservo :))]
Vale per \u, \L e \E, ma $1..$9 funzionano come le ho usate io, con le
parentesi tonde non quotate da \.


Insegnami tu ; P


Un calcio nel didietro! non era per te la domanda
: )


 Allora chiamalo similTrim

 rispetto alla versione senza!
ce n'è una versione senza? dov'è quest'impostore che lo trimmo senza pietà? ; )

> POWERTRIM!!!! (suona bene?)
si, mi sembra il nome di una "Eau de toilette"...
;-)


 
La mia conoscenza delle regex viene giustappunto dal Perl :-P
la prima delle cose che servono e` proprio l'uso di $1, $2, .., $9 come
variabili ricavate dal match tra parentesi.
Supponi ad esempio di voler strippare l'iniziale del middel name
americano, hai due vie:
1) new String(nome).replace(/ [a-zA-Z]\. /," ");
oppure
2) new String(nome).replace(/^([^ ]+) .* ([^ ]+)$/, "$1 $2");
il primo ^ indica l'inizio stringa, il ^ nel gruppo di [] indica il not,
le parentesi tonde servono a far "ricordare" a $1 e $2 i due gruppi che
matchano. Le due regex non si equivalgono... prendiamo "Tom B. Scott",
"Al Jr. Smith" e "Maria De Rossi":
1) -> "Tom Scott", "Al Jr. Smith", "Maria De Rossi"
2) -> "Tom Scott", "Al Smith", "Maria Rossi"
Quindi ogni volta che si pensa una regola bisogna pensarla ammodino :))
una cosa che mi aspettavo ma che -curiosamente- non mi ha funzionato e`
questa: .replace(/.../, "$1 FOO".toLowerCase() ) non sembra andare, in
quanto "FOO"=>"foo", ma $1 rimane quello che era senza essere
trasformato in lowercase :-\
Tu hai idee in proposito?


 Ora non so bene se JS supporti il parametro "g" (globalmente) e i
oh yeah
la sintassi delle RegExp è questa:
/pattern/scope
pattern è una di quelle mostruosità che il mio cervello rifiuta di assimilare,
scope può essere g (globale), i (ignora maiuscole/minuscole) oppure gi (globale,
ignora maiuscole/minuscole)

 (globale, ignora maiuscole/minuscole)
Le altre opzioni (e, m etc.) non ci sono?


Ottima idea ^___^


 Tu hai idee in proposito?
rgxp = new RegExp("pattern", "scope")
.replace(rgxp, rgxp.$1.toLowerCase() + " FOO".toLowerCase())
magari va

 wrote:

Se vada non lo so (proverollo), ma la forma e` davvero elegante :)
