Ruby Language
strängar
Sök…
Syntax
- 'En sträng' // skapar en sträng via en citerad bokstav
- "En sträng" // skapar en sträng via dubbelciterade bokstäver
- String.new ("En sträng")
- % q (A sträng) // alternativ syntax för att skapa enstaka citerade strängar
- % Q (A-sträng) // alternativ syntax för att skapa dubbla citerade strängar
Skillnad mellan enda citerade och dubbelciterade strängbokstäver
Huvudskillnaden är att dubbelciterade String bokstäver stödjer stränginterpolationer och hela uppsättningen av flukt-sekvenser.
Till exempel kan de inkludera godtyckliga Ruby-uttryck via interpolering:
# Single-quoted strings don't support interpolation
puts 'Now is #{Time.now}'
# Now is #{Time.now}
# Double-quoted strings support interpolation
puts "Now is #{Time.now}"
# Now is 2016-07-21 12:43:04 +0200
Dubbelciterade strängar stöder också hela uppsättningen av flukt-sekvenser inklusive "\n" , "\t" ...
puts 'Hello\nWorld'
# Hello\nWorld
puts "Hello\nWorld"
# Hello
# World
... medan enstaka citerade strängar stöder inga flyktningssekvenser, och utesluter den minimala uppsättning som krävs för att enstaka citerade strängar ska vara användbara: Bokstavliga enkla citationstecken och backstryk, '\'' respektive '\\' .
Skapa en sträng
Ruby tillhandahåller flera sätt att skapa ett String objekt. Det vanligaste sättet är att använda enstaka eller dubbla citat för att skapa en " strängbokstav ":
s1 = 'Hello'
s2 = "Hello"
Huvudskillnaden är att dubbelciterade strängbokstäver är lite mer flexibla eftersom de stöder interpolering och vissa motströmssekvenser.
Det finns också flera andra möjliga sätt att skapa en strängbokstavlig med hjälp av godtyckliga strängavgränsare. En godtycklig strängavgränsare är en % följt av ett matchande par avgränsare:
%(A string)
%{A string}
%<A string>
%|A string|
%!A string!
Slutligen kan du använda sekvensen %q och %Q , som motsvarar ' och " ":
puts %q(A string)
# A string
puts %q(Now is #{Time.now})
# Now is #{Time.now}
puts %Q(A string)
# A string
puts %Q(Now is #{Time.now})
# Now is 2016-07-21 12:47:45 +0200
Sekvenserna %q och %Q är användbara när strängen innehåller antingen enstaka citat, dubbla citat eller en blandning av båda. På detta sätt behöver du inte undvika innehållet:
%Q(<a href="/profile">User's profile<a>)
Du kan använda flera olika avgränsare, så länge det finns ett matchande par:
%q(A string)
%q{A string}
%q<A string>
%q|A string|
%q!A string!
Strängen sammankoppling
Sammanfoga strängar med + -operatören:
s1 = "Hello"
s2 = " "
s3 = "World"
puts s1 + s2 + s3
# => Hello World
s = s1 + s2 + s3
puts s
# => Hello World
Eller med << operatören:
s = 'Hello'
s << ' '
s << 'World'
puts s
# => Hello World
Observera att << -operatören modifierar objektet på vänster sida.
Du kan också multiplicera strängar, t.ex.
"wow" * 3
# => "wowwowwow"
Stränginterpolering
Den dubbelciterade avgränsaren " och %Q sekvensen stöder stränginterpolering med #{ruby_expression} :
puts "Now is #{Time.now}"
# Now is Now is 2016-07-21 12:47:45 +0200
puts %Q(Now is #{Time.now})
# Now is Now is 2016-07-21 12:47:45 +0200
Fall manipulation
"string".upcase # => "STRING"
"STRING".downcase # => "string"
"String".swapcase # => "sTRING"
"string".capitalize # => "String"
Dessa fyra metoder modifierar inte den ursprungliga mottagaren. Till exempel,
str = "Hello"
str.upcase # => "HELLO"
puts str # => "Hello"
Det finns fyra liknande metoder som utför samma åtgärder men ändrar originalmottagaren.
"string".upcase! # => "STRING"
"STRING".downcase! # => "string"
"String".swapcase! # => "sTRING"
"string".capitalize! # => "String"
Till exempel,
str = "Hello"
str.upcase! # => "HELLO"
puts str # => "HELLO"
Anmärkningar:
- före Ruby 2.4 hanterar dessa metoder inte unicode.
Dela en sträng
String#split delar en String i en Array , baserad på en avgränsare.
"alpha,beta".split(",")
# => ["alpha", "beta"]
En tom String resulterar i en tom Array :
"".split(",")
# => []
En icke-matchande avgränsare resulterar i en Array innehåller ett enda objekt:
"alpha,beta".split(".")
# => ["alpha,beta"]
Du kan också dela en sträng med vanliga uttryck:
"alpha, beta,gamma".split(/, ?/)
# => ["alpha", "beta", "gamma"]
Avgränsaren är valfri, som standard delas en sträng ut på vitutrymmet:
"alpha beta".split
# => ["alpha", "beta"]
Gå med strängar
Array#join förenar en Array in a String , baserat på en avgränsare:
["alpha", "beta"].join(",")
# => "alpha,beta"
Avgränsaren är valfri och är standard som en tom String .
["alpha", "beta"].join
# => "alphabeta"
En tom Array resulterar i en tom String , oavsett vilken avgränsare som används.
[].join(",")
# => ""
Multiline strängar
Det enklaste sättet att skapa en multiline-sträng är att bara använda flera rader mellan citattecken:
address = "Four score and seven years ago our fathers brought forth on this
continent, a new nation, conceived in Liberty, and dedicated to the
proposition that all men are created equal."
Det huvudsakliga problemet med den tekniken är att om strängen innehåller en offert, kommer den att bryta strängsyntaxen. För att lösa problemet kan du istället använda en heredok :
puts <<-RAVEN
Once upon a midnight dreary, while I pondered, weak and weary,
Over many a quaint and curious volume of forgotten lore—
While I nodded, nearly napping, suddenly there came a tapping,
As of some one gently rapping, rapping at my chamber door.
"'Tis some visitor," I muttered, "tapping at my chamber door—
Only this and nothing more."
RAVEN
Ruby stöder skal-stil här dokument med <<EOT , men den avslutande texten måste starta raden. Det skruvar upp kodindragningen, så det finns inte mycket skäl att använda den stilen. Tyvärr har strängen indragningar beroende på hur själva koden är indragad.
Ruby 2.3 löser problemet genom att införa <<~ som avlägsnar överskott av ledande utrymmen:
def build_email(address)
return (<<~EMAIL)
TO: #{address}
To Whom It May Concern:
Please stop playing the bagpipes at sunrise!
Regards,
Your neighbor
EMAIL
end
Procentsträngar arbetar också för att skapa flerlinje strängar:
%q(
HAMLET Do you see yonder cloud that's almost in shape of a camel?
POLONIUS By the mass, and 'tis like a camel, indeed.
HAMLET Methinks it is like a weasel.
POLONIUS It is backed like a weasel.
HAMLET Or like a whale?
POLONIUS Very like a whale
)
Det finns några sätt att undvika interpolering och flykt-sekvenser:
Enstaka offert istället för dubbla offert:
'\n is a carriage return.'Mindre bokstäver
qi en procentsträng:%q[#{not-a-variable}]Enkel citat terminalsträngen i en heredoc:
<<-'CODE' puts 'Hello world!' CODE
Formaterade strängar
Ruby kan injicera en mängd värden i en sträng genom att ersätta alla platshållare med värdena från den medföljande matrisen.
"Hello %s, my name is %s!" % ['World', 'br3nt']
# => Hello World, my name is br3nt!
Platshållarna representeras av två %s och värdena tillhandahålls av matrisen ['Hello', 'br3nt'] . Operatören % instruerar strängen att injicera matrisvärdena.
Stringkaraktersättare
tr metoden returnerar en kopia av en sträng där tecknen i det första argumentet ersätts av tecknen i det andra argumentet.
"string".tr('r', 'l') # => "stling"
För att ersätta endast den första förekomsten av ett mönster med med ett annat uttryck använda sub metoden
"string ring".sub('r', 'l') # => "stling ring"
Om du vill ersätta alla förekomster av ett mönster med det uttrycket, använd gsub
"string ring".gsub('r','l') # => "stling ling"
För att radera tecken, mata in en tom sträng för den andra parametern
Du kan också använda reguljära uttryck i alla dessa metoder.
Det är viktigt att notera att dessa metoder bara returnerar en ny kopia av en sträng och inte kommer att ändra strängen på plats. För att göra det måste du använda tr! , sub! och gsub! metoder respektive.
Förstå data i en sträng
I Ruby är en sträng bara en sekvens av byte tillsammans med namnet på en kodning (som UTF-8 , US-ASCII , ASCII-8BIT ) som anger hur du kan tolka dessa byte som tecken.
Rubinsträngar kan användas för att hålla text (i princip en sekvens av tecken), i vilket fall UTF-8-kodningen vanligtvis används.
"abc".bytes # => [97, 98, 99]
"abc".encoding.name # => "UTF-8"
Rubinsträngar kan också användas för att hålla binära data (en sekvens av byte), i vilket fall ASCII-8BIT-kodningen vanligtvis används.
[42].pack("i").encoding # => "ASCII-8BIT"
Det är möjligt för sekvensen av byte i en sträng att inte matcha kodningen, vilket resulterar i fel om du försöker använda strängen.
"\xFF \xFF".valid_encoding? # => false
"\xFF \xFF".split(' ') # ArgumentError: invalid byte sequence in UTF-8
Stringsubstitution
p "This is %s" % "foo"
# => "This is foo"
p "%s %s %s" % ["foo", "bar", "baz"]
# => "foo bar baz"
p "%{foo} == %{foo}" % {:foo => "foo" }
# => "foo == foo"
Se String % docs och Kernel :: sprintf för mer information.
Strängen börjar med
För att hitta om en sträng börjar med ett mönster, start_with? metoden är praktiskt
str = "zebras are cool"
str.start_with?("zebras") => true
Du kan också kontrollera mönstret med index
str = "zebras are cool"
str.index("zebras").zero? => true
Strängen slutar med
För att hitta om en sträng slutar med ett mönster, end_with? metoden är praktiskt
str = "I like pineapples"
str.end_with?("pineaaples") => false
Positioneringssträngar
I Ruby kan strängar vara vänster-rättfärdiga, höger-rättfärdiga eller centrerade
För att vänstertillföra sträng använder du ljust metoden. Detta tar in två parametrar, ett heltal som representerar antalet tecken i den nya strängen och en sträng, som representerar mönstret som ska fyllas.
Om heltalet är större än längden på den ursprungliga strängen kommer den nya strängen att vara rättfärdigad med den valfria strängparametern som tar återstående utrymme. Om strängparametern inte ges, kommer strängen vadderas med mellanslag.
str ="abcd"
str.ljust(4) => "abcd"
str.ljust(10) => "abcd "
För att rättfärdiggöra en sträng använder du rjust metoden. Detta tar in två parametrar, ett heltal som representerar antalet tecken i den nya strängen och en sträng, som representerar mönstret som ska fyllas.
Om heltalet är större än längden på den ursprungliga strängen, kommer den nya strängen att rättfärdigas med den valfria strängparametern som tar återstående utrymme. Om strängparametern inte ges, kommer strängen vadderas med mellanslag.
str = "abcd"
str.rjust(4) => "abcd"
str.rjust(10) => " abcd"
För att centrera en sträng använder center metoden. Detta tar in två parametrar, ett heltal som representerar bredden på den nya strängen och en sträng, som den ursprungliga strängen är vadderad med. Strängen justeras mot mitten.
str = "abcd"
str.center(4) => "abcd"
str.center(10) => " abcd "