Paramètres de fonction JavaScript et méthodes d'objets

Le premier est utilisé pour les fonctions «autonomes» simples, tandis que le second est utilisé pour les méthodes objet. Par exemple, un objet numérique a par défaut une méthode toString (). Certaines méthodes objet peuvent également exiger que des paramètres soient passés entre les parenthèses.

Les variables (une déclaration de fonction est juste une fonction stockée dans une variable) sont recherchées dans la chaîne de portées (remontant à la portée externe suivante jusqu'à ce qu'une variable avec le nom soit trouvée):

num = addMe(num);

Les propriétés d'un objet sont recherchées dans la chaîne de prototypes d'objets, donc si vous faites

function addMe(a){
 a = a+1;
 console.log(a); // 2
 return a;
}

var num = 1;
addMe(num);
console.log(num); // 1 ... ?

alors a est recherché dans les portées comme expliqué ci-dessus, alors b est accédé sur l'objet résultant (tout est un objet en JavaScript, sauf pour "rien" ( undefined , null )) en recherchant la chaîne de prototypes. Pour un objet simple, la chaîne est assez courte:

 1..whereDoIComeFrom()

Ici b sera trouvé dans l'objet lui-même. Cependant, tous les objets héritent de l'objet Object.prototype , donc si vous ajoutez une propriété à cela (veuillez ne pas le faire):

Number.prototype.addMe = function() {
 console.log(this);
};

// two dots are needed to distinguish it from numbers with a fraction (e.g. 1.2)
1..addMe();

vous pouvez puis recherchez-le sur chaque objet, car la recherche traverse la chaîne de prototypes et atteint Object.prototype:

 console.log({}.test); // 1

Maintenant pour les nombres (comme dans votre cas), ils héritent du Number.prototype donc vous pouvez faire:

 Object.prototype.test = 1;

Cela dit, maintenant addMe peut être appelé sur chaque numéro, partout dans votre code. Bien que cela puisse sembler utile, c'est en fait une douleur car vous ne savez pas où une certaine méthode a été ajoutée

 const a = { b: 1 }; // object -> Object.prototype

qui rend le code illisible et non structuré. Au lieu de cela, si vous avez besoin d'une certaine fonctionnalité plusieurs fois, résumez-la dans une fonction, ne touchez pas aux prototypes natifs.

Je suppose que addMe n'est qu'un exemple simplifié , si ce n'est pas le cas, continuez à lire:

Si vous passez un argument à une fonction en JavaScript, la valeur sera copiée (c'est un peu plus compliqué avec les non primitives (tout sauf les nombres, les booléens, etc.) .)) dans la variable de paramètre de la fonction appelée ainsi ici:

a.b

vous avez en fait deux variables ( a et num code>), changer a ne change pas num . Mais lorsque vous retournez a vous pouvez faire:

 let a = 1; // outer scope

 { // inner scope
   console.log(a); // looked up in "inner scope", than "outer scope"
}

qui copie la valeur de num dans a , puis augmente a de un, puis recopie la valeur de a dans num.

Lorsque vous avez fait var num = 1 , vous avez créé un objet JavaScript. Cela ressemble à un nombre mais vous pouvez considérer tout dans JavaScript comme un objet (simplification) et tous ces objets ont des caractéristiques différentes. Ainsi, un nombre a certaines fonctionnalités, une chaîne a d'autres fonctionnalités, etc.

Vous avez mentionné une fonctionnalité: toString . Une autre fonctionnalité serait toLowerCase.

toString et toLowerCase sont des fonctions fournies avec JavaScript. Ces fonctions sont ensuite "placées" sur tous ces objets pour que nous les utilisions.

Je peux avoir une variable de type chaîne comme

function addMe(number) {
  return number+1 
}

const answer = addMe(1) //2

Ce code fonctionnera car il a été décidé que la fonction toLowerCase devrait fonctionner sur les chaînes

Je peux aussi avoir un tableau (liste d'éléments) p>

const list = ['A', 'B', 'C']

const answer = list.toLowerCase()
console.log(answer)

Mais ce code ne fonctionnera pas car toLowerCase ne fonctionne pas sur les tableaux. Donc, vous obtenez le message d'erreur suivant: list.toLowerCase n'est pas une fonction .

Fondamentalement, il dit: Je ne sais pas ce que toLowerCase signifie lorsqu'il est utilisé sur cette variable de liste (tableau ).

En JavaScript, cela s'appelle des prototypes. Le prototype est un moyen pour JavaScript d'obtenir des fonctionnalités d'un autre. En gros: j'ai toutes sortes de fonctions, quel objet peut utiliser quelles fonctions. C'est ce qu'on appelle la chaîne de prototypes.

Dans les deux cas, vous utilisez une fonction. addMe est une fonction que vous avez créée et toString est une fonction en JavaScript qui a été placée sur des objets via cette chaîne de prototypes.

Je ne sais pas vraiment si ma syntaxe est correcte

Oui, votre syntaxe est correcte. Votre fonction addMe est le moyen standard de créer une fonction en JavaScript.

Mais je veux savoir quand alimenter une variable en tant que paramètre, comme comment je donnez la variable num à la fonction addMe.

Tout comme vous l'avez fait, vous définissez une fonction et des paramètres comme vous l'avez fait.

..et quand utiliser la fonction .toString () en mettant un point après la variable et en tapant la fonction.

Lorsque vous voulez placer votre fonction sur un objet afin que toutes les instances de cet objet puissent vous cet objet.

Dans la plupart des cas, surtout lorsque vous débutez. Vous n'avez pas à vous soucier de ces prototypes. Comme vous l'avez fait.

var text = 'MY TEXT'
var lowercaseText = text.toLowerCase()
console.log(lowercaseText) // my text

Est une manière standard de définir une fonction et de l'appeler.