Parfois, lorsque je visite un site Web informatique, je constate qu'il y a beaucoup de choses qui recherchent la nouveauté, la nouveauté, la spécialisation et les préjugés ! On peut dire qu'il y a de tout dans le monde ! Mais face à la situation actuelle des logiciels chinois, d'une part, nous constatons qu'il existe de très nombreux logiciels pratiques en cours de compilation, et que de nombreuses personnes font des heures supplémentaires et sont très occupées ; des logiciels pratiques que personne n'a développés et que quelqu'un attend. D'un autre côté, nous avons également constaté qu'il y a beaucoup de programmeurs inactifs qui ne savent pas ce qu'ils veulent développer ! Je ne sais pas quelles compétences en programmation je dois maîtriser, donc je passe beaucoup de temps à apprendre ceci et cela en ligne. En plus d'apprendre, j'apprends toujours, mais je ne le fais tout simplement pas. , ce qui est navrant. De nombreux programmeurs ne savent pas que ce qui manque le plus à ces logiciels pratiques actuellement, ce ne sont pas des choses nouvelles, étranges, spécialisées ou biaisées, mais une technologie pratique, ainsi que la qualité et les compétences dans l'application de la technologie pratique.
Puisque la programmation est « tous les chemins mènent à Rome », les programmeurs disposent d'une grande autonomie et peuvent utiliser n'importe quelle méthode pour implémenter des fonctions, ce qui entraîne des niveaux de programmation inégaux. Je pense que les programmeurs doivent maîtriser des compétences pratiques en programmation.Pour maîtriser ces compétences, ils doivent maîtriser l'essence de ces compétences. Ce n'est qu'en comprenant parfaitement ces essences qu'ils pourront résumer leur champ d'application et leurs points d'attention : et les programmeurs qui ne savent qu'écrire des programmes. mais je ne sais pas pourquoi ils sont écrits de cette manière. Il n'est peut-être pas possible d'utiliser les meilleures instructions, les instructions les plus simples et les instructions les plus appropriées pour écrire des programmes, et encore moins d'utiliser des compétences plus élevées pour combiner ces instructions afin d'obtenir une qualité élevée. programmes.
Dans la pratique de la programmation à long terme, je crois que les compétences de programmation suivantes constituent la base et doivent être maîtrisées. D'autres compétences de programmation de niveau supérieur doivent être utilisées pour les apprendre.
1. Affectation
L'affectation est une instruction de base indispensable en programmation, et c'est l'instruction la plus fondamentale. Maîtriser cette affirmation semble très simple, mais plus elle est simple, plus vous devez y prêter attention. L'affectation la plus simple consiste à attribuer une valeur à une variable. Par exemple x=1.
L'essence de l'affectation est le transfert entre les choses. De plus, l'affectation elle-même est un processus intermédiaire, et la signification reflétée au niveau du code est d'attribuer une valeur ou un pointeur de mémoire en mémoire à un pointeur de mémoire.
L'affectation comporte deux aspects : l'un est : quelle valeur, variable ou objet est pris, et l'autre est : à quelle variable ou objet est affecté. Lorsque les programmeurs programment, ils sont souvent confus sur deux aspects : quelles valeurs, variables et objets j'obtiens, comment trouver ces valeurs, variables et objets, et à qui dois-je les attribuer après les avoir obtenus. C'est ce que nous rencontrons souvent.
Lorsque nous attribuons des valeurs, nous devons prêter attention à :
1) Les types de données des deux côtés de l’équation doivent être égaux.
2) Les instructions d'affectation sont plus rapides que les autres instructions. Ceci doit être pris en compte lorsque l’on se concentre sur l’efficacité.
Les instructions d'affectation sont plus rapides que les appels de fonction et que les instructions de boucle.
Par exemple : une instruction de boucle est écrite dans une énorme boucle :
pour(i=0;i<3;i++)
UNE[i]=i+1;
Autant le transformer en une déclaration d'affectation :
A[0]=1 ;
UNE[1]=2;
UNE[2]=3;
3) Lorsqu'il existe plusieurs instructions d'affectation, le traitement de l'affectation peut être séquentiel.
4) Il y a trop d'énoncés d'affectation (plus de 20, qui sont très rigides à lire et n'ont aucun contenu technique, et il faudra peut-être en tenir compte).
2. Traitement conditionnel
Le traitement conditionnel vient juste après le traitement d'affectation dans le contenu de programmation, et les changements de programme sont essentiellement provoqués par le traitement conditionnel. Différents traitements seront effectués lorsque différentes conditions seront remplies. Par conséquent, l’essence du traitement conditionnel est que les changements dans les choses entraînent des changements correspondants.
Dans la pratique de la programmation, nous sommes souvent confus quant aux questions suivantes : quelles conditions ? Ce qu'il faut faire? Et réfléchissez également au moment où commencer à considérer les conditions.
Le traitement des affectations est un traitement séquentiel. La condition augmente la possibilité de traitement de l'affectation. Lorsque la condition est remplie, l'affectation A peut être exécutée. Lorsque la condition n'est pas remplie, l'affectation B peut être exécutée.
Lors des conditions de traitement, nous devons prêter attention à :
1) Comment choisissons-nous mes conditions ? C'est notre expression conditionnelle.
En fait, cette question est très compliquée.
D’une manière générale, nous prendrons la condition la plus importante comme première condition. Cependant, nous considérerons également la condition du plus grand ensemble de résultats qui satisfait la condition comme première condition. Ces conditions finales ne peuvent souvent pas être remplies, ou même une fois remplies, elles ne nécessitent pas beaucoup de traitement.
Dès la conception des expressions conditionnelles, nous pouvons utiliser une seule variable pour représenter la condition, ou plusieurs opérations sur des variables pour représenter la condition. Une seule variable peut être représentée par des types numériques, caractères ou logiques. Parmi eux, c'est aussi très particulier.
Par exemple. drapeau==1;flag=='1';flag==Vrai
Les deux peuvent permettre de transférer les conditions du programme, mais de nombreux facteurs doivent être pris en compte lors du choix.
2) Ne laissons pas de côté les exceptions
Par exemple, lorsque l’on considère i=1 et i=2, nous ne considérons pas i<1 et i>2.
L'omission de conditions indique souvent que nos programmeurs n'ont pas le concept global et le concept d'exceptions. C'est l'une des raisons pour lesquelles de nombreux programmes sont mal écrits.
3) Il ne peut y avoir d’intersection entre les conditions
Par exemple:
Si(i>1 &&i<=5)
x=1 ;
Si(i>4&&i<10)
x=2 ;
Quand i=5,
x est d'abord égal à 1, puis est égal à 2. Cela doit être évité. De nombreuses erreurs de programme sont liées à de tels problèmes.
4) Portez une attention particulière à la couverture du traitement conditionnel.
Par exemple : si (drapeau==1)
X=1 ;
Si(drapeau==2)
X=2 ;
X=5 ;
Quelles que soient les conditions, x est toujours égal à 5.
5) Soyez conscient des adaptations respectives de if et case. Sachez quand utiliser si et quand utiliser le cas.
3. Cycle
La boucle est une simple expression d'opérations répétées. Tant qu'il y a des opérations répétées, les instructions de boucle peuvent être utilisées. L'essence des cycles est la répétition.
Lors du traitement des boucles, nous devons faire attention à :
1) Le traitement circulaire est un aspect important qui affecte l'efficacité
Lorsqu'il y a un problème d'efficacité dans le programme, vous devez d'abord le rechercher dans l'instruction de boucle.
2) Conditions préalables au traitement en boucle
De manière générale, les instructions de boucle peuvent être utilisées pour des exécutions répétées plus de trois fois. Pour moins de trois fois, il est préférable de ne pas utiliser d'instructions de boucle.
Par exemple:
Pour (i=0;i<3;i++)
B[je]=je;
Il vaut mieux écrire :
B[0]=0 ;
B[1]=1;
B[2]=2;
Bien entendu, en termes de lisibilité et d’évolutivité, les instructions de boucle peuvent également être utilisées.
3) Différentes conditions de boucle utilisent différentes instructions de boucle
Les programmeurs doivent savoir quand utiliser for, quand utiliser do while et quand utiliser foreach.
Bien que les déclarations ci-dessus puissent atteindre le même objectif, les programmeurs doivent néanmoins connaître leur champ d'application afin qu'elles puissent être les plus appropriées.
4) Utilisez pleinement les instructions de la boucle, telles que la boucle d'interruption, la boucle continue, le retour de fonction, la sortie du programme, etc., pour rendre la boucle plus colorée.
4. Opérations sur les chaînes
Les chaînes sont une représentation importante de l’information. La manipulation de chaînes est l’une des opérations les plus couramment utilisées en programmation. L’essence de l’opération sur les chaînes est le traitement de l’information. Puisqu’il n’existe pas de normes pour beaucoup d’informations, les programmeurs les manipulent pour se conformer à leurs propres exigences standard.
Par exemple : certaines chaînes contiennent une variété d'informations, alors les chaînes doivent être divisées ; certaines chaînes manquent d'informations, puis les chaînes doivent être fusionnées.
Faites principalement attention aux aspects suivants lors du fonctionnement des chaînes :
1) Traitement des chaînes vides
Étant donné que la chaîne d'origine comportera plusieurs espaces au début et à la fin de la chaîne pour des raisons opérationnelles et système, les espaces doivent être supprimés avant que la chaîne ne soit traitée.
2) Traitement du code tronqué
Il y a divers caractères tronqués dans certaines chaînes, provoquant l'apparition de caractères incompréhensibles dans l'affichage de la chaîne. Ces situations sont principalement causées par la présence de codes de caractères de contrôle dans les chaînes et par des incompatibilités de caractères dans les caractères chinois.
3) Traitement des délimiteurs
Les délimiteurs apparaissent souvent dans un enregistrement ou un paramètre pour séparer les informations, et les informations peuvent être extraites via des délimiteurs. En pratique, il peut arriver que le contenu de l'information lui-même contienne des délimiteurs, ou que des délimiteurs soient générés lors d'une génération de code tronqué. Dans ces cas, les délimiteurs doivent être modifiés ou un traitement spécial doit être effectué.
4) Conversion entre caractères et autres types de données
Dans la programmation réelle, la cohérence des objets sur lesquels nous opérons nécessite souvent l'opération de conversion de chaînes en d'autres types de données, ou de conversion d'autres types de données en chaînes. De manière générale, il est plus facile de convertir d'autres types de données en chaînes, mais lors de la conversion de chaînes en d'autres types de données, vous devez déterminer si le format de chaîne avant la conversion répond aux exigences.
Par exemple : pour convertir "1 000 000" en valeur numérique, supprimez "," avant la conversion.
5) Traitement des sous-chaînes
Le traitement des sous-chaînes est souvent utilisé dans les requêtes. Il existe trois types de correspondance de sous-chaînes : front, middle et last. La correspondance de sous-chaîne prend souvent plus de temps. Plus la sous-chaîne est courte et plus la chaîne de requête est longue, plus cela prend de temps. Lors d'une requête dans le champ indexé, seule la première correspondance peut utiliser l'index pour atteindre l'objectif d'une requête rapide. Cependant, si les correspondances intermédiaires et ultérieures sont utilisées, l'index sera invalide et chaque enregistrement doit être mis en correspondance un par un. , ce qui prend le plus de temps. Les programmeurs doivent comprendre le contenu ci-dessus et tirer parti de la situation afin de traiter correctement les sous-chaînes afin d'atteindre des objectifs de requête rapides.
5. Opérations arithmétiques
Les opérations arithmétiques sont juste derrière les opérations sur les chaînes en programmation. Parmi eux, l'ajout de 1 comporte de nombreuses opérations et est largement utilisé. L'addition, la soustraction, la multiplication et la division sont les plus couramment utilisées dans les logiciels d'application généraux. L’essence des opérations arithmétiques est le traitement d’informations numériques. Les opérations arithmétiques sont des exigences algorithmiques pour des applications pratiques d'une part, et des algorithmes de programmation d'autre part.
Par exemple, le système d'application doit calculer l'aire d'un rectangle. Ensuite, l'instruction S=L*D sera écrite.
Si vous souhaitez programmer et calculer l'aire de 100 rectangles, vous avez besoin d'un pointeur pour calculer l'aire du rectangle suivant via le pointeur + 1. Le pointeur est incrémenté de 1. Cette opération est requise par l'algorithme.
Les opérations arithmétiques sont utilisées dans des applications où les calculs de formules sont relativement simples. Cependant, les techniques et la mise en œuvre des opérations arithmétiques utilisées dans les algorithmes ne sont pas si simples. Les points clés à noter sont les suivants : définir certaines variables intermédiaires et les transformer en opérations de boucle via l'addition et la soustraction de variables intermédiaires.
6. Tableau
Un tableau est une collection qui stocke des données. Les opérations sur les tableaux sont également couramment rencontrées en programmation : l'essence d'un tableau est une collection d'éléments. Cependant, il convient de noter que le nombre d'objets de collection est limité et que son tableau est stocké en mémoire, les opérations sur le tableau sont donc très rapides. Une grande partie de l’utilisation des tableaux consiste à utiliser des instructions de boucle. La combinaison de tableaux et de boucles améliore considérablement la qualité des programmes.
Pour les tableaux, nous devons faire attention à :
1. Problèmes liés au nombre de baies
2. Méthode de représentation et forme de stockage des tableaux multidimensionnels
3. Problème de tableau hors limites
4. Tableau vide
5. L'utilisation de tableaux dans les instructions de boucle.
Pièce jointe : je pensais que ce sujet pouvait être résolu en un seul article, mais plus j'écrivais, plus il devenait de plus en plus difficile pour moi de le simplifier puis de le simplifier, alors écrivons-le en plusieurs parties.
Article suivant « Compétences pratiques en programmation que les programmeurs devraient maîtriser 2 »
Contenu principal :
7. Appelez
8. Opérations sur les fichiers
9. Opérations logiques
10. Tableau
11. Base de données
12. Contrôles
13. Classe
14. Paramétrage