Haxe 4.0 എന്ന പ്രോഗ്രാമിംഗ് ഭാഷയുടെ പ്രകാശനം

ലഭ്യമാണ് ടൂൾകിറ്റ് റിലീസ് ഹാക്സ് 4.0, ശക്തമായ ടൈപ്പിംഗ്, ഒരു ക്രോസ്-കംപൈലർ, ഫംഗ്‌ഷനുകളുടെ ഒരു സ്റ്റാൻഡേർഡ് ലൈബ്രറി എന്നിവയ്‌ക്കൊപ്പം അതേ പേരിലുള്ള മൾട്ടി-പാരഡൈം ഹൈ-ലെവൽ പ്രോഗ്രാമിംഗ് ഭാഷ ഉൾപ്പെടുന്നു. പ്രോജക്റ്റ് C++, HashLink/C, JavaScript, C#, Java, PHP, Python, Lua എന്നിവയിലേക്കുള്ള വിവർത്തനത്തെയും അതുപോലെ JVM, HashLink/JIT, Flash, Neko bytecode എന്നിവയിലേക്കുള്ള സമാഹാരത്തെയും പിന്തുണയ്ക്കുന്നു. കംപൈലർ കോഡ് വിതരണം ചെയ്തത് GPLv2 ലൈസൻസിന് കീഴിൽ, ഒരു സാധാരണ ലൈബ്രറിയും ഹാക്സിനായി വികസിപ്പിച്ച ഒരു വെർച്വൽ മെഷീനും നെക്കോ MIT ലൈസൻസിന് കീഴിൽ.

ഭാഷയാണ് എക്സ്പ്രഷൻ-ഓറിയന്റഡ് ശക്തമായ ടൈപ്പിംഗ് ഉപയോഗിച്ച്. ഒബ്ജക്റ്റ് ഓറിയന്റഡ്, ജനറിക്, ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ആശയങ്ങൾ പിന്തുണയ്ക്കുന്നു.
Haxe വാക്യഘടന ECMAScript-ന് അടുത്താണ് വികസിക്കുന്നു സ്റ്റാറ്റിക് ടൈപ്പിംഗ്, ഓട്ടോടൈപ്പ് അനുമാനം, പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ, ജനറിക്‌സ്, ഇറ്ററേറ്റർ അടിസ്ഥാനമാക്കിയുള്ള ലൂപ്പുകൾ, AST മാക്രോകൾ, GADT (ജനറലൈസ്ഡ് ആൾജിബ്രാക് ഡാറ്റ തരങ്ങൾ), അമൂർത്ത തരങ്ങൾ, അജ്ഞാത ഘടനകൾ, ലളിതമായ അറേ നിർവചനങ്ങൾ, സോപാധികമായ കംപൈലേഷൻ എക്‌സ്‌പ്രഷനുകൾ, മെറ്റാഡാറ്റ അറ്റാച്ച് ചെയ്യുന്ന ഫീൽഡ് എന്നിവ പോലുള്ള അതിന്റെ സവിശേഷതകൾ , ക്ലാസുകളും എക്സ്പ്രഷനുകളും, സ്ട്രിംഗ് ഇന്റർപോളേഷൻ ('എന്റെ പേര് $നാമം'), തരം പാരാമീറ്ററുകൾ ("പുതിയ Main‹String›('foo')"), കൂടാതെ വളരെ കൂടുതൽ.

ക്ലാസ് ടെസ്റ്റ് {
സ്റ്റാറ്റിക് ഫംഗ്‌ഷൻ മെയിൻ() {
var ആളുകൾ = [
"എലിസബത്ത്" => "പ്രോഗ്രാമിംഗ്",
"ജോയൽ" => "ഡിസൈൻ"
];

എന്നതിനായി (പേരിൽ പേര്. കീകൾ()) {
var ജോലി = ആളുകൾ[പേര്];
ട്രേസ് ('$പേര് ഉപജീവനത്തിനായി $ജോലി ചെയ്യുന്നു!');
}
}
}

പ്രധാന പുതുമകൾ പതിപ്പ് 4.0:

• "Sring->Int->Bool" എന്നതിന് പകരം "(name:String, age:Int)->Bool" അല്ലെങ്കിൽ "(String, Int)->Bool" എന്ന ഫംഗ്‌ഷൻ തരം വ്യക്തമാക്കുന്നതിനുള്ള പുതിയ വാക്യഘടന.
• ആരോ ഫംഗ്‌ഷൻ വാക്യഘടന "(a, b) -> a + b" എന്നതിന് പകരം "function(a, b) return a + b" ആണ്.
• നൾ മൂല്യങ്ങളുടെ ഉപയോഗവുമായി ബന്ധപ്പെട്ട പ്രശ്നങ്ങളിൽ നിന്നുള്ള സംരക്ഷണം (പരീക്ഷണാത്മക സവിശേഷത, ചില ഫീൽഡുകൾ, ക്ലാസുകൾ അല്ലെങ്കിൽ പാക്കേജുകൾക്കായി ഓപ്ഷണലായി പ്രവർത്തനക്ഷമമാക്കി).
• മാറ്റമില്ലാത്ത ക്ലാസ് ഫീൽഡുകൾക്കും ലോക്കൽ വേരിയബിളുകൾക്കുമുള്ളതാണ് "ഫൈനൽ" കീവേഡ്. "ഫൈനൽ" ഫംഗ്‌ഷനുകൾ അനന്തരാവകാശത്താൽ അസാധുവാക്കുന്നത് തടയുന്നതിനും പാരമ്പര്യമായി ലഭിക്കാത്ത ക്ലാസുകൾ/ഇന്റർഫേസുകൾക്കുമായി നിർവചിക്കുന്നതിനും ഉപയോഗിക്കാം.
• പിന്തുണ Neko ഒഴികെയുള്ള എല്ലാ കംപൈലേഷൻ ടാർഗെറ്റുകളിലും അടിസ്ഥാന തരം "സ്ട്രിംഗ്" എന്നതിനായുള്ള യൂണികോഡ് സ്റ്റാൻഡേർഡ്.
• ബിൽറ്റ്-ഇൻ ഇന്റർപ്രെറ്റർ ആദ്യം മുതൽ മാറ്റിയെഴുതി, അത് ഇപ്പോൾ പേരിൽ വരുന്നു ഏവൽ. പുതിയ വ്യാഖ്യാതാവിന് നന്ദി, സ്ക്രിപ്റ്റുകളും മാക്രോകളും വളരെ വേഗത്തിൽ പ്രവർത്തിക്കുന്നു. ഇന്ററാക്ടീവ് ഡീബഗ്ഗിംഗ് മോഡ് പിന്തുണയ്ക്കുന്നു.
• സമാഹരിക്കാനുള്ള പുതിയ ടാർഗെറ്റ് സിസ്റ്റം (ലക്ഷ്യം) ഹാഷ്ലിങ്ക് - Haxe-യ്‌ക്കായി പ്രത്യേകം രൂപകൽപ്പന ചെയ്‌ത ഉയർന്ന പ്രകടനമുള്ള റൺടൈം, JIT അല്ലെങ്കിൽ C-യ്‌ക്കായുള്ള ബൈറ്റ്‌കോഡിലേക്കുള്ള സമാഹാരത്തെ പിന്തുണയ്‌ക്കുന്നു, C-യുമായി എളുപ്പത്തിൽ സംയോജിപ്പിക്കുന്നു, അതുപോലെ തന്നെ ലോ-ലെവൽ ന്യൂമറിക് തരങ്ങളിലേക്കും പോയിന്ററുകളിലേക്കും ആക്‌സസ് ഉണ്ട്.
• പുതിയ JVM ടാർഗെറ്റ് - ജാവയിൽ ടാർഗെറ്റ് ചെയ്യുമ്പോൾ "-D jvm" ഫ്ലാഗ് ചേർത്ത് Java കോഡ് കംപൈലേഷൻ ഘട്ടം ഒഴിവാക്കി jvm ബൈറ്റ്കോഡ് സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
• ഫംഗ്‌ഷനുകളോ കൺസ്‌ട്രക്‌റ്ററുകളോ ആയി പ്രഖ്യാപിച്ചിട്ടില്ലെങ്കിലും, വിളിക്കുന്ന ഘട്ടത്തിൽ ഇൻലൈൻ-വിന്യസിക്കാനുള്ള കഴിവ്.
• ഉൾപ്പെടുത്താനുള്ള സാധ്യത സ്റ്റാറ്റിക് എക്സ്റ്റൻഷനുകൾ "@:using(path.ToExtension)" ഉപയോഗിച്ച് ഒരു തരം ("enum" പോലുള്ളവ) പ്രഖ്യാപിക്കുമ്പോൾ.
• "obj.foo = bar" എക്‌സ്‌പ്രഷനുകൾ റീലോഡ് ചെയ്യുന്നതിന് അബ്‌സ്‌ട്രാക്റ്റ് തരങ്ങൾ ഇപ്പോൾ "@:op(a.b)" ഓപ്പറേറ്ററിന്റെ "സെറ്റ്" പതിപ്പിനെ പിന്തുണയ്ക്കുന്നു.
• "for" ലൂപ്പ് വാക്യഘടന ഇപ്പോൾ കീ-മൂല്യം ആവർത്തനത്തെ പിന്തുണയ്ക്കുന്നു: "for (key => മൂല്യം ശേഖരത്തിൽ) {}".
• എക്സ്പ്രഷനുകളിൽ xml പോലുള്ള മാർക്ക്അപ്പ് ഉപയോഗിക്കുന്നതിനുള്ള പിന്തുണ: "var a = ‹hi/›;". ഇപ്പോൾ, ഈ ഫീച്ചർ മാക്രോകൾ ഉപയോഗിച്ച് പാഴ്‌സിംഗ് ചെയ്യാൻ മാത്രമേ ലഭ്യമാകൂ, ഡിസൈൻ ഘട്ടത്തിലാണ്.
• അജ്ഞാത ഘടനാ തരങ്ങളുടെ "പൂർണ്ണ" നൊട്ടേഷനിലെ ഓപ്ഷണൽ ഫീൽഡുകൾക്കുള്ള വാക്യഘടന ഇതാണ്: "{ var ?f: Int; }" ("{ ?f:Int }" എന്ന ഹ്രസ്വ വാക്കിന് പകരമായി).
• Enum മൂല്യങ്ങൾ ഇപ്പോൾ ഫംഗ്‌ഷൻ ആർഗ്യുമെന്റുകൾക്കുള്ള ഡിഫോൾട്ട് മൂല്യങ്ങളാകാം: "function foo‹T›(option:Option‹T› = ഒന്നുമില്ല)".
• "enum abstract Name(BasicType) {}" വാക്യഘടനയ്ക്ക് ഇനി "enum" എന്നതിലെ "@:" പ്രിഫിക്‌സ് ആവശ്യമില്ല.
• അമൂർത്തമായ സംഖ്യകൾക്കായി സ്വയമേവ നമ്പറിംഗ്:

  enum abstract Foo(Int) {
  var A; // 0
  var B; // 1
  }
  enum abstract Bar(String) {
  var A; // "എ"
  var B; // "ബി"
  }

• "extern" കീവേഡിന് ഇനി "@:" പ്രിഫിക്‌സിന്റെ ഉപയോഗം ആവശ്യമില്ല.
• ഓപ്ഷൻ നീക്കം ചെയ്തു "നടപ്പിലാക്കുന്നു സ്ട്രിംഗുകൾ വഴി ക്ലാസ് ഫീൽഡുകൾ ആക്സസ് ചെയ്യാൻ ഡൈനാമിക്". എക്‌സ്‌റ്റേൺ ക്ലാസുകൾക്കോ ​​അല്ലെങ്കിൽ ഒരു അമൂർത്ത തരം നടപ്പിലാക്കുന്നതിലൂടെയോ ലഭ്യമാണ്.
• ടൈപ്പ് ഇന്റർസെക്ഷനായി "A & B" വാക്യഘടന ചേർത്തു, ഇത് നിലവിൽ അജ്ഞാത ഘടനകൾക്കും ടൈപ്പ് പാരാമീറ്റർ പരിമിതികൾക്കും മാത്രം ബാധകമാണ്. പഴയ നിയന്ത്രണ വാക്യഘടന നീക്കം ചെയ്തു.
• ശൂന്യമായ "മാപ്പ്" സംഭവങ്ങൾ സൃഷ്ടിക്കുന്നത് "var map:Map‹Int, String› = [];" എന്ന വാക്യഘടന വഴി ലഭ്യമാണ്. ഒരു അറേയ്ക്ക് സമാനമാണ്.
• "haxe.ds.ReadOnlyArray" എന്ന ഡാറ്റ ഘടന ചേർത്തു.
• മെറ്റാഡാറ്റയ്ക്ക് ഇപ്പോൾ നെയിംസ്‌പെയ്‌സുകൾ ഉണ്ടായിരിക്കാം (“@:prefix.name ഫംഗ്‌ഷൻ() {…}”). അതുപോലെ നിർവചനങ്ങൾക്കൊപ്പം: "#if (some.flag ... #end".
• ഉപയോഗിക്കുന്ന IDE-കൾക്കായുള്ള പുതിയ സേവന പ്രോട്ടോക്കോൾ VSCode-നുള്ള പ്ലഗിൻ.
• വെബ് API-കൾക്കായി അപ്‌ഡേറ്റ് ചെയ്‌ത ബാഹ്യ നിർവചനങ്ങൾ (എക്‌സ്റ്റേൺ) കൂടാതെ നഷ്‌ടമായവ ചേർത്തു.

അവലംബം: opennet.ru