modul Net::HTTPHeader

Gibt den String-Feldwert für den case-insensitiven Feldschlüssel key zurück oder nil, wenn kein solcher Schlüssel vorhanden ist; siehe Felder.

res = Net::HTTP.get_response(hostname, '/todos/1')
res['Connection'] # => "keep-alive"
res['Nosuch']     # => nil

Beachten Sie, dass einige Feldwerte über Komfortmethoden abgerufen werden können; siehe Getter.

Setzt den Wert für den case-insensitiven key auf val und überschreibt den vorherigen Wert, falls das Feld existiert; siehe Felder.

req = Net::HTTP::Get.new(uri)
req['Accept'] # => "*/*"
req['Accept'] = 'text/html'
req['Accept'] # => "text/html"

Beachten Sie, dass einige Feldwerte über Komfortmethoden gesetzt werden können; siehe Setter.

Fügt den Wert val dem Array-Wert für das Feld key hinzu, wenn das Feld existiert; erstellt das Feld mit dem angegebenen key und val, wenn es nicht existiert. siehe Felder.

req = Net::HTTP::Get.new(uri)
req.add_field('Foo', 'bar')
req['Foo']            # => "bar"
req.add_field('Foo', 'baz')
req['Foo']            # => "bar, baz"
req.add_field('Foo', %w[baz bam])
req['Foo']            # => "bar, baz, baz, bam"
req.get_fields('Foo') # => ["bar", "baz", "baz", "bam"]

Setzt den Header 'Authorization' unter Verwendung der angegebenen account- und password-Strings.

req.basic_auth('my_account', 'my_password')
req['Authorization']
# => "Basic bXlfYWNjb3VudDpteV9wYXNzd29yZA=="

Gibt true zurück, wenn das Feld 'Transfer-Encoding' existiert und den Wert 'chunked' hat, andernfalls false; siehe Transfer-Encoding Response Header.

res = Net::HTTP.get_response(hostname, '/todos/1')
res['Transfer-Encoding'] # => "chunked"
res.chunked?             # => true

Gibt zurück, ob die HTTP-Sitzung geschlossen werden soll.

Gibt zurück, ob die HTTP-Sitzung offen gehalten werden soll.

Gibt den Wert des Feldes 'Content-Length' als Integer zurück oder nil, wenn kein solches Feld vorhanden ist; siehe Content-Length Request Header.

res = Net::HTTP.get_response(hostname, '/nosuch/1')
res.content_length # => 2
res = Net::HTTP.get_response(hostname, '/todos/1')
res.content_length # => nil

Setzt den Wert des Feldes 'Content-Length' auf die gegebene numerische Zahl; siehe Content-Length Response Header.

_uri = uri.dup
hostname = _uri.hostname           # => "jsonplaceholder.typicode.com"
_uri.path = '/posts'               # => "/posts"
req = Net::HTTP::Post.new(_uri)    # => #<Net::HTTP::Post POST>
req.body = '{"title": "foo","body": "bar","userId": 1}'
req.content_length = req.body.size # => 42
req.content_type = 'application/json'
res = Net::HTTP.start(hostname) do |http|
  http.request(req)
end # => #<Net::HTTPCreated 201 Created readbody=true>

Gibt ein Range-Objekt zurück, das den Wert des Feldes 'Content-Range' darstellt, oder nil, wenn kein solches Feld existiert; siehe Content-Range Response Header.

res = Net::HTTP.get_response(hostname, '/todos/1')
res['Content-Range'] # => nil
res['Content-Range'] = 'bytes 0-499/1000'
res['Content-Range'] # => "bytes 0-499/1000"
res.content_range    # => 0..499

Gibt den Medientyp aus dem Wert des Feldes 'Content-Type' zurück oder nil, wenn kein solches Feld existiert; siehe Content-Type Response Header.

res = Net::HTTP.get_response(hostname, '/todos/1')
res['content-type'] # => "application/json; charset=utf-8"
res.content_type    # => "application/json"

Entfernt den Header für den case-insensitiven key (siehe Felder); gibt den gelöschten Wert zurück oder nil, wenn kein solcher Schlüssel existiert.

req = Net::HTTP::Get.new(uri)
req.delete('Accept') # => ["*/*"]
req.delete('Nosuch') # => nil

Wie each_header, aber die Schlüssel werden in kapitalisierter Form zurückgegeben.

Net::HTTPHeader#canonical_each ist ein Alias für Net::HTTPHeader#each_capitalized.

Ruft den Block mit jedem kapitalisierten Feldnamen auf.

res = Net::HTTP.get_response(hostname, '/todos/1')
res.each_capitalized_name do |key|
  p key if key.start_with?('C')
end

Ausgabe

"Content-Type"
"Connection"
"Cache-Control"
"Cf-Cache-Status"
"Cf-Ray"

Die Großschreibung ist systemabhängig; siehe Groß-/Kleinschreibung.

Gibt einen Enumerator zurück, wenn kein Block gegeben wird.

Ruft den Block mit jedem Schlüssel/Wert-Paar auf.

res = Net::HTTP.get_response(hostname, '/todos/1')
res.each_header do |key, value|
  p [key, value] if key.start_with?('c')
end

Ausgabe

["content-type", "application/json; charset=utf-8"]
["connection", "keep-alive"]
["cache-control", "max-age=43200"]
["cf-cache-status", "HIT"]
["cf-ray", "771d17e9bc542cf5-ORD"]

Gibt einen Enumerator zurück, wenn kein Block gegeben wird.

Net::HTTPHeader#each ist ein Alias für Net::HTTPHeader#each_header.

Ruft den Block mit jedem Feldschlüssel auf.

res = Net::HTTP.get_response(hostname, '/todos/1')
res.each_key do |key|
  p key if key.start_with?('c')
end

Ausgabe

"content-type"
"connection"
"cache-control"
"cf-cache-status"
"cf-ray"

Gibt einen Enumerator zurück, wenn kein Block gegeben wird.

Net::HTTPHeader#each_name ist ein Alias für Net::HTTPHeader#each_key.

Ruft den Block mit jedem String-Feldwert auf.

res = Net::HTTP.get_response(hostname, '/todos/1')
res.each_value do |value|
  p value if value.start_with?('c')
end

Ausgabe

"chunked"
"cf-q-config;dur=6.0000002122251e-06"
"cloudflare"

Gibt einen Enumerator zurück, wenn kein Block gegeben wird.

Mit einem Block gibt den String-Wert für key zurück, wenn er existiert; andernfalls gibt er den Wert des Blocks zurück; default_val wird ignoriert; siehe Felder.

res = Net::HTTP.get_response(hostname, '/todos/1')

# Field exists; block not called.
res.fetch('Connection') do |value|
  fail 'Cannot happen'
end # => "keep-alive"

# Field does not exist; block called.
res.fetch('Nosuch') do |value|
  value.downcase
end # => "nosuch"

Ohne Block gibt den String-Wert für key zurück, wenn er existiert; andernfalls wird default_val zurückgegeben, wenn es angegeben wurde; andernfalls wird eine Ausnahme ausgelöst.

res.fetch('Connection', 'Foo') # => "keep-alive"
res.fetch('Nosuch', 'Foo')     # => "Foo"
res.fetch('Nosuch')            # Raises KeyError.

Gibt den Array-Feldwert für den angegebenen key zurück oder nil, wenn kein solcher Feld vorhanden ist; siehe Felder.

res = Net::HTTP.get_response(hostname, '/todos/1')
res.get_fields('Connection') # => ["keep-alive"]
res.get_fields('Nosuch')     # => nil

Gibt true zurück, wenn das Feld für den case-insensitiven key existiert, andernfalls false.

req = Net::HTTP::Get.new(uri)
req.key?('Accept') # => true
req.key?('Nosuch') # => false

Gibt den führenden ('Typ')-Teil des Medientyps aus dem Wert des Feldes 'Content-Type' zurück oder nil, wenn kein solches Feld existiert; siehe Content-Type Response Header.

res = Net::HTTP.get_response(hostname, '/todos/1')
res['content-type'] # => "application/json; charset=utf-8"
res.main_type       # => "application"

Setzt den Header 'Proxy-Authorization' unter Verwendung der angegebenen account- und password-Strings.

req.proxy_basic_auth('my_account', 'my_password')
req['Proxy-Authorization']
# => "Basic bXlfYWNjb3VudDpteV9wYXNzd29yZA=="

Gibt ein Array von Range-Objekten zurück, die den Wert des Feldes 'Range' darstellen, oder nil, wenn kein solches Feld vorhanden ist; siehe Range Request Header.

req = Net::HTTP::Get.new(uri)
req['Range'] = 'bytes=0-99,200-299,400-499'
req.range # => [0..99, 200..299, 400..499]
req.delete('Range')
req.range # # => nil

Gibt die Integer-Länge des im Feld 'Content-Range' angegebenen Bereichs zurück oder nil, wenn kein solches Feld vorhanden ist; siehe Content-Range Response Header.

res = Net::HTTP.get_response(hostname, '/todos/1')
res['Content-Range'] # => nil
res['Content-Range'] = 'bytes 0-499/1000'
res.range_length     # => 500

Setzt den Wert des Feldes 'Content-Type'; gibt den neuen Wert zurück; siehe Content-Type Request Header.

req = Net::HTTP::Get.new(uri)
req.set_content_type('application/json') # => ["application/json"]

Net::HTTPHeader#content_type= ist ein Alias für Net::HTTPHeader#set_content_type.

Speichert Formulardaten für die Verwendung in einer POST- oder PUT-Anfrage.

Die in params angegebenen Formulardaten bestehen aus null oder mehr Feldern; jedes Feld ist

• Ein Skalarwert.

• Ein Name/Wert-Paar.

• Ein für das Lesen geöffneter IO-Stream.

Das Argument params sollte ein Enumerable sein (params.map wird aufgerufen) und ist oft ein Array oder ein Hash.

Zuerst richten wir eine Anfrage ein

_uri = uri.dup
_uri.path ='/posts'
req = Net::HTTP::Post.new(_uri)

Argument params als Array

Wenn params ein Array ist, ist jedes seiner Elemente ein Unterarray, das ein Feld definiert; das Unterarray kann enthalten

• Ein String

  req.set_form([['foo'], ['bar'], ['baz']])
  

• Zwei Strings

  req.set_form([%w[foo 0], %w[bar 1], %w[baz 2]])
  

• Wenn das Argument enctype (siehe unten) als 'multipart/form-data' angegeben wird

  • Ein String-Name und ein für das Lesen geöffneter IO-Stream.

    require 'stringio'
    req.set_form([['file', StringIO.new('Ruby is cool.')]])
    

  • Ein String-Name, ein für das Lesen geöffneter IO-Stream und ein Options-Hash, der diese Einträge enthalten kann.

    • :filename: Der Name der zu verwendenden Datei.

    • :content_type: Der Inhaltstyp der hochgeladenen Datei.

    Beispiel

    req.set_form([['file', file, {filename: "other-filename.foo"}]]

Die verschiedenen Formen können gemischt werden.

req.set_form(['foo', %w[bar 1], ['file', file]])

Argument params als Hash

Wenn params ein Hash ist, ist jeder seiner Einträge ein Name/Wert-Paar, das ein Feld definiert.

• Der Name ist ein String.

• Der Wert kann sein

  • nil.

  • Ein weiterer String.

  • Ein für das Lesen geöffneter IO-Stream (nur wenn das Argument enctype – siehe unten – als 'multipart/form-data' angegeben wird).

Beispiele

# Nil-valued fields.
req.set_form({'foo' => nil, 'bar' => nil, 'baz' => nil})

# String-valued fields.
req.set_form({'foo' => 0, 'bar' => 1, 'baz' => 2})

# IO-valued field.
require 'stringio'
req.set_form({'file' => StringIO.new('Ruby is cool.')})

# Mixture of fields.
req.set_form({'foo' => nil, 'bar' => 1, 'file' => file})

Das optionale Argument enctype gibt den Wert an, der für das Feld 'Content-Type' gesetzt werden soll, und muss einer der folgenden Werte sein:

• 'application/x-www-form-urlencoded' (der Standard).

• 'multipart/form-data'; siehe RFC 7578.

Das optionale Argument formopt ist ein Hash von Optionen (nur anwendbar, wenn das Argument enctype 'multipart/form-data' ist), der die folgenden Einträge enthalten kann:

• :boundary: Der Wert ist der Begrenzer-String für die Multipart-Nachricht. Wenn er nicht angegeben wird, ist der Begrenzer ein zufälliger String. Siehe Boundary.

• :charset: Der Wert ist die Zeichenkodierung für die Formularübermittlung. Feldnamen und Werte von Nicht-Datei-Feldern sollten mit diesem Zeichensatz kodiert werden.

Setzt den Anforderungs-Body auf einen URL-kodierten String, der aus dem Argument params abgeleitet wird, und setzt das Anforderungsheaderfeld 'Content-Type' auf 'application/x-www-form-urlencoded'.

Die resultierende Anfrage ist für HTTP-Anfragen POST oder PUT geeignet.

Das Argument params muss für die Verwendung als Argument enum für URI.encode_www_form geeignet sein.

Wenn nur das Argument params angegeben ist, wird der Body auf einen URL-kodierten String mit dem Standardtrenner '&' gesetzt.

req = Net::HTTP::Post.new('example.com')

req.set_form_data(q: 'ruby', lang: 'en')
req.body            # => "q=ruby&lang=en"
req['Content-Type'] # => "application/x-www-form-urlencoded"

req.set_form_data([['q', 'ruby'], ['lang', 'en']])
req.body            # => "q=ruby&lang=en"

req.set_form_data(q: ['ruby', 'perl'], lang: 'en')
req.body            # => "q=ruby&q=perl&lang=en"

req.set_form_data([['q', 'ruby'], ['q', 'perl'], ['lang', 'en']])
req.body            # => "q=ruby&q=perl&lang=en"

Wenn auch der String-Argument sep angegeben ist, wird dieser String als Trenner verwendet.

req.set_form_data({q: 'ruby', lang: 'en'}, '|')
req.body # => "q=ruby|lang=en"

Net::HTTPHeader#form_data= ist ein Alias für Net::HTTPHeader#set_form_data.

Setzt den Wert für das Feld 'Range'; siehe Range Request Header.

Mit dem Argument length

req = Net::HTTP::Get.new(uri)
req.set_range(100)      # => 100
req['Range']            # => "bytes=0-99"

Mit den Argumenten offset und length

req.set_range(100, 100) # => 100...200
req['Range']            # => "bytes=100-199"

Mit dem Argument range

req.set_range(100..199) # => 100..199
req['Range']            # => "bytes=100-199"

Net::HTTPHeader#range= ist ein Alias für Net::HTTPHeader#set_range.

Gibt den nachfolgenden ('Subtyp')-Teil des Medientyps aus dem Wert des Feldes 'Content-Type' zurück oder nil, wenn kein solches Feld existiert; siehe Content-Type Response Header.

res = Net::HTTP.get_response(hostname, '/todos/1')
res['content-type'] # => "application/json; charset=utf-8"
res.sub_type        # => "json"

Gibt einen Hash der Schlüssel/Wert-Paare zurück.

req = Net::HTTP::Get.new(uri)
req.to_hash
# =>
{"accept-encoding"=>["gzip;q=1.0,deflate;q=0.6,identity;q=0.3"],
 "accept"=>["*/*"],
 "user-agent"=>["Ruby"],
 "host"=>["jsonplaceholder.typicode.com"]}

Gibt den nachfolgenden ('Parameter')-Teil des Werts des Feldes 'Content-Type' zurück oder nil, wenn kein solches Feld existiert; siehe Content-Type Response Header.

res = Net::HTTP.get_response(hostname, '/todos/1')
res['content-type'] # => "application/json; charset=utf-8"
res.type_params     # => {"charset"=>"utf-8"}