js中递归函数的使用介绍_javascript技巧
下面我们就做一个10以内的阶乘试试看吧:
[Ctrl+A 全选 注:如需引入外部Js需刷新才能执行]
递归函数的调用就说这么多了
js递归函数调用自身时的保险方式。
来自js高级程序设计
一个典型阶乘递归函数:
function fact(num){
if (numreturn 1;
}else{
return num*fact(num-1);
}
}
以下代码可导致出错:
var anotherFact = fact;
fact = null;
alert(antherFact(4)); //出错
由于fact已经不是函数了,所以出错。
用arguments.callee可解决问题,这是一个指向正在执行的函数的指针。
新的函数为:
function fact(num){
if (numreturn 1;
}else{
return num*arguments.callee(num-1); //此处更改了。
}
}
var anotherFact = fact;
fact = null;
alert(antherFact(4)); //结果为24.
JS普通递归的改进
递归函数是在一个函数通过名字调用自身的情况下构成的,如下所示:
function factorial(num)
{
if(num{
return 1;
}
else
{
return num * factorial(num-1);
}
}
这是一个经典的阶乘函数。表面看来没有什么问题,但下面的代码却可能导致它出错。
var anotherFactorial = factorial;
anotherFactorial(4); //输出 24
factorial = null;
anotherFactorial (4); //TypeError: Property 'factorial' of object [object Window] is not a function chrome 下测试
原因在于,我们定义的函数名,其实是指向函数的一个指针,此时定义了anotherFactorial 也指向了那个函数,所以调用anotherFactorial (4)可以成功的输出24
此时 factorial = null; 那么执行定义函数的引用就剩下了anotherFactorial,那么在调用anotherFactorial(4)就会显示以上的错误的信息。
此时可以使用arguments.callee来替代函数定义中的 factorial,
函数的定义就变成了:
function factorial(num)
{
if(num{
return 1;
}
else
{
return num * arguments.callee(num-1);
}
}
那么在使用上面的4行测试代码,最后一行测试代码也可以成功的输出24.
--------------------------------------
上述的内容摘自>第2版 144页 7.1节

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds



Python est un langage de programmation très puissant et de nombreux programmeurs choisissent Python comme langage de programmation principal. Cependant, trop de fonctions imbriquées dans le code peuvent rendre le programme difficile à maintenir et à comprendre. Cet article explique comment résoudre l'erreur d'imbrication excessive des fonctions dans le code Python. Une brève introduction à l'imbrication de fonctions L'imbrication de fonctions fait référence au processus de définition d'une autre fonction dans le corps d'une fonction. L'imbrication de fonctions peut rendre la structure du programme plus claire et le code plus facile à lire et à maintenir. Cependant, un trop grand nombre de fonctions imbriquées peut conduire à une structure de code trop complexe.

Pour optimiser les performances des fonctions récursives, vous pouvez utiliser les techniques suivantes : Utiliser la récursion de queue : placez des appels récursifs à la fin de la fonction pour éviter une surcharge récursive. Mémorisation : stockez les résultats calculés pour éviter les calculs répétés. Méthode diviser pour mieux régner : décomposer le problème et résoudre les sous-problèmes de manière récursive pour améliorer l'efficacité.

Les fonctions récursives sont utilisées dans les algorithmes de recherche pour explorer des structures de données arborescentes. La recherche en profondeur utilise une pile pour explorer les nœuds, tandis que la recherche en largeur utilise une file d'attente pour parcourir couche par couche. Dans des applications pratiques, telles que la recherche de fichiers, les fonctions récursives peuvent être utilisées pour rechercher un fichier donné dans un répertoire spécifié.

Les conditions de sortie des fonctions récursives C++ incluent : Conditions de base : vérifiez si la fonction atteint un état qui peut renvoyer directement des résultats, en jugeant généralement si une certaine condition ou valeur de paramètre atteint le seuil. Condition de fin de récursion : Alternative ou en plus à la condition de base, garantissant que la fonction s'arrête après un certain nombre d'appels récursifs, en suivant la profondeur de récursion ou en définissant une limite maximale de profondeur de récursion.

L'application de fonctions récursives dans les algorithmes de tri en C++ Les algorithmes de tri par insertion et de tri par fusion implémentés par les fonctions récursives peuvent décomposer des problèmes complexes en sous-problèmes plus petits et les résoudre efficacement grâce à des appels récursifs. Tri par insertion : trie un tableau en insérant des éléments un par un. Tri par fusion : divisez pour mieux régner, divisez le tableau et triez récursivement les sous-tableaux, et enfin fusionnez les sous-tableaux triés.

La stratégie d'optimisation de la récursion de queue réduit efficacement la profondeur de la pile des appels de fonction et empêche le débordement de pile en convertissant les appels récursifs de queue en boucles. Les stratégies d'optimisation incluent : Détecter la récursion de queue : vérifiez s'il existe des appels récursifs de queue dans la fonction. Convertissez les fonctions en boucles : utilisez des boucles au lieu d'appels récursifs et maintenez une pile pour enregistrer l'état intermédiaire.

Comment implémenter factorielle à l'aide de fonctions récursives en langage Go ? Factorielle est un calcul courant en mathématiques qui multiplie un entier non négatif n par tous les entiers positifs plus petits que lui, jusqu'à 1. Par exemple, la factorielle de 5 peut être exprimée sous la forme 5 !, calculée comme suit : 54 321 = 120. En programmation informatique, nous utilisons souvent des fonctions récursives pour mettre en œuvre des calculs factoriels. Tout d’abord, nous devons comprendre le concept de fonctions récursives. Une fonction récursive fait référence au processus d'appel de la fonction elle-même dans le cadre de la définition de la fonction. Lors de la résolution d'un problème, une fonction récursive sera continuellement

Ici, nous avons un répertoire. Notre tâche est de créer un programme C pour lister tous les fichiers et sous-répertoires d'un répertoire. Un répertoire est un lieu/zone/emplacement où un ensemble de fichiers sera stocké. Un sous-répertoire est un répertoire situé dans le répertoire racine, qui, à son tour, peut contenir un autre sous-répertoire. En langage de programmation C, vous pouvez facilement répertorier tous les fichiers et sous-répertoires d’un répertoire. Le programme suivant montre comment répertorier tous les fichiers et sous-répertoires d'un répertoire. //Exemple de programme C pour lister tous les fichiers et sous-répertoires du répertoire Démonstration en direct #include<stdio.h>#include<dirent.h>intmain(void){ &am
