Welcome to Software Development on Codidact!
Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.
Post History
The official ruby documentation explains the observed difference between the outputs of print and puts. The important bits are as follows: print For any non-string object given as argument (suc...
Answer
#11: Post edited
by
elgonzo
·
2021-06-13T14:14:38Z (almost 3 years ago)
Spelling...
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
> Each given object that isn't a string will be converted by calling its to_s method.- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe (and which is also documented, [link](https://docs.ruby-lang.org/en/master/Array.html#method-i-to_s)).
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/IO.html#method-i-puts)):
> If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
By the way, you can also achive almost the same output as `print` with `puts` by explictly invoking the `to_s` method like:- ```
- puts friends.to_s
- ```
- which will output
- > ["Mad man", "hey"]
- (It is only almost the same output as `print friends`, since `puts` writes a newline at the end of the output, whereas `print` does not -- unless of course you change the output record separator to a newline. See also hkotsubo's comment below.)
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object **that isn't a string** will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe (and which is also documented, [link](https://docs.ruby-lang.org/en/master/Array.html#method-i-to_s)).
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/IO.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object **that isn't a string or array** will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
- By the way, you can also achieve almost the same output as `print` with `puts` by explicitly invoking the `to_s` method like:
- ```
- puts friends.to_s
- ```
- which will output
- > ["Mad man", "hey"]
- (It is only almost the same output as `print friends`, since `puts` writes a newline at the end of the output, whereas `print` does not -- unless of course you change the output record separator to a newline. See also hkotsubo's comment below.)
#10: Post edited
by
elgonzo
·
2021-05-26T17:28:19Z (almost 3 years ago)
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe (and which is also documented, [link](https://docs.ruby-lang.org/en/master/Array.html#method-i-to_s)).
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/IO.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
- By the way, you can also achive almost the same output as `print` with `puts` by explictly invoking the `to_s` method like:
- ```
- puts friends.to_s
- ```
- which will output
- > ["Mad man", "hey"]
(It is only almost the same output as `print friends`, since `puts` writes a newline at the end of the output, whereas `print` does not. Unless of course you change the output record separator to a newline. See also hkotsubo's comment below.)
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe (and which is also documented, [link](https://docs.ruby-lang.org/en/master/Array.html#method-i-to_s)).
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/IO.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
- By the way, you can also achive almost the same output as `print` with `puts` by explictly invoking the `to_s` method like:
- ```
- puts friends.to_s
- ```
- which will output
- > ["Mad man", "hey"]
- (It is only almost the same output as `print friends`, since `puts` writes a newline at the end of the output, whereas `print` does not -- unless of course you change the output record separator to a newline. See also hkotsubo's comment below.)
#9: Post edited
by
elgonzo
·
2021-05-26T17:27:37Z (almost 3 years ago)
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe (and which is also documented, [link](https://docs.ruby-lang.org/en/master/Array.html#method-i-to_s)).
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/IO.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
- By the way, you can also achive almost the same output as `print` with `puts` by explictly invoking the `to_s` method like:
- ```
- puts friends.to_s
- ```
- which will output
- > ["Mad man", "hey"]
(It is only almost the same output as `print friends`, since `puts` writes a newline at the end of the output, whereas `print` does not.)
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe (and which is also documented, [link](https://docs.ruby-lang.org/en/master/Array.html#method-i-to_s)).
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/IO.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
- By the way, you can also achive almost the same output as `print` with `puts` by explictly invoking the `to_s` method like:
- ```
- puts friends.to_s
- ```
- which will output
- > ["Mad man", "hey"]
- (It is only almost the same output as `print friends`, since `puts` writes a newline at the end of the output, whereas `print` does not. Unless of course you change the output record separator to a newline. See also hkotsubo's comment below.)
#8: Post edited
by
elgonzo
·
2021-05-26T12:25:02Z (almost 3 years ago)
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe (and which is also documented, [link](https://docs.ruby-lang.org/en/master/Array.html#method-i-to_s)).
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/IO.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
By the way, you can also achive the same output as `print` with `puts` by explictly invoking the `to_s` method like:- ```
- puts friends.to_s
- ```
- which will output
> ["Mad man", "hey"]
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe (and which is also documented, [link](https://docs.ruby-lang.org/en/master/Array.html#method-i-to_s)).
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/IO.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
- By the way, you can also achive almost the same output as `print` with `puts` by explictly invoking the `to_s` method like:
- ```
- puts friends.to_s
- ```
- which will output
- > ["Mad man", "hey"]
- (It is only almost the same output as `print friends`, since `puts` writes a newline at the end of the output, whereas `print` does not.)
#7: Post edited
by
elgonzo
·
2021-05-24T21:41:18Z (almost 3 years ago)
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe (and which is also documented, [link](https://docs.ruby-lang.org/en/master/Array.html#method-i-to_s)).
- <br>
- <h3>puts</h3>
On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-puts)):- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
- By the way, you can also achive the same output as `print` with `puts` by explictly invoking the `to_s` method like:
- ```
- puts friends.to_s
- ```
- which will output
- > ["Mad man", "hey"]
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe (and which is also documented, [link](https://docs.ruby-lang.org/en/master/Array.html#method-i-to_s)).
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/IO.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
- By the way, you can also achive the same output as `print` with `puts` by explictly invoking the `to_s` method like:
- ```
- puts friends.to_s
- ```
- which will output
- > ["Mad man", "hey"]
#6: Post edited
by
elgonzo
·
2021-05-24T21:24:23Z (almost 3 years ago)
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe.- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
- By the way, you can also achive the same output as `print` with `puts` by explictly invoking the `to_s` method like:
- ```
- puts friends.to_s
- ```
- which will output
- > ["Mad man", "hey"]
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe (and which is also documented, [link](https://docs.ruby-lang.org/en/master/Array.html#method-i-to_s)).
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
- By the way, you can also achive the same output as `print` with `puts` by explictly invoking the `to_s` method like:
- ```
- puts friends.to_s
- ```
- which will output
- > ["Mad man", "hey"]
#5: Post edited
by
elgonzo
·
2021-05-24T21:11:34Z (almost 3 years ago)
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe.
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
- By the way, you can also achive the same output as `print` with `puts` by explictly invoking the `to_s` method like:
- ```
- puts friends.to_s
```
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe.
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
- By the way, you can also achive the same output as `print` with `puts` by explictly invoking the `to_s` method like:
- ```
- puts friends.to_s
- ```
- which will output
- > ["Mad man", "hey"]
#4: Post edited
by
elgonzo
·
2021-05-24T21:10:22Z (almost 3 years ago)
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe.
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe.
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- <br>
- By the way, you can also achive the same output as `print` with `puts` by explictly invoking the `to_s` method like:
- ```
- puts friends.to_s
- ```
#3: Post edited
by
elgonzo
·
2021-05-24T21:07:36Z (almost 3 years ago)
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe.
- <br>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- <h3>print</h3>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe.
- <br>
- <h3>puts</h3>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
#2: Post edited
by
elgonzo
·
2021-05-24T21:06:47Z (almost 3 years ago)
The official ruby documentation will tell you as much. The important bits are as follows:- <br>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe.
- <br>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
- The official ruby documentation explains the observed difference between the outputs of `print` and `puts`. The important bits are as follows:
- <br>
- For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)):
- > Each given object that isn't a string will be converted by calling its to_s method.
- And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe.
- <br>
- On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-puts)):
- > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method.
- Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.
#1: Initial revision
by
elgonzo
·
2021-05-24T21:06:11Z (almost 3 years ago)
The official ruby documentation will tell you as much. The important bits are as follows: <br> For any non-string object given as argument (such as an array, for example), `print` invokes the object's `to_s` method and outputs the resulting string returned by `to_s`. Quote from doc ([link](https://docs.ruby-lang.org/en/master/ARGF.html#method-i-print)): > Each given object that isn't a string will be converted by calling its to_s method. And as it so happens, the `to_s` method of your array produces the `["Mad man", "Hey"]` output you observe. <br> On the other hand, `puts` behaves differently when provided with an array. Quote from doc ([link](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-puts)): > If called with an array argument, writes each element on a new line. Each given object that isn't a string or array will be converted by calling its to_s method. Contrary to `print`, `puts` does NOT call the array's `to_s` method but rather directly outputs the array elements line-by-line.