Concepten van programmeertalen
Toen ik concepten van programmeertalen begon te leren, wist ik niet zoiets als de basis. Ik kende gewoon de basisprincipes van A + en Network +. Maar C, Java, Python waren voor mij een heel andere wereld. Trouwens, er was bijna niemand om me te helpen, omdat ik de enige was onder mijn vrienden met een IT-achtergrond. Dus besloot ik uiteindelijk dat ik zou gaan leren van de meest voorkomende concepten van programmeertalen die er zijn. Ik kwam toen te weten over C en C ++. Ik begon met het leren van C, maar ik was eigenlijk hals over kop sinds het importeren van modules en al die dingen gingen meestal uit op mij. Ik heb C een maand geleerd, toen dacht ik dat C een beetje moeilijk was en begon ik dus Bash te leren.
Hoewel bash een scripttaal is en geen programmeertaalconcepten, was het weer een beetje moeilijk te begrijpen. Ik liep vast bij cron-banen en zo. Eindelijk, nergens om te gaan, begon ik Python te leren. Maar nee hoor … het was het ergste. Toen ik codes in C schreef, moest ik elk stukje code schrijven. Maar in Python was er veel magie om daadwerkelijk te begrijpen wat er gebeurt. En ja, deze magie is anders dan die je denkt en 'magie' is het officiële woord in Python. Magie in Python betekent dat je iets wilt doen, en dat ding gebeurt, maar je weet niet hoe het is gebeurd. Ja, en dat is waar Python vaak ingewikkeld van wordt.
Toen ik al deze concepten van programmeertaal begon te leren, was het belangrijkste dat ik niet kon begrijpen waarom ik een specifieke module moest importeren. Als u bijvoorbeeld een hallo wereldprogramma schrijft in C, schrijven we meestal 'include stdio.h' of 'include conio.h'. Dus mijn vraag was waarom alleen dit. Ik zag zelfs sommige mensen die niet eens het conio-gedeelte intypen. Op dezelfde manier importeren we in python om complexe wiskunde te doen cmath, maar waarom combineren ontwikkelaars wiskunde en cmath niet al en verkorten ze het hele proces van het tweemaal importeren? Maar toen dacht ik, laten we één ding doen. Laten we beginnen met de basisprincipes van programmeertaalconcepten.
Ik besloot de bodem van de rots te raken en vanaf daar te beginnen. En vanaf nu kan ik elk programma schrijven in bijna alle concepten van programmeertaal zoals Java, C, C ++, Haskell, Scala, Python, Ruby en nog veel meer. Door de jaren heen heb ik een ijzersterke basis voor programmeerconcepten kunnen bouwen. En de belangrijkste reden hiervoor is dat ik al mijn basisbegrippen heb weggewerkt in concepten van programmeertalen. Je hoort misschien nauwelijks iemand praten over de basisprincipes, maar deze zijn het belangrijkst om je concepten goed te krijgen bij het programmeren van concepten, en dat is de belangrijkste reden om aan deze blog te schrijven. Laten we beginnen met de basisprincipes en terminologieën van programmeertaalconcepten.
Pseudo-codes, wiskunde en opmerkingen over concepten van programmeertalen
Als je wiskunde kent, komen de meeste dingen gemakkelijk langs. Het schrijven van een programma verschilt niet veel van het oplossen van een wiskundeprobleem. Trouwens, bij het leren van functionele talen zoals Haskell, is wiskunde het enige dat een voorwaarde kan zijn voor het leren van die concepten van programmeertalen. De meeste problemen kunnen worden opgelost door eenvoudige wiskunde en pseudo-codes. Wiskunde en pseudo-codes gaan hand in hand. Wanneer u bijvoorbeeld een specifiek probleem wilt oplossen, schrijft u het gewoon op in een eenvoudig algebraïsch en geometrisch formaat in de vorm van stellingen en dus bewezen formaten. Schrijf deze stukjes code nu op in pseudocode-formaat. Als ik pseudocodes zeg, bedoel ik het schrijven van het programma op zo'n manier dat wanneer je een echt programma schrijft, je alleen enkele waarden en vocabulaires hoeft te veranderen en het programma zou werken. Als u bijvoorbeeld de som van alle getallen van 1 tot 20 wilt berekenen, kunt u op de volgende manier een pseudocode schrijven: -
| laat x = 1x = x + 1 als x = 20 stop dan en print xelse door en herhaal alles opnieuw |
Nu is deze code een beetje buggy, maar daar zijn we niet voor. Zoals je kunt zien, heb ik eerst de waarde van x aan 1 toegewezen en daarna heb ik 1, 2, 3 toegevoegd tot het 20 bereikt. Als x 20 bereikt, stopt het programma en drukt de uitvoer af, anders gaat het door en blijft het herhalen hetzelfde. Dus wanneer u dit soort pseudocode schrijft, wordt het uiterst eenvoudig om het gewoon in een echt programma om te zetten. En zorg er ook voor dat je opmerkingen schrijft naast al die regels waarvan je denkt dat ze verwarrend zijn. De belangrijkste reden voor het schrijven van opmerkingen is omdat het eerst niet wordt uitgevoerd, en ten tweede kun je altijd aangeven wat je hebt gedaan, waar je hebt gedaan en waarom je iets hebt gedaan. Opmerkingen zijn niet erg nuttig in 5-10 coderegels, maar wanneer u meerdere bestanden hebt met ongeveer 40-50 coderegels in elk bestand, wordt het gemakkelijk om te achterhalen waar de bug ligt of waarom een bestand door slechts kijkend naar de commentaren.
Aanbevolen cursussen
- Online Windows 10-training
- Certificatietraining in softwaretestbundel
- Python programmeertraining
- Online certificeringstraining in Django
Variabelen, constanten en gegevenstypen op concepten van programmeertalen
Een variabele is iets dat kan worden gebruikt om gegevens, tekenreeksen, nummers of bijna alles op te slaan. Een verzameling van dergelijke gegevens staat bekend als een array. Als ik naar het vorige voorbeeld verwijs, kun je zien dat ik in het begin de waarde van één aan X heb toegewezen, waardoor het X een variabele maakt. Hier is die een geheel getal en is X de toegewezen variabele. Op dezelfde manier kan ik ook een string in een variabele invoeren. Een eenvoudig voorbeeld zou zijn: -
| X = 'Hallo wereld' echo $ X |
Nu is het bovenstaande een feitelijk concept van programmeertalen die kunnen worden uitgevoerd in bash, wat een geweldige Linux-terminal is. X krijgt de waarde van de tekenreeks 'hallo wereld' en echo drukt alles wat zich binnen X bevindt af. Het dollarteken wordt gebruikt om aan te geven dat we hier de waarde van X noemen.
Op een vergelijkbare manier zijn constanten ook variabelen, maar in tegenstelling tot variabelen kunnen constanten niet worden gewijzigd. In het eerste voorbeeld van concepten van programmeertalen, heb ik de waarde van één aan X toegewezen, en daarna bleef ik deze in oplopende volgorde verhogen. Maar voor een constante, zal X er altijd één zijn en de waarde kan niet worden gewijzigd totdat de concepten van programmeertalen zijn gestopt. Gegevenstypen zijn slechts een splitsing van verschillende soorten gegevens. Bijvoorbeeld reële getallen, gehele getallen, praalwagens of zelfs Booleaanse waarden en tekenreeksen. Boolean verwijst naar Waar en Onwaar en wordt vaak voorgesteld door 1 en 0.
Functies en procedures voor concepten van programmeertalen
In deze programmeertaalconcepten worden functies gewoon waarden toegewezen aan grote stukken codes. Ze worden meestal zo gemaakt, zodat een persoon de hele code niet steeds opnieuw hoeft op te schrijven en eenvoudig de hele code met slechts één eenvoudige syntaxis kan oproepen. Een functie is slechts een ingekapselde taak die meerdere uit te voeren instructies bevat. Bij het schrijven van grote stukken codes worden functies meestal vooraf ontwikkeld en opgeslagen in afzonderlijke bestanden in een map. Later, wanneer dat stuk code een willekeurig aantal keren nodig is, kan men gewoon de bestandsnaam of de functienaam die is gedefinieerd oproepen en het hele stuk code binnen het bestand wordt uitgevoerd.
Functies hebben hun eigen werkruimte, wat betekent dat alle variabelen binnen een functie alleen bruikbaar zijn totdat de uitvoering van de code is voltooid. Als het eenmaal is voltooid, wordt de variabele ongedefinieerd (behalve in het geval van garbage collection, die ik hier niet heb vermeld, omdat dat een enorm onderwerp is om over te bespreken). En functies kunnen ook binnen een functie worden genest. Dit betekent dat een functie ook een andere functie kan aanroepen, inclusief zichzelf. Maar de laatste wordt niet aanbevolen, omdat dat zal resulteren in een opstartlus totdat het anders op een acute manier wordt uitgevoerd.
Procedures zijn daarentegen bijna gelijk aan Functies, behalve dat functies altijd een waarde retourneren, terwijl een procedure slechts een uitvoering van opdrachten is. Vooral als je programmeerconcepten begint te leren, zie je veel mensen de termen functies en procedures door elkaar gebruiken. Maar dit is niet het geval als u begint met het leren van functionele concepten van programmeertalen zoals Haskell of Scala. Een ding om in gedachten te houden bij het schrijven van functies is om ervoor te zorgen dat ze geen bijwerkingen hebben.
Voorwaarden en loops over concepten van programmeertalen
Conditie en lussen zijn iets dat ik eerder in het voorbeeld heb uitgelegd. Ze gaan als volgt: 'Als het regent, word ik nat. Anders zal ik niet zijn '. Ja, dat klinkt als een dom voorbeeld, maar dat is het meest eenvoudig dat het kan krijgen. Voorwaardelijke uitspraken zijn van elkaar afhankelijk. Meestal zijn ze onderling verbonden en gaan ze in de vorm van "als, dan, anders en elif". Zelfs voorwaardelijke uitspraken kunnen ook worden genest. Voorwaarden binnen omstandigheden zijn tegenwoordig heel gewoon, maar als inspringingen en opmerkingen niet op de juiste manier worden gedaan, wordt het programma extreem buggy en moeilijk te begrijpen.
Aan de andere kant worden Lussen gebruikt om de uitvoering van codes, functies en procedures te herhalen totdat het gewenste resultaat is geretourneerd. Als je mijn eerste voorbeeld bekijkt, zul je zien dat ik iets heb gezegd om alles opnieuw te herhalen. Lussen zijn dus zeer krachtig en maken concepten van programmeertalen extreem compact. Maar te veel gebruik van lussen zal het programma traag maken. Ze mogen alleen worden gebruikt als dat nodig is. Lussen hebben de vorm van "for, While, Do-While-lus en for-elke lus". De while, do-while en de for-lus zijn de meest gebruikte lussen. De pseudo-codes voor de while, do-while en for loop zouden als volgt gaan: -
| Herhalingslus:- |
| Terwijl de voorwaarde onwaar is, (voert u de code uit en controleert u of de voorwaarde waar is) Stop wanneer de voorwaarde waar wordt. |
| Do - While Loop: - |
| Doe ( voer een code uit ) terwijl ( controleer of een verklaring waar is, anders herhaal de Do) |
| For loop:- |
| voor (a, b, c) (code uitvoeren) |
| In de bovenstaande code is a een voorwaarde die eenmaal en eerst wordt uitgevoerd, b is de voorwaarde van de lus en c is de code die wordt uitgevoerd zodra de lus op het punt staat te stoppen. |
Besturingsstructuren op concepten van programmeertalen
Besturingsstructuren in programmeerconcepten zijn slechts een combinatie van voorwaarden, lussen en andere sets codes. De besturingsstructuur is een codeblok dat de hele structuur van de programmeertaalconcepten analyseert en vervolgens beslist welke verder te gaan; zoals het stoppen, of herhalen of een functie oproepen of het andere codeblok uitvoeren. Kortom, om meer specifiek te zijn, controlestructuren in concepten van programmeertalen is slechts een besluitvormingsproces dat de stroom van een programma bepaalt. Een volledig stuk code werkt op een manier van het volgende bloktype: -
| Voorwaarde Controle structuur Einde van controle Structuur Post Staat |
Objectgeoriënteerd programmeren en functioneel programmeren
Nu is dit een van de meest besproken onderwerpen door ontwikkelaars. Object-georiënteerd programmeren gaat alleen over 'objecten'. Neem die uitspraak niet te letterlijk. Object-georiënteerd programmeren of OOP behandelt in principe gegevens die velden, attributen, procedures en methoden bevatten. C is een objectgeoriënteerde programmeertaalconcepten. Python is niet puur objectgebaseerd. Maar er zijn boeken geweest waarvan sommige mensen geneigd zijn te zeggen dat Python ook objectgericht kan werken. Nu vergelijkbaar met objectgeoriënteerd programmeren, is er ook iets dat bekend staat als concepten voor functionele programmeertalen. Functionele talen zijn meer op wiskunde gebaseerd. Een puur functioneel concept van programmeertalen dat ik me kan herinneren is Haskell. Een andere is Scala, maar deze is niet volledig functioneel, maar kan op die manier worden gemaakt. Haskell daarentegen werkt meestal niet zoals andere concepten van programmeertalen en is gebaseerd op pure logica. Het hebben van een bug in Haskell is heel minder omdat er in ieder geval minder bijwerkingen zijn van functies in Haskell dan Java, C, Python of de meeste andere talen.
Al met al zijn programmeerconcepten heel gemakkelijk te leren. Je hoeft alleen maar de juiste logica in een probleem in te voeren en meerdere manieren te vinden om een probleem op te lossen in plaats van slechts één om een probleem op te lossen. Als je de basis eenmaal goed hebt, zou het ontwikkelen van software of leerkaders daarop een fluitje van een cent zijn.
Aanbevolen artikelen
Dit is een leidraad geweest voor concepten van programmeertalen, hier hebben we besproken dat hoe programmeerconcepten gemakkelijk te leren zijn als men een goed idee heeft om problemen op meerdere manieren op te lossen. U kunt ook de volgende artikelen bekijken voor meer informatie -
- Belangrijke functies over Haskell-programmeertaal
- Wat zijn de voordelen van Cheatsheet voor C ++ programmeertaal (basisprincipes)
- 12 beste stappen om R Programming Language te installeren (Beknopte handleiding)
- Carrières in R Programmering
- 13 beste interviewvragen en antwoorden over programmeren in C