1.
function bar() {
return foo;
foo = 10;
function foo() {}
var foo = '11';
}
alert(typeof bar())
Solution:----
function bar() {
function foo() {}
// function declaration are hoisted up
return foo;
foo = 10;
foo = '11';
}
alert(typeof bar())
// function
2.
[] + [] + 'foo'.split('');
"" + "" + ["f","o","o"];
"" + ["f","o","o"]
"f,o,o"
3.
new Array(5).toString();
",,,,"
4.
var x = 0;
function foo() {
x++;
this.x = x;
return foo;
}
var bar = new new foo;
console.log(bar.x);
// here foo is always returning itself.
so bar is always return function foo(){.....}
bar.x is undefined
5.
var bar = 1,
foo = {};
foo: { // this is not a object delaration
bar: 2;
baz: ++bar;
};
foo.baz + foo.bar + bar;
so undefined + undefined + 2 = NaN
---------------------------
var bar = 1;
foo = {
bar: 2,
baz: bar++
};
//
foo{bar:2, baz:1}
---------------------------
var bar = 1;
foo = {
bar: 2,
baz: ++bar
};
//
foo{bar:2, baz:2}
6.
var myArr = ['foo', 'bar', 'baz'];
myArr[2];
console.log("2" in myArr);
// in console.log(index in myArr)
true
7.
function foo(a, b) {
arguments[0] = 11;
arguments[1] = 22;
console.log(a,b)
}
foo(1,2);
// 11 22
function foo(a, b) {
//arguments[0] = 11;
//arguments[1] = 22;
console.log(a,b)
}
foo(1,2);
// 1 2
function foo(a, b) {
arguments[0] = 11;
arguments[1] = 22;
console.log(a,b)
}
foo();
// undefined undefined
-----------------------------------
VERY VERY IMP
Function declarations are hoisted over variable declarations but not over variable
assignments.
var double = 22;
function double(num) {
return (num*2);
}
console.log(double);
// 22
var double;
function double(num) {
return (num*2);
}
console.log(double);
// double(){...}
-----------------------------------
Very Imp
var foo = 1;
function bar() {
if (!foo) {
var foo = 10;
}
alert(foo);
}
bar();
what happened here
var foo = 1;
function bar() {
var foo;
if (!foo) { // !undefined = !false = true;
var foo = 10;
}
alert(foo);
}
bar();
// here bar() is 10
-----------------------------------
var a = 1;
function b() {
a = 10;
return;
function a() {}
}
b();
alert(a);
what happened here?
var a = 1;
function b() {
var a = function () {} // local
a = 10; // local
return;
}
b();
alert(a);
// 1
-----------------------------------
function foo(a) {
alert(arguments.length);
}
foo(1, 2, 3);
//3
-----------------------------------
Hoisting of functions before varables
Functions definition moves first before variables.
console.log(UseMe);
var UseMe;
function UseMe()
{
console.log("UseMe function called");
}
-----------------------------------
// How we achieve this.......typeof bar === "object"
(bar !== null) && (typeof bar === "object") && (bar.constructor.name !== 'Array'){
console.log('object');
}
-----------------------------------
undefined == null // true
undefined ==== null // false
typeof undefined == typeof null // false
tricky
typeof undefined == typeof NULL // true (because null is not case
sensitive)
typeof undefined === typeof NULL // true
-----------------------------------
Check number is interger?
function checkInt(n){
if(typeof n === "number"){
return true;
}
return false;
}
-----------------------------------
const a = {},
b = {c:'b'},
c = {b:'c'};
a[b] = 11;
a[c] = 22;
console.log(a[b])
Ans.
when we define
a[b] = 12;
a['m'] = 10;
a {[object object]:12, m:10}
so when we define
a[b] = 11 {[object object]:11}
a[c] = 22 {[object object]:22}
so console.log(a[b]) // 22
-----------------------------------
SCOPE
var foo = "bar";
function bar(){
var foo = "baz";
function baz(){
foo = "bam";
bam = "yay";
}
baz();
}
bar();
// foo = ?
// bam = ?
// baz() = ?
-----------------------------------
String("cool") === "cool"; // true
new String("cool") === "cool" // false
-----------------
const arr = [1, 2, 3];
const double = arr.map(function(el) {
return el * 2;
});
console.log(double); // [2, 4, 6]
-----------------
Drawback of creating methods in JavaScript?
A new copy of the method would be created for each instance.
ex.
function person(name){
this.name = name;
this.getName = function(){
return this.name;
}
}
So when we instance of person, the each instance have separate "getName" method
-------------------------
var x = 5;
(function () {
console.log(x);
var x = 10;
console.log(x);
})();
op:-
undefined , 10
this is like
(function () {
var x
console.log(x); // undefined
x = 10;
console.log(x); // 10
})();
-------------------------
var foo = 10;
bar = 3;
(function () {
var foo = 2;
bar = 1;
})()
bar = bar + foo;
console.log(bar);
bar = 1 + 10 = 11
-------------------------
var Foo = Function Bar()
{
return 7;
};
typeof Bar(); // Reference error
-------------------------
What will happen here?
function sum(a, b) {
return a + b;
}
sum.foo = "Add";
// foo property will added to function sum
-----------------------
var a = false;
for(i=0;i<5;i++){
var a = true;
}
if(a){
console.log(a);
}
// true
------------------------
Call by value / Call by Reference
call by value and call by reference
premitives are copied by their value
objects are copied by their reference
var number = 10;
function fun(number){
number++;
}
fun(number);
console.log(number); //10
ex-2
var obj = {value:10};
function fun(obj){
obj.value++;
}
fun(obj);
console.log(obj); // {value:11}
----------------------
var x = 1;
var y = x++;
console.log("x" + x, "y" + y)
// x2 y1
var x = 1;
var y = ++x;
console.log("x" + x, "y" + y)
// x2 y2
-------------------------------
Scopes
var a = 1;
function foo() {
var a = 10;
console.log(a);
}
console.log(a);
foo();
---------------
{
let foo = 10;
console.log( foo );
}
console.log( foo );
----------------
for (let i = 0; i < 5; i++) {
console.log( i );
}
console.log( i );
---------------
foo();
var foo;
function foo() {
console.log( 1 );
}
foo = function() {
console.log( 2 );
};
function foo() {
console.log( 3 );
}
----------------
var y = 1;
if (function f(){}) {
y += typeof f;
}
console.log(y);
----------------
Date()
// Javascript Add 110 minutes to current date and time
var d = new Date();
d.setMinutes(d.getMinutes()+100);
// Compare two timestamps
d1 = new Date("2014-01-15 00:00:00");
d2 = new Date("2014-01-12 00:00:00");
if(d1>d2){
console.log("d1 is greater")
}else if (d1<d2){
console.log("d2 is greater")
}else{
console.log("equal")
}
// millisecond to date
x = new Date();
var n = d.getTime();
var x = new Date(n);
alert(x);
----------------
Object tricky
var box = {}
box["material"] = "cool";
var func = function(){
return "material";
}
box[func()];
//pass object to a function
function person(name){
this.name = name;
}
var p1 = new person("sam");
function changeName(obj){
return obj.name = "new Name";
}
changeName(p1);
2.
function getSum(n1,n2){
return n1 + n2;
}
console.log(getSum.length) //2
---------------------
1.
var cat = function(x) {
return x * 2;
}
console.log(cat.name);
2.
blah = function () {
return lala;
};
console.log(blah());
3.
blah = function () {
return "lala";
};
console.log(blah());
4.
function blabbermouth() { };
console.log(blabbermouth.name);
5.
love_story = function(x, y) {
console.log(arguments);
};
love_story("princess", "frog");
6. Callback Functions
function c(f) {
return f();
}
function blub() {
return "monsters";
}
c(blub);
