Reference Type
A reference type is a data structure that organizes data and functions together. It is also often called a class, but this title is not appropriate. Although ECMAScript is technically an object-oriented language, it does not have the basic structures such as classes and interfaces supported by traditional object-oriented languages. Reference types are sometimes called object definitions because they describe the properties and methods that a class of objects have.
As mentioned earlier, the value of the reference type is an object. In ECMAScript, a reference type is a data structure used to organize data and functions, while an object is an instance of a specific reference type.
var a=new Object();
The above declares an instance with reference type Object and stores this instance in variable a, which means that the variable does not actually contain the instance itself, but a pointer to this instance.
For Object types, commonly used object literal notation to create instances. var a={name:"Nick", age:20} The advantage of doing this is to give people a wrapper feeling. The access to objects uses dot notation or square bracket notation. It is equivalent to a["name"], note that the "name" here is represented by a string.
For Array types, you can use array literal notation.
For Array type, length can be used to change the length of the array. (Add or remove items from the end of the array)
The method to detect an array is (value)
Conversion method: toString() is converted into a string that divides each item with ",". valueOf(), the returned array is still the same. toLocaleString() can be implemented using the following example.
var p1={
toString:function(){return "guo";},
toLocaleString:function(){return "yuzhe";}
}
var p2={
toString:function(){return "song";},
toLocaleString:function(){return "hap";}
}
var p=[p1,p2];
alert(p); //guo,song
alert(()); //yuzhe,hap
It can be seen that alert calls the toString() method before outputting, and there is also the join() method, which is used to return the specified symbol to a string. Its default (no parameter setting) is ",".
Stack method: push() adds an item at the end and returns the length of the array. pop() deletes the item at the end and returns the delete item.
Queue method: shift() overflows the first item of the array and returns this item. unshift() adds an item in the first section and returns the length of the array.
Reorder method (return value is an array):
reverse() reverse() reverse order. a[length-1]=a[0]
sort() ascending sort method The default sort() is sorted in ASCII, not the number size we think, so we need to use it in this way to compare the size.
function compare(no1,no2){
if(no1<no2){
return -1;}
else if(no1>no2){
return 1;}
else{
return 0;}
}
var a=[1,2,3,4,6,5];
(compare);
alert(a)
To produce a descending effect, just reverse the if statement.
How to operate:
concat() creates a copy that has no effect on the original array, and its function is to add accepted parameters to the end of the array.
slice() creates a copy, accepts 1 or 2 parameters (returns the start and end positions of the item, and does not include the end positions). In the case of only one parameter, it returns all items from the specified position to the end. If the parameter is negative, the result is length+arguments. If the end position is smaller than the start position, an empty array will be returned.
splice(): 1. Delete method-Specify two parameters, the position of the first item to be deleted and the number of items to be deleted.
2. Insert method-Specify three parameters, starting position, 0 (number of things to be deleted), and the items to be inserted.
3. Replacement method-Specify three parameters, starting position, number of deleted, and item to be inserted
The insert/replacement position is the starting position.
Location method:
indexOf() returns the array of items to be searched, and if not, return -1. Parameters: the item to be searched and the (optional) index (subscript) of the starting point position.
lastIndexOf() is the reverse order of indexOf().
Iteration method:
2 parameters: the function to be run and the scope of (optional). The function passed into these methods needs to have three parameters (item (value of the array item), index (position of the item), array (array object itself)).
every() runs a given function on each item in the array, and each item returns ture and true
filter() returns an array of items that will return true
forEach() runs the given function for each item without a return value
map() returns an array of functions executed results each time
If some() is true, it returns true.
<script>
var a=[1,2,3,4];
var b=(function(item,index,array){
return item>2;
});
alert(b); //false
</script>
Merge method:
reduce() starts traversal from the first item of the number, reduceRight() starts traversal from the last item of the array
Use reduce() to find all sums in an array
<script>
var a=[1,2,3,4];
var b=(function(prve,cur,index,array){
return prve+cur;
});
alert(b); //10
When the first execution is executed, prev is 1 and cur is 2. When the second execution is executed, prev is 3 and cur is 3.
The above is the reference type of the JavaScript introductory tutorial introduced to you by the editor. I hope it will be helpful to you!