Do these two lines of code match? JavaScript versus Ruby

Question

Do these two lines of code match? JavaScript versus Ruby

Using Ruby:

->  { 10.times {|i| puts i} }.call

For JavaScript:

(function (){
    for (i = 0; i<10; i++){
        console.log(i);
    }
})()

As someone with a background in JS, I found it interesting to learn about lambdas and Procs in Ruby, as they are functions without names that can be called. This concept reminded me of anonymous functions or Immediately Invoked Function Expressions (IIFE) in JavaScript.

Are these two examples similar? If not, what sets them apart?

javascript ruby-on-rails ruby

Answer 1

Answer №1

These two statements are incredibly dissimilar in almost every way.

If we were to find the equivalent ECMAScript code for this Ruby snippet:

-> { 10.times {|i| puts i} }.call

It might look something like this:

(() => { 10.times(i => puts(i)) }).call()

However, since numbers cannot have methods in ECMAScript, a solution similar to the following is necessary:

(() => { times(10, i => puts(i)) }).call()

To make this work, we would need to include some extra Ruby library support code:

(() => { times(10, i => puts(i)) }).call()

function times(i, f) { if (i-- === 0) return; else { times(i, f); f(i) }}
function puts(s) { console.log(s) }

While still not identical to the original Ruby behavior, it's much closer compared to the alternative proposal:

Your approach introduces i into the global scope, whereas the Ruby code retains the variable as local to the inner block.
Ruby utilizes the method Proc#call rather than a function call operator, which ECMAScript also employs (Function.prototype.call).
Ruby uses a custom iteration method on Integer, while your ECMAScript suggestion involves a for loop.
In Ruby, Kernel#puts writes implicitly to the default output stream, while your ECMAScript version explicitly writes to the console.
self in Ruby is lexically bound, but in ECMAScript, this is dynamically tied to the function object unless an arrow function literal is used, ensuring lexical binding of this.

Conversely, the ECMAScript equivalent to:

(function (){
    for (i = 0; i<10; i++){
        console.log(i);
    }
})()

Might be represented by:

-> { $i = 0; while $i < 10 do $stdout.puts($i); $i += 1 end }.()

Once again, this is not completely analogous:

Ruby lacks a for loop and makes use of a while loop instead.
The call operator in Ruby is absent, with .() merely being syntactic sugar for the call method.
this in nested function expressions is dynamically bound, whereas self remains lexically bound in Ruby.

Answer 2

These two statements are incredibly dissimilar in almost every way.

If we were to find the equivalent ECMAScript code for this Ruby snippet:

-> { 10.times {|i| puts i} }.call

It might look something like this:

(() => { 10.times(i => puts(i)) }).call()

However, since numbers cannot have methods in ECMAScript, a solution similar to the following is necessary:

(() => { times(10, i => puts(i)) }).call()

To make this work, we would need to include some extra Ruby library support code:

(() => { times(10, i => puts(i)) }).call()

function times(i, f) { if (i-- === 0) return; else { times(i, f); f(i) }}
function puts(s) { console.log(s) }

While still not identical to the original Ruby behavior, it's much closer compared to the alternative proposal:

Your approach introduces i into the global scope, whereas the Ruby code retains the variable as local to the inner block.
Ruby utilizes the method Proc#call rather than a function call operator, which ECMAScript also employs (Function.prototype.call).
Ruby uses a custom iteration method on Integer, while your ECMAScript suggestion involves a for loop.
In Ruby, Kernel#puts writes implicitly to the default output stream, while your ECMAScript version explicitly writes to the console.
self in Ruby is lexically bound, but in ECMAScript, this is dynamically tied to the function object unless an arrow function literal is used, ensuring lexical binding of this.

Conversely, the ECMAScript equivalent to:

(function (){
    for (i = 0; i<10; i++){
        console.log(i);
    }
})()

Might be represented by:

-> { $i = 0; while $i < 10 do $stdout.puts($i); $i += 1 end }.()

Once again, this is not completely analogous:

Ruby lacks a for loop and makes use of a while loop instead.
The call operator in Ruby is absent, with .() merely being syntactic sugar for the call method.
this in nested function expressions is dynamically bound, whereas self remains lexically bound in Ruby.

Do these two lines of code match? JavaScript versus Ruby

Answer №1

Similar questions

Leverage the power of gRPC with Node.js and TypeScript for seamless

Leveraging mongo-triggers for automation

Adding multiple text as label and sublabel in a React MUI Tooltip can be achieved by utilizing the appropriate

The responsiveness of Angular Material appears to be limited when tested in Chrome's debug mode for different devices

Combining items from the identical array in pairs using distinct identifiers

Encountering an error when using AngularJS 1.7 with ES6 and webpack: Uncaught TypeError - Property 'module' is undefined

How come the values keep appearing without any loops or subsequent calls being made to the PHP file?

How can you begin using version 4.4.0 of nuxtjs/axios in nuxt.js?

Modifying embedded text using a variable

What is the method to escape from a for loop in Protractor?

Managing form submissions in React with inputs spread across multiple components

Tips for showing numbers in 2 decimal places while still storing them in 4 decimal places within Angular

Fixed Element Transitioning from Starting Position on Scroll

Looking to refresh the current page once an image has been successfully uploaded and the bootstrap model has been closed? Learn how to achieve this using cropper

Effortless trending items formula for an online retail store using JavaScript

The use of Bootstrap carousel indicators effectively controls event propagation

Create a new array by adding keys and their values to multiple documents

Two approaches to discovering a set of items within an array that yield contrasting outcomes

JavaScript template engines that rely on the DOM tree system

Dynamic resizing navigation with JQUERY