Method js JavaScript core principles
Tags: javascript, webdev, beginners, programming
Published: 2023-05-03 16:49:50

JavaScript Method is a property of an object, that performs certain function or task.

## Object Method
It's a function property in an object scope.
```
// object containing major types of method
const person = {
    name: 'John',
    
    greet: function() { 
let reply = 'Good morning ' + this.name
console.log(reply); 
},

//short syntax
greetBack() {
  return "How are you " + this.name + " ?"
},

//Compose Method
["reply" + 2]() {
  console.log('I am fine ' + this.name)
},

//Async Method
kate: async function() {
  console.log(this.name + ', Boss want to see you');
},

async boss() {
  let reply = 'Have your seat, ' + this.name
  await console.log(reply);
},

//Generator Method 
increment: function* () {
    let index = 5;
    while (true) {
      yield console.log(index++);
    }
  },
  
async *decrement () {
    yield console.log(4);
  },

};

person.greet(); //Good morning John
console.log(person.greetBack()); //How are you John ?
person.reply2(); // I am fine John
person.kate(); //John, Boss want to see you
person.boss(); //Have your seat, John 
person.increment().next(); //5
person.decrement().next(); //4 
```

## Adding Method to Object
```
#1
var a = new Object();
a.method = function(){}

#2
var a = new Object();
a.prototype.method = function(){}

#3
function myObject() {
    this.method = function(){}
}
var a = new myObject();

#4
function myObject() {}
myObject.prototype.method = function(){}
var a = new myObject();

#5
var a = {
    method: function(){}
}
```

## Class Method

```
class Greeting {
  msg = "Good morning friend's";
//Method
  morningGreet() {
    return this.msg;
  }
}

class Person extends Greeting {
  speak() {
    return super.morningGreet();
  }
}

//instance of class
const john = new Person();
console.log(john.speak());   
```

```
class Person { 
  
constructor(name) { 		
this.name = name; 	
} 

getName() { 	
	return this.name;
 	}
 	
//Static Method
static createAnonymous(gender) {
 		let name = gender == "female" ? "John Doe" : "Jane Doe";
 		let req = new Person(name);
 		return console.log(req);
} 

//Private Method
#occupation = "UI/UX";
#biodata; 

#status() {
  let req = "She is an elegant " + this.#occupation + " by profession and well mannered person."
  return console.log(req)
}

//Private Static Method
static #age() {
  let req = 'Jane Doe is 20 year old beautiful woman.'  
  return console.log(req)
}

//returning request of both private and static method with getProfile()
getProfile() {
  let statusA, statusB;
//calling private and static private method in statusA and statusB
  statusA = Person.#age();
  statusB = this.#status();
  
  let req = statusA + statusB;
  return console.log(req);
} 	

}
Person.createAnonymous('female');

//calling instance of static method
let person = new Person();
person.constructor.createAnonymous('female');

person.getProfile();

person.createAnonymous('female') //Type Error
```

**Note:**
* you can't call a private method into a static private method but you can call static private method inside private method 
* If you attempt to call the static method from an instance of the class, you’ll get an error when using new.

## Accessing Method
This is a means of getting the method name from the object name.
```
objectName.methodName()
```

```
const client = {
name:  'Jane Doe',
greet() {
return `Good morning Mrs ${client.name}`;
}
}
```

```
//Accessing Method
client.greet(); //Good morning Mrs Jane Doe
```

```
//Accessing Property
client.name; //Jane Doe 
```