Ruby передается по ссылке или по значению?

@user.update_languages(params[:language][:language1], 
                       params[:language][:language2], 
                       params[:language][:language3])
lang_errors = @user.errors
logger.debug "--------------------LANG_ERRORS----------101-------------" 
                + lang_errors.full_messages.inspect

if params[:user]
  @user.state = params[:user][:state]
  success = success & @user.save
end
logger.debug "--------------------LANG_ERRORS-------------102----------" 
                + lang_errors.full_messages.inspect

if lang_errors.full_messages.empty?

@userОбъект добавляет ошибки к lang_errorsпеременной в update_lanugagesметоде. когда я выполняю сохранение @userобъекта, я теряю ошибки, которые изначально были сохранены в lang_errorsпеременной.

Хотя то, что я пытаюсь сделать, было бы скорее хаком (который, похоже, не работает). Я хотел бы понять, почему значения переменных вымываются. Я понимаю, что передача по ссылке, поэтому я хотел бы знать, как значение может храниться в этой переменной, не стираясь.

В традиционной терминологии Ruby строго передается по значению . Но это не совсем то, что вы спрашиваете здесь.

Ruby не имеет понятия чистого, не ссылочного значения, поэтому вы определенно не можете передать его методу. Переменные всегда являются ссылками на объекты. Чтобы получить объект, который не изменится из-под вас, вам нужно дублировать или клонировать переданный вами объект, таким образом давая объект, на который никто больше не ссылается. (Однако даже это не является пуленепробиваемым - оба стандартных метода клонирования делают поверхностное копирование, поэтому переменные экземпляра клона по-прежнему указывают на те же объекты, что и оригиналы. Если объекты, на которые ссылается ивар, видоизменяются, это будет по-прежнему отображаются в копии, поскольку ссылаются на те же объекты.)

Остальные ответчики все правы, но друг попросил меня объяснить ему это, и что на самом деле сводится к тому, как Ruby обрабатывает переменные, поэтому я подумал, что поделюсь некоторыми простыми картинками / объяснениями, которые я написал для него (извинения за длину и, вероятно, некоторое упрощение)

В1: Что происходит, когда вы назначаете новую переменную strзначению 'foo'?

str = 'foo'
str.object_id # => 2000

A: Создана вызываемая метка, strкоторая указывает на объект 'foo', который для состояния этого интерпретатора Ruby оказывается в ячейке памяти 2000.

Q2: Что происходит, когда вы назначаете существующую переменную strновому объекту с помощью =?

str = 'bar'.tap{|b| puts "bar: #{b.object_id}"} # bar: 2002
str.object_id # => 2002

A: Метка strтеперь указывает на другой объект.

Q3: что происходит, когда вы назначаете новую переменную = в str?

str2 = str
str2.object_id # => 2002

A: Создана новая метка с именем, str2которая указывает на тот же объект, что и str.

Q4: что произойдет, если объект, на который ссылается str и str2будет изменен?

str2.replace 'baz'
str2 # => 'baz'
str  # => 'baz'
str.object_id # => 2002
str2.object_id # => 2002

A: Обе метки по-прежнему указывают на один и тот же объект, но сам объект мутировал (его содержимое изменилось на что-то другое).

Как это связано с первоначальным вопросом?

В основном это то же самое, что происходит в Q3 / Q4; метод получает свою собственную частную копию переменной / label ( str2), которая передается ему ( str). Он не может изменить объект, на который str указывает метка , но он может изменить содержимое объекта, на который они оба ссылаются, чтобы содержать else:

str = 'foo'

def mutate(str2)
  puts "str2: #{str2.object_id}"
  str2.replace 'bar'
  str2 = 'baz'
  puts "str2: #{str2.object_id}"
end

str.object_id # => 2004
mutate(str) # str2: 2004, str2: 2006
str # => "bar"
str.object_id # => 2004

Ruby использует «передачу по ссылке на объект»

(Используя терминологию Python.)

Сказать, что в Ruby используется «передача по значению» или «передача по ссылке», на самом деле недостаточно, чтобы быть полезным. Я думаю, что, как большинство людей знают это в наши дни, эта терминология («значение» против «ссылка») происходит из C ++.

В C ++ «передача по значению» означает, что функция получает копию переменной, и любые изменения в копии не изменяют оригинал. Это верно и для объектов. Если вы передаете переменную объекта по значению, тогда весь объект (включая все его члены) копируется, и любые изменения в элементах не изменяют эти элементы в исходном объекте. (Другое дело, если вы передаете указатель по значению, но в Ruby все равно нет указателей, AFAIK.)

class A {
  public:
    int x;
};

void inc(A arg) {
  arg.x++;
  printf("in inc: %d\n", arg.x); // => 6
}

void inc(A* arg) {
  arg->x++;
  printf("in inc: %d\n", arg->x); // => 1
}

int main() {
  A a;
  a.x = 5;
  inc(a);
  printf("in main: %d\n", a.x); // => 5

  A* b = new A;
  b->x = 0;
  inc(b);
  printf("in main: %d\n", b->x); // => 1

  return 0;
}

Вывод:

in inc: 6
in main: 5
in inc: 1
in main: 1

В C ++ «передача по ссылке» означает, что функция получает доступ к исходной переменной. Он может назначить целое новое литеральное целое число, и тогда исходная переменная также будет иметь это значение.

void replace(A &arg) {
  A newA;
  newA.x = 10;
  arg = newA;
  printf("in replace: %d\n", arg.x);
}

int main() {
  A a;
  a.x = 5;
  replace(a);
  printf("in main: %d\n", a.x);

  return 0;
}

Вывод:

in replace: 10
in main: 10

Ruby использует передачу по значению (в смысле C ++), если аргумент не является объектом. Но в Ruby все является объектом, поэтому в Ruby нет смысла передавать по значению в C ++.

В Ruby используется «передача по ссылке на объект» (для использования терминологии Python):

• Внутри функции любому члену объекта могут быть назначены новые значения, и эти изменения сохранятся после возврата из функции. *
• Внутри функции присвоение переменной нового объекта приводит к тому, что переменная перестает ссылаться на старый объект. Но после возврата из функции исходная переменная все равно будет ссылаться на старый объект.

Поэтому Ruby не использует «передачу по ссылке» в смысле C ++. Если это так, то присвоение нового объекта переменной внутри функции приведет к тому, что старый объект будет забыт после возврата функции.

class A
  attr_accessor :x
end

def inc(arg)
  arg.x += 1
  puts arg.x
end

def replace(arg)
  arg = A.new
  arg.x = 3
  puts arg.x
end

a = A.new
a.x = 1
puts a.x  # 1

inc a     # 2
puts a.x  # 2

replace a # 3
puts a.x  # 2

puts ''

def inc_var(arg)
  arg += 1
  puts arg
end

b = 1     # Even integers are objects in Ruby
puts b    # 1
inc_var b # 2
puts b    # 1

Вывод:

1
2
2
3
2

1
2
1

Вот почему в Ruby, если вы хотите изменить объект внутри функции, но забыть об этих изменениях при возврате функции, вы должны явно сделать копию объекта, прежде чем вносить временные изменения в копию.

Ruby передается по ссылке или по значению?

Ruby передается по значению. Всегда. Без исключений. Нет, если Никаких "но.

Вот простая программа, которая демонстрирует этот факт:

def foo(bar)
  bar = 'reference'
end

baz = 'value'

foo(baz)

puts "Ruby is pass-by-#{baz}"
# Ruby is pass-by-value

Ruby в строгом смысле передается по значению, НО значения являются ссылками.

Это можно назвать « передачей по значению ». Эта статья имеет лучшее объяснение, которое я читал: http://robertheaton.com/2014/07/22/is-ruby-pass-by-reference-or-pass-by-value/

Передача-ссылка-значение может быть кратко объяснена следующим образом:

Функция получает ссылку (и получит доступ) к тому же объекту в памяти, который используется вызывающей стороной. Однако он не получает ящик, в котором вызывающая сторона хранит этот объект; Как и в случае передачи значения по значению, функция предоставляет свой собственный блок и создает новую переменную для себя.

Получающееся поведение фактически является комбинацией классических определений передачи по ссылке и передачи по значению.

Уже есть несколько хороших ответов, но я хочу опубликовать определение пары авторитетов по этому вопросу, но также надеюсь, что кто-то может объяснить, что сказали авторитеты Матц (создатель Ruby) и Дэвид Фланаган в своей превосходной книге О'Рейли, Язык программирования Ruby .

[из 3.8.1: Ссылки на объекты]

Когда вы передаете объект методу в Ruby, это ссылка на объект, которая передается методу. Это не сам объект, и это не ссылка на ссылку на объект. Другой способ сказать, что аргументы метода передаются по значению, а не по ссылке , но что переданные значения являются ссылками на объекты.

Поскольку ссылки на объекты передаются методам, методы могут использовать эти ссылки для изменения базового объекта. Эти модификации затем видны, когда метод возвращается.

Это все имеет смысл для меня до последнего абзаца и особенно до последнего предложения. Это в лучшем случае вводит в заблуждение, а в худшем - смешивает. Каким образом изменения в этой переданной по значению ссылке могут изменить базовый объект?

Ruby передается по ссылке или по значению?

Руби это передача по ссылке. Всегда. Без исключений. Нет, если Никаких "но.

Вот простая программа, которая демонстрирует этот факт:

def foo(bar)
  bar.object_id
end

baz = 'value'

puts "#{baz.object_id} Ruby is pass-by-reference #{foo(baz)} because object_id's (memory addresses) are always the same ;)"

=> 2279146940 Ruby является передачей по ссылке 2279146940, потому что object_id (адреса памяти) всегда одинаковы;)

def bar(babar)
  babar.replace("reference")
end

bar(baz)

puts "some people don't realize it's reference because local assignment can take precedence, but it's clearly pass-by-#{baz}"

=> некоторые люди не понимают, что это ссылка, потому что локальное назначение может иметь приоритет, но оно явно передается по ссылке

Параметры являются копией оригинальной ссылки. Таким образом, вы можете изменить значения, но не можете изменить исходную ссылку.

Попробуй это:--

1.object_id
#=> 3

2.object_id
#=> 5

a = 1
#=> 1
a.object_id
#=> 3

b = 2
#=> 2
b.object_id
#=> 5

идентификатор a содержит object_id 3 для объекта значения 1, а идентификатор b содержит object_id 5 для объекта значения 2.

Теперь сделайте это:

a.object_id = 5
#=> error

a = b
#value(object_id) at b copies itself as value(object_id) at a. value object 2 has object_id 5
#=> 2

a.object_id 
#=> 5

Теперь, a и b оба содержат один и тот же object_id 5, который ссылается на объект значения 2. Таким образом, переменная Ruby содержит object_ids для ссылки на объекты значения.

Выполнение следующих действий также дает ошибку:

c
#=> error

но это не даст ошибки:

5.object_id
#=> 11

c = 5
#=> value object 5 provides return type for variable c and saves 5.object_id i.e. 11 at c
#=> 5
c.object_id
#=> 11 

a = c.object_id
#=> object_id of c as a value object changes value at a
#=> 11
11.object_id
#=> 23
a.object_id == 11.object_id
#=> true

a
#=> Value at a
#=> 11

Здесь идентификатор возвращает значение объекта 11, чей идентификатор объекта равен 23, то есть object_id 23 находится на идентификаторе a. Теперь мы видим пример с использованием метода.

def foo(arg)
  p arg
  p arg.object_id
end
#=> nil
11.object_id
#=> 23
x = 11
#=> 11
x.object_id
#=> 23
foo(x)
#=> 11
#=> 23

Аргумент в foo присваивается с возвращаемым значением х. Это ясно показывает, что аргумент передается значением 11, а значение 11 само по себе является объектом с уникальным идентификатором объекта 23.

Теперь посмотрите также:

def foo(arg)
  p arg
  p arg.object_id
  arg = 12
  p arg
  p arg.object_id
end

#=> nil
11.object_id
#=> 23
x = 11
#=> 11
x.object_id
#=> 23
foo(x)
#=> 11
#=> 23
#=> 12
#=> 25
x
#=> 11
x.object_id
#=> 23

Здесь идентификатор arg сначала содержит object_id 23 для ссылки 11, а после внутреннего присваивания со значением объекта 12 он содержит object_id 25. Но он не меняет значение, на которое ссылается идентификатор x, используемый в вызывающем методе.

Следовательно, Ruby передается по значению, а переменные Ruby не содержат значений, но содержат ссылку на объект значения.

Руби интерпретируется. Переменные - это ссылки на данные, но не сами данные. Это облегчает использование одной и той же переменной для данных разных типов.

Присвоение lhs = rhs затем копирует ссылку на rhs, а не данные. Это отличается в других языках, таких как C, где присваивание копирует данные в lhs из rhs.

Таким образом, для вызова функции переданная переменная, скажем, x, действительно копируется в локальную переменную в функции, но x является ссылкой. Затем будет две копии ссылки, обе ссылаются на одни и те же данные. Один будет в звонящем, другой в функции.

Назначение в функции затем скопирует новую ссылку на версию функции x. После этого версия вызывающего абонента x остается неизменной. Это все еще ссылка на исходные данные.

Напротив, использование метода .replace для x приведет к тому, что ruby ​​сделает копию данных. Если замена используется перед любыми новыми назначениями, тогда вызывающая сторона также увидит изменение данных в своей версии.

Точно так же, пока исходная ссылка находится в такте для переданной переменной, переменные экземпляра будут такими же, как видит вызывающая сторона. В рамках объекта переменные экземпляра всегда имеют самые современные ссылочные значения, независимо от того, предоставляются ли они вызывающей стороной или задаются в функции, которой был передан класс.

'Вызов по значению' или 'Вызов по ссылке' здесь запутан из-за путаницы над '=' В скомпилированных языках '=' является копией данных. Здесь на этом интерпретируемом языке '=' является справочной копией. В этом примере передается ссылка, за которой следует ссылочная копия, хотя '=', которая перекрывает оригинал, переданный в ссылке, а затем люди говорят об этом, как если бы '=' была копией данных.

Чтобы соответствовать определениям, мы должны придерживаться «.replace», так как это копия данных. С точки зрения «.replace» мы видим, что это действительно передача по ссылке. Кроме того, если мы пройдем через отладчик, мы увидим, что ссылки передаются, поскольку переменные являются ссылками.

Однако если мы должны сохранить '=' в качестве системы отсчета, тогда мы действительно увидим переданные данные вплоть до назначения, а затем мы больше не увидим их после назначения, пока данные вызывающей стороны остаются неизменными. На поведенческом уровне это передается по значению, пока мы не считаем переданное значение составным - поскольку мы не сможем сохранить его часть при изменении другой части в одном назначении (как это назначение изменяет ссылку и оригинал выходит за рамки видимости). Также будет бородавка, в этом случае переменные в объектах будут ссылками, как и все переменные. Следовательно, мы будем вынуждены говорить о передаче «ссылки по значению» и должны использовать связанные выражения.

Следует отметить, что вам даже не нужно использовать метод «заменить», чтобы изменить исходное значение. Если вы назначите одно из значений хеш-функции для хэша, вы измените исходное значение.

def my_foo(a_hash)
  a_hash["test"]="reference"
end;

hash = {"test"=>"value"}
my_foo(hash)
puts "Ruby is pass-by-#{hash["test"]}"

Two references refer to same object as long as there is no reassignment. 

Любые обновления в том же объекте не будут ссылаться на новую память, поскольку она все еще находится в той же памяти. Вот несколько примеров:

    a = "first string"
    b = a



    b.upcase! 
    => FIRST STRING
    a
    => FIRST STRING

    b = "second string"


a
    => FIRST STRING
    hash = {first_sub_hash: {first_key: "first_value"}}
first_sub_hash = hash[:first_sub_hash]
first_sub_hash[:second_key] = "second_value"

    hash
    => {first_sub_hash: {first_key: "first_value", second_key: "second_value"}}

    def change(first_sub_hash)
    first_sub_hash[:third_key] = "third_value"
    end

    change(first_sub_hash)

    hash
    =>  {first_sub_hash: {first_key: "first_value", second_key: "second_value", third_key: "third_value"}}

Да, но ....

Ruby передает ссылку на объект, и поскольку все в ruby ​​является объектом, вы можете сказать, что он передается по ссылке.

Я не согласен с сообщениями здесь, утверждающими, что это передача по значению, которая кажется мне педантичной, символической игрой.

Однако, по сути, он «скрывает» поведение, потому что большинство операций ruby ​​предоставляет «из коробки» - например, строковые операции создают копию объекта:

> astringobject = "lowercase"

> bstringobject = astringobject.upcase
> # bstringobject is a new object created by String.upcase

> puts astringobject
lowercase

> puts bstringobject
LOWERCASE

Это означает, что большую часть времени исходный объект остается неизменным, создавая впечатление, что ruby ​​является «передачей по значению».

Конечно, при разработке ваших собственных классов понимание деталей этого поведения важно как для функционального поведения, эффективности памяти и производительности.