Results for: "String#[]"

Struct#[]=

Assigns a value to a member.

With symbol or string argument name given, assigns the given value to the named member; returns value:

Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe[:zip] = 54321 # => 54321
joe # => #<struct Customer name="Joe Smith", address="123 Maple, Anytown NC", zip=54321>

Raises NameError if name is not the name of a member.

With integer argument n given, assigns the given value to the n-th member if n is in range; see Array Indexes at Array:

joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe[2] = 54321           # => 54321
joe[-3] = 'Joseph Smith' # => "Joseph Smith"
joe # => #<struct Customer name="Joseph Smith", address="123 Maple, Anytown NC", zip=54321>

Raises IndexError if n is out of range.

Hash#[]=

Associates the given object with the given key; returns object.

Searches for a hash key equivalent to the given key; see Hash Key Equivalence.

If the key is found, replaces its value with the given object; the ordering is not affected (see Entry Order):

h = {foo: 0, bar: 1}
h[:foo] = 2 # => 2
h[:foo]     # => 2

If key is not found, creates a new entry for the given key and object; the new entry is last in the order (see Entry Order):

h = {foo: 0, bar: 1}
h[:baz] = 2 # => 2
h[:baz]     # => 2
h           # => {:foo=>0, :bar=>1, :baz=>2}

Related: []; see also Methods for Assigning.

ENV::[]=

Creates, updates, or deletes the named environment variable, returning the value. Both name and value may be instances of String. See Valid Names and Values.

If the named environment variable does not exist:

If value is nil, does nothing.

ENV.clear
ENV['foo'] = nil # => nil
ENV.include?('foo') # => false
ENV.store('bar', nil) # => nil
ENV.include?('bar') # => false

If value is not nil, creates the environment variable with name and value:

# Create 'foo' using ENV.[]=.
ENV['foo'] = '0' # => '0'
ENV['foo'] # => '0'
# Create 'bar' using ENV.store.
ENV.store('bar', '1') # => '1'
ENV['bar'] # => '1'

If the named environment variable exists:

If value is not nil, updates the environment variable with value value:

# Update 'foo' using ENV.[]=.
ENV['foo'] = '2' # => '2'
ENV['foo'] # => '2'
# Update 'bar' using ENV.store.
ENV.store('bar', '3') # => '3'
ENV['bar'] # => '3'

If value is nil, deletes the environment variable:

# Delete 'foo' using ENV.[]=.
ENV['foo'] = nil # => nil
ENV.include?('foo') # => false
# Delete 'bar' using ENV.store.
ENV.store('bar', nil) # => nil
ENV.include?('bar') # => false

Raises an exception if name or value is invalid. See Invalid Names and Values.

Ractor#[]=

set a value in ractor-local storage of current Ractor Obsolete and use Ractor.[]= instead.

Ractor::[]=

set a value in ractor-local storage of current Ractor

Thread#[]=

Attribute Assignment—Sets or creates the value of a fiber-local variable, using either a symbol or a string.

Warning::[]=

Sets the warning flags for category. See Warning.[] for the categories.

StringIO#string=

Assigns the underlying string as other_string, and sets position to zero; returns other_string:

StringIO.open('foo') do |strio|
  p strio.string
  strio.string = 'bar'
  p strio.string
end

Output:

"foo"
"bar"

Related: StringIO#string (returns the underlying string).

StringScanner#string=

Replaces the [stored string] with the given other_string:

Sets both [positions] to zero.
Clears [match values].
Returns other_string.

scanner = StringScanner.new('foobar')
scanner.scan(/foo/)
put_situation(scanner)
# Situation:
#   pos:       3
#   charpos:   3
#   rest:      "bar"
#   rest_size: 3
match_values_cleared?(scanner) # => false

scanner.string = 'baz'         # => "baz"
put_situation(scanner)
# Situation:
#   pos:       0
#   charpos:   0
#   rest:      "baz"
#   rest_size: 3
match_values_cleared?(scanner) # => true

Win32::Registry#[]=

Write value to a registry value named name.

If wtype is specified, the value type is it. Otherwise, the value type is depend on class of value: :Integer

REG_DWORD

:String

REG_SZ

:Array

REG_MULTI_SZ

Gem::ConfigFile#[]=

Set configuration option key to value.

YAML::DBM#[]=

Set key to value in database.

value will be converted to YAML before storage.

See store for more information.

ObjectSpace::WeakMap#[]=

Associates the given value with the given key.

If the given key exists, replaces its value with the given value; the ordering is not affected.

ObjectSpace::WeakKeyMap#[]=

Associates the given value with the given key

The reference to key is weak, so when there is no other reference to key it may be garbage collected.

If the given key exists, replaces its value with the given value; the ordering is not affected

Net::HTTPHeader#[]=

Sets the value for the case-insensitive key to val, overwriting the previous value if the field exists; see Fields:

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

Note that some field values may be set via convenience methods; see Setters.

Gem::done_installing

Adds a post-installs hook that will be passed a Gem::DependencyInstaller and a list of installed specifications when Gem::DependencyInstaller#install is complete

Module::nesting

Returns the list of Modules nested at the point of call.

module M1
  module M2
    $a = Module.nesting
  end
end
$a           #=> [M1::M2, M1]
$a[0].name   #=> "M1::M2"

Proc#binding

Returns the binding associated with prc.

def fred(param)
  proc {}
end

b = fred(99)
eval("param", b.binding)   #=> 99

TracePoint#binding

Returns the generated binding object from the event.

Note that for :c_call and :c_return events, the method returns nil, since C methods themselves do not have bindings.

Returns a Binding object, describing the variable and method bindings at the point of call. This object can be used when calling Binding#eval to execute the evaluated command in this environment, or extracting its local variables.

class User
  def initialize(name, position)
    @name = name
    @position = position
  end

  def get_binding
    binding
  end
end

user = User.new('Joan', 'manager')
template = '{name: @name, position: @position}'

# evaluate template in context of the object
eval(template, user.get_binding)
#=> {:name=>"Joan", :position=>"manager"}

Binding#local_variable_get can be used to access the variables whose names are reserved Ruby keywords:

# This is valid parameter declaration, but `if` parameter can't
# be accessed by name, because it is a reserved word.
def validate(field, validation, if: nil)
  condition = binding.local_variable_get('if')
  return unless condition

  # ...Some implementation ...
end

validate(:name, :empty?, if: false) # skips validation
validate(:name, :empty?, if: true) # performs validation

Object#instance_variable_defined?

Returns true if the given instance variable is defined in obj. String arguments are converted to symbols.

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
fred.instance_variable_defined?(:@a)    #=> true
fred.instance_variable_defined?("@b")   #=> true
fred.instance_variable_defined?("@c")   #=> false