Modul URI

Ähnlich wie URI.decode_www_form_component, außer dass '+' beibehalten wird.

Gibt Namens-/Wertpaare zurück, die aus der gegebenen Zeichenkette str abgeleitet wurden, welche eine ASCII-Zeichenkette sein muss.

Die Methode kann verwendet werden, um den Body eines Net::HTTPResponse-Objekts res zu dekodieren, für das res['Content-Type'] gleich 'application/x-www-form-urlencoded' ist.

Die zurückgegebenen Daten sind ein Array von 2-elementigen Unterarrays; jedes Unterarray ist ein Namens-/Wertpaar (beide sind Zeichenketten). Jede zurückgegebene Zeichenkette hat die Kodierung enc und ungültige Zeichen wurden durch String#scrub entfernt.

Ein einfaches Beispiel

URI.decode_www_form('foo=0&bar=1&baz')
# => [["foo", "0"], ["bar", "1"], ["baz", ""]]

Die zurückgegebenen Zeichenketten haben bestimmte Konvertierungen, ähnlich denen, die in URI.decode_www_form_component durchgeführt werden.

URI.decode_www_form('f%23o=%2F&b-r=%24&b+z=%40')
# => [["f#o", "/"], ["b-r", "$"], ["b z", "@"]]

Die gegebene Zeichenkette kann aufeinanderfolgende Trennzeichen enthalten.

URI.decode_www_form('foo=0&&bar=1&&baz=2')
# => [["foo", "0"], ["", ""], ["bar", "1"], ["", ""], ["baz", "2"]]

Ein anderes Trennzeichen kann angegeben werden.

URI.decode_www_form('foo=0--bar=1--baz', separator: '--')
# => [["foo", "0"], ["bar", "1"], ["baz", ""]]

Gibt eine Zeichenkette zurück, die aus der gegebenen URL-kodierten Zeichenkette str dekodiert wurde.

Die gegebene Zeichenkette wird zuerst als Encoding::ASCII_8BIT (unter Verwendung von String#b) kodiert, dann dekodiert (wie unten) und schließlich mit der gegebenen Kodierung enc erzwungen kodiert.

Die zurückgegebene Zeichenkette

• Behält bei

  • Die Zeichen '*', '.', '-' und '_'.

  • Zeichen im Bereich 'a'..'z', 'A'..'Z' und '0'..'9'.

  Beispiel

  URI.decode_www_form_component('*.-_azAZ09')
  # => "*.-_azAZ09"
  

• Konvertiert

  • Das Zeichen '+' in das Zeichen ' '.

  • Jede „Prozentnotation“ in ein ASCII-Zeichen.

  Beispiel

  URI.decode_www_form_component('Here+are+some+punctuation+characters%3A+%2C%3B%3F%3A')
  # => "Here are some punctuation characters: ,;?:"
  

Verwandt: URI.decode_uri_component (behält '+' bei).

Ähnlich wie URI.encode_www_form_component, außer dass ' ' (Leerzeichen) als '%20' kodiert wird (anstatt als '+').

Gibt eine URL-kodierte Zeichenkette zurück, die aus dem gegebenen Enumerable enum abgeleitet wurde.

Das Ergebnis eignet sich für die Verwendung als Formulardaten für eine HTTP-Anfrage, deren Content-Type 'application/x-www-form-urlencoded' lautet.

Die zurückgegebene Zeichenkette besteht aus den Elementen von enum, die jeweils in eine oder mehrere URL-kodierte Zeichenketten konvertiert und alle mit dem Zeichen '&' verbunden sind.

Einfache Beispiele

URI.encode_www_form([['foo', 0], ['bar', 1], ['baz', 2]])
# => "foo=0&bar=1&baz=2"
URI.encode_www_form({foo: 0, bar: 1, baz: 2})
# => "foo=0&bar=1&baz=2"

Die zurückgegebene Zeichenkette wird mit der Methode URI.encode_www_form_component gebildet, die bestimmte Zeichen konvertiert.

URI.encode_www_form('f#o': '/', 'b-r': '$', 'b z': '@')
# => "f%23o=%2F&b-r=%24&b+z=%40"

Wenn enum Array-ähnlich ist, wird jedes Element ele in ein Feld konvertiert.

• Wenn ele ein Array mit zwei oder mehr Elementen ist, wird das Feld aus seinen ersten beiden Elementen gebildet (und alle zusätzlichen Elemente werden ignoriert).

  name = URI.encode_www_form_component(ele[0], enc)
  value = URI.encode_www_form_component(ele[1], enc)
  "#{name}=#{value}"
  

  Beispiele

  URI.encode_www_form([%w[foo bar], %w[baz bat bah]])
  # => "foo=bar&baz=bat"
  URI.encode_www_form([['foo', 0], ['bar', :baz, 'bat']])
  # => "foo=0&bar=baz"
  

• Wenn ele ein Array mit einem Element ist, wird das Feld aus ele[0] gebildet.

  URI.encode_www_form_component(ele[0])
  

  Beispiel

  URI.encode_www_form([['foo'], [:bar], [0]])
  # => "foo&bar&0"
  

• Andernfalls wird das Feld aus ele gebildet.

  URI.encode_www_form_component(ele)
  

  Beispiel

  URI.encode_www_form(['foo', :bar, 0])
  # => "foo&bar&0"
  

Die Elemente eines Array-ähnlichen enum können gemischt sein.

URI.encode_www_form([['foo', 0], ['bar', 1, 2], ['baz'], :bat])
# => "foo=0&bar=1&baz&bat"

Wenn enum Hash-ähnlich ist, wird jedes key/value-Paar in ein oder mehrere Felder konvertiert.

• Wenn value Array-konvertierbar ist, wird jedes Element ele in value mit key gepaart, um ein Feld zu bilden.

  name = URI.encode_www_form_component(key, enc)
  value = URI.encode_www_form_component(ele, enc)
  "#{name}=#{value}"
  

  Beispiel

  URI.encode_www_form({foo: [:bar, 1], baz: [:bat, :bam, 2]})
  # => "foo=bar&foo=1&baz=bat&baz=bam&baz=2"
  

• Andernfalls werden key und value gepaart, um ein Feld zu bilden.

  name = URI.encode_www_form_component(key, enc)
  value = URI.encode_www_form_component(value, enc)
  "#{name}=#{value}"
  

  Beispiel

  URI.encode_www_form({foo: 0, bar: 1, baz: 2})
  # => "foo=0&bar=1&baz=2"
  

Die Elemente eines Hash-ähnlichen enum können gemischt sein.

URI.encode_www_form({foo: [0, 1], bar: 2})
# => "foo=0&foo=1&bar=2"

Gibt eine URL-kodierte Zeichenkette zurück, die aus der gegebenen Zeichenkette str abgeleitet wurde.

Die zurückgegebene Zeichenkette

• Behält bei

  • Die Zeichen '*', '.', '-' und '_'.

  • Zeichen im Bereich 'a'..'z', 'A'..'Z' und '0'..'9'.

  Beispiel

  URI.encode_www_form_component('*.-_azAZ09')
  # => "*.-_azAZ09"
  

• Konvertiert

  • Das Zeichen ' ' in das Zeichen '+'.

  • Jedes andere Zeichen in eine „Prozentnotation“; die Prozentnotation für das Zeichen *c* ist '%%%X' % c.ord.

  Beispiel

  URI.encode_www_form_component('Here are some punctuation characters: ,;?:')
  # => "Here+are+some+punctuation+characters%3A+%2C%3B%3F%3A"
  

Encoding

• Wenn str die Kodierung Encoding::ASCII_8BIT hat, wird das Argument enc ignoriert.

• Andernfalls wird str zuerst in Encoding::UTF_8 (mit geeigneten Zeichenersetzungen) und dann in die Kodierung enc konvertiert.

In beiden Fällen hat die zurückgegebene Zeichenkette die erzwungene Kodierung Encoding::US_ASCII.

Verwandt: URI.encode_uri_component (kodiert ' ' als '%20').

Gibt ein neues Objekt zurück, das aus dem gegebenen scheme, arguments und default konstruiert wurde.

• Das neue Objekt ist eine Instanz von URI.scheme_list[scheme.upcase].

• Das Objekt wird initialisiert, indem der Klasseninitialisierer unter Verwendung von scheme und arguments aufgerufen wird. Siehe URI::Generic.new.

Beispiele

values = ['john.doe', 'www.example.com', '123', nil, '/forum/questions/', nil, 'tag=networking&order=newest', 'top']
URI.for('https', *values)
# => #<URI::HTTPS https://john.doe@www.example.com:123/forum/questions/?tag=networking&order=newest#top>
URI.for('foo', *values, default: URI::HTTP)
# => #<URI::HTTP foo://john.doe@www.example.com:123/forum/questions/?tag=networking&order=newest#top>

Führt die gegebenen URI-Zeichenketten str gemäß RFC 2396 zusammen.

Jede Zeichenkette in str wird vor dem Zusammenführen in eine RFC3986 URI konvertiert.

Beispiele

URI.join("http://example.com/","main.rbx")
# => #<URI::HTTP http://example.com/main.rbx>

URI.join('http://example.com', 'foo')
# => #<URI::HTTP http://example.com/foo>

URI.join('http://example.com', '/foo', '/bar')
# => #<URI::HTTP http://example.com/bar>

URI.join('http://example.com', '/foo', 'bar')
# => #<URI::HTTP http://example.com/bar>

URI.join('http://example.com', '/foo/', 'bar')
# => #<URI::HTTP http://example.com/foo/bar>

Ermöglicht das Öffnen verschiedener Ressourcen, einschließlich URIs.

Wenn das erste Argument auf die Methode 'open' reagiert, wird 'open' darauf mit den restlichen Argumenten aufgerufen.

Wenn das erste Argument eine Zeichenkette ist, die mit (protocol):// beginnt, wird sie von URI.parse analysiert. Wenn das analysierte Objekt auf die Methode 'open' reagiert, wird 'open' darauf mit den restlichen Argumenten aufgerufen.

Andernfalls wird Kernel#open aufgerufen.

OpenURI::OpenRead#open stellt URI::HTTP#open, URI::HTTPS#open und URI::FTP#open, Kernel#open bereit.

Wir können URIs und Zeichenketten akzeptieren, die mit http://, https:// und ftp:// beginnen. In diesen Fällen wird das geöffnete Dateiobjekt von OpenURI::Meta erweitert.

Gibt ein neues URI-Objekt zurück, das aus der gegebenen Zeichenkette uri konstruiert wurde.

URI.parse('https://john.doe@www.example.com:123/forum/questions/?tag=networking&order=newest#top')
# => #<URI::HTTPS https://john.doe@www.example.com:123/forum/questions/?tag=networking&order=newest#top>
URI.parse('http://john.doe@www.example.com:123/forum/questions/?tag=networking&order=newest#top')
# => #<URI::HTTP http://john.doe@www.example.com:123/forum/questions/?tag=networking&order=newest#top>

Es wird empfohlen, zuerst die Zeichenkette uri mit URI::RFC2396_PARSER.escape zu escapen, wenn sie ungültige URI-Zeichen enthalten könnte.

Setzt die Standard-Parser-Instanz.

Registriert die gegebene klass als die Klasse, die instanziiert werden soll, wenn eine URI mit dem gegebenen scheme analysiert wird.

URI.register_scheme('MS_SEARCH', URI::Generic) # => URI::Generic
URI.scheme_list['MS_SEARCH']                   # => URI::Generic

Beachten Sie, dass nach dem Aufruf von String#upcase auf scheme, dieses ein gültiger Konstantenname sein muss.

Gibt einen Hash der definierten Schemata zurück.

URI.scheme_list
# =>
{"MAILTO"=>URI::MailTo,
 "LDAPS"=>URI::LDAPS,
 "WS"=>URI::WS,
 "HTTP"=>URI::HTTP,
 "HTTPS"=>URI::HTTPS,
 "LDAP"=>URI::LDAP,
 "FILE"=>URI::File,
 "FTP"=>URI::FTP}

Verwandt: URI.register_scheme.

Gibt ein 9-elementiges Array zurück, das die Teile der aus der Zeichenkette uri gebildeten URI darstellt; jedes Array-Element ist eine Zeichenkette oder nil.

names = %w[scheme userinfo host port registry path opaque query fragment]
values = URI.split('https://john.doe@www.example.com:123/forum/questions/?tag=networking&order=newest#top')
names.zip(values)
# =>
[["scheme", "https"],
 ["userinfo", "john.doe"],
 ["host", "www.example.com"],
 ["port", "123"],
 ["registry", nil],
 ["path", "/forum/questions/"],
 ["opaque", nil],
 ["query", "tag=networking&order=newest"],
 ["fragment", "top"]]

Gibt eine Zeichenkette zurück, die Zeichen dekodiert, die dem regexp aus der gegebenen URL-kodierten Zeichenkette str entsprechen.

Gibt eine Zeichenkette zurück, die aus der gegebenen Zeichenkette str abgeleitet wurde, mit URI-kodierten Zeichen, die regexp gemäß table entsprechen.