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) : x est le pattern à rechercher dans chaque élément du vecteur 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.

match permet de faire une jointure entre deux frames quand on sait qu'il y a une correspondance 1 pour 1 :

fr1 <- data.frame(x1 = c("a", "b", "c", "d"), y1 = c(3, 4, 5, 6))
fr2 <- data.frame(x2 = c("c", "a", "d", "b"), y2 = c(50, 30, 60, 40))
cbind(fr1, fr2[match(fr1$x1, fr2$x2), ])
  

regexpr (expression régulière) :

• regexpr(x, vect) : x est le pattern à rechercher dans chaque élément du vecteur 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.

gregexpr (expression régulière répétée) :

• gregexpr(x, vect) : x est le pattern à rechercher dans chaque élément du vecteur vect. Retourne une liste avec un élément par élément du vecteur vect, chaque élément de la liste étant soit -1 si pas de match, soit le vecteur des positions de début de match. Chaque élément a aussi un attribut match.length qui donne la longueur des matchs.
• gregexpr("(AA+|CC+|GG+|TT+)", c("ACCCTAGGGGTAAAAAACGATGCTAGG", "AGGCGTTTTTAAA", "ACGT"), perl = TRUE) donne :

  [[1]]
  [1]  2  7 12 26
  attr(,"match.length")
  [1] 3 4 6 2
  
  [[2]]
  [1]  2  6 11
  attr(,"match.length")
  [1] 2 5 3
  
  [[3]]
  [1] -1
  attr(,"match.length")
  [1] -1
    

• si res <- gregexpr("(AA+|CC+|GG+|TT+)", c("ACCCTAGGGGTAAAAAACGATGCTAGG", "AGGCGTTTTTAAA", "ACGT"), perl = TRUE) :
  • res[[1]] : vecteur des positions dans le premier élément du vecteur ("ACCCTAGGGGTAAAAAACGATGCTAGG") matchant l'expression régulère (2 7 12 26).
  • attr(res[[1]], "match.length") : vecteur des longueurs des matchs à chaque position, ici la longueur des sous-chaînes d'au moins deux lettres répétées (3 4 6 2).

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("a", c("abc", "bca", "def"), invert = TRUE) : donne 3 (les éléments qui n'ont pas le match).
• 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" "bca" (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 = "")