Chaînes de caractères.

Les chaînes de caractères peuvent être délimitées par '' ou ""

nchar("toto") : longueur de la chaîne de caractères (ou vecteur des longueurs si vecteur de chaînes). Par exemple nchar(c("truc", "bidule")) donne 4 6. Attention, ce n'est pas length !

toupper(x), tolower(x) : pour convertir en minuscules ou majuscules.

LETTERS, letters : le vecteur des lettres de l'alphabet en majuscules ou minuscules.

paste (concaténation) :

• paste("a", "b", "c") : donne "a b c" (chaînes concaténées séparées par un espace.
• paste("a", "b", "c", sep = "") : donne "abc".
• paste(c("a", "b"), 1:4, sep="|") : donne c("a|1" "b|2" "a|3" "b|4")
• paste(c("a", "b", "c"), collapse = "|") : donne "a|b|c".

substr("abcdef", 2, 4) : extraction de sous chaîne. Ici donne "bcd" (début et fin en comptant à partir de 1 et positions incluses.

strsplit : permet de splitter des chaînes de caractères en fonction d'une sous-chaîne ou d'une expression régulière :

• strsplit(x, split) : splitte le vecteur x selon l'expression régulière split (si split = "", split en caractères individuels). Attention : le résultat est une liste de vecteurs. Exemple :
  strsplit(c("a,b", "c,d", "e,f,g"), ",") donne list(c("a", "b"), c("c", "d"), c("e", "f", "g"))
• strsplit(x, split, fixed = TRUE) : considère split comme étant une sous-chaîne (par défaut, une expression régulière).
• strsplit(x, split, perl = TRUE) : considère split comme étant une expression régulière de type perl (par défaut, perl = FALSE).
• unlist(strsplit('a_bb_ccc', '_')) : donne un simple vecteur : "a" "bb" "ccc"

match (matching exact) :

• match(x, vect) : retourne le premier index de vect pour lequel l'élément est exactement identique à x. Renvoie NA si pas de correspondance.
• match("de", c("ab", "de", "ac", "ab", "de")) donne 2.
• Le premier élément peut être lui-même un vecteur : match(c("ac", "de"), c("ab", "de", "ac", "ab", "de")) donne 3 2.
• match marche aussi avec des entiers : match(c(6, 8, 4), c(6, 5, 4, 3, 2, 1)) renvoie 1 NA 3.
• is.na(match(x, vect)) : renvoie TRUE si pas d'élément x dans vect, FALSE sinon.

regexpr (expression régulière) :

• regexpr(x, vect) : retourne un vecteur de même taille que vect donnant la liste des positions de x dans chaque élément avec une valeur de -1 si pas trouvé (index à partir de 1). En plus, il y a un attribut match.length qui donne la longueur matchée (-1 si pas de match).
• regexpr("a", c("abc", "bac", "def")) donne 1 2 -1 (avec un attribut match.length : 1 1 -1).
• regexpr considère que x est une expression régulière posix :
  • regexpr(x, vect, perl = TRUE) : pour chercher une expression régulière perl.
  • regexpr(x, vect, fixed = TRUE) : pour chercher une simple chaîne de caractères.
• regexpr permet donc de renvoyer facilement un vecteur de booléens : TRUE si match, FALSE sinon : regexpr(x, vect) != -1.

grep (expression régulière) :

• grep(x, vect) : cherche x dans chaque élément du vecteur vect et renvoie tous les indices où elle est trouvée. Par défaut, x est une expression régulière posix.
• grep("a", c("abc", "bca", "def")) : donne 1 2.
• grep(x, vect, perl = TRUE, ignore.case = TRUE) : x est une expression régulière perl et on ignore la casse.
• grep(x, vect, fixed = TRUE) : x est une simple chaîne de caractères.
• grep("a", c("abc", "bca", "def"), value = TRUE) : donne "abc" "bac" (les valeurs au lieu des indices).
• Pour récupérer tous les éléments de vect qui ne contiennent pas x : v[setdiff(seq(v), grep(x, v))] (marche même si x ne matche aucun élément de vect).

sub (remplacement d'expression régulière) :

• sub(pattern, replacement, vect) : remplace la première occurrence du pattern par replacement dans chaque élément de vect.
• sub(chaine, replacement, vect, fixed = TRUE) : remplace la première occurrence de la chaine par replacement dans chaque élément de vect.
• sub("a\\d", "X", c("a4b", "ca3da6"), perl = TRUE) : donne "Xb" "cXda6" (attention, tous les \ entre "" doivent être backslashés pour éviter leur interprétation !).
• On peut utiliser \1, \2, ... pour matcher les parenthèses successives. Exemple sub("a(\\d)", "X\\1", c("a4b", "ca3da6"), perl = TRUE) donne "X4b" "cX3da6"

gsub (remplacement d'expression régulière répété) :

• gsub(pattern, replacement, vect) : remplace toutes les occurrences du pattern par replacement dans chaque élément de vect.
• gsub("a\\d", "X", c("a4b", "ca3da6"), perl = TRUE) : donne "Xb" "cXdX"

abbreviate(x, 3) : essaie d'abréger les valeurs de x aux 3 premiers caractères, de façon à avoir unicité des noms. Par exemple :
abbreviate(c("toit", "toute", "tourner"), 3) donne "toit" "tout" "trn"

Traduction de caractères : chartr(oldChar, newChar, vect) : pour traduire une liste de caractères. Exemple :
chartr("pm", "cl", c("pomme", "map")) donne "colle" "lac"

Pour renverser toutes les chaînes de caractères d'un vecteur :
sapply(lapply(strsplit(c("ABC", "cba"), '', fixed = TRUE), rev), paste, collapse = "")