tipos - Comprensión de JavaScript en detalle: ¿es una clase, una función o solo una variable?
pasar parametros a una funcion javascript desde html (7)
Soy un principiante en JavaScript, y encuentro un concepto muy confuso. Considere el siguiente código:
var person = {
firstName :"Penelope",
lastName :"Barrymore",
// Since the "this" keyword is used inside the showFullName method below, and the showFullName method is defined on the person object,
// "this" will have the value of the person object because the person object will invoke showFullName ()
showFullName:function () {
console.log (this.firstName + " " + this.lastName);
}
}
person.showFullName (); // Penelope Barrymore
¿Es la persona una clase o función o solo una variable?
Si asumir que esa persona es una clase, es el código person.showFullName (); la forma correcta de invocarlo, porque en C # o en cualquier otro idioma escribimos
person perObj = new person();
perObj.showFullName();
?
¿Es la persona una clase o función o solo una variable?
JavaScript no tiene clases. La persona variable es una variable que apunta a una ubicación de memoria que contiene un objeto.
El objeto en sí tiene varios aspectos. Hay un conjunto de propiedades adjuntas que están todas vinculadas al objeto persona. Una de esas propiedades contiene un valor que es objeto de función. Este objeto de función contiene un contexto de ejecución.
El contexto de ejecución ECMA tiene un entorno local, un entorno léxico y un enlace. El enlace de este apunta al objeto persona. El entorno local de la función está orientado a las declaraciones dentro de la función, y el entorno léxico de la función está orientado a las declaraciones disponibles para el objeto Persona.
Es un objeto, no una clase.
Considérelo de esta manera:
En otros idiomas OO clásicos, cuando crea una instancia de una clase , obtiene una instancia ; y esta instancia es una especie de equivalente a un objeto JavaScript -
Los objetos de JavaScript son "bolsas" dinámicas de propiedades. Es un conjunto de pares nombre-valor y esos valores pueden ser de cualquier tipo: funciones u objetos.
En su caso, nombre firstName, lastName, and showFullName son propiedades del objeto person.
person.firstName, person.showFullName() las propiedades de un objeto utilizando la notación de punto (.), Por ejemplo: person.firstName, person.showFullName()
JavaScript no tiene clases o no es un lenguaje basado en clases. En cambio, decimos que es un lenguaje basado en prototipos.
Solo para agregar a Barmar, también podría haber hecho algo como esto (en caso de que lo encuentre más parecido a C #):
var person = function() {
this.firstName = "";
this.lastName = "";
}
person.prototype.showFullName = function () {
console.log (this.firstName + " " + this.lastName);
}
var perObj = new person();
perObj.firstName = "Penelope";
perObj.lastName = "Barrymore";
perObj.showFullName();
person en su código es un object . En otras palabras, person es una instancia de Object , y prototipo de person es igual a prototipos en otros objetos, creados por el inicializador {} :
// Object initialiser or literal
person = {
some methods and properties
}
// Called as a constructor
person = new Object({some methods and properties})
Eso significa que su objeto personal hereda los métodos específicos de los objetos del prototipo, como hasOwnProperty() , toString() , valueOf() , etc.
El último Object constructor escrito puede crear no solo objetos "similares a hash", sino cualquier otro tipo de objetos (matrices, cadenas, etc.). Todo en javascript es objetos, incluso primitivos (tienen objetos de envoltura y tienen constructores propios).
Ejemplo:
persons = new Object([person_1, person_2, person_3])
person_age = new Object(18)
person_name = new Object(''John'')
Podemos escribir todas las expresiones anteriores en otra sintaxis:
persons = new Array(person_1, person_2, person_3) //or
persons = [person_1, person_2, person_3]
person_age = new Number(18) //or
person_age = 18
person_name = new String(''John'') //or
person_name = ''John''
Se pueden crear cadenas y números utilizando un objeto global apropiado sin new
Nuevo tipo de objeto
Si es necesario crear un nuevo tipo de objeto, debe definir una nueva función de constructor y definir un prototipo (ECMAScript 5.1)
NewObjectType = function(arg1, arg2){
this.arg1 = arg1 //define object''s property arg1
this.arg2 = arg2 //define object''s property arg2
private_function = function(){}
this.public_function = function(){} //this function can''t be inherited, because not in prototype
}
NewObjectType.prototype = {
constructor : NewObjectType,
public_inheritable_function_1 : function(){},
public_inheritable_function_2 : function(){}
}
//creating new instance of NewObjectType:
my_new_object = new NewObjectType(arg1, arg2)
my_new_object instanceof NewObjectType //true
my_new_object instanceof Object //true, because prototype was created with {} literal, and Object''s prototype built into the prototype chain
Explicación:
Cuando se llama a new NewObjectType se new NewObjectType nueva instancia de NewObjectType. Prototype propiedad de NewObjectType función constructora NewObjectType se vinculará con la propiedad __proto__ oculta de la nueva instancia.
Objeto sin prototipo
Si necesita crear un objeto claro sin los métodos de Object, debe crearlo sin prototipo utilizando el método create:
person = Object.create(null)
Puede ser útil como simple almacenamiento de valor-clave
Tipo, que no se hereda de Objeto.
Si necesita crear un nuevo tipo de objeto sin prototipo de objeto en la cadena de prototipos, puede usar la siguiente sintaxis:
NewObjectType = function(arg1, arg2){}
NewObjectType.prototype = Object.create(null)
NewObjectType.prototype.constructor = NewObjectType
NewObjectType.prototype.public_inheritable_function = function(){}
my_new_object = new NewObjectType(arg1, arg2)
my_new_object instanceof NewObjectType //true
my_new_object instanceof Object //false
person es en realidad un objeto literal en JavaScript. Los literales de objetos son aquellos que se definen como
var obj = {
// Properties and methods
};
Y su tipo es objeto. En JavaScript no tenemos nada llamado clase .
- Todo es un objeto. (incluso funciones)
Un objeto literal es una lista separada por comas de pares nombre-valor envueltos entre llaves. Los literales de objetos encapsulan datos, encerrándolos en un paquete ordenado.
http://www.dyn-web.com/tutorials/object-literal/
Aunque tenemos clases en ECMAScript 6, no son clases reales como en otros idiomas.
MDN dice:
Las clases de JavaScript se introducen en ECMAScript 6 y son azúcar sintáctica sobre la herencia basada en el prototipo existente de JavaScript. La sintaxis de clase no está introduciendo un nuevo modelo de herencia orientado a objetos a JavaScript. Las clases de JavaScript proporcionan una sintaxis mucho más simple y clara para crear objetos y lidiar con la herencia.
person es un objeto. Tiene 3 propiedades, denominadas firstName , lastName y showFullName . Las dos primeras propiedades contienen cadenas. La última propiedad contiene una función.
Cuando llama a una función con la sintaxis <expression>.<function>(<arguments>) , donde <expression> evalúa a un objeto y <function> es el nombre de una de sus propiedades, entonces mientras la función ejecuta el especial variable this se establece en el objeto. Así es como this.firstName y this.lastName pueden acceder a esas propiedades del objeto.
Esta función no es muy útil cuando hay un solo objeto, ya que podría usar fácilmente la variable person . Pero podrías usar la misma función para múltiples objetos.
function showFull() {
console.log(this.firstName + " " + this.lastName);
}
var person1 = {
firstName: "Penelope",
lastName: "Barrymore",
showFullName: showFull
};
var person2 = {
firstName: "John",
lastName: "Smith",
showFullName: showFull
}
person1.showFullName(); // Penelope Barrymore
person2.showFullName(); // John Smith