Summary of object and function in javascript

After learning traditional object-oriented languages, such as java c++, I am a little uncomfortable when I transfer to javascript, especially the so-called object function in javascript, which sometimes I get confused. So I have simply sorted out some conceptual things below to facilitate learning and understanding, and will explain them in combination with some Java object-oriented knowledge.

Let’s first understand a few concepts:

1. First of all, what does Object refer to in ECMAScript? There are 5 simple data types in ECMAScript: Undefined, Null, Boolean, Number, String. There is also a complex data type, that is Object.

2. Reference type--the concept of class in java

Reference type value --- The concept of objects in java

3. Functions---- The concept of methods in java

4.var --- declares an operator of a variable. Because the js variable is of loose type, loose means that it can be used to save any data. The variable is only used to represent a placeholder, so the variable does not have to specify String, int, and just var. Note that the object can be declared with var.

5.Object(), what is --- The constructor of Object in java, the constructor of Object in js.

Object

js can dynamically add properties and methods.

For example, create an Object instance

var obj = new Object();

The variable obj is the object of new Object().

Next:

 var obj = new Object();obj.name = 'Zeng';obj.age = 12;obj.fun = function () { console.log(this.name+this.age);}

But this is not very encapsulation, so the object literal representation is more often used

 var obj = { name:'Zeng', age:12, fun:function () { console.log(this.name+this.age); }}obj.fun(); // Print out: Zeng12

Access to object properties:

1. Use brackets

console.log(obj["name"]);

2. Use points, it is recommended to use this method

console.log(obj.name );

function

Functions are an important part of any language. Functions are called js. You can also understand that they are the Java methods and C language functions, all the same. However, in terms of declaration and use, the functions of js can be very different.

An example of a function:

 function fun() { return "example";}console.log(fun()); // Output: 'Example'

It's also possible:

 var fun = function() { return "Create functions using expressions"};console.log(fun()); // Output: "Create functions using expressions"

In the above example, you will notice that the function has no function name, only one variable name fun, and there is another at the end of the expression; semicolon,

You can just understand it as an expression that declares a variable. Declaring other variables is written like this:

var name = "Zeng"; // There are variable names and semicolons

Let's take an example with parameters:

 function fun() { return arguments[0] + arguments[1] + arguments[2];}console.log(fun("This is","A","Example")); // Output: "This is an example"

Isn't it a bit strange? First of all, the function I created does not have parameters. It is given parameters when called, and parameters can be obtained and returned in the function.

Actually, here we need to make a point that the js function does not mind passing in a few parameters, nor does it care what type of parameters are! The reason is that the internal reception parameters of the function are stored in an array!

The array is the arguments above. Of course, the array doesn't mind passing a few parameters in. If there are parameters, I will add one, and if there are no parameters, I will null.

We can use this feature as an example:

Overloading of imitation methods--use different parameters to perform different reactions

 function fun() { if(arguments.length == 1){ return arguments[0]*10; } if(arguments.length == 2){ return (arguments[0]+arguments[1])*10; } return 10;}console.log(fun(11,111)); // Return 1220! ! ! !

No overload:

The above example is an overload of imitation functions. Why do I need to imitate it? I will be able to create several functions with different parameters soon.

 function fun( num1) { return "Fun with only one parameter"}function fun( num1,num2) { return "Fun with two parameters";}console.log(fun(11)); // Output "Fun with two parameters"

It is clearly called a function with one parameter, but it is indeed executed with two parameters. Reason: js defines two functions with the same name, and the name only belongs to the function defined later! ! ! So there is no overloading feature in js.

The function name is a pointer:

 var fun = function(num1,num2) { return num1+num2;};var new_fun = fun;fun = null; // Set the function to nullconsole.log(new_fun(10,20)); //Output: 30console.log(fun(10,20)); //Exception: fun is not a function

It can be seen that although fun = null; before this var new_fun = fun; that is, the pointer also pointed to new_fun, so the new_fun() function can still be executed, and the function body is not nulled

Functions can also be used as values:

 function add(fun,num) { return fun(num);}function add_10(num) { return num+10;}console.log(add(add_10,200)); // Output: 210

It can be explained as follows:

 function add(function, parameter) { return function (passed parameter);}

The arguments.callee of the function

Here is a recursive example

 function fun(num) { if(num<=1){ console.log(num ); return 1 ; }else { console.log(num ); return num * arguments.callee(num-1); }}console.log(fun(3)); // Output 6