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
Value of reference type --- The concept of objects in java
3. Functions --- The concept of methods in java
--- Declare an operator of a variable. Because the js variable is loose, the so-called loose means that it can be used to store any data. The variable is only used to represent a placeholder, so the variable does not have to specify String, int, and directly var. Note that the object can be declared with var.
(), 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();
= 'Zeng';
= 12;
= function () {
(+);
}
However, this is not very encapsulation, so the object literal representation is more often used
var obj = {
name:'Zeng',
age:12,
fun:function () {
(+);
}
}
(); // Print out: Zeng12
Access to object properties:
1. Use brackets(obj["name"]);
2. Use point, it is recommended to use this method( );
function
Functions are an important part of any language. Functions are called js. You can also understand that they are the same as Java methods and C language functions. However, in terms of declaration and use, the functions of js can be very different.
An example of a function:
function fun() {
return "example";
}
(fun()); // Output: 'Example'
It's also possible:
var fun = function() {
return "Create functions with expressions"
};
(fun()); // Output: "Create a function 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 semicolon at the end of the expression,
You can 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];
}
(fun("This is","one","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( == 1){
return arguments[0]*10;
}
if( == 2){
return (arguments[0]+arguments[1])*10;
}
return 10;
}
(fun(11,111)); // Return to 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 "Function with only one parameter"
}
function fun( num1,num2) {
return "Function with two parameters";
}
(fun(11)); // Output "Function 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 null
(new_fun(10,20)); //Output: 30(fun(10,20)); //Top an 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;
}
(add(add_10,200)); // Output: 210
It can be explained as follows:
function add( function , parameter ) {
return function ( 传递过来的parameter );
}
Functional
Here is a recursive example
function fun(num) {
if(num<=1){
(num );
return 1 ;
}else {
(num );
return num * (num-1);
}
}
(fun(3)); // Output 6