Reemplazar "solo palabras completas"
 

Hola.

Para hacer un reemplazo de texto utilizo la función StringReplace.

Pero quiero hacerlo de forma que solo reemplace en el caso de que aparezca la palabra completa y no cuando hay más texto en la palabra.

Por ejemplo, si se reemplaza 'abc' por '123' en este texto 'abc abcd aabcc', busco la forma de conseguir que el resultado sea '123 abcd aabcc' en lugar de '123 123d a123c'.

El resultado que quiero obtener, no se puede conseguir con StringReplace. ¿Alguien conoce la forma de hacerlo?.

Aclaro que busco una solución de código (si se puede, claro) antes que la instalación de un componente.

Gracias de antemano.

Puedes hacerlo controlando la posición de la palabra a reemplazar en el texto, si es la posición 1 (inicio de la línea) tienes que controlar además que después de la palabra hay un espacio. Si la posición es al final (chequeas que después hay un #13#10 y delante hay un espacio) también la reemplazarías. Lo demás queda igual, si no está en el principio de la línea ni al final entonces tendrás que comprobar que tiene un espacio delante y otro detrás.
Ahora te dejo el reto que lo hagas :D

Gracias por tu respuesta, Casimiro.

Hago un pequeño añadido que no tuve en cuenta en mi primer mensaje.

La utilidad se usaría para reemplazar nombres de constantes de texto en el código de un programa delphi.

Lo cual pienso que complica las cosas un poco, porque además de espacios en blanco y caracteres de fin de línea, pueden aparecer "=", ")", "(", "+", etc...

Si conociera todas las posibilidades que hay de caracteres antes y después de la aparición de la palabra (que realmente sería una constante de texto), creo que podría hacer la función que efectuara el reemplazo.

Voy a poner las posibilidades que se me ocurren:

"espacio en blanco" + ( ) ; , = [ ]

¿Alguien alguna otra posibilidad que no aparezca en la línea anterior?.

Gracias de antemano.

Bueno, eso no cambia mucho lo que he comentado antes, sólo debes crear una constante, por ejemplo, y añadir los caracteres que se pueden encontrar y luego comparar con ellos:

Código Delphi [-]
const _caracteres_posibles_ = ' +()[],:;';  // aquí añades todos los caracteres posibles

Luego en lugar de controlar si hay un espacio, debes controlar si hay alguno de esa constante.

Código Delphi [-]
if  elcaracterleido in _caracteres_posibles_ then
  hacerloquesea

Gracias otra vez.

Lo que propones simplifica lo que pensaba hacer y, además, añades ":" entre los caracteres posibles.

¿Habrá algún otro caracter que pueda aparecer antes y/o después del nombre de una constante de texto?.

Salu2.

Si se complica seleccionar todos los caracteres no deseados posibles por haber algunos desconocidos, se podria rellenar la constante que te comenta Casimiro con los valores que si admites y conoces ("a...z" y "A...Z"). En lugar de comprobar si el caracter se encuentra en entre ellos comprobarias si el caracter NO se encuentra y entonces ya procederias a lo que siga en tu programa.

Muchas gracias Reevil.

Posiblemente esa sea la mejor forma de simplificarlo.

Creo que con esa idea y las que aportó Casimiro, podré realizar lo que quería.

Salu2.

Hola de nuevo.

Aquí está la función y la forma de llamarla. Resuelve todos los problemas que planteaba cuando empecé este hilo.

La función reemplaza las apariciones de un nombre de constante en el código de un programa Delphi.

No confunde los nombres "acerco52" con "co5".

Si el nombre de la constante aparece varias veces en una misma línea, actúa con cada aparición de forma independiente, por lo que se evita el error comentado en el párrafo anterior.

En el ejemplo se recorre un memo en el cual previamente se habría cargado el código de 'archivo.pas'.

Código Delphi [-]
procedure TForm1.Button3Click(Sender: TObject);
var
  cc : integer ;
  aa, bb, ff : string ;
begin
        // Reemplazar en un memo
        //-----------------------

  Memo1.Lines.LoadFromFile( 'archivo.pas');

  for cc := 0 to Memo1.Lines.Count -1 do
  begin
    bb := LowerCase ( Memo1.Lines [cc] ) ;            // Línea del memo
    aa := LowerCase ( 'Texto a buscar' ) ;           // Texto a buscar
    ff := 'texto con el que se reemplaza' ;        // Texto para sustituir

    if 0< pos ( aa, bb )
    then
      begin
        Memo1.Lines [cc] := Cambia_en_linea( Memo1.Lines [cc], aa, ff, cc) ;
      end;
  end;

end;


function TForm1.Cambia_en_linea ( bb, aa, ff : string; nn: integer ): string;
var
  cc : integer ;
  ab, aa1, bb0, bb1 : string ;
  antes, despues : boolean ;
begin
       // Reemplaza en la línea del memo los nombres de las constantes
       //---------------------------------------------------------------

  aa1 := LowerCase( aa ) ;
  bb0 := bb ;
  bb1 := bb + ' ' ;
  cc := pos ( aa1, Lowercase ( bb1 ) ) ;

  while cc > 0
  do
  begin
    if  cc=1     // al inicio de la línea
    then
      begin
        ab := copy (bb1, cc + Length ( aa1 ), 1 ) ;
        if ab[1] in  ['a'..'z', 'A'..'Z', '0'..'9','_' ]
          then bb0 := StringReplace( bb0, aa1, 'nonotnonot', [rfIgnoreCase])
          else bb0 := StringReplace( bb0, aa1, 'siyessiyes', [rfIgnoreCase]) ;
      end

    else if cc > 1
    then         // a la mitad o final de la línea
      begin
        ab := copy (bb1, cc -1, 1 ) ;
        if ab[1] in  ['a'..'z', 'A'..'Z', '0'..'9','_' ]
          then antes := false
          else antes := true ;

        ab := copy (bb1, cc + Length ( aa1 ), 1 ) ;
        if ab[1] in  ['a'..'z', 'A'..'Z', '0'..'9','_' ]
          then despues := false
          else despues := true ;

        if ( antes ) and ( despues )
          then bb0 := StringReplace( bb0, aa1, 'siyessiyes', [rfIgnoreCase])
          else bb0 := StringReplace( bb0, aa1, 'nonotnonot', [rfIgnoreCase]) ;
      end;

    cc := pos ( aa1, Lowercase ( bb0 ) ) ;
    if cc > 0
      then bb1 := bb0 + ' ' ;
  end;

  bb0 := StringReplace( bb0, 'siyessiyes', ff,  [rfreplaceall, rfIgnoreCase]) ;
  bb0 := StringReplace( bb0, 'nonotnonot', aa1, [rfreplaceall, rfIgnoreCase]) ;

  Result := bb0 ;

end;

Lo dejo en el foro por si a alguna persona le puede resultar útil en alguna situación parecida.

Gracias de nuevo a Casimiro y a Reevil. Sin sus sugerencias y explicaciones no creo que lo hubiera podido realizar tan fácil y rapidamente.

Saludos.