English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
L'oggetto Stringa in Ruby viene utilizzato per memorizzare o manipolare una sequenza di uno o più byte.
Le stringhe Ruby si dividono in stringhe di apici singoli (') e stringhe di apici doppi (") con la differenza che le stringhe di apici doppi possono supportare più caratteri di escape.
La stringa più semplice è la stringa di apici singoli, ovvero la stringa memorizzata all'interno degli apici singoli:
'Questa è una stringa di un programma Ruby'
Se hai bisogno di usare il carattere di apice singolo all'interno di una stringa di apici singoli, devi usare il carattere di escape (\) all'interno della stringa di apici singoli, in modo che l'interprete Ruby non consideri il carattere di apice singolo come il simbolo di fine della stringa:
'Non vorrai leggere il libro di O'Reilly?'
La barra inversa può anche escapare un'altra barra inversa, in modo che la seconda barra inversa non venga interpretata come carattere di escape.
Ecco le caratteristiche relative alle stringhe in Ruby.
Possiamo usare #{} Uso di hash e parentesi graffe per calcolare il valore dell'espressione:
Imbedding di variabili all'interno di una stringa:
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
name1 = "Joe"
name2 = "Mary"
puts "Ciao #{name1}, dove è #{name2}?"Esempio di output:
Ciao Joe, dove è Mary?
Operazione matematica all'interno di una stringa:
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
x, y, z = 12, 36, 72
puts "Il valore di x è #{x}"
puts "Il valore di x + y è #{x + y}"
puts "La media di x + y + z è #{(x + y + z)/3}"Esempio di output:
Il valore di x è 12 Il valore di x + y è 48 La media di x + y + z è 40
Ruby supporta anche una variabile di stringa guidata da %q e %Q. %q utilizza le regole di citazione con virgolette singole, mentre %Q utilizza le regole di citazione con virgolette doppie, seguite da un carattere di inizio delimitatore come (!, [ o { e da un carattere di fine delimitatore come }, ] o ).
Il carattere che segue q o Q è il delimitatore. Il delimitatore può essere qualsiasi singolo carattere non alfanumerico. Ad esempio: [,{,(,<,! e così via. La stringa verrà letta fino a quando non si trova il carattere di fine corrispondente.
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
desc1 = %Q{La stringa Ruby può utilizzare '' e "".}
desc2 = %q|La stringa Ruby può utilizzare '' e "".|
puts desc1
puts desc2Esempio di output:
Le stringhe Ruby possono utilizzare '' e "". Le stringhe Ruby possono utilizzare '' e "".
la tabella sottostante elenca i caratteri di escape o i caratteri non stampabili che possono essere esposti con il simbolo di backslash.
Attenzione:dentro una stringa racchiusa tra virgolette doppi, i caratteri di escape vengono interpretati. Dentro una stringa racchiusa tra virgolette singole, i caratteri di escape non vengono interpretati e vengono esposti come sono.
| simbolo di backslash | carattere esadecimale | Description |
|---|---|---|
| \a | 0x07 | simbolo di allarme |
| \b | 0x08 | tasto di cancellazione |
| \cx | Control-x | |
| \C-x | Control-x | |
| \e | 0x1b | carattere di escape |
| \f | 0x0c | carattere di pagina |
| \M-\C-x | Meta-Control-x | |
| \n | 0x0a | carattere di nuova riga |
| \nnn | rappresentazione ottale, dove n va da 0 a 7 | |
| \r | 0x0d | carattere di ritorno a capo |
| \s | 0x20 | spazio |
| \t | 0x09 | tabulatore |
| \v | 0x0b | tabulatore verticale |
| \x | Carattere x | |
| \xnn | Rappresentazione esadecimale, dove n va da 0.9, a.f o A.F |
Il set di caratteri predefinito di Ruby è ASCII, i caratteri possono essere rappresentati da un singolo byte. Se utilizzi UTF-8 o altri set di caratteri moderni, i caratteri possono essere rappresentati da uno a quattro byte.
Puoi cambiare il set di caratteri all'inizio del programma come segue:
$KCODE = 'u'
Di seguito sono riportati i valori possibili di $KCODE.
| Codifica | Description |
|---|---|
| a | ASCII (uguale a none). Questo è il valore predefinito. |
| e | EUC. |
| n | None (uguale a ASCII). |
| u | UTF-8. |
Abbiamo bisogno di un esempio di oggetto String per chiamare i metodi String. Di seguito è riportato il modo in cui creare un esempio di oggetto String:
new [String.new(str="")]
Questo restituirà una stringa che contiene str Un nuovo oggetto stringa di copia. Ora, usando str Oggetto, possiamo chiamare qualsiasi metodo disponibile. Ad esempio:
#!/usr/bin/ruby
myStr = String.new("THIS IS TEST")
foo = myStr.downcase
puts "#{foo}"Questo produrrà il seguente risultato:
this is test
Di seguito sono riportati i metodi stringa pubblici (supponendo che str sia un oggetto String):
| Numero di Ordine | Metodo & Descrizione |
|---|---|
| 1 | str % arg Formatta una stringa utilizzando lo standard di formattazione. Se arg contiene una sostituzione superiore a una, arg deve essere un array. Per ulteriori informazioni sugli standard di formattazione, vedere "modulo nucleare" sotto sprintf. |
| 2 | str * integer Restituisce una nuova stringa che contiene integer copie di str. In altre parole, str viene ripetuto integer volte. |
| 3 | str + other_str Concatena other_str a str. |
| 4 | str << obj Collega un oggetto a una stringa. Se l'oggetto è un Fixnum con valore tra 0 e 255, viene convertito in un carattere. Confrontalo con concat. |
| 5 | str <=> other_str Confronta str con other_str, restituisce -1 (minore), 0 (uguale) o 1 (maggiore). Il confronto è sensibile alle maiuscole e minuscole. |
| 6 | str == obj Controlla l'uguaglianza di str e obj. Se obj non è una stringa, restituisce false, se str <=> obj, restituisce true, restituisce 0. |
| 7 | str =~ obj 7 |
| 7 | Corrisponde a str secondo lo schema di espressione regolare obj. Restituisce la posizione di inizio della corrispondenza, altrimenti restituisce false. 8 str[position] # Attenzione: viene restituito l'ASCII anziché il carattere str[start, length] str[start..end] |
| str[start...end] | Estrai una sottosequenza utilizzando l'indice. 9 |
| str.capitalize | Converti la stringa in maiuscolo per la visualizzazione. 10 |
| str.capitalize! | Uguale a capitalize, ma str viene modificato e restituito. 11 |
| str.casecmp | Confronto di stringhe senza distinzione tra maiuscole e minuscole. str.center |
| Centra la stringa. | 13 str.chomp |
| Rimuove il separatore di record ($/), solitamente \n, dalla fine della stringa. Se non ci sono separatori di record, non viene eseguita alcuna operazione. | 14 str.chomp! |
| Uguale a chomp, ma str viene modificato e restituito. | str.chop Rimuove l'ultimo carattere da str. |
| 16 | str.chop! Uguale a chop, ma str viene modificato e restituito. |
| 17 | str.concat(other_str) Concatena other_str a str. |
| 18 | str.count(str, ...) Conta i caratteri di una o più sequenze di caratteri. Se ci sono più sequenze di caratteri, conta l'intersezione di queste sequenze. |
| 19 | str.crypt(other_str) Applica un hash di crittografia unidirezionale a str. Il parametro è una stringa di due caratteri, ciascuno dei quali ha un intervallo di a.z, A.Z, 0.9, . o /. |
| 20 | str.delete(other_str, ...) Restituisce una copia di str, eliminando tutti i caratteri presenti nell'intersezione dei parametri. |
| 21 | str.delete!(other_str, ...) Uguale a delete, ma str viene modificato e restituito. |
| 22 | str.downcase Restituisce una copia di str, sostituendo tutte le lettere maiuscole con lettere minuscole. |
| 23 | str.downcase! Uguale a downcase, ma str viene modificato e restituito. |
| 24 | str.dump Restituisce la versione di str, sostituendo tutti i caratteri non stampabili con il simbolo \nnn e scappando tutti i caratteri speciali. |
| 25 | str.each(separator=$/) { |substr| block } Usare il parametro come separatore di record (predefinito è $/), separare str e passare ogni substrazione al blocco fornito. |
| 26 | str.each_byte { |fixnum| block } Passare ogni byte di str al blocco, restituendo ogni byte in rappresentazione decimale. |
| 27 | str.each_line(separator=$/) { |substr| block } Usare il parametro come separatore di record (predefinito è $/), separare str e passare ogni substrazione al blocco fornito. |
| 28 | str.empty? Se str è vuota (cioè la lunghezza è 0), restituisce true. |
| 29 | str.eql?(other) Se due stringhe hanno la stessa lunghezza e contenuto, queste due stringhe sono uguali. |
| 30 | str.gsub(pattern, replacement) [o] str.gsub(pattern) { |match| block } Restituisce una copia di str con tutte le occorrenze di pattern sostituite con il valore di replacement o block. Il pattern di solito è un'espressione regolare Regexp; se è una stringa String, non vengono interpretati i caratteri meta dell'espressione regolare (cioè, /\d/ corrisponde a un numero, ma '\d' corrisponde a una barra inversa seguita da 'd'). |
| 31 | str[fixnum] [o] str[fixnum,fixnum] [o] str[range] [o] str[regexp] [o] str[regexp, fixnum] [o] str[other_str] Utilizzare i seguenti parametri per riferimento str: il parametro è un Fixnum, restituisce la codifica dei caratteri del fixnum; il parametro sono due Fixnum, restituisce una substrazione da offset (primo fixnum) fino alla lunghezza (secondo fixnum); il parametro è un range, restituisce una substrazione del range; il parametro è un regexp, restituisce la parte corrispondente alla stringa; il parametro è un regexp con fixnum, restituisce i dati corrispondenti alla posizione fixnum; il parametro è other_str, restituisce la substrazione corrispondente a other_str. Un Fixnum negativo inizia dal termine della stringa -1. |
| 32 | str[fixnum] = fixnum [or] str[fixnum] = new_str [or] str[fixnum, fixnum] = new_str [or] str[range] = aString [or]
str[regexp] =new_str [or] str[regexp, fixnum] =new_str [or] str[other_str] = new_str ] Sostituisce l'intera stringa o una parte della stringa. Uguale a slice!. |
| 33 | str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { |match| block } Esegue la sostituzione con String#gsub, restituisce str, se non viene eseguita alcuna sostituzione restituisce nil. |
| 34 | str.hash Restituisce un hash basato sulla lunghezza e sul contenuto della stringa. |
| 35 | str.hex Considera i caratteri iniziali di str come una stringa di numeri esadecimali (un simbolo opzionale e un opzionale 0x), e restituisce il numero corrispondente. Restituisce zero in caso di errore. |
| 36 | str.include? other_str [or] str.include? fixnum Restituisce true se str contiene la stringa o il carattere specificato. |
| 37 | str.index(substring [, offset]) [or] str.index(fixnum [, offset]) [or] str.index(regexp [, offset]) Restituisce l'indice della prima occorrenza del sottostringa, carattere (fixnum) o modello (regexp) in str. Restituisce nil se non trovato. Se fornito un secondo parametro, specifica la posizione di partenza della ricerca nella stringa. |
| 38 | str.insert(index, other_str) Inserisce other_str prima del carattere all'indice dato, modifica str. Gli indici negativi iniziano a contare dalla fine della stringa e inseriscono dopo il carattere dato. L'intenzione è di iniziare l'inserimento di una stringa all'indice dato. |
| 39 | str.inspect Restituisce la versione stampabile di str, con i caratteri speciali escaped. |
| 40 | str.intern [or] str.to_sym Restituisce il simbolo corrispondente a str, se prima non esisteva, lo crea. |
| 41 | str.length Restituisce la lunghezza di str. Comparala con size. |
| 42 | str.ljust(integer, padstr=' ') Se l'integer è maggiore della lunghezza di str, restituisce una nuova stringa di lunghezza integer, con str allineato a sinistra e padstr come riempimento. Altrimenti, restituisce str. |
| 43 | str.lstrip Restituisce una copia di str, con gli spazi iniziali rimossi. |
| 44 | str.lstrip! Rimuove gli spazi iniziali da str, se non cambia restituisce nil. |
| 45 | str.match(pattern) Se pattern non è un'espressione regolare, converte pattern in un'espressione regolare Regexp e chiama il suo metodo di ricerca sullo str. |
| 46 | str.oct Considera i caratteri iniziali di str come una stringa di numero decimale (un simbolo opzionale), e restituisce il numero corrispondente. Se la conversione fallisce, restituisce 0. |
| 47 | str.replace(other_str) Sostituisce il contenuto di str con i valori corrispondenti di other_str. |
| 48 | str.reverse Restituisce una nuova stringa, che è l'ordine inverso di str. |
| 49 | str.reverse! Inverte str, str viene modificato e restituito. |
| 50 | str.rindex(substring [, fixnum]) [or] str.rindex(fixnum [, fixnum]) [or] str.rindex(regexp [, fixnum]) Restituisce l'indice dell'ultima occorrenza della sottostringa, del carattere (fixnum) o del modello (regexp) in str. Se non viene trovato, restituisce nil. Se viene fornito un secondo parametro, specifica la posizione in cui terminare la ricerca nella stringa. I caratteri al di fuori di questo punto non verranno considerati. |
| 51 | str.rjust(integer, padstr=' ') Se l'integer è maggiore della lunghezza di str, restituisce una nuova stringa di lunghezza integer, allineata a destra con str e riempita con padstr. Altrimenti, restituisce str. |
| 52 | str.rstrip Restituisce una copia di str con gli spazi finali rimossi. |
| 53 | str.rstrip! Rimuove gli spazi finali da str, e se non ci sono cambiamenti restituisce nil. |
| 54 | str.scan(pattern) [o] str.scan(pattern) { |match, ...| block } Le due forme abbinano il pattern (può essere un Regexp o una Stringa) e scansionano str. Per ogni corrispondenza, viene generato un risultato che viene aggiunto all'array dei risultati o inviato al block. Se il pattern non contiene gruppi, ogni risultato indipendente è costituito dalla stringa corrispondente e da $&. Se il pattern contiene gruppi, ogni risultato indipendente è un array che contiene ciascun ingresso del gruppo. |
| 55 | str.slice(fixnum) [o] str.slice(fixnum, fixnum) [o] str.slice(range) [o] str.slice(regexp) [o] str.slice(regexp, fixnum) [o] str.slice(other_str) Vedi str[fixnum], ecc. str.slice!(fixnum) [o] str.slice!(fixnum, fixnum) [o] str.slice!(range) [o] str.slice!(regexp) [o] str.slice!(other_str) Elimina la parte specificata da str e restituisce la parte eliminata. Se il valore è fuori da un intervallo, viene generato un IndexError se il parametro è di tipo Fixnum. Se il parametro è di tipo range, viene generato un RangeError. Se il parametro è un Regexp o una String, l'azione viene ignorata. |
| 56 | str.split(pattern=$;, [limit]) Divide str in sottostringhe basate sul separatore e restituisce un array di queste sottostringhe. Se pattern È una stringa String, allora viene utilizzata come separatore nella divisione di str. Se pattern è un singolo spazio, str viene diviso in base agli spazi, ignorando gli spazi iniziali e i caratteri di spazio consecutivi. Se pattern È un'espressione regolare Regexp, str viene divisa al punto di match di pattern. Quando pattern matcha una stringa di lunghezza zero, str viene divisa in singoli caratteri. Se omesso pattern Il parametro utilizza il valore di $; se omesso. Se $; è nil (predefinito), str viene diviso in base agli spazi, come se fosse stato specificato ` ` come separatore. Se omesso limit Parametro, che sopprime i campi null finali. Se limit è un numero positivo, restituisce al massimo il numero specificato di campi (se limit è 1, restituisce l'intera stringa come unico elemento dell'array). Se limit è negativo, il numero di campi restituiti non è limitato e non sopprime i campi null finali. |
| 57 | str.squeeze([other_str]*) Utilizza il programma descritto da String#count per costruire una serie di caratteri dal parametro other_str. Restituisce una nuova stringa in cui i caratteri duplicati nella serie vengono sostituiti da un singolo carattere. Se non viene fornito un parametro, tutti i caratteri duplicati vengono sostituiti da un singolo carattere. |
| 58 | str.squeeze!([other_str]*) Come squeeze, ma str cambia e viene restituito, o nil se non ci sono cambiamenti. |
| 59 | str.strip Restituisce una copia di str, rimuovendo gli spazi iniziali e finali. |
| 60 | str.strip! Rimuove gli spazi iniziali e finali da str, restituendo nil se non ci sono cambiamenti. |
| 61 | str.sub(pattern, replacement) [or] str.sub(pattern) { |match| block } Restituisce una copia di str, sostituendo la prima occorrenza di pattern con replacement o il valore di block. pattern di solito è un'espressione regolare Regexp; se è una stringa String, non vengono interpretati i caratteri meta dell'espressione regolare. |
| 62 | str.sub!(pattern, replacement) [or] str.sub!(pattern) { |match| block } Esegue la sostituzione di String#sub e restituisce str, se non viene eseguita alcuna sostituzione viene restituito nil. |
| 63 | str.succ [or] str.next Restituisce l'erede di str. |
| 64 | str.succ! [or] str.next! Corrisponde a String#succ, ma str viene modificato e restituito. |
| 65 | str.sum(n=16) Restituisce la somma di controllo n-bit dei caratteri di str, dove n è un parametro Fixnum opzionale, di default 16. Il risultato è semplicemente la somma dei valori binari di ciascun carattere di str, con modulo 2n - 1. Questo non è un somma di controllo particolarmente buona. |
| 66 | str.swapcase Restituisce una copia di str, convertendo tutte le lettere maiuscole in minuscole e tutte le minuscole in maiuscole. |
| 67 | str.swapcase! Corrisponde a String#swapcase, ma str viene modificato e restituito, se non cambia viene restituito nil. |
| 68 | str.to_f Restituisce il risultato di interpretare i caratteri iniziali di str come numero decimale. I caratteri in eccesso alla fine del numero valido vengono ignorati. Se non ci sono numeri validi all'inizio di str, viene restituito 0.0. Questo metodo non genera eccezioni. |
| 69 | str.to_i(base=10) Restituisce il risultato di interpretare i caratteri iniziali di str come base numerica (base 2, 8, 10 o 16). I caratteri in eccesso alla fine del numero valido vengono ignorati. Se non ci sono numeri validi all'inizio di str, viene restituito 0. Questo metodo non genera eccezioni. |
| 70 | str.to_s [or] str.to_str Restituisce il valore ricevuto. |
| 71 | str.tr(from_str, to_str) Restituisce una copia di str, sostituendo i caratteri di from_str con quelli corrispondenti in to_str. Se to_str è più corto di from_str, viene riempito con l'ultimo carattere. Entrambi i stringhe possono essere rappresentati con il simbolo c1.c2 per indicare l'intervallo di caratteri. Se from_str inizia con ^, indica tutti i caratteri tranne quelli elencati. |
| 72 | str.tr!(from_str, to_str) Corrisponde a String#tr, ma str viene modificato e restituito, se non cambia viene restituito nil. |
| 73 | str.tr_s(from_str, to_str) El str viene trattato secondo le regole descritte da String#tr e poi vengono rimossi i caratteri ripetuti che influenzano la traduzione. |
| 74 | str.tr_s!(from_str, to_str) Equivalent to String#tr_s, but str will change and return, or return nil if there is no change. |
| 75 | str.unpack(format) Decode str based on the format string (may contain binary data), and return an array of each extracted value. The format character consists of a series of single-character instructions. A number can follow each instruction to indicate the number of times the instruction is repeated. An asterisk (*) will use all remaining elements. The format character sSiIlL may be followed by an underscore (_) to specify the local size of the underlying platform for the type, otherwise, a consistent size independent of the platform is used. Spaces in the format string are ignored. |
| 76 | str.upcase Return a copy of str with all lowercase letters replaced with uppercase letters. The operation is case-insensitive, only characters a to z are affected. |
| 77 | str.upcase! Change the content of str to uppercase, if there is no change, return nil. |
| 78 | str.upto(other_str) { |s| block } Iterate over consecutive values, starting with str, ending with other_str (inclusive), and alternately pass each value to the block. The String#succ method is used to generate each value. |
The following table lists the unpacking commands of the String#unpack method.
| Command | Return | Description |
|---|---|---|
| A | Stringa | Remove trailing nulls and spaces. |
| a | Stringa | String. |
| B | Stringa | Extract bits from each character (starting with the most significant bit). |
| b | Stringa | Extract bits from each character (starting with the least significant bit). |
| C | Fixnum | Extract a character as an unsigned integer. |
| c | Fixnum | Extract a character as an integer. |
| D, d | Float | Consider the characters of the length of sizeof(double) as a native double. |
| E | Float | Consider the characters of the length of sizeof(double) as a littleendian byte order double. |
| e | Float | Consider the characters of the length of sizeof(float) as a littleendian byte order float. |
| F, f | Float | Consider the characters of the length of sizeof(float) as a native float. |
| G | Float | Consider the characters of the length of sizeof(double) as a double in network byte order. |
| g | Float | Consider the characters of the length of sizeof(float) as a float in network byte order. |
| H | Stringa | Estrai esadecimale da ogni carattere (prima il bit più significativo). |
| h | Stringa | Estrai esadecimale da ogni carattere (prima il bit meno significativo). |
| I | Intero | Considera i caratteri consecutivi di lunghezza sizeof(int) (modificati tramite _) come integer nativo. |
| i | Intero | Considera i caratteri consecutivi di lunghezza sizeof(int) (modificati tramite _) come integer nativo signed. |
| L | Intero | Considera quattro caratteri consecutivi (modificati tramite _) come long integer nativo unsigned. |
| l | Intero | Considera quattro caratteri consecutivi (modificati tramite _) come long integer nativo signed. |
| M | Stringa | Citazione stampabile. |
| m | Stringa | Codifica Base64. |
| N | Intero | Considera quattro caratteri come unsigned long in ordine di byte network. |
| n | Fixnum | Considera due caratteri come unsigned short in ordine di byte network. |
| P | Stringa | Considera i caratteri di lunghezza sizeof(char *) come puntatore e torna \emph{len} caratteri dalla posizione di riferimento. |
| p | Stringa | Considera i caratteri di lunghezza sizeof(char *) come puntatore a stringa terminata da null. |
| Q | Intero | Considera otto caratteri come quad word (64 bit) unsigned. |
| q | Intero | Considera otto caratteri come quad word (64 bit) signed. |
| S | Fixnum | Considera due caratteri consecutivi (se usato _ è diverso) come unsigned short in ordine di byte nativo. |
| s | Fixnum | Considera due caratteri consecutivi (se usato _ è diverso) come short signed in ordine di byte nativo. |
| U | Intero | Carattere UTF-8, come intero unsigned. |
| u | Stringa | Codifica UU. |
| V | Fixnum | Considera quattro caratteri come unsigned long in ordine di byte little-endian. |
| v | Fixnum | Considera due caratteri come unsigned short in ordine di byte little-endian. |
| w | Intero | Intero compresso BER. |
| X | Salta un carattere indietro. | |
| x | Salta un carattere in avanti. | |
| Z | Stringa | Usato con *, rimuovi i null trailing fino al primo null. |
| @ | Salta l'offset specificato dal parametro length. |
Prova il seguente esempio, decomprimi vari dati.
"abc \0\0abc \0\0".unpack('A6Z6') #=> ["abc", "abc "]
"abc \0\0".unpack('a3a3') #=> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*') #=> ["abc ", "abc "]
"aa".unpack('b8B8') #=> ["10000110", "01100001"]
"aaa".unpack('h2H2c') #=> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS') #=> [-2, 65534]
"now=20is".unpack('M*') #=> ["now is"]
"whole".unpack('xax2aX2aX1aX2a') #=> ["h", "e", "l", "l", "o"]