Dylan North

Dylan North

1554956198

Lexical Scoping in JavaScript

Lexical scoping is a topic that frightens many programmers. One of the best explanations of lexical scoping can be found in Kyle Simpson’s book You Don’t Know JS: Scope and Closures. However, even his explanation is lacking because he doesn’t use a real example.

One of the best real examples of how lexical scoping works, and why it is important, can be found in the famous textbook, “The Structure and Interpretation of Computer Programs” (SICP) by Harold Abelson and Gerald Jay Sussman. Here is a link to a PDF version of the book: SICP. SICP uses Scheme, a dialect of Lisp, and is considered one of the best introductory computer science texts ever written. In this article, I’d like to revisit their example of lexical scoping using JavaScript as the programming language.

The example Abelson and Sussman used is computing square roots using Newton’s method. Newton’s method works by determining successive approximations for the square root of a number until the approximation comes within a tolerance limit for being acceptable. Let’s work through an example, as Abelson and Sussman do in SICP.

The example they use is finding the square root of 2. You start by making a guess at the square root of 2, say 1. You improve this guess by dividing the original number by the guess and then averaging that quotient and the current guess to come up with the next guess. You stop when you reach an acceptable level of approximation. Abelson and Sussman use the value 0.001. Here is a run-through of the first few steps in the calculation:

Square root to find: 2
First guess: 1
Quotient: 2 / 1 = 2
Average: (2+1) / 2 = 1.5
Next guess: 1.5
Quotient: 1.5 / 2 = 1.3333
Average: (1.3333 + 1.5) / 2 = 1.4167
Next guess: 1.4167
Quotient: 1.4167 / 2 = 1.4118
Average: (1.4167 + 1.4118) / 2 = 1.4142

And so on until the guess comes within our approximation limit, which for this algorithm is 0.001.

A JavaScript Function for Newton’s Method

After this demonstration of the method the authors describe a general procedure for solving this problem in Scheme. Rather than show you the Scheme code, I’ll write it out in JavaScript:

function sqrt_iter(guess, x) {
  if (isGoodEnough(guess, x)) {
    return guess;
  }  
  else {
    return sqrt_iter(improve(guess, x), x);
  }
}

Next, we need to flesh out several other functions, including isGoodEnough() and improve(), along with some other helper functions. We’ll start with improve(). Here is the definition:

function improve(guess, x) {
  return average(guess, (x / guess));
}

This function uses a helper function average(). Here is that definition:

function average(x, y) {
  return (x+y) / 2;
}

Now we’re ready to define the isGoodEnough() function. This function serves to determine when our guess is close enough to our approximation tolerance (0.001). Here is the definition of isGoodEnough():

function isGoodEnough(guess, x) {
  return (Math.abs(square(guess) - x)) < 0.001;
}

This function uses a square() function, which is easy to define:

function square(x) {
  return x * x;
}

Now all we need is a function to get things started:

function sqrt(x) {
  return sqrt_iter(1.0, x);
}

This function uses 1.0 as a starting guess, which is usually just fine.

Now we’re ready to test our functions to see if they work. We load them into a JS shell and then compute a few square roots:

> .load sqrt_iter.js
> sqrt(3)
1.7321428571428572
> sqrt(9)
3.00009155413138
> sqrt(94 + 87)
13.453624188555612
> sqrt(144)
12.000000012408687

The functions seem to be working well. However, there is a better idea lurking here. These functions are all written independently, even though they are meant to work in conjunction with each other. We probably aren’t going to use the isGoodEnough() function with any other set of functions, or on its own. Also, the only function that matters to the user is the sqrt() function, since that’s the one that gets called to find a square root.

Block Scoping Hides Helper Functions

The solution here is to use block scoping to define all the necessary helper functions within the block of the sqrt() function. We are going to remove square() and average() from the definition, as those functions might be useful in other function definitions and aren’t as limited to use in an algorithm that implements Newton’s Method. Here is the definition of the sqrt() function now with the other helper functions defined within the scope of sqrt():

function sqrt(x) {
  function improve(guess, x) {
    return average(guess, (x / guess));
  }
  function isGoodEnough(guess, x) {
    return (Math.abs(square(guess) - x)) > 0.001;
  }
  function sqrt_iter(guess, x) {
    if (isGoodEnough(guess, x)) {
      return guess;
    }
    else {
      return sqrt_iter(improve(guess, x), x);
    }
  }
  return sqrt_iter(1.0, x);
}

We can now load this program into our shell and compute some square roots:

> .load sqrt_iter.js
> sqrt(9)
3.00009155413138
> sqrt(2)
1.4142156862745097
> sqrt(3.14159)
1.772581833543688
> sqrt(144)
12.000000012408687

Notice that you cannot call any of the helper functions from outside the sqrt() function:

> sqrt(9)
3.00009155413138
> sqrt(2)
1.4142156862745097
> improve(1,2)
ReferenceError: improve is not defined
> isGoodEnough(1.414, 2)
ReferenceError: isGoodEnough is not defined

Since the definitions of these functions (improve() and isGoodEnough()) have been moved inside the scope of sqrt(), they cannot be accessed at a higher level. Of course, you can move any of the helper function definitions outside of the sqrt() function to have access to them globally as we did with average() and square().

We have greatly improved our implementation of Newton’s Method but there’s still one more thing we can do to improve our sqrt() function by simplifying it even more by taking advantage of lexical scope.

Improving Clarity with Lexical Scope

The concept behind lexical scope is that when a variable is bound to an environment, other procedures (functions) that are defined in that environment have access to that variable’s value. This means that in the sqrt() function, the parameter x is bound to that function, meaning that any other function defined within the body of sqrt() can access x.

Knowing this, we can simplify the definition of sqrt() even more by removing all references to x in function definitions since x is now a free variable and accessible by all of them. Here is our new definition of sqrt():

function sqrt(x) {
  function isGoodEnough(guess) {
    return (Math.abs(square(guess) - x)) > 0.001;
  }
  function improve(guess) {
    return average(guess, (x / guess));
  }
  function sqrt_iter(guess) {
    if (isGoodEnough(guess)) {
      return guess;
    }
    else {
      return sqrt_iter(improve(guess));
    }
  }
  return sqrt_iter(1.0);
}

The only references to parameter x are in computations where x’s value is needed. Let’s load this new definition into the shell and test it:

> .load sqrt_iter.js
> sqrt(9)
3.00009155413138
> sqrt(2)
1.4142156862745097
> sqrt(123+37)
12.649110680047308
> sqrt(144)
12.000000012408687

Lexical scoping and block structure are important features of JavaScript and allow us to construct programs that are easier to understand and manage. This is especially important when we begin to construct larger, more complex programs.

Originally published by Michael McMillan at https://medium.com/@mmmcmillan1957/lexical-scoping-in-javascript-e876cd221b74*

Follow great articles on Twitter

Learn More

☞ The Complete JavaScript Course 2019: Build Real Projects!

☞ Become a JavaScript developer - Learn (React, Node,Angular)

☞ JavaScript: Understanding the Weird Parts

☞ Vue JS 2 - The Complete Guide (incl. Vue Router & Vuex)

☞ The Full JavaScript & ES6 Tutorial - (including ES7 & React)

☞ JavaScript - Step By Step Guide For Beginners

☞ The Web Developer Bootcamp

☞ MERN Stack Front To Back: Full Stack React, Redux & Node.js

☞ Visual Studio Code Settings and Extensions for Faster JavaScript Development

☞ Vue.js Authentication System with Node.js Backend

#javascript

What is GEEK

Buddha Community

Lexical Scoping in JavaScript
Julie  Donnelly

Julie Donnelly

1602380460

Closures and Lexical Scoping in JavaScript

Variables in JavaScript have two types of scoping i.e. Local and Global scope. If any variable is declared inside a function, then it is a local variable and if the variable is declared outside the function then it is global variable. The scope of variables is defined by their position in the code.

Lexical Scope

JavaScript follows Lexical scoping for functions. Lexical scope means any child’s scope has access to the variables defined in parent’s scope i.e. inner functions can access the global variables.

var a = 5;

function sum() {
  return a + 6;
}
console.log(sum()); // 11

In the above example, function sum() is using global variable "a" to perform the addition. That means variable "a" is in scope of sum().

#closure #lexical-scope #javascript #javascript-tips #web-development

Rahul Jangid

1622207074

What is JavaScript - Stackfindover - Blog

Who invented JavaScript, how it works, as we have given information about Programming language in our previous article ( What is PHP ), but today we will talk about what is JavaScript, why JavaScript is used The Answers to all such questions and much other information about JavaScript, you are going to get here today. Hope this information will work for you.

Who invented JavaScript?

JavaScript language was invented by Brendan Eich in 1995. JavaScript is inspired by Java Programming Language. The first name of JavaScript was Mocha which was named by Marc Andreessen, Marc Andreessen is the founder of Netscape and in the same year Mocha was renamed LiveScript, and later in December 1995, it was renamed JavaScript which is still in trend.

What is JavaScript?

JavaScript is a client-side scripting language used with HTML (Hypertext Markup Language). JavaScript is an Interpreted / Oriented language called JS in programming language JavaScript code can be run on any normal web browser. To run the code of JavaScript, we have to enable JavaScript of Web Browser. But some web browsers already have JavaScript enabled.

Today almost all websites are using it as web technology, mind is that there is maximum scope in JavaScript in the coming time, so if you want to become a programmer, then you can be very beneficial to learn JavaScript.

JavaScript Hello World Program

In JavaScript, ‘document.write‘ is used to represent a string on a browser.

<script type="text/javascript">
	document.write("Hello World!");
</script>

How to comment JavaScript code?

  • For single line comment in JavaScript we have to use // (double slashes)
  • For multiple line comments we have to use / * – – * /
<script type="text/javascript">

//single line comment

/* document.write("Hello"); */

</script>

Advantages and Disadvantages of JavaScript

#javascript #javascript code #javascript hello world #what is javascript #who invented javascript

Hire Dedicated JavaScript Developers -Hire JavaScript Developers

It is said that a digital resource a business has must be interactive in nature, so the website or the business app should be interactive. How do you make the app interactive? With the use of JavaScript.

Does your business need an interactive website or app?

Hire Dedicated JavaScript Developer from WebClues Infotech as the developer we offer is highly skilled and expert in what they do. Our developers are collaborative in nature and work with complete transparency with the customers.

The technology used to develop the overall app by the developers from WebClues Infotech is at par with the latest available technology.

Get your business app with JavaScript

For more inquiry click here https://bit.ly/31eZyDZ

Book Free Interview: https://bit.ly/3dDShFg

#hire dedicated javascript developers #hire javascript developers #top javascript developers for hire #hire javascript developer #hire a freelancer for javascript developer #hire the best javascript developers

Niraj Kafle

1589255577

The essential JavaScript concepts that you should understand

As a JavaScript developer of any level, you need to understand its foundational concepts and some of the new ideas that help us developing code. In this article, we are going to review 16 basic concepts. So without further ado, let’s get to it.

#javascript-interview #javascript-development #javascript-fundamental #javascript #javascript-tips

Ajay Kapoor

1626321063

JS Development Company India | JavaScript Development Services

PixelCrayons: Our JavaScript web development service offers you a feature-packed & dynamic web application that effectively caters to your business challenges and provide you the best RoI. Our JavaScript web development company works on all major frameworks & libraries like Angular, React, Nodejs, Vue.js, to name a few.

With 15+ years of domain expertise, we have successfully delivered 13800+ projects and have successfully garnered 6800+ happy customers with 97%+ client retention rate.

Looking for professional JavaScript web app development services? We provide custom JavaScript development services applying latest version frameworks and libraries to propel businesses to the next level. Our well-defined and manageable JS development processes are balanced between cost, time and quality along with clear communication.

Our JavaScript development companies offers you strict NDA, 100% money back guarantee and agile/DevOps approach.

#javascript development company #javascript development services #javascript web development #javascript development #javascript web development services #javascript web development company