web-dev-qa-db-fra.com

Méthode vs Fonctions et autres questions

En ce qui concerne JS, quelle est la différence entre les deux? Je sais que les méthodes sont associées à des objets, mais je ne comprends pas à quoi servent les fonctions? Comment la syntaxe de chacun d'eux diffère-t-elle?

Aussi, quelle est la différence entre ces 2 syntaxes:

var myFirstFunc = function(param) {
    //Do something
};

et

function myFirstFunc(param) {
    //Do something
};

En outre, j'ai vu quelque part que nous devions faire quelque chose comme ceci avant d'utiliser une fonction:

obj.myFirstFunc = myFirstFunc;
obj.myFirstFunc("param");

Pourquoi la première ligne est-elle requise et que fait-elle?

Désolé si ce sont des questions de base, mais je commence par JS et je suis confus.

EDIT: Pour le dernier morceau de code, voici ce dont je parle:

// here we define our method using "this", before we even introduce bob
var setAge = function (newAge) {
  this.age = newAge;
};
// now we make bob
var bob = new Object();
bob.age = 30;
// and down here we just use the method we already made
bob.setAge = setAge;
javascriptfunctionmethods
21
Karan Goel

Pour répondre à votre question de titre sur la différence entre une "fonction" et une "méthode".

C'est la sémantique et cela a à voir avec ce que vous essayez d'exprimer.

En javascript, chaque fonction est un objet. Un objet est une collection de paires clé: valeur. Si une valeur est une primitive (entier, chaîne, booléen) ou un autre objet, la valeur est considérée comme une propriété. Si une valeur est une fonction, cela s'appelle une «méthode».

Dans le cadre d'un objet, une fonction est appelée méthode de cet objet. Il est appelé à partir de l'espace de noms d'objet 'MyObj.theMethod ()'. Puisque nous avons dit qu'une fonction est un objet, une fonction dans une fonction est considérée comme une méthode de cette fonction. Vous pouvez dire que je vais utiliser la méthode save method de mon objet. Vous pouvez également dire que "la méthode de sauvegarde accepte un function en tant que paramètre". Mais vous ne diriez généralement pas qu'une fonction accepte une méthode en tant que paramètre.

BTW le livre Javascript Patterns de Stoyan Stefanov couvre vos questions en détail, et je le recommande vivement si vous voulez vraiment comprendre la langue. Voici une citation du livre sur ce sujet.

Il peut donc arriver qu'une fonction A, étant un objet, possède des propriétés et des méthodes, une dont B se trouve être une autre fonction B. Alors B peut accepter une fonction C en tant que argument et, une fois exécuté, peut renvoyer une autre fonction D.

29
mastaBlasta

Il n'y a pas de différence réelle, mais les deux choses sont différentes:

Méthode: La méthode est une fonction à laquelle un objet est associé.

var obj = {
name : "John snow",
work : function someFun(paramA, paramB) {
    // some code..
}

Fonction: Quand aucun objet n’y est associé, il s’agit de fonctionner.

function fun(param1, param2){
// some code...
}
7
Pushpendra Singh

Une méthode est une propriété d'un objet dont la valeur est une fonction. Les méthodes sont appelées sur des objets au format suivant: object.method ().

// c'est un objet nommé développeur

 const developer = {
  name: 'Andrew',
  sayHello: function () {
    console.log('Hi there!');
  },
  favoriteLanguage: function (language) {
    console.log(`My favorite programming language is ${language}`);
  }
};

// favoriteLanguage: and sayHello: and name: tous sont des propriétés de l'objet nommé developer

maintenant, disons que vous deviez appeler la propriété favoriteLanguage qui est une fonction à l'intérieur de l'objet.

vous l'appelez comme ça 

developer.favoriteLanguage('JavaScript');

// My favorite programming language is JavaScript'

donc ce que nous appelons cela: developer.favoriteLanguage ('JavaScript'); ce n'est pas une fonction ce n'est pas un objet? ce que c'est? c'est une méthode

1
Rida

Votre première ligne, crée un objet qui référence une fonction. Vous le référeriez comme ceci:

myFirstFunc(param);

Mais vous pouvez le transmettre à une autre fonction car elle retournera la fonction comme ceci:

function mySecondFunction(func_param){}
mySecondFunction(myFirstFunc);

La deuxième ligne crée simplement une fonction appelée myFirstFunc qui serait référencée comme ceci:

myFirstFunc(param);

Et sa portée est limitée en fonction de l'endroit où elle est déclarée; si elle est déclarée en dehors de toute autre fonction, elle appartient à la portée globale. Cependant, vous pouvez déclarer une fonction dans une autre fonction. La portée de cette fonction est alors limitée à la fonction dans laquelle elle est déclarée. 

function functionOne(){
    function functionTwo(){}; //only accessed via the functionOne scope!
}

Vos derniers exemples créent des instances de fonctions qui sont ensuite référencées via un paramètre d'objet. Donc ça:

function myFirstFunc(param){};

obj.myFirst = myFirstFunc(); //not right!
obj.myFirst = new myFirstFunc(); //right!

obj.myFirst('something here'); //now calling the function

Dit que vous avez un objet qui référence une instance d'une fonction. La clé ici est que si la fonction change, le référence que vous avez enregistré dans obj.myFirst ne sera pas changé. 

Bien que @kevin soit fondamentalement juste, il n’existe que des fonctions dans JS; vous pouvez créer des fonctions qui ressemblent beaucoup plus à des méthodes qu’à des fonctions, prenons ceci par exemple: 

function player(){

    this.stats = {
        health: 0,
        mana: 0,

        get : function(){
            return this;
        },

        set : function( stats ){
            this.health = stats.health;
            this.mana = stats.mana;
        }  
}

Vous pouvez alors appeler player.stats.get() et il vous renverra la valeur heath et mana. Je considérerais donc get et set comme des méthodes de l’objet player.stats. 

1
Ryan
var myFirstFunc = function(param) {
    //Do something
};

et

function myFirstFunc(param) {
    //Do something
};

sont (presque) identiques. La seconde est (généralement) juste un raccourci. Cependant, comme le montre jsfiddle ( http://jsfiddle.net/cu2Sy/ ), function myFirstFunc fera en sorte que la fonction soit définie dès que la portée englobante est entrée, alors que myFirstFunc = function ne le créera que lorsque son exécution sera atteinte. ligne.

Quant aux méthodes, elles ont un argument this, qui est l’objet actuel, donc:

var obj = {};
obj.func = function( ) {
    // here, "this" is obj
    this.test = 2;
}
console.log( obj.test ); // undefined
obj.func( );
console.log( obj.test ); // 2

La syntaxe exacte que vous avez montrée est parce que vous pouvez aussi faire ceci:

function abc( ) {
    this.test = 2;
}
var obj = {};
obj.func = abc;
obj.func( ); // sets obj.test to 2

mais vous ne devriez pas sans bonne raison.

0
Dave

Beaucoup de réponses disent le long de la ligne qu'un méthode est ainsi appelé une fonction lorsqu'elle est définie sur un objet.

Bien que cela soit souvent vrai dans la façon dont le mot est utilisé lorsque les gens parlent de JavaScript ou de la programmation orientée objet en général (voir ici ), il convient de noter que dans ES6, le terme méthode a pris une signification très spécifique (voir section 14.3 Définitions de méthodes des spécifications).

Définitions de méthodes

Une méthode (au sens strict) est une fonction qui a été définie par la syntaxe de méthode concise dans un littéral d'objet ou comme méthode de classe dans une déclaration/expression de classe:

// In object literals:
const obj = {
    method() {}
};

// In class declarations:
class MyClass {
    method() {}
}

Spécificités de la méthode

Cette answer donne un bon aperçu des spécificités de méthodes (au sens strict), à savoir:

  1. les méthodes reçoivent une propriété interne [[HomeObject]] qui leur permet d'utiliser super.
  2. les méthodes ne sont pas créées avec une propriété prototype et ne possèdent pas de méthode [[Construct]] interne, ce qui signifie qu'elles ne peuvent pas être appelées avec new.
  3. le nom d'une méthode ne devient pas une liaison dans le champ d'application de la méthode.

Vous trouverez ci-dessous quelques exemples illustrant la manière dont les méthodes (au sens strict) diffèrent des fonctions définies sur les objets par le biais d'expressions de fonctions:

Exemple 1

const obj = {
    method() {
        super.test;         // All good!
    },
    ordinaryFunction: function ordinaryFunction() {
        super.test;         // SyntaxError: 'super' keyword unexpected here
    }
};

Exemple 2

const obj = {
    method() {},
    ordinaryFunction: function ordinaryFunction() {}
};

console.log( obj.ordinaryFunction.hasOwnProperty( 'prototype' ) );  // true
console.log( obj.method.hasOwnProperty( 'prototype' ) );            // false

new obj.ordinaryFunction();     // All good !
new obj.method();               // TypeError: obj.method is not a constructor

Exemple 3

const obj = {
    method() {
        console.log( method );
    },
    ordinaryFunction: function ordinaryFunction() {
        console.log( ordinaryFunction );
    }
};

obj.ordinaryFunction()  // All good!
obj.method()            // ReferenceError: method is not defined

0
Oliver Sieweke

Une fonction exécute une liste d'instructions par exemple:

 function add() { 
     var a = 2; 
     var b = 3;
     var c = a + b;
     return c;
 }

1) Une méthode est une fonction qui est appliquée à un exemple d'objet:

 var message = "Hello world!";
 var x = message.toUpperCase(); // .toUpperCase() is a built in function

2) Créer une méthode en utilisant un constructeur d'objet. Une fois que la méthode appartient à l'objet, vous pouvez l'appliquer à cet objet. Exemple:

function Person(first, last, age, eyecolor) {
    this.firstName = first;
    this.lastName = last;
    this.age = age;
    this.eyeColor = eyecolor;
    this.name = function() {return this.firstName + " " + this.lastName;};
}

document.getElementById("demo").innerHTML = person.fullName(); // using the 
method

Définition d'une méthode: Une méthode est une propriété d'un objet qui est une fonction. Les méthodes sont définies de la même manière que les fonctions normales, sauf qu'elles doivent être affectées en tant que propriété d'un objet. 

0
ticktock