Moje notatki na temat prostych zagadnień w kodowaniu (cz. 1)

NO.1
To są tylko moje notatki na temat kodowania, które mają posłużyć mi do lepszego poznawania tej wspaniałej umiejętności.


IDE i kompilatory
Komentarze
"Foremki" do kodu
Wyświetlanie
Błędy

Na razie tyle, ponieważ dalsze tematy będą w 2. części i tutaj mówię o banalnych rzeczach.

Zamierzam ten artykuł edytować zawsze, kiedy znajdzie się jakiś błąd lub będę chciała wtrącić więcej.

Dużo się namęczyłam, żeby zebrać to razem, więc jak zauważysz jakąś wpadkę, to zamiast się oburzać, po prostu napisz, a to zmienię.

Piszę to na Steemit, bo może się komuś przydać.

Może się też nie przydać, bo nie ma jednego środka dla wszystkich.¯\_(ツ)_/¯

Ten artykuł nie jest próbą udowodnienia, że kodowanie jest łatwe. Wymaga to:

rozwijania zdolności umysłowych
praktyki jako koder konkretnego języka
poznawania składni, w tym różnych bibliotek
wiedzy o algorytmach
(najlepiej) znajomości języka angielskiego
i jeszcze wielu innych rzeczy

Więc, nie jest to banalne.

Mój post zrozumieją Ci, którzy mają już jakąś drobną wiedzę w tej dziedzinie.

Jest tak, że jak się uczysz o różnych językach, to widać, że pewne elementy są takie same. Jak poznałeś wiedzę o komentarzach, to do użycia ich w czymś nowym potrzebujesz jedynie znać składnię.

A czasami są takie zagadnienia, które są specyficzne dla jednego języka.

Ja próbuję się zająć tym przypadkiem, w którym informacje są podobne.

ZINTEGROWANE ŚRODOWISKO PROGRAMISTYCZNE [IDE] I KOMPILATOR [COMPILER]

Zintegrowane Środowisko Programistyczne [Integrated Development Environment (IDE)] | jest to program (lub zbiór programów) przeznaczony do ułatwionego pisania kodu. Jego typowe funkcje to automatyczne porządkowanie i uzupeł[->nianie]oraz odpowiednie kolorowanie składni (nie, to nie jest link 😛). Tak naprawdę, kod możesz tworzyć nawet w notatniku, ale robienie tego w IDE jest prostsze i bardziej intuicyjne. Te środowiska programistyczne mają wiele użytecznych funkcji, takich jak

zintegrowanie z kompilatorami
ulepszone wskazywanie błędów
automatycznie sprawdzanie nowych wersji użytecznych narzędzi
często wsparcie dla wielu języków kodowania
czasami nawet możliwość wizualnego tworzenia aplikacji
i wiele innych.
Nie będę wchodziła w dyskusje nad tym które programy są najlepsze. Sprawdź recenzje dostępne w Internecie, albo zapytaj specjalistę, i sam wybierz ten odpowiadający twoim potrzebom. Chcę jedynie powiedzieć, że warto (nawet powinno się) ich używać, żeby zmniejszyć sobie ilość frustracji i skupić na tworzeniu.

Kompilator [Compiler] | to praktycznie niezbędne narzędzie, które służy przetłumaczeniu

języka przyjaznego programiście
➩ na przyjazny komputerowi (język maszynowy).
Czyli tworzy program.
Żeby zobaczyć jak taki komputerowy kod wygląda, należy otworzyć jakiś plik, na przykład typu exe, w notatniku.

notepad.exe otworzone w notepadzie... 😃

Jeśli nie używasz IDE, to z kompilatora korzysta się zwykle w terminalu, co wymaga minimalnej wiedzy o jego używaniu.

Są różne kompilatory tych samych języków i nie są one sobie równe. Mają różne parametry, niektóre nie obsługują pewnych elementów języka, więc ich używanie będzie bardziej ograniczone. Żeby znaleźć najlepszy, podobnie jak wcześniej, polecam poszukać w Internecie i popytać specjalistów.

Korzystanie z IDE i kompilatora może być dla początkujących problematyczne, ponieważ na początku mogą nie działać, bo czasami trzeba jeszcze robić takie rzeczy jak edycja zmiennej PATH [PATH variable] czy doinstalowanie odpowiednich plików.

Zalecam więc dokładne zapoznanie się z instrukcjami instalacji i spokojne oswojenie się ze środowiskiem.

W systemach Windows od XP do 10, żeby zmienić zmienną środowiskową:

Wejdź w Panel sterowania [Control Panel], a w Windows 7 i Vista kliknij prawym przyciskiem myszy na Mój komputer/Komputer [My computer]/[Computer] i wybierz Ustawienia [Settings].
Wyszukaj i kliknij System.
Następnie wejdź w Zaawansowane ustawienia systemu [Advanced system settings], w Windows XP będzie samo Zaawansowane [Advanced],
później w Zmienne środowiskowe [Environment Variables],
a potem odszukaj zmienną środowiskową PATH, po czym kliknij na nią i wciśnij Edytuj [Edit], a jak nie ma takiej opcji, to Nowa [New].
W okienku, które wyskoczy, wpisz odpowiednią wartość.
Wyjdź z wszystkich okienek, wciskając OK.

W Linux i Solaris robisz to tak:

powłoka Bash

Edytuj plik startowy (~/.bashrc) i zmodyfikuj zmienną PATH.
PATH=/usr/local/.......:$PATH
export PATH
Załaduj plik startowy.
% . /.profile

powłoka C (csh)

Edytuj plik startowy (~/.cshrc) i ustaw zmienną PATH.
set path=(/usr/local/..... $path)
Załaduj plik startowy.
% source ~/.cshrc

KOMENTARZE [COMMENTS]

Komentarze w kodowaniu mają głównie na celu dezaktywowanie jakiegoś fragmentu, pozwalają na lepszą orientację w tekście (możesz ich używać podobnie jak zakładek w książce) oraz mogą być cenną wskazówką (taki przypis do kodu). Nie są interpretowane przez kompilator, więc możesz w nich wpisać cokolwiek, na przykład coś humorystycznego. Regularne dokumentowanie swojego dzieła pozwala nie tylko na jaśniejsze rozumienie za co odpowiada kod, ale także na jego lepsze rozwijanie.

Niektórzy słusznie twierdzą, że jeśli musisz wyjaśniać swoje instrukcje, to znaczy, że nie są napisane odpowiednio prosto, a to sprawia, że są gorsze. Jednocześnie uważam, że prostego kodu może być tak dużo, że podzielenie go na segmenty (na przykład: //ZMIENNE, //FUNKCJA O TAKIM DZIAŁANIU, //INNA FUNKCJA) oszczędza mnóstwo frustracji. Wiem z własnego doświadczenia. A czasami wyjaśnienie może pomóc mniej zaawansowanym.

C, C#, C++, Objective-C, Go, Groovy, Java, JavaScript, PHP, Scala, Swift

//KOMENTARZ JEDNOLINIOWY
/*KOMENTARZ WIELO-
LINIOWY*/

CSS

/*KOMENTARZ WIELO-
LINIOWY*/

Delphi/Object Pascal

//KOMENTARZ JEDNOLINIOWY
{KOMENTARZ WIELO-
LINIOWY}

HTML

‹!--KOMENTARZ WIELO-
LINIOWY--›

MATLAB

% KOMENTARZ JEDNOLINIOWY
%{
KOMENTARZ WIELO-
LINIOWY
%}

Perl, Python, PHP, R, Ruby

#KOMENTARZ JEDNOLINIOWY

Perl

=begin comment
KOMENTARZ WIELO-
LINIOWY
=cut

Python

"""[lub '''] KOMENTARZ WIELO-
LINIOWY"""

Ruby

=begin
KOMENTARZ WIELO-
LINIOWY
=end

SQL, PL/SQL

--KOMENTARZ JEDNOLINIOWY
/*KOMENTARZ WIELO-
LINIOWY*/

Visual Basic

' KOMENTARZ JEDNOLINIOWY
REM KOMENTARZ JEDNOLINIOWY

Komentarze to po prostu twój opis, który nie ma absolutnie żadanego wpływu na działanie programu. Proste. Nie sądzę, że jest sens się nad tym zatrzymywać.

Istnieją także komentarze do dokumentacji. Dzięki nim, podczas kompilacji programu, w sposób automatyczny tworzona jest dokumentacja. Są też specjalne tagi, które pozwalają ją urozmaicić, ale o tym będzie w następnym artykule, bo w w najprostszych programach nie jest to na razie potrzebne.

FOREMKI DO KODU

Otóż, języki mają swoje "foremki," które musisz wykorzystać, żeby skompilować program. Inaczej ci się nie uda. W tej sekcji zebrałam wszystkie reguły do kupy.

Zazwyczaj, żeby skompilować kod, musisz zamknąć go w "ramce" main, czasami nazywa się to inaczej.
Zwykle musisz też pisać średniki (;) po instrukcjach. W niektórych językach nie trzeba ich używać, choć wtedy musisz pisać pojedyncze wyrażenia w osobnych linijkach i liczą się wcięcia [indentation] w zagnieżdżonym kodzie (czyli skład funkcji, instrukcji warunkowych, itd.). Jeżeli chcesz napisać wszystko w jednym wierszu, to musisz oddzielać to średnikami i nie wszędzie jest to możliwe.
W niektórych językach, żeby móc używać podstawowych funkcji, musisz importować jakąś bibliotekę [i], co powoduje niewidoczne wpisanie funkcji do twojego kodu. W innych, najważniejsze wyrażenia są wczytywane automatycznie, choć w bardziej zaawansowanych projektach i tak musisz korzystać z różnych zewnętrzynych paczek.
Niektóre zwracają także uwagę na to, jakiej wielkości są litery, czyli są [case sensitive] {cs}. Innymi słowy, widzą różnicę między komendą print a pRiNt oraz pomiędzy zmienną hello a HELLO. Co ciekawe, niektóre języki są tylko w połowie wyczulone, czyli patrzą na wielkość w nazwach zmiennych, ale w nazwach funkcji już nie {½cs}. Nie wyczulone są [case insensitive] {ci}.

C, C++ (;) [i] {cs}

#include <biblioteka> /*szuka w standardowych katalogach bibliotecznych*/
#include "lokacja/biblioteka" /*szuka w plikach kodu lub w podanej lokacji (opcjonalnie)*/
//----------------------------------------------------------------------------------------------------
int main()
{
   tutaj twój kod;
   return 0;
}

Objective-C (;) [i] {cs}

#import <biblioteka> //szuka w standardowych katalogach bibliotecznych
#import "lokacja/biblioteka" //szuka w plikach kodu lub w podanej lokacji (opcjonalnie)
//'import' różni się tym od 'include', że upewnia się, że wczytanie nie nastąpi kilka razy, co mogłoby doprowadzić do błędu
//----------------------------------------------------------------------------------------------------
int main(int argc, const char * argv[])
{
   tutaj twój kod;
   return 0;
}

C# (;) [i] {cs}

using Przestrzeń; //nie importuje przestrzeni nazw, tylko pozwala nie używać przedrostka
using Przestrzeń.Klasa;
using nazwa = Przestrzeń; //tworzy alias dla przestrzeni nazw, używasz go tak: 'nazwa::klasa', czyli z dwoma dwukropkami, a nie z kropką
using nazwa = Przestrzeń.Klasa; //tworzy alias dla przedrostka używasz go normalnie, z kropką
//----------------------------------------------------------------------------------------------------
{
   class nazwa
   {
      static void Main (string[] args)
      {
         tutaj twój kod;
      }
   }
}

CSS (;) {½cs}

@import "lokacja/nazwa";
@import url("link/nazwa");
//----------------------------------------------------------------------------------------------------
w osobnym pliku nie potrzeba ramki
__________
w HTML, umieszczasz to gdzieś między tagami <head></head>:
<style>
   tutaj twój kod;
</style>

Delphi/Object Pascal (;) {ci}

program Nazwa;
uses biblioteka; //więcej bibliotek oddzielasz przecinkami
begin
   tutaj twój kod;
end. //przy ostatnim 'end' stawiasz kropkę, ale po 'end' w funkcjach średnik

Go [i] {cs}

package nazwa
//----------------------------------------------------------------------------------------------------
import "paczka" // pojedynczy import
import "lokacja/paczka" 
import nazwa "paczka" //tworzy alias dla przedrostka
import . "paczka" //pozwala używać bez przedrostka
import _ "paczka" //kompilator nie będzie narzekał, że na razie jej nie używasz
import (
    nazwa "paczka1"
    "paczka2"
) //import wielu paczek na raz
//----------------------------------------------------------------------------------------------------
func main()
{
   tutaj twój kod
}

Groovy {cs}

import paczka.* //gwiazdka oznacza: wszystko
import paczka.klasa //importuje tylko konkretną klasę
import static paczka.klasa // pozwala nie używać przedrostka
import static paczka.*
import paczka as nazwa //tworzy alias dla przedrostka
import static paczka.klasa.metoda as nazwa //tworzy alias dla metody (nie ma przedrostka)
//następujące paczki są zaimportowane automatycznie: 'java.lang.*', 'java.util.*', 'java.io.*', 'java.net.*', 'groovy.lang.*', 'groovy.util.*', 'java.math.BigInteger', 'java.math.BigDecimal'
//----------------------------------------------------------------------------------------------------
class Nazwa
{
   static void main(String[] args)
   {
      tutaj twój kod
   }
}

HTML {ci}

<html>
   <head>
      <link href="lokacja/nazwa.css" type="text/css" rel="stylesheet">
      <script src="lokacja/nazwa.js"></script>
   </head>
   <body>
      tutaj twój kod
   </body>
</html>

Java (;) {cs}

import paczka.*; //gwiazdka oznacza: wszystko
import paczka.klasa; //importuje tylko konkretną klasę
import static paczka.klasa; // pozwala nie używać przedrostka
import static paczka.*;
import paczka as nazwa; //tworzy alias dla przedrostka
import static paczka.klasa.metoda; //tworzy alias dla metody (nie ma przedrostka)
//niech nie zmylą Cię nazwy paczek w Java - 'java.awt' i 'java.awt.color' to dwie różne rzeczy 'import java.awt.*;' nie zaimportuje 'java.awt.color'!
//----------------------------------------------------------------------------------------------------
public class nazwa
{
   public static void main (String[] args)
   {
      tutaj twój kod;
   }
}

JavaScript (;) {cs}

w osobnym pliku nie potrzeba ramki
__________
w HTML, umieszczasz to gdzieś między tagami <head></head> albo <body></body>:
<script>
   tutaj twój kod;
</script>

MATLAB {cs}

A = importdata(plik)
nie potrzeba ramki

Perl (;) {cs}

require Moduł; #szuka w katalogach zapisanych w '@INC', sprawdza czy istnieje, ładuje i kompiluje
use Moduł; #jest to to samo, co kod w komentarzu poniżej
=begin comment
BEGIN {
    require Moduł;
    Moduł -> import;
}
=cut
use Moduł (); #jest jak powyższy kod, tylko bez drugiej linijki (Moduł -> import;)
#w Module może być metoda 'import', która zazwyczaj pozwala na używanie funkcji bez przedrostka
#----------------------------------------------------------------------------------------------------
nie potrzeba ramki;

PHP (;) {½cs}

zarówno w osobnym pliku, jak i w HTML:
<?php
   include 'plik';
   tutaj twój kod;
?>
jeśli chcesz go umieścić w HTML, możesz to zrobić gdziekolwiek

Python {cs}

import moduł //zwyczajny import
import paczka.subpaczka.moduł
import moduł1, moduł2
from moduł import funkcja //pozwala używać funkcji bez przedrostka
from moduł import funkcja1, funkcja2
from moduł import * //gwiazdka oznacza: wszystko
import moduł as nazwa //tworzy alias dla przedrostka
from moduł import funkcja as nazwa //tworzy alias dla funkcji
dir(moduł) //pokazuje zawartość
//----------------------------------------------------------------------------------------------------
tutaj twój kod

R {cs}

.libPaths() #pokazuje lokacje, w których są paczki
library() #pokazuje wszystkie paczki
search() #pokazuje wykorzystane paczki
install.packages("lokacja/paczka", repos = NULL, type = "source") #instaluje paczkę do środowiska
install.packages("paczka") #instaluję paczkę ze strony CRAN
library(paczka) #importuje paczkę, a jeśli nie zostanie znaleziona, wyskoczy błąd
library("paczka", lib.loc="lokacja") #zanim możesz użyć zainstalowanej paczki, załaduj ją do środowiska
require(paczka) #importuje paczkę, a jeśi nie zostanie znaleziona, nie będzie błedu, tylko ostrzeżenie
#'require' zwraca też wartość logiczną, więc może być użyte do sprawdzenia obecności paczki i w razie czego zainstalowania jej
//----------------------------------------------------------------------------------------------------
nie potrzeba ramki

Ruby {cs}

rquire "moduł" //szuka w katalogach z modułami ($LOAD_PATH)
require_relative "lokacja/moduł" //szuka w folderze, gdzie znajduje się plik z twoim kodem
//----------------------------------------------------------------------------------------------------
nie potrzeba ramki

Scala (;) {cs}

import paczka._ //podkreślnik oznacza: wszystko
import paczka.klasa //importuje konkretną klasę
import paczka.{klasa1, klasa2} //importuje klasy: klasa1 i klasa2
import paczka.{klasa => nazwa} //tworzy alias dla przedrostka
//W Scala, możesz używać 'import' w każdym miejscu w kodzie, nie tylko na początku
//paczki 'scala' oraz 'java.lang' są importowane automatycznie
//----------------------------------------------------------------------------------------------------
object nazwa
{
   def main (args: Array[Strings])
   {
      tutaj twój kod;
   }
}

SQL (;) {ci}

nie potrzeba ramki;

PL/SQL (;) {ci}

DECLARE 
   tutaj twoje deklaracje;
BEGIN 
   tutaj twoje komendy;
EXCEPTION 
   tutaj obsługa wyjątków;
END;

Swift {cs}

import moduł //importuje i pozwala używać funkcji bez przedrostka
import moduł.submoduł
import rodzaj moduł.element //pozwala używać podany element konkretnego rodzaju (struct, class, enum, protocol, typealias, func, let albo var) bez przedrostka
//----------------------------------------------------------------------------------------------------
tutaj twój kod

Visual Basic {ci}

Imports Moduł /wbrew nazwie, nie importuje, a tylko pozwala używać funkcji bez przedrostka
Imports Moduł.Element
Imports Nazwa = Moduł //tworzy alias dla przedrostka
Imports Nazwa = Moduł.Element
//'Imports' możesz używać tylko w głównym pliku
//----------------------------------------------------------------------------------------------------
Module Nazwa
   Sub Main()
      tutaj twój kod
   End Sub
End Module

Możesz się zastanawiać, czy kod musi być ładnie uporządkowany, z różnymi elementami w osobnych linijkach. Otóż, dużą część możesz upchać w jednym wierszu, ograniczając spacje tam, gdzie się da. I o ile jest to zła praktyka❗, to jeśli masz taki fetysz, to twój wybór. Sam sprawdź, na jakie upakowanie kodu pozwala ci kompilator.

#include <iostream>
int main()
{
   std::cout << "Hello!" << "\n";
   std::cout << "How are you?" << "\n";
}

Można to zapisać jako:

#include <iostream>
int main(){std::cout<<"Hello!"<<"\n"<<"How are you?"<<"\n";}

Jest to technicznie możliwe, ale gorąco zachęcam, żeby utrzymywać kod w porządku i prostocie, ponieważ przyczynia się to do skuteczniejszego usuwania błędów i łatwiejszego rozwijania projektu❕❕❕

W "ramkach" mogłeś zauważyć takie elementy jak argc, args, argv. Uruchamiając program w terminalu, możesz używać go z różnymi argumentami. Jeżeli korzystałeś kiedyś z wiersza poleceń, to doskonale o tym wiesz. Więcej o tym i o importowaniu napiszę w dziale o funkcjach, bo wtedy wszystko będzie zrozumiałe.

WYŚWIETLANIE [OUTPUT]

Większość języków pozwala na pokazywanie jakiegoś tekstu na ekranie, dzięki czemu możliwa jest komunikacja z użytkownikiem. W przeciwnym wypadku, operacje przebiegałyby w sposób niewidoczny. Komenda, która na to pozwala, przyjmuje różne DANE, takie jak funkcje, liczby, tekst, i operacje na tych danych. Będzie o nich mowa później.

Tekst i znaki zapisuje się w cudzysłowach. Niestety, języki różnią się w tym między sobą.

W C, C++, C#, Java, Scala i Swift tekst zapisujesz tylko w podwójnym cudzysłowie, a znaki w pojedynczym.
W Objective-C tekst i znaki zapisujesz tylko w podwójnym cudzysłowie z małpą @ na początku.
W Delphi/Object Pascal, SQL i PL/SQL tekst i znaki zapisujesz tylko w pojedynczym cudzysłowie.
W Go i Visual Basic tekst i znaki zapisujesz tylko w podwójnym cudzysłowie.
W Groovy i Python tekst i znaki zapisujesz w dowolnym cudzysłowie. Pamiętaj tylko, że początkowy musi być taki sam jak końcowy!
W MATLAB, Perl, PHP i Ruby mamy ciekawą sytuację, bo tekst i znaki możesz pisać w dowolnym cudzysłowie, ale ten w pojedynczym interpretuje wszystko dosłownie. Znaczy to, że napisanie w nim \n nie przenosi do nowej linii, tylko wyświetla \n!
W R też można wpisać tekst i znaki w dowolny cudzysłów, ale tym razem każdy interpretuje wszystko dosłownie.

Wszystkie inne rzeczy, czyli liczby, zmienne, stałe, itd. pisze się bez cudzysłowu.

Liczby zapisane w cudzysłowie stają się tekstem i nie możesz wtedy przeprowadzać na nich operacji matematycznych.

C
(musisz importować bibliotekę "stdio.h") #include <stdio.h>

printf(DANE); //żeby przeniosło do nowej linii musisz dopisać \n w tekście

System.Console.Write(DANE); //nie przenosi do nowej linii
System.Console.WriteLine(DANE); //przenosi do nowej linii

C++
(musisz importować bibliotekę "iostream") #include <iostream>

std::cout << DANE; //nie przenosi do nowej linii
std::cout << DANE << "\n"; //przenosi do nowej linii, nie wymusza opróżnienia bufora
std::cout << std::endl; //przenosi do nowej linii, wymusza opróżnienie bufora
//możesz wpisać różne DANE w jednym wierszu, oddzielone tym: <<

Objective-C
(musisz importować bibliotekę "Foundation/Foundation.h") #include <Foundation/Foundation.h>

NSLog(DANE); //wypisuje czas i przenosi do nowej linii
//możesz też użyć funkcji printf() znanej z C

CSS
Ten język służy do manipulowania wyglądem stron internetowych, więc należy się temu osobny tutorial.

Delphi/Object Pascal

write(DANE); //nie przenosi do nowej linii
writeln(DANE); //przenosi do nowej linii

Go
(musisz importować paczkę "fmt") import "fmt"

fmt.Print(DANE) //nie przenosi do nowej linii
fmt.Println(DANE) //przenosi do nowej linii

Groovy

print(DANE) //nie przenosi do nowej linii
println(DANE) //przenosi do nowej linii

HTML
Cały język jest sztuką wyświetlania rzeczy na ekranie, więc należy się temu osobny tutorial.

Java

System.out.print(DANE); //nie przenosi do nowej linii
System.out.println(DANE); //przenosi do nowej linii

JavaScript

console.log(DANE); //wyświetla linijkę DANYCH w konsoli
window.alert(DANE); //wyświetla okienko z DANYMI
document.write(DANE); //wpisuje DANE do określonego pliku
document.getElementById("nazwa").innerHTML = DANE; //wpisuje DANE do elementu w HTML
//możesz wpisać różne DANE w jednym wierszu, oddzielone przecinkami

MATLAB
Ten język służy do wykonywania obliczeń i tworzenia symulacji, więc należy się temu osobny tutorial.

disp(DANE) //przenosi do nowej linii

Perl

print DANE; lub print(DANE); //nie przenosi do nowej linii
//żeby przeniosło do nowej linii musisz dopisać \n w tekście
//możesz wpisać różne DANE w jednym wierszu, oddzielone przecinkami

PHP

print DANE; lub print(DANE); //nie przenosi do nowej linii
echo DANE; lub echo(DANE); //nie przenosi do nowej linii
//echo bez nawiasów może wypisać wiele DANYCH w jednym wierszu, oddzielone przecinkami

Python

print(DANE) //przenosi do nowej linii
print(DANE, end = '') //nie przenosi do nowej linii
//możesz wpisać różne DANE w jednym wierszu, oddzielone przecinkami

Ten język służy do obliczeń statystycznych i wizualizacji wyników, więc należy się temu osobny tutorial.

print(DANE) //przenosi do nowej linii
cat(DANE) //nie przenosi do nowej linii

Ruby

print DANE #nie przenosi do nowej linii
puts [DANE] #przenosi do nowej linii po każdym elemencie
p DANE #interpretuje wszystkie znaki dosłownie i przenosi do nowej linii
#możesz wpisać różne DANE w jednym wierszu, oddzielone przecinkami

Scala

print(DANE) //nie przenosi do nowej linii
println(DANE) //przenosi do nowej linii

Swift

print(DANE) //nie przenosi do nowej linii
//możesz wpisać różne DANE w jednym wierszu, oddzielone przecinkami

SQL
Ten język służy do zarządzania bazami danych, więc należy się temu osobny tutorial.

PRINT DANE; //w SQL Server możesz dzięki temu wyświetlić wiadomość do klienta

PL/SQL

dbms_output.put_line(DANE);

Visual Basic

System.Console.Write(DANE); //nie przenosi do nowej linii
System.Console.WriteLine(DANE); //przenosi do nowej linii

Osobno chciałabym jeszcze powiedzieć o metodzie printf, czyli print formated. Jest to znana z języka C funkcja, która jest także obecna w wielu innych.
Na początku może się ona wydawać straszna, bo istnieje wiele wersji: printf, fprintf, sprintf, snprintf oraz odpowiedniki z 'v' na początku: vprintf, vfprintf, vsprintf, vsnprintf.
Ale prawda jest taka, że wszystkie robią dokładnie to samo: formatują tekst. Różnica polega na tym gdzie zostaną wyświetlone/zapisane.
Zwyczajne printfwypisuje tekst do standardowego wyjścia [standard output (stdout)], czyli w większości przypadków na ekran. To z f na początku do pliku [file], a te z s i sn do ciągu znaków [string buffer]. Odpowiedniki tych czterech funkcji z v na początku różnią się tym, że zamiast argumentów przyjmują jeden argument typu va_list.

Po co o tym mówię? Ponieważ możesz się zastanawiać czy jest to potrzebne albo może lepsze.

Odpowiedź: jeżeli w języku, który chcesz poznać trzeba tego używać, to naucz się. W przeciwnym wypadku, istnieją alternatywne metody na formatowanie danych i zapisywanie do różnych miejsc. printf ma swoje zalety, takie jak zwięzłość zapisu, i swoje wady, na przykład podatność na błędy, bo musisz zawsze określać typy swoich argumentów. W każdym razie, umiejętność wykorzystania printf oswoi Cię z podobnymi strukturami w innych językach.

Jak interesują Cię szczegóły, poczytaj sobie dyskusję na ten temat: https://stackoverflow.com/questions/2872543/printf-vs-cout-in-c.

Zapisywanie do pliku i ciągu znaków oraz różnice między typami danych to temat na odzielny artykuł.

Pokażę tylko jak używa się printf.

printf("To jest liczba pi z kilkoma cyframi po przecinku: %f.", pi);

I już. Argument wprowadza się poprzez wpisanie go po przecinku. Zastępuje on odpowiadający mu w kolejności procent z literką obok (w tym przypadku %f). Co to jest ta literka? Każdy argument musi mieć odpowiadający typ. f oznacza liczbę z przecinkiem, a tym właśnie jest zmienna pi wpisana jako argument. Proste, prawda?

Inny przykład:

printf("Mam %s oraz %s.", jab, ban);

Wyświetli się Mam jabłko oraz banan.. s to typ odpowiadający tekstowi.

C, Groovy, Perl

printf("TEKST", argumenty);

C++
(musisz importować bibliotekę "iostream") #include <iostream>

std::printf("TEKST", argumenty); //możesz też wykorzystać 'printf' z C

Objective-C
(musisz importować bibliotekę "Foundation/Foundation.h") #include <Foundation/Foundation.h>

NSLog("TEKST", argumenty); //możesz też wykorzystać 'printf' z C

fmt.Printf("TEKST", argumenty)

Java

System.out.printf("TEKST", argumenty);

MATLAB

fprintf("TEKST", argumenty)

Python

print("TEKST".format(argumenty)) #w tekście wpisujesz nawiasy klamrowe z numeracją od zera {0} wzwyż
#argumenty zostaną przypisane w miejsce odpowiedającej im w kolejności klamry

W każdym z tych języków printf używa się podobnie, więc nie trudno się tego nauczyć. Trzeba tylko sprawdzić jakie znaki [specifier characters] określają konkretne typy. Po prostu poszukaj w google. Tutaj jest C http://www.cplusplus.com/reference/cstdio/printf/, tutaj Java http://www.java2s.com/Tutorials/Java/Data_Format/Java_Format_Specifier.htm. Są podobne.

BŁĘDY [ERRORS]

Błąd w kodowaniu - to nieporozumienie, niezrozumienie lub pomyłka odzwierciedlone w kodzie, powodujące nieoczekiwane działanie programu.

Błąd składni [Syntax error]

Każdy język ma swoje zasady dotyczące formatowania kodu, których nie można łamać. Musisz postawić średnik na końcu; tekst musi być w "cudzysłowie" albo Wielkość Liter Ma Znaczenie.
Błąd składni w kodowaniu dotyczy nie respektowania wymaganych form zapisu.
Brak przecinka między dwoma zmiennymi.
Bezsensowne lub niepełne użycie jakiś symboli, na przykład 2 + * 4 = a albo postawienie plusa + lub jakiegoś nieużywanego znaku w losowym miejscu bez kontekstu.
Nieodpowiednia wielkość liter: Include zamiast include.
Błąd ten występuje zatem wtedy, gdy w kodzie nie ma czegoś, co musi tam być oraz gdy coś jest w nieodpowiedniej formie lub miejscu.
dobrze: print("Hello!");
źle: print("Hello!"):
źle: print("Hello!);
dobrze: a = 2 + 2 * 4;
źle: a = 2 + * 4;
dobrze: print(variable); //taka zmienna została stworzona
źle: print(variabl); //taka zmienna nie została stworzona
O ile człowiek zrozumie tekst, w którym są źle postawione przecinki, to komputer nie zaakceptuje ani jednego przypadku błędu i nie będzie się domyślał.
Jest to jeden z najgorszych i najczęstszych błędów, bo wszystko może być sensownie napisane, ale gdzieś zgubiłeś głupią literkę ℒ !

Błąd semantyczny [Semantic error]

Nawet jeśli napiszesz wszystkie wyrażenia z nienaganną interpunkcją, odpowiednimi literami i w pełni, to i tak możesz użyć wyrażeń języka w taki sposób, że nie będzie się dało tego zrealizować.
To tak jakbyś próbował włożyć kwadratowy klocek do okrągłego wejścia podobnej wielkości.
Albo jakby ktoś kazał Ci podłączyć rurę od odkurzacza do miksera i posprzątać pokój.
Błąd ten więc popełniasz, kiedy próbujesz wykonać instrukcje, które są niewykonalne.
źle: int a; int b; b = a + 1;
/*Zmienna 'a' nie ma przypisanej wartości, więc nie można do niej nic dodać. Jak chcesz dodać 1 do !@#?*/
źle: int c = "hello";

/*Typ 'integer' jest przeznaczony dla liczb całkowitych, więc nie można mu przypisać tekstu. Próbujesz włożyć gwiazdkę do wejścia na kółko.*/

To już jest poważniejszy błąd, bo wynika z nieodpowiedniego operowania wyrażeniami. Czasami jest to wina niedopatrzenia, bo na przykład zapomniałeś włożyć przedmiotu do koszyka 🧺, a czasami wynik niezrozumienia, bo chcesz użyć miotły 🧹, żeby ugotować makaron 🍜.

Niektórzy łączą błędy składni i błędy semantyczne w jedno i nazywają to po prostu błędami składni [syntax errors]. Mi jest to obojętne. Oba w końcu dotyczą niepoprawnego wykorzystania składni języka. Przyznam, że sama czasami nie jestem pewna do której kategorii przyporządkować, więc takie uproszczenie byłoby w porządku.
Najważniejsze, żeby rozumieć o co w nich chodzi i skutecznie z nimi walczyć.

Błąd logiczny [Logical error]

Ten rodzaj jest chyba najgorszy, ponieważ z takim błędem możesz skompilować i uruchomić program, w przeciwieństwie do dwóch poprzednich (są wyjątki, ale nie wchodźmy w szczegóły).
Masz z nim do czynienia, kiedy instrukcja nie wykonuje kodu, który chciałeś, ponieważ sformułowałeś ją nieodpowiednio, czyli źle zrozumiałeś logikę stojącą za tym.
Najbardziej obrazowy przykład: chciałeś zrobić program, który sprawdza, czy wpisana wartość jest liczbą pierwszą, a po wpisaniu 9 wyświetla ci się:
9 jest liczbą pierwszą. 😦
Zwykle wygląda to tak, że kod jest skomplikowany i trudno wyłapać który to fragment powoduje niespodziewane zachowanie.
Metaforycznie wygląda to mniej więcej tak:
67e2f80e2a6f2aaf5fb5c6cf1db16703
"Którą literkę tu zmienić, żeby zaczęło mi pokazywać liczby pierwsze? 😨"
Co ciekawe, przydaje się wtedy obycie z matematyką. Jeżeli więc pytałeś się kiedyś z pogardą: "Po co mi w to ogóle w życiu?!" to...

Nie błąd, ale...

Na koniec chciałabym omówić coś, co może nie jest błędem, ale nie powinno się tego robić. Są to niezalecane czynności. Uczysz się ich unikać z czasem, kiedy stajesz się coraz lepszym koderem. Nie są to wielkie sprawy, ale zbierane razem tworzą coś, co polepsza jakość programów i świadczy o jakości tworzącego.
Są to najtrudniejsze do uniknięcia rzeczy, ponieważ nie są oczywiste. Nie sprawiają, że nie możesz skompilować kodu. Nie powodują, że program wywala do pulpitu. Nie zmieniają wymaganego działania programu. Nikt o nich nie trąbi. I czasami wynikają one z indywidualnych uwarunkowań, więc nikt oprócz Ciebie nie może o nich nawet wiedzieć.
A jednak, gdy unikasz tych złych praktyk, to twoje programy stają się bardziej czytelne, działają szybciej, zajmują mniej miejsca, są bardziej kompatybilne z różnymi wersjami języka, łatwiej się z nich korzysta.
Jak się tego nauczyć? Otóż musisz ćwiczyć, czytać książki na ten temat, uczyć się od lepszych kolegów po fachu, samemu rozmyślać na ten temat.
Małe wskazówki już padły w tym artykule: a) używaj dobrych narzędzi, b) pisz prosty, uporządkowany i zrozumiały kod, c) twórz odpowiednie komentarze porządkujące (a do większych programów dokumentację).
Jest to coś, czego nie przeskoczysz tabelkami scalającymi informacje o kodowaniu. Tutaj liczy się

DOŚWIADCZENIE.

Część tej wiedzy znajdzie się oczywiście w następnych artykułach.

Na tym chciałabym zakończyć. Są to absolutne podstawy, które można by uczyć dzieci w podstawówce. Bardziej złożone zagadnienia omówię wkrótce.

To taka rozgrzewka.

polish
pl-artykuly
pl-programowanie
pl-komputery

IT
5 years ago
63
$3.22

Moje notatki na temat prostych zagadnień w kodowaniu (cz. 1)

ZINTEGROWANE ŚRODOWISKO PROGRAMISTYCZNE [IDE] I KOMPILATOR [COMPILER]

notepad.exe otworzone w notepadzie... 😃

powłoka Bash

powłoka C (csh)

KOMENTARZE [COMMENTS]

FOREMKI DO KODU

WYŚWIETLANIE [OUTPUT]

BŁĘDY [ERRORS]

Błąd składni [Syntax error]

Błąd semantyczny [Semantic error]

Błąd logiczny [Logical error]

Nie błąd, ale...

DOŚWIADCZENIE.

Comments

Most popular

Chrzan [#QAL]

Daily Chrzan #44

Chrzan [#32M]

Daily Chrzan #47 & #48

Chrzan #51

35% = 110%

Daily Chrzan #46

Daily Chrzan #50

Daily Chrzan #43

Daily Chrzan #45

Moje notatki na temat prostych zagadnień w kodowaniu (cz. 1)

ZINTEGROWANE ŚRODOWISKO PROGRAMISTYCZNE [IDE] I KOMPILATOR [COMPILER]

notepad.exe otworzone w notepadzie... 😃

powłoka Bash

powłoka C (csh)

KOMENTARZE [COMMENTS]

FOREMKI DO KODU

WYŚWIETLANIE [OUTPUT]

BŁĘDY [ERRORS]

Błąd składni [Syntax error]

Błąd semantyczny [Semantic error]

Błąd logiczny [Logical error]

Nie błąd, ale...

DOŚWIADCZENIE.

Leave reply

Comments

Most popular