Programmation web JavaScript------fonctions (fonctions générales, fonctions dynamiques, fonctions anonymes)

Fonction
1. Fonction générale
format :
nom de la fonction (paramètres formels...)
{
instruction d'exécution
retourner la valeur de retour ;
Une fonction est un package de plusieurs instructions d'exécution et ne sera exécutée que lorsqu'elle est appelée.
Remarque : si vous appelez une fonction avec des paramètres mais ne lui transmettez pas de valeur, la fonction s'exécutera toujours. Ou si vous appelez une fonction sans paramètres et lui transmettez une valeur, la fonction s'exécutera toujours.
Pour faire simple : tant que vous écrivez le nom de la fonction suivi d'une paire de parenthèses, la fonction s'exécutera. Qu'en est-il des paramètres passés ?
En fait, il y a un objet tableau de paramètres (arguments) dans la fonction, qui encapsule les paramètres passés dans un tableau
.

Exemple :

function demo(){<span style="font-family: 宋体;">//定义函数。</span>
	alert(arguments.length);
}
demo(“hello”,123,true);//调用函数。

Ensuite, le résultat de la boîte de dialogue contextuelle est 3. Si vous souhaitez obtenir toutes les valeurs des paramètres, vous pouvez parcourir le tableau via une boucle for.

for(var x=0; x<arguments.length; x++){
	alert(arguments[x]);
}

Afin d'améliorer la lisibilité, il est préférable de transmettre les paramètres réels selon les paramètres formels définis selon les spécifications.

Autres façons d'écrire la fonction lors de l'appel :

var show = demo();//show变量接收demo函数的返回值。
var show = demo;//这种写法是可以的，意为show和demo代表同一个函数。
		//那么该函数也可以通过show()的方式运行。

<script type="text/javascript">
  	function getValue(){
  	<span style="white-space:pre">	</span>alert("aa");
  		return 100;
<span style="white-space:pre">	</span>}
//var v = getValue();
//alert("v="+v);
  	var v2=getValue; //相当于getValue把引用值传给v2，因此v2也是一个“function对象”----getValue和v2都是引用变量
  	//alert("v2="+v2 );//其实是输出v2对象的toString()
  	//alert("v2="+v2() ); //调用v2这个函数对象---调用函数
</script>

Bien que la fonction soit déclarée comme deux paramètres lorsqu'elle est définie, n'importe quel nombre de

peut être transmis lorsqu'il est appelé.

<span style="font-weight: normal;"><span style="font-size:12px;">function show(x,y){
  	alert(x+","+y);
}
//show(23,22);//23,22
//show(23); //23,undefined
//show(); //undefined,undefined
//show(23,22,11);//23,22 后面的一个参数函数接收了但没有用</span></span>

Dans chaque fonction, il y a un tableau d'arguments par défaut, qui stocke tous les paramètres réels transmis lors de cet appel

//函数的参数全部是js内部用一个arguments数组来接收与存放的---该对象是js内部隐含帮我们做的，我们可以访问到这个数组对象
function show2(x,y){
  	arguments[0]=1000;//可以把形参x的值改掉
  	document.write(x+","+y+"<br/>");
  	for(var i=0;i<arguments.length;i++){
  	<span style="white-space:pre">	</span>document.write(arguments[i]+",");
  <span style="white-space:pre">	</span>}
}
show2(11,22,33,44);
  	   
//※综上，函数的技术细节：
//1, js中的函数是没有重载，只以函数名来识别的---其实函数名就是一个function对象的引用的名字
//2, js函数中有一个内部维护的arguments数组来接收与保存形参

Détails techniques :

1. pas de duplication de fonctions dans js Chargé, identifié uniquement par le nom de la fonction. Le nom de la fonction est le nom de référence de l'objet fonction

2. Les paramètres de la fonction sont tous reçus et stockés dans un tableau d'arguments à l'intérieur. js ------ l'objet Cela est fait implicitement pour nous à l'intérieur de js, et nous pouvons accéder et modifier la valeur

2. La fonction dynamique
est implémentée via l'objet intégré Fonction de Js .

Exemple :

<script type="text/javascript">
//把函数的形参用第1个参数传入，函数体中的代码用第2个参数传入----可以通过调用者动态传入函数体，因此非常灵活，该思想类似Java当中的类反射。
<span style="white-space:pre">	</span>var add = new Function("a,b","var s = a+b; return s; ");
//alert( add(12,11));
</script>

est le même que :

function demo(x,y){
	alert(x+y);
}
demo(4,6);

La différence est que les fonctions dynamiques, les paramètres et les corps de fonction peuvent être transmis via des paramètres . Spécifié dynamiquement.

3. Fonction anonyme

Format : function(){...}

Exemple :

var demo = function(){...}
demo();

Définissant généralement le comportement des attributs d'événement plus couramment utilisé.

Exemple :

function test()
{
	alert(“load ok”);
}
window.onload = test;

peut s'écrire sous la forme d'une fonction anonyme :

window.onload = function()
{
	alert(“load ok”);
}

La fonction anonyme est un format abrégé.

Exemples de définition et d'appel de fonctions :

<html>
  <head>
    <title>javascript数组与函数练习</title>
  </head>
  
  <body>
  <script type="text/javascript">
    //写一个获取数组中元素最大值的函数
    function getMax(arr){
    	var max=0;//最大值的下标
    	for(var x=1;x<arr.length;x++){
    		if(arr[x]>arr[max]){
    			max = x;
    		}
    	}
    	return arr[max];
    }
    //调用
    var arr=[23,-3,45,0,-100,47,22];
    var v = getMax(arr);
    //alert("v="+v);
    
    //数组排序
    function sortArray(arr){
    	for(var x=0;x<arr.length-1;x++){
    		for( var y=x+1;y<arr.length;y++){
    			if(arr[x]>arr[y]){
    				swap(arr,x,y);
    			}
    		}
    	}
    }
    function swap(arr,x,y){
    	var temp = arr[x];
    	arr[x] = arr[y];
    	arr[y] = temp;
    }
    
    //alert(arr);
    //document.write(arr+"<br/>");
   // sortArray(arr);
    //alert(arr);
    //document.write(arr+"<br/>");
    
    //我们的输出函数---把内容输出到页面且换行
    function println(str){
    	 document.write(str+"<br/>");
    }
    println(arr);
    sortArray(arr);
    println(arr);
    
    //到数组当中查找元素
    function searchElement(arr,key){
    	for(var x=0;x<arr.length;x++){
    		if(arr[x]==key){
    			return x;
    		}
    	}
    	return -1;
    }
    println( searchElement(arr,0) );
    println( searchElement(arr,123) );
    
  </script>
  
  <script type="text/javascript">
    //二分查找
    function binarySearch(arr,key){
    	var max,min,mid;
    	min=0;
    	max=arr.length-1;
    	while(min<=max){
    		mid = (max+min)>>1;
    		if(key>arr[mid]){//落在右边
    			min = mid+1;    			
    		}else if(key<arr[mid]){//落在左边
    			max = mid-1;
    		}else{
    			return mid;
    		}
    	}
    	return -1;
    }
    println( binarySearch(arr,0) );
    println( binarySearch(arr,123) );
    
    //数组反转
    function reverseArray(arr){
    	for(var start=0,end=arr.length-1; start<end; start++,end--){
    		swap(arr,start,end);
    	}
    }
    reverseArray(arr);
    println("反转之后:"+arr);
  </script>

  </body>
</html>

Ce qui précède est le contenu de la programmation Web JavaScript------fonctions (fonctions générales, fonctions dynamiques, fonctions anonymes), plus Veuillez faire attention au site Web PHP chinois (www.php.cn) pour le contenu !