01_Javascript as a Dynamic Typed language

-

  • Source Code: Original code (usually typed by a human into a computer)
  • Translation: Converting source code into something a computer can read (i.e. machine code)
  • Run-Time: Period when program is executing commands (after compilation, if compiled)
  • Compiled: Code translated before run-time
  • Interpreted: Code translated on the fly, during execution




Typing

“When types are checked” : "3" + 5 will raise a type error in strongly typed languages, such as


  • Python and Go, because they don't allow for "type coercion": the ability for a value to change type implicitly in certain contexts (e.g. merging two types using +). Weakly typed languages, such as JavaScript, won't throw a type error (result: '35').


  • Static: "Types checked before run-time.Static typing can be also considered as limited form of program verification and in a type-safe language, can be considered also an optimization. If a compiler can prove that a program is well-typed, then it does not need dynamics checks, allowing the resulting compiled binary to run faster and to be smaller."

  • Dynamic: Types checked on the fly, during execution

  • The definitions of “Static & Compiled” and “Dynamic & Interpreted” are quite similar…but remember it’s “when types are checked” vs. “when source code is translated”.

"Type-checking has nothing to do with the language being compiled or interpreted!"

JavaScript is dynamically vs weakly typed language.

Does JS have types?

 JavaScript is untyped or that it shouldn’t call its type system types. It doesn’t require you to declare a type when making a variable like in some other strongly typed languages i.e int x = 10 I  would argue that JS does have types.
JS is both dynamically typed and weakly typed.

Statically Typed

JS is not statically typed unless you’re using a language, tool such as Typescript or Flow that compiles to JS code. But we’ll briefly cover it for comparison reasons.
Statically typed means the type is enforced and won’t change so easily. All variables must be declared with a type.
int x = 5
string y = 'abc'

Dynamically Typed

Dynamically typed languages infer variable types at runtime. This means once your code is run the compiler/interpreter will see your variable and its value then decide what type it is. The type is still enforced here, it just decides what the type is.
var a = 1 // int
b = 'test' // string
// etc

Weakly Typed

Weakly typed languages allow types to be inferred as another type. For example, 1 + '2' // '12' In JS it sees you’re trying to add a number with a string — an invalid operation — so it coerces your number into a string and results in the string ‘12’.

Primitives

These six types are considered to be primitives. A primitive is not an object and has no methods of its own. All primitives are immutable.
  • Boolean — true or false
  • Null — no value
  • Undefined — a declared variable but hasn’t been given a value
  • Number — integers, floats, etc
  • String — an array of characters i.e words
  • Symbol — a unique value that's not equal to any other value
  • Everything else is an Object type.


Why is Null an Object?

The documentation lists it as a primitive type, yet its typeof returns ‘object’.
Basically, this is a bug that isn’t fixed because it would break existing code. This bug has been around since the first version of JavaScript. The bug comes from the typeof function in the JS source — Use some pseudo code to simplify it.


Comments

Post a Comment

Popular posts from this blog

JavaScript — Double Equals vs. Triple Equals - weird things on JavaScript

-
The Problem JavaScript has two  visually  similar, yet  very different , ways to test equality. You can test equality with  ==  or  === . Here are the differences: Triple Equals When using triple equals  ===  in JavaScript, we are testing for  strict  equality. This means both the  type  and the  value  we are comparing have to be the same. Lets look at a couple examples of strict equality. In this first example we’re comparing the  number  5 with the  number  5. As expected,  true  is returned. Both are  numbers , and both share the same  value  of 5. 5 === 5 // true With this in mind, we can look at two more examples that will return  true : 'hello world' === 'hello world' // true (Both Strings , equal values ) true === true // true (Both Booleans , equal values ) Awesome. Now lets take a look at some examples that will return  false : In this example we’ll comp...
Read more

06_Understanding Execution Context and Execution Stack in Javascript

-
Image
Let look inside js engine the things that execute our code and in the end ,it is all about our memory management and execution steps. For this we have two important concept: The heap memory is our long term memory , it is all about memory allocation , stores data in your system and manages access to it. " i mean browser does that , browser manages heap things, browser taps into our system memory and of course   OS , it allocates memory to the browser app. There the data gets stored which we work in our program and most importantly long term data. There is then Stack thing , is end important for execution of code. Stack is kind of short term memory means Stack control over which function is currently executing.                 "  Heap memory  is used by all the parts of the application whereas  stack memory  is used only by one thread of execution. Whenever an object is created, it's always stored  in...
Read more

Creating and inserting element- part-2

-
createElement() : creating a new array and appending to end of node  <! DOCTYPE html> < html lang = "en" > < head > < meta charset = "UTF-8" > < meta name = "viewport" content = "width=device-width, initial-scale=1.0" > < meta http-equiv = "X-UA-Compatible" content = "ie=edge" > < title > Arrays & Iterables </ title > < script src = "app.js" defer></ script > </ head > < body > < ul > < li > Item 1 </ li > < li > Item 2 </ li > < li > Item 4 </ li > < li > Item 3 </ li > </ ul > < script > const list = document . querySelector ( 'ul' ) const newLi = document . createElement ( 'li' ) // it just create a <Li> element // but still not attache...
Read more