Wie man Ruby String zu n Zeichen erzwingt

Wie Kraft, Ruby string-variable Ausgabe mit puts zu n Zeichen, so dass, wenn die variable mehr, wird es abgeschnitten, wenn Sie kürzer, wird Sie erweitert durch folgende oder führende Leerzeichen?

Gibt es einige standard-Verfahren, dies zu tun?

InformationsquelleAutor der Frage Paul | 2013-02-05

49

Ruby unterstützt die Verwendung von format-strings, wie viele andere Sprachen:
```
[11] (pry) main: 0> '%3.3 s' % 'f' 
=> "f" 
[12] (pry) main: 0> '%3.3 s' - % 'foo' 
=> "foo" 
[13] (pry) main: 0> '%3.3 s' - % 'foobar' 
=> "foo" 
```
Wenn Sie wollen-pad auf der rechten Seite, verwenden Sie ein - im format-string:
```
[14] (pry) main: 0> '%-3.3 s' % 'f' 
=> "f" 
[15] (pry) main: 0> '%-3.3 s' - % 'foo' 
=> "foo" 
[16] (pry) main: 0> '%-3.3 s' - % 'foobar' 
=> "foo" 
```
Könnten Sie auch printf oder sprintfaber ich bevorzuge die mehr generische die %die wie sprintf.

Aus der sprintf docs:
```
 s | Argument ist ein string, der ersetzt werden soll. Wenn das format 
| Sequenz enthält eine Präzision, bei den meisten, dass viele Zeichen 
| kopiert werden. 
```
und:
```
- | all - | Links-rechtfertigen das Ergebnis dieser Umwandlung. 
```
Was ist, wenn ich will-pad nicht mit Leerzeichen, sondern mit einigen anderen Zeichen?

Der zugrunde liegenden Ruby-code ist in C geschrieben, und es ist hart codiert, um die Verwendung ' ' als Füllzeichen, so dass es nicht direkt möglich, es sei denn, Sie möchten, ändern Sie die Quelle, kompilieren Sie Ihre Ruby und live mit einer einmaligen version von der Sprache. Stattdessen können Sie etwas tun:
```
[17] (pry) main: 0> ('%-3.3 s' % 'f').gsub(' ', '.') 
=> "f.." 
```
Dieser bekommt eine Menge komplizierter als eine einfache gsub obwohl. Oft ist es besser, passen Sie die Zeichenfolge ohne Verwendung von format-strings, wenn Sie brauchen, um zu liefern spezielle Zeichen. Format-strings sind sehr mächtig, aber Sie sind nicht völlig flexibel.

Ansonsten würde ich gehen mit so etwas wie @steenslag Lösung, die die basis für Ihre eigenen Rollen. Sie verlieren die Fähigkeit zur Nutzung von format-strings und sind darauf angewiesen, Ihre Verkettung von strings oder etwas ähnliches zu bekommen, einspaltig ausgegeben, aber es wird auch funktionieren.

InformationsquelleAutor der Antwort the Tin Man
27

Machen eine Zeichenfolge fester Länge kürzer:
```
  str_var.slice(1..10)
```
Machen eine Zeichenfolge fester Länge mehr:
```
  str_var.ljust(10, ' ')
```
Sie kombiniert werden könnten, in so etwas wie:
```
  (str_var.length > 10) ? str_var.slice(1..10) : str_var.ljust(10, ' ')
```
Wo str_var ist, natürlich, Ihren string

InformationsquelleAutor der Antwort MiGro

class String
  def fix(size, padstr=' ')
    self[0...size].rjust(size, padstr) #or ljust
  end
end

p 'lettersletters'.fix(9) #=> "lettersle"
p 'letters'.fix(10, '.')  #=> "...letters"

Verbindet die slice - Methode ([]) mit rjust.

InformationsquelleAutor der Antwort steenslag

3

Für einen reinen Rubin one-liner, die Sie dies tun können:
```
(str + ' ' * length)[0,length]
```
Die Ausbeute:
```
str = "Hello"
length = 10
=> "Hello     "
```
oder:
```
str = "Hello"
length = 2
=> "He"
```
InformationsquelleAutor der Antwort superluminary
1

Wenn Sie reden über eine Methode zum abschneiden von strings würde ich check out ActionView::Helpers::TextHelper#truncate

Aus den Beispielen:
```
truncate("Once upon a time in a world far far away")

# => Once upon a time in a world...
```
InformationsquelleAutor der Antwort Kormie

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.