Programovacie jazyky a ich vývoj

Štandardy

Prebraté z www.tutorialspoint.com a en.wikipedia.org

1. ANSI C, C89/C90: ANSI C zaviedol niekoľko nových funkcií a objasnil nejednoznačnosti prítomné v skorších verziách jazyka. Štandard ANSI C bol prijatý medzinárodne a stal sa známym ako C89 (alebo C90, v závislosti od roku ratifikácie). Dlhé roky slúžil ako základ pre kompilátory a vývojové nástroje.
2. C99: V roku 1999 ISO/IEC schválila aktualizovanú verziu normy C známu ako C99. C99 zaviedol nové funkcie, vrátane inline funkcií, niekoľko nových dátových typov, ako je typ reprezentujúci komplexné čísla, polia s premenlivou dĺžkou atď. Pridal tiež podporu pre jednoriadkové komentáre v štýle C++ začínajúce na // .
3. C11: Štandard C11, publikovaný v roku 2011, je ďalšou veľkou revíziou normy C. Pridáva novú funkcionalitu, ako podpora viacerých vlákien, anonymné štruktúry a uniony a vylepšená podpora Unicode. Má vylepšenú kompatibilitu s C++.
4. C17: Štandard C17 bol zverejnený v júni 2018. S touto štandardnou revíziou neboli zavedené žiadne nové funkcie. Vykonáva iba určité technické opravy a objasnenia chýb v C11.
5. C18: Zverejnený v roku 2018. Zahŕňa menšie revízie a opravy chýb v porovnaní s C11.
6. C23: Začal sa tvoriť v roku 2016, neformálne ako C2x, a bol publikovaný 31. októbra 2024. Jednou zo zaujímavostí je pridanie typu char8_t na ukladanie údajov kódovaných UTF-8.

Štandardy

Prebraté z webreference.com

1. ECMAScript 1 (ES1) (1997)
2. ECMAScript 2 (ES2) (1998)
3. ECMAScript 3 (ES3) (1999)
4. ECMAScript 4 (nikdy nevydaný)
5. ECMAScript 5 (ES5) (2009)
6. ECMAScript 5.1 (ES5.1) (2011)
7. ECMAScript 6 (ES6) (2015)
8. ECMAScript 2016 (ES7)
9. ECMAScript 2017 (ES8)
10. ECMAScript 2018 (ES9)
11. ECMAScript 2019 (ES10)
12. ECMAScript 2020 (ES11)
13. ECMAScript 2021 (ES12)
14. ECMAScript 2022 (ES13)
15. ECMAScript 2023 (ES14)

ECMAScript 1 (ES1)

Bol založený na jazyku JavaScript a zahŕňal funkcie, ako sú premenné, funkcie a základné príkazy toku riadenia.

ECMAScript 2 (ES2)

Urobil menšie zmeny v jazyku a zameral sa hlavne na to, aby bol štandard konzistentnejší.

ECMAScript 3 (ES3)

Zaviedol niekoľko dôležitých funkcií, ako sú regulárne výrazy, príkazy try-catch a vylepšené spracovanie reťazcov.

                    
// Príklad použitia regulárneho výrazu v ES3
var text = "Hello, World!";
var regex = /Hello/;
console.log(regex.test(text)); // Vystup: true
                    
                    

                    
// Príklad použitia bloku try/catch v ES3
try {
    var x = y + 1;
} catch (error) {
    console.log(error); // Vystup: ReferenceError: y is not defined
}
                    
                    

ECMAScript 4

ECMAScript 4 bol plánovaný ako štvrtá verzia štandardu ECMAScript, ale nebol nikdy vydaný. Jeho zámerom bolo zaviesť významné zmeny do jazyka, vrátane tried, rozhraní a menných priestorov. Návrh však narazil na značný odpor a od vývoja sa nakoniec upustilo.

ECMAScript 5 (ES5)

Zaviedol niekoľko dôležitých vlastností, ako je striktný režim, podpora JSON a vylepšená manipulácia s poľami.

ECMAScript 5.1 (ES5.1)

ECMAScript 5.1 bol menšou aktualizáciou ECMAScript 5. Väčšinou sa zameriaval na to, aby bol štandard konzistentnejší a opravoval chyby.

ECMAScript 6 (ES6)

Zaviedol niekoľko dôležitých vlastností, ako sú let a const, „arrow functions“, „template literals“ (šablónové literály) a triedy.

                    
// Príklad použitia let a const v ES6
let name = "John Doe";
const age = 30;
                    
                    

                    
// Príklad na arrow function v ES6
let add = (a, b) => a + b;
console.log(add(1, 2)); // Vystup: 3
                    
                    

                    
// Príklad použitia šablónového literálu v ES6
let message = `Hello, ${name}!`;
console.log(message); // Vystup: "Hello, John Doe!"
                    
                    

                    
// Príklad triedy v ES6
class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }

    greet() {
        return `Hello, ${this.name}!`;
    }
}
let john = new Person("John Doe", 30);
console.log(john.greet()); // Vystup: "Hello, John Doe!"
                    
                    

ECMAScript 2016 (ES7)

Zaviedol dve hlavné funkcie: operátor umocňovania a Array.prototype.includes().

                    
// Príklad použitia umocňovacieho operátora v ES7
let square = 2**2;
console.log(square); // Output: 4
                    
                    

                    
// Príklad použitia Array.prototype.includes v ES7
let numbers = [1, 2, 3, 4, 5];
console.log(numbers.includes(3)); // Vystup: true
                    
                    

ECMAScript 2017 (ES8)

Zaviedol niekoľko nových funkcií vrátane async/await Object.values(), Object.entries(), a string padding.

                    
// Príklad použitia async/await v ES8
async function fetchData() {
    let response = await fetch('https://api.example.com/data');
    let data = await response.json();
    return data;
}
                    
                    

ECMAScript 2018 (ES9)

Táto verzia priniesla významné aktualizácie, ako sú asynchrónne iterácie, Promise.prototype.finally() a operátory rest/spread.

                    
// Príklad použitia Promise.prototype.finally() v ES9
fetch('https://api.example.com/data')
    .then(data => console.log(data))
    .catch(error => console.log(error))
    .finally(() => console.log('Finished!'));
                    
                    

                    
// Príklad použitia operátorov rest/spread v ES9
let person = { name: "John Doe", age: 30, country: "USA" };
let {name, ...rest} = person;
console.log(name); // Vystup: "John Doe"
console.log(rest); // Vystup: { age: 30, country: "USA" }
                    
                    

ECMAScript 2019 (ES10)

Zviedol funkcie ako Array.prototype.flat(), Array.prototype.flatMap(), a Object.fromEntries().

ECMAScript 2020 (ES11)

Táto verzia prišila s vlastnosťami, ako sú BigInt pre väčšie celé čísla, Promise.allSettled(), „Nullish Coalescing Operator“ (??) a voliteľné reťazenie (?.).

                    
// Príklad použitia "nullish coalescing" v ES11
let value = null;
console.log(value ?? "default"); // Vystup: "default"
                    
                    

ECMAScript 2021 (ES12)

Zaviedol ďalšie logické operátory priraďovania, číselné oddeľovače, Promise.any() a String.prototype.replaceAll().

                    
// Príklad použitia číselných oddeľovačov v ES12
let billion = 1_000_000_000; // Ekvivalent: let billion = 1000000000;
console.log(billion); // Vystup: 1000000000
                    
                    

ECMAScript 2022 (ES13)

Zaviedol niekoľko významných nových vlastností, napríklad:

• Schopnosť používať najvyššiu úroveň await, vďaka čomu je možné použiť kľúčové slovo mimo asynchrónnej funkcie.
• Nové prvky triedy: súkromné a verejné atribúty a metódy inštancií, súkromné a verejné statické atribúty a metódy.
• Syntax #x in obj, ktorá vám umožňuje testovať prítomnosť súkromných polí na objektoch.
• Metóda at pre reťazce a polia, ktorá umožňuje relatívne indexovanie.

Nové vlastnosti sú podrobnejšie prebraté tu.

ECMAScript 2023 (ES14)

V tejto verzii pribudlo niekoľko nových metód na Array.prototype a TypedArray.prototype, vrátane toSorted, toReversed, with, findLast a findLastIndex. Okrem toho do Array.prototype bola pridaná metóda toSpliced.

Táto verzia začala podporovať #! komentáre na začiatku súborov, čím sa pripravila pôda pre priamo spustiteľné súbory ECMAScript.