Un, fonction de fonction

Une fonction est aussi un objet, certaines fonctions (code) peuvent être encapsulées dans la fonction, et ces fonctions (code) peuvent être exécutées si nécessaire.
Certains codes peuvent être enregistrés dans la fonction à appeler en cas de besoin.

Deuxièmement, utilisez le constructeur pour créer un objet fonction

Nous utilisons rarement des constructeurs pour créer des objets de fonction dans le développement réel

var fun=new Function();
//构造函数来创建函数对象

Lorsque vous utilisez typeof pour vérifier un objet fonction, la fonction est renvoyée.
Le code à encapsuler peut être passé au constructeur sous la forme d'une chaîne.

var fun=new Function("console.log('Hello 这是我的第一个函数');");

Le code encapsulé dans la fonction ne sera pas exécuté immédiatement
Le code de la fonction sera exécuté lorsque la fonction sera appelée
Syntaxe de la fonction d'appel : function object ()
Lorsque la fonction est appelée, le code encapsulé dans la fonction sera exécuté dans l'ordre

var fun=new Function("console.log('Hello 这是我的第一个函数');");
fun();//调用函数
结果：Hello 这是我的第一个函数

Troisièmement, utilisez des déclarations de fonction pour créer des fonctions

语法：
    function 函数名([形参1,形参2...形参n]){
    
    
             语句...(需要封装的代码)
}

语法：
    function fun2(){
    
    
        console.log('Hello 这是我的第二个函数');
}
//调用fun2
fun2();

Quatre, utilisez des expressions de fonction pour créer une fonction

var 函数名= function([形参1,形参2...形参n]){
    
    
             语句...(需要封装的代码);
}

function(){
    
    
  console.log("我是一个匿名函数中封装的代码");
}

Créez d'abord une fonction anonyme, puis définissez une variable fun3, puis affectez l'objet de fonction anonyme à la variable.

//定义变量fun3保存函数对象
var fun3=function(){
    
    
  console.log("我是一个匿名函数中封装的代码");
}
fun3();

Cinq, les paramètres de la fonction

Un ou plusieurs paramètres formels peuvent être spécifiés dans le () de la fonction. Plusieurs paramètres formels sont séparés par des virgules. Déclarer un paramètre formel équivaut à déclarer la variable correspondante dans la fonction, mais pas à affecter une valeur.

    function sum(a,b){
    
    
        console.log(a+b);
}

Lors de l'appel d'une fonction, vous pouvez spécifier des paramètres réels dans (). Le paramètre réel sera affecté au paramètre formel correspondant.

sum(1,2);//调用函数sum，指定实参

Lors de l'appel d'une fonction, l'analyseur ne vérifie pas le type du paramètre réel, donc soyez prudent, s'il est possible de recevoir un paramètre non conforme, vous pouvez vérifier le type de paramètre.
Lors de l'appel d'une fonction, l'analyseur ne vérifie pas le nombre de paramètres réels et les paramètres réels redondants ne sont pas affectés.
Si le nombre de paramètres réels est inférieur au nombre de paramètres formels, le nouveau paramètre sans paramètres réels correspondants ne sera pas défini.
Les paramètres réels de la fonction peuvent être n'importe quel type de données.

Six, la valeur de retour de la fonction return

Vous pouvez utiliser return pour définir la valeur de retour de la fonction
2. Syntaxe: return value (variable);
La valeur après retour sera renvoyée comme résultat de l'exécution de la fonction, et une variable peut être définie pour recevoir ce résultat.
Dans la fonction, l'instruction après retour ne sera pas exécutée

function sum(a,b,c){
    
    
				var d=a+b+c;
				return d;不写
			}
			//调用函数
			//变量result的值就是函数的执行结果
			//函数返回什么result的值就是什么
			var result=sum(1,2,3);
			console.log(result);

Si l'instruction return n'est suivie d'aucune valeur, cela équivaut à renvoyer un indéfini. Ne pas écrire est également indéfini.
5. Tout type de valeur peut être retourné après retour. Peut aussi être un objet

function people(){
    
    
				  return {
    
    name:"lili"}; 	 
		  }
		 var a= people();//函数people作为实参传值
		 console.log(a);

Peut aussi être une fonction

Sept, le paramètre réel peut être n'importe quelle valeur

Le paramètre réel peut être n'importe quel type de données ou un objet. Lorsque nous avons trop de paramètres, nous pouvons encapsuler les paramètres dans un objet, puis transmettre les paramètres réels via l'objet.

 function people(o){
    
    //o是形参，obj是一个实参对象，obj将赋值给o
	console.log("我叫"+o.name+",我今年"+o.age+"岁了,我是"+o.gender+"生");
	 }
		  var obj = {
    
    
			  name:"lili",
			  age:22,
			  gender:"女"
		  };
		  people(obj);//将一个对象obj作为实参传入

Le paramètre réel peut être un groupe d'objets ou une fonction

  
function people(o){
    
    //o是形参，obj是一个实参对象，obj将赋值给o
			  console.log("我叫"+o.name+",我今年"+o.age+"岁了,我是"+o.gender+"生");
		  }
		  var obj = {
    
    
			  name:"lili",
			  age:22,
			  gender:"女"
		  }; 
		   people(obj);//将一个对象obj作为实参传入
 function fun(result){
    
    
			  //console.log("这是一个函数作为实参的例子："+result);
			 result(obj);
		
		  }
		  fun(people);//函数people作为实参传值

Vous pouvez passer une fonction anonyme comme argument à une autre fonction.

function test(){
    
    }
test()是调用函数对象
fun(test(10))相当于fun这个函数对象调用了test函数以10为形参的返回结果
test是函数对象，相当于与直接使用这个函数对象

 function fun1(){
    
    
				  return {
    
    name:"lili"}; 	 
		  }
		  function fun2(a){
    
    
			  console.log( a.name); //lili
			  
		  }
		  fun2(fun1());//调用fun1函数对象的返回值

Huit, pause et continuer et revenir

Break peut sortir de la boucle en cours, et aucun après les temps de boucle en cours ne sera exécuté.
continue équivaut à ignorer la boucle en cours et à continuer à s'exécuter après avoir ignoré la boucle en cours.
return peut terminer la fonction entière

Neuf, exécutez la fonction immédiatement

function(){
    
    
  console.log("我是一个匿名函数中封装的代码");
}
//给匿名函数加一个括号表示一个整体
//在这个函数对象后面再加一个括号，表示调用这个函数对象，这是一个立即执行函数。
(function(){
    
    
  console.log("我是一个匿名函数中封装的代码");
})();

Fonction d'exécution immédiate: la fonction est définie et appelée immédiatement. Ce type de fonction est appelé fonction d'exécution immédiate et la fonction d'exécution immédiate n'est généralement exécutée qu'une seule fois.

Ten, la classe constructeur

Créez un constructeur, spécifiquement utilisé pour créer un objet Person, pour tous les différents types de l'objet.
Le constructeur est une fonction ordinaire et la méthode de création n'est pas différente de la méthode ordinaire. La différence est que la première lettre du constructeur est généralement en majuscule.
La fonction ordinaire est appelée directement et le constructeur doit utiliser le nouveau mot-clé pour appeler

function Person(){
    
    	
			}
			//new构造一个新对象
			var per= new Person();
			console.log(per);//{}

Le flux d'exécution du constructeur:
(1) Créez un nouvel objet immédiatement
(2) Définissez l'objet nouvellement créé comme ceci dans la fonction et utilisez-le pour faire référence à l'objet nouvellement créé dans le constructeur. Per contient l'adresse de l'objet nouvellement créé, et cela pointe vers l'objet nouvellement créé, qui est le par objet.
(3) Exécuter le code dans la fonction ligne par ligne
(4) Renvoyer l'objet de la nouvelle clé comme valeur de retour `

function Person(){
    
    	
     this.name="孙悟空";
     this.age=18;
     this.sayName=function(){
    
    
       console.log(this.name);
};
			}
			//new构造一个新对象
			var per= new Person();
			console.log(per);

Valeur de réussite:

function Person(name,age){
    
    	
     this.name=name;
     this.age=age;
     this.sayName=function(){
    
    
       console.log(this.name);
};
			}
			//new构造一个新对象
	var per= new Person("孙悟空",18);
	var per2= new Person("猪八戒",28);
			console.log(per);

Les objets créés avec le même constructeur sont appelés objets de première classe. Par exemple, per1 et per2 sont des objets du même type, qui appartiennent tous à la classe person. Un constructeur est également appelé une classe.
Nous utiliserons un constructeur pour créer un objet appelé une instance de cette classe. Par exemple, per est une instance de la classe Person.
Utilisez instanceof pour vérifier si un objet est une instance. Syntaxe: si l' objet instanceof constructeur renvoie true, pas false

console.log(per instanceof Person);

Tous les objets sont des descendants d'Object, donc tout objet et Object renverront true lors de l'exécution de instanceof check.
Créez un constructeur Person. Dans le constructeur Person, une méthode sayName est ajoutée pour chaque objet.
À l'heure actuelle, notre méthode est créée à l'intérieur du constructeur, c'est-à-dire qu'une nouvelle méthode sayName est créée chaque fois que le constructeur est exécuté, et le sayName de toutes les instances est unique.
Cela conduit à la création d'une nouvelle méthode lorsque le constructeur est exécuté une fois, et au nombre de nouvelles méthodes créées autant de fois qu'il est exécuté. Ces méthodes sont toutes identiques, ce qui est totalement inutile.
Définissez la méthode sayName dans la portée globale

function Person(name,age){
    
    	
     this.name=name;
     this.age=age;
     this.sayName=fun;
			}
//将sayName方法放在全局作用域中定义
function fun(){
    
    
       console.log(this.name);
};
			//new构造一个新对象
	var per= new Person("孙悟空",18);
	var per2= new Person("猪八戒",28);
			console.log(per);

Mais la définition de la fonction dans la portée globale pollue l'espace de noms de la portée globale, et il n'est pas sûr de la définir dans la portée globale.
Prenez les notes d'étude 9-prototype

	function Person(name,age){
    
    	
						     this.name=name;
						     this.age=age;
						   
									}

									//new构造一个新对象
							var per= new Person("孙悟空",18);
							var per2= new Person("猪八戒",28);
							Person.prototype.sayName=function(){
    
    
                                    console.log(this.name);
									}
							console.log(per.sayName());

L'étude JavaScript note sept fonctions