Newsgroup: it.comp.lang.visual-basic
Titolo: metodi intelligenti in VB .NET per gestire stringhe

Qual'è il metodo più intelligente (se possibile con una istruzione)
per ridurre a 1 il numero di blank tra parole in un testo ???
 
cioè avendo un testo la cui spaziatura è molto irregolare, come si 
riduce ad uno solo un numero qualsiasi di blanks (variabile e 
sconosciuto a priori) che si trova tra due parole ?

John ha scritto:

Un loop su Replace(testo,"  ", " ") finché il risultato è zero.
 
Bye, G.


...ecco appunto...questa è una soluzione 'manuale'.
Cercavo qualcosa di 'automatico' da eseguire su 150 files... :-))))
 
 


 
sorry.  ho capito cosa intendi. Intendi fare un loop con l'istruzione 
'replace'...
Sono talmente abituato ultimamente a fare le cose manualmente perchè non 
trovo i metodi adeguati, che pensavo ti riferissi al 'find/replace' del 
text editor....
 
OK. grazie.
 
 
 
 

 'replace'...
 
 
comunque, così a lume di naso, perchè dovrebbe funzionare ? Non dovrebbe 
lasciare le cose inalterate ??
 
comunque lo provo lo stesso.
 
 
 

 comunque, così a lume di naso, perchè dovrebbe funzionare ?
 > Non dovrebbe lasciare le cose inalterate ??
 
La prima stringa è di due spazi, la seconda di uno solo.
Ad ogni giro se trova due spazi li sostituisce con uno
solo, finché tutte le serie di spazi si riducono ad un
solo spazio.
 
Bye, G.

"John"  wrote in message news:jea0al$mnj$1...@speranza.aioe.org...

Hanno inventato le regular expression anche per questo.
 
 

 Hanno inventato le regular expression anche per questo.
 
Giusto :-)
Non le ho mai capite davvero, e le ho odiate talmente
tanto che le ho cancellate dalla mente :-(.
 
Direi comunque che una cosa così debba funzionare:
Imports System.Text.RegularExpressions
Testo = Regex.Replace(Testo, "[ ]+", " ")
 
Bye, G.

 Testo = Regex.Replace(Testo, "[ ]+", " ")
 
Ho fatto un paio di test di velocità (un po' a CDC, a
dire la verità...), e la velocità di una String Replace,
du una Regexp Replace e di una StringBuilder Replace
mi sembrano praticamente identiche.
 
La maggior parte del tempo del test è occupato dal richiamo
e dalla conversione del testo dalla textbox a stringa
e viceversa, per cui l'ho escluso dal conteggio.
Tra l'altro per le prove ho copiato a mano il testo di prova
da un file pseudocasuale creato col blocco note (con gruppi
di spazi variabili da 1 a 5) e incollato più volte fino a
raggiungere il limite della textbox che ho impostato
a 10.000.000.
Lo so, non è il massimo della professionalità, ma per
quello che mi interessava ho visto che il tempo necessario
per la sostituzione è stato in tutti e tre i casi di pochi
decimi di secondo, su una stringa, appunto, di circa 10
milioni di caratteri.
 
Il codice è questo, sicuramente ottimizzabile:
 
*************
Imports System.Text.RegularExpressions
Imports System.Text
Public Class Form1
     Private Sub Button1_Click(sender As System.Object, e As 
System.EventArgs) Handles Button1.Click
         Debug.Print("metodo Regex.Replace")
         Dim Testo As String
         Testo = TextBox1.Text
         Debug.Print(Len(Testo))
         Debug.Print(Now)
         Testo = Regex.Replace(Testo, "[ ]+", " ")
         Debug.Print(Now)
         TextBox1.Text = Testo
         Debug.Print(Len(Testo))
         Debug.Print(" fine metodo Regex.Replace")
     End Sub
 
     Private Sub Button2_Click(sender As System.Object, e As 
System.EventArgs) Handles Button2.Click
         Debug.Print("metodo replace su String")
         Dim Testo As String
         Dim Prima As Integer
         Dim Dopo As Integer
         Testo = TextBox1.Text
         Prima = Len(Testo)
         Debug.Print(Prima)
         Debug.Print(Now)
         Do
             Testo = Replace(Testo, "  ", " ")
             Dopo = Len(Testo)
             If Prima = Dopo Then
                 Exit Do
             Else
                 Prima = Dopo
             End If
         Loop
         Debug.Print(Now)
         TextBox1.Text = Testo
         Debug.Print(Dopo)
         Debug.Print(" fine metodo replace su String")
     End Sub
 
     Private Sub Button3_Click(sender As System.Object, e As 
System.EventArgs) Handles Button3.Click
         Debug.Print("metodo Stringbuilder Replace")
         Debug.Print(Now)
         Dim Prima As Integer
         Dim Dopo As Integer
         Dim Testo As New StringBuilder(TextBox1.Text)
         Prima = Testo.Length
         Debug.Print(Prima)
         Debug.Print(Now)
         Do
             Testo = Testo.Replace("  ", " ")
             Dopo = Testo.Length
             If Prima = Dopo Then
                 Exit Do
             Else
                 Prima = Dopo
             End If
         Loop
         Debug.Print(Now)
         TextBox1.Text = Testo.ToString
         Debug.Print(Dopo)
         Debug.Print(" fine metodo Stringbuilder Replace")
     End Sub
End Class
*************************
 
Se qualcuno ha commenti... :-)
 
Bye, G.


 
alla faccia della 'una istruzione sola'... :-)))
 
Forse era più pratico il loop Replace("  ", " ")....


Hai provato con python?
Se ne sente parlare molto bene in giro.
 
-- 
-> G.Chiappori
www.chiappori.it
 
www.chiappori.com
 
 
 

 Se qualcuno ha commenti... :-)
Solo uno....una stringbuilder è da preferire da una quantità di 
inizializzazioni in poi...
 
Se devo fare
A$= "pippo" uno 2 3 4 5 volte come hai detto sono praticamente 
identiche...anche se non è vero!ma qualche tick di differenza non si 
nota!
Quando hai da elaborare una buona quantità di testo...e credo che se 
hai un testo "pieno" di doppi tripli quadrupli spazi o pieno di tab da 
convertire sia proprio il caso...in questo caso usare una stringbuilder 
che lavora NON su nuove inizializzazioni di stringhe ...ma su un 
classico buffer in memoria...sia proprio il caso di usarlo!
 
In un caso la stringbuilder rallenta...ma per un attimo...se finisce lo 
spazio di memoria del buffer e ne deve allocare altro!
 
Non lo dico a te che lo sai Paperino...lo dico ai niubbi che casomai 
compiono loop con a$=a$+ nuovodato$ o A$=String.replace(A$,"p","P") !!!
 
Morale....abituatevi ad usare stringbuilder per trattare il testo 
DINAMICAMENTE!
Usate le stringhe solo per contenere i testi dei pulsanti o messaggi di 
avvertimento...ossia "roba" che una volta inizializzata difficilmente 
cambia! ...un tick qua un tick là ...alla fine la vostra applicazione 
sarà più veloce!
 
-- 
----- Italliaaaaa 3227! -----
Ti prego, ti prego, non ci uccidere. Ti prego baby, lo sai che ti amo. 
Non avrei mai voluto lasciarti, non è stata colpa mia. Davvero, sono 
sincero. Quel giorno finì la benzina. Si bucò un pneumatico. Non avevo 
i soldi per il taxi! Il mio smoking non era arrivato in tempo dalla 
tintoria! Era venuto a trovarmi da lontano un amico che non vedevo da 
anni! Qualcuno mi rubò la macchina! Ci fu un terremoto! Una tremenda 
inondazione! Un'invasione di cavallette!
John Belushi [da "Blues Brothers"]
 
 


 
il tutto deve essere fatto su un progetto giá esistente in VB .NET.
e non mi sembra il caso di cambiare IDE ogni 5 minuti.
 
Ma non perdo mai occasione di fare cose in python.
 


 
Ho copiato il tuo esempio così :
 
Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As 
System.EventArgs) Handles Button3.Click
         testo = File.ReadAllText("file.txt")
         testo2 = ""
 
 
         lungo = Len(testo)
         RTB1.AppendText("len = " & lungo & LF)
 
         testo2 = Regex.Replace(testo, "[ ]+", " ")
 
         File.WriteAllText("regex.txt", testo2)
     End Sub
 
ma non mi funziona : il testo rimane inalterato.
Cosa ho sbagliato ???
(gli imports li ho messi regolarmente prima della Classe Form1)

 (gli imports li ho messi regolarmente prima della Classe Form1)
 
 
 
ora funziona perfettamente. Avevo sbagliato file di input : avevo preso 
quello coi 'tab'.
Tutto OK.
 
Grazie della dritta. Oggi ho imparato qualcosa di nuovo.