• Définir un modèle de recherche
• Les métacaractères et le caractère "d'échappement"
• Les attaches
• Les classes de caractères
• Les caractères Unicode
• Les opérateurs
• Les options de compilation
• Définir un modèle de remplacement de texte

• Utiliser les expressions régulières consiste avant tout à faire passer un texte spécial comme critère de recherche. Ce texte spécial, au lieu d'être littéral, définit un modèle d'expression qui sera recherché.

• Dans les expressions régulières, la plupart des caractères conservent leur sens littéral, et quelques uns jouent un rôle particulier : ce sont les métacaractères, décrits ci-dessous.

• Le compilateur AppleScript considère la caractère backslash \ et les guillemets " comme des caractères spéciaux : pour les utiliser vous devez les faire précéder du caractère "d'échappement" qu'est backslash. Ainsi, "\"" est la manière d'entrer une guillemet, et "\\" correspond à un backslash.

• Pour restaurer le sens littéral des métacaractères (par exemple, le crochet [), il faut les faire précéder du caractère d'échappement backslash \. Par exemple, [a-z]\[[0-9]\] permet de trouver c[8].

• Dans d'autres cas, comme vous le verrez ci-dessous, il se peut qu'un caractère défini avec un backslash soit un métacaractère, tandis que ce caractère seul conserve son sens littéral.

• Les métacaractères ne font pas sens à l'intérieur de crochets (sauf les crochets eux-même, qui définissent une classe de caractères, par exemple [a-z], voir plus loin) retrouvent leur sens littéral à l'intérieur des crochets. Par exemple, [.] et [\] correspondent au point et au backslash, respectivement.

• Le backslash lui-même doit être précédé du caractère d'échappement (c'est-à-dire backslash) pour retrouver son sens littéral. Ainsi pour trouver un backslash avec une expression régulière en AppleScript, il faut écrire quatre backslash.

  find text "\\\\" in "escape with \\" with regexp
  find text "\\" in "escape with \\"

Vous pouvez utiliser les caractères suivant comme repères correspondant à certaines positions particulières du texte.

• ^ (chapeau) commencement d'une ligne, ou le début de la sélection de la fenêtre, ou le début du texte stocké dans une variable
• $ fin de ligne, ou fin de la sélection d'une fenêtre, ou fin du texte stocké dans une variable

change "^to be" into "" in "to be or not to be" with regexp -- " or not to be"

change "to be$" into "" in "to be or not to be" with regexp
-- "to be or not "

Il s'agit là du comportement par défaut; voir aussi la section concernant les options de compilation qui modifient le sens de ces repères.

• \b début ou fin d'un mot
• \B strictement à l'intérieur d'un mot

find text "\\bbe" in "tobe or not to be" with regexp

trouvera le second mot "be".

• . (point) signifie n'importe quel caractère excepté le retour chariot CR (ASCII 13).

  find text "n(.*)" in "to be or not to be" with regexp

  trouvera la fin de la ligne à partir de "not".

Il s'agit du comportement par défaut; voir également les options de compilation qui permettent au . (point) de correspondre aussi à des retours lignes CR (ASCII 13).

• [] les crochets encapsulent une définition d'une classe de caractères. Par exemple, [0-9] trouve tous les chiffres.
• - définit un intervalle de caractères (selon l'ordre ASCII) entre les deux caractères de part et d'autre du signe moins ; par exemple [a-zA-Z] trouvera les 52 lettres de l'alphabet minuscules et majuscules.
• ^ définit une classe en excluant les caractères qui suivent le caractère chapeau.

  find text "[^@]*" in "homer@lol.com" with regexp and string result
  -- "homer"

  (La signification de l'étoile * est donnée plus loin)
• \w n'importe quel caractère pouvant faire parti d'un mot
• \W n'importe quel caractère pouvant être un séparateur de mots
• \r CR, retour chariot, ASCII 13
• \n LF, fin de ligne, ASCII 10
• \t tabulation, ASCII 9
• [:alnum:] ensemble prédéfini, les lettres de l'alphabet latin et les chiffres. Les ensembles prédéfinis ne marchent qu'à l'intérieur de crochets. Par exemple, ^[[:alnum:]]{5}@ trouvera un ensemble d'exactement 5 caractères alphanumériques situés au début d'une ligne et suivi par un "@".
• [:alpha:] les lettres de l'alphabet latin
• [:lower:] les lettres minuscules
• [:upper:] les lettres majuscules
• [:digit:] les chiffres
• [:xdigit:] les chiffres hexadécimaux (minuscules et majuscules)
• [:blank:] espace ou tabulation
• [:space:] espace, tabulation, CR, LF or FF
• [:cntrl:] l'ensemble des caractères ASCII dont le code est < 32 ou = 127
• [:punct:] ni un caractère de contrôle ni un alphanumérique

change "^" into "--" in selection of window 1 with regexp

change "^[[:space:]]*--" into "" in selection of window 1 with regexp

Respectivement, commentera ou décommentera, le bloc de texte sélectionné dans la fenêtre active.

Pour inclure un ] littéral à l'intérieur de [], mettez-le en premier dans la liste.

Pour inclure un ^ littéral à l'intérieur de [] mettez-le n'importe où sauf en première position.

Pour inclure un - littéral à l'intérieur de [] mettez-le en dernier.

\w et \W ne sont considérés comme des métacaractères qu'en dehors de [].

\r, \n et \t sont considérés comme des métacaractères à l'intérieur et à l'extérieur des crochets, sauf s'ils sont précédés d'un backslash.

Ainsi, pour trouver un backslash suivi par un r (ou pour rechercher la séquence \n ou \t), il faut insérer un backslash supplémentaire comme caractère d'échappement du backslash : recherchez \\r.

\u est un métacaractère supplémentaire utilisable dans les expressions régulières sur les caractères Unicode : \u suivi du nombre hexadécimal correspondant à un caractère Unicode, correspond à ce caractère.

L'exemple qui suit trouve les symboles mathématiques (caractères Unicode 0x2200 à 0x22FF) dans une formule donnée. (Du fait de la limitation en ASCII des sources AppleScript, il faut entrer le texte original dans une fenêtre Unicode.)

set x to text of Unicode window 1
  --  "∀x|x∈[0,+∞] ∃y, y∉Ω, ∫y(x).dx ≪ y∧1"
find text "[\\u2200-\\u22FF]" in x with regexp, string result and all occurrences
  --  {"&#8704", "&#8712", "&#8734", "&#8707", "&#8713", "&#8747", "&#8810", "&#8743"}

• * zéro ou une ou plusieurs occurrences du groupe précédent, par exemple ^[[:space:]]* trouvera toutes les combinaisons d'espaces et de tabulations en début de ligne
• + une ou plusieurs occurrences
• ? zéro ou une occurrence
• {i, j} i à j occurrences, par exemple [0-9]{2,4} trouvera un groupe de 2, 3 or 4 chiffres
• {i,} i occurrences ou plus
• {i} i occurrences exactement
• | ou, par exemple begin|end cherchera "begin" ou "end"
• () groupe de caractères, par exemple ([0-9]{3},)+ pourra trouver "123,234,345,". vous pouvez également utiliser les groupes pour y faire référence par la suite :

• \1, \2 ... \9 sont des références aux premiers groupes successifs du modèle de recherche. Ces références peuvent être utilisées, soit dans l'expression régulière elle-même, soit dans le paramètre using de find text, ou dans le paramètre into de change.

  ^(.*)\r(.*\r)*\1$ trouvera un bloc de texte entouré de deux lignes identiques. Tandis que :

  find text "^(.*)\\r(.*\\r)*\\1$" in someText with regexp using "\\1"

  trouvera le même modèle de texte, mais ne retournera que la ligne en double.

  \0 fait référence à l'ensemble du texte trouvé.

  Les références aux groupes peuvent être utiles avec la commande change.

  change "([0-9]{2})/([0-9]{2})" into "\\2/\\1" in someText with regexp

  changera par exemple "25/12" en "12/25".

  L'ordre des groupes est l'ordre des parenthèses ouvrantes. Si un groupe est répété dans le modèle de recherche, il correspondra à la dernière occurence.

  find text "(^|[^0-9])(([0-9]{1,3}\\.){3}[0-9]{1,3})" in theText using "\\2" with regexp, all occurrences and string result

  renverra (sous forme de textes) la liste de toutes les adresses IP trouvées dans theText.

  find text "(^|[^0-9])(([0-9]{1,3}\\.){3}[0-9]{1,3})" in theText using "\\3" with regexp, all occurrences and string result

  renverra (sous forme de textes finissant par un point) la liste des troisièmes octets des adresses IP trouvées dans theText.

• D'autres opérateurs peuvent être définis par des syntaxes spécifiques et sont disponibles dans la syntaxe par défaut.

  Par exemple, la "laziness" est définie par certaines syntaxes dans lesquelles vous pouvez utiliser l'opérateur +?.

  find text "<.+>" in "<div>Satimage-Software</div>" with regexp
  --renvoie un résultat différent de :
  find text "<.+?>" in "<div>Satimage-Software</div>" with regexp

  Le "lookaround" est défini par certaines syntaxes dans lesquelles vous pouvez utiliser les opérateurs (?=), (?!), (?<=) et (?<!).

  find text "m(?!i)" in "min, max" with regexp
  --ne trouve pas le premier "m" car il n'est pas suivi d'un "i", tout en ne retenant pas la lettre "a" suivant le second "m" dans le résultat

Le dictionnaire de Smile indique que les expressions régulières avec find text et change possèdent les options "IGNORECASE", "EXTEND", "MULTILINE", "SINGLELINE", "FIND LONGEST", "FIND NOT EMPTY", "DONT CAPTURE GROUP", "NOTBOL" et "NOTEOL". Ces options ne sont utilisables que par script. Elles permettent de modifier le comportement défini par la regexp syntax.

find text "(b?|.*)" in "aaa" regexpflag {"FIND NOT EMPTY"} with regexp

Le texte de remplacement, tel qu'il est entré dans le dialogue de Recherche ou comme paramètre into de la commande change, peut inclure les métacaractères suivants : \0, \1 ... \9 (les références aux groupes définis dans le modèle de recherche - \0 réfère à l'ensemble du texte trouvé) et les caractères spéciaux \r, \n et \t.

Les mêmes caractères sont valides pour le texte passé pour le paramètre using de find text. Le paramètre using de find text supporte du texte ou une liste de textes - qui reconnaissent les métacaractères du paragraphe précédent.

find text "(.+) (.+)" in "Mickey Mouse" using {"Dest: Mr \\2", "Dear \\1,"} with regexp and string result