Diskuze: Var vs. ostatní typy

C# .NET .NET (C# a Visual Basic) Var vs. ostatní typy American English version English version

Avatar
Michael Olšavský:

Vím, že c# je silně typový jazyk, ale v poslední době na hodně zahraničních fórech nalézám typ var u většiny promněných. DOšlo mi, že je to stejná promněná jako v javascriptu - bez typu. Co je lepší používat? Zůstat u normálních typů nebo u tohohle globálního?

 
Odpovědět 2.2.2013 13:50
Avatar
matesax
Redaktor
Avatar
Odpovídá na Michael Olšavský
matesax:

Silně typovaný = vždy uváděj typy. Var nemá smysl - ani u páce s databázemi - vždy se dá uvést typ...

 
Nahoru Odpovědět 2.2.2013 13:55
Avatar
Petr Nymsa
Redaktor
Avatar
Odpovídá na Michael Olšavský
Petr Nymsa:

Já vidím používání var hlavně ve WIndows 8 aplikacích a to přímo u programů od Microsoftu. Pochopil jsem, že pokud nevíš přesně co potřebuješ za typ, nevíš co přesně metoda vrací (víš že soubor , ale nevíš do čeho to uložit) , tak použiješ var. Ale stále mi přijde hezčí, přehlednější používat a rozlišovat typy :)

Nahoru Odpovědět 2.2.2013 13:56
Pokrok nezastavíš, neusni a jdi s ním vpřed
Avatar
matesax
Redaktor
Avatar
Odpovídá na Petr Nymsa
matesax:

Kdepak - to víš vždy před kompilací - s vhodným IDE stačí jen najet nad problémové místo a je...

Ještě:

var v JS je skoro zbytečný - jediný rozdíl mezi C# je, že v C# je 100% zbytečný. var v JS použiješ jen při definici globální proměnné - aby se k ní dalo přistupovat z různých objektů, jinak není potřeba...

I když teď si říkám, jestli v JS také není zbytečný úplně...

Editováno 2.2.2013 14:01
 
Nahoru Odpovědět 2.2.2013 14:00
Avatar
Luboš Běhounek (Satik):

Var NENÍ proměnná bez typu. Var se překládá už v době kompilace a kompilátor si tam sám doplní typ, kterého ta proměnná je.

Pokud chcete mít proměnnou, do které byste nacpali cokoliv, tak se na to používá typ Object...

Nahoru Odpovědět  +5 2.2.2013 14:10
:)
Avatar
lcet.m
Člen
Avatar
Odpovídá na matesax
lcet.m:

Matěji, ty kecko, keyword "var" samozřejmě je zbytečný, celý C# je zbytečný jakož i .NET a OOP jsou zbytečné. Totiž úplně všechno nad instrukční sadou procesoru je zbytečné.

Nevím, jestli třeba víš co je to LINQ. Srovnej si

IQueryable<MyNamespace.MyClass> items = ...

vs.

var items = ...

Var v C# opravdu N E N Í totéž co var v JS. Var v C# typ, který jednoznačně určuje inicializace. Samozřejmě nejde udělat:

var x = null;

ani

var x = "Matej je tele";
x = 255;

Brisingře, klidně var používej všude kde to jde, oddálíš si karpální tunel a ušetříš na klávesnicích, jinak nic jinak než bez varu nebude.

Btw. Object tedy ehm ehm taky není zrovna "proměnná do které byste nacpali cokoliv". Je to prostě proměnná typu object. Že je zrovna všechno v .NETu zděděné ze System.Object je fakt, ale obdoba JS "var" je v C# "dynamic". V čem je rozdíl pochopí ti, kteří se podívají na pojmy boxing a unboxing.

 
Nahoru Odpovědět  +2 3.2.2013 23:42
Avatar
Odpovídá na lcet.m
Luboš Běhounek (Satik):

Dynamic umí až MSVS 2010, já ještě používám 2008 :D

Nahoru Odpovědět 4.2.2013 0:15
:)
Avatar
lcet.m
Člen
Avatar
Odpovídá na Luboš Běhounek (Satik)
lcet.m:

Ale to ještě neznamená, že se proměnná typu object dá nějak srovnávat s dynamickým typem.

 
Nahoru Odpovědět 4.2.2013 0:25
Avatar
matesax
Redaktor
Avatar
Odpovídá na lcet.m
matesax:

Strkej si to své mámě - takhle do mě furt jebat. Já LINQ používám. Uvaruj se třeba k smrti - dělej si prase kód - jak chceš. Já se chci ve svém kódu vyznat...

Jsi idiot, když si myslíš, že nevím, co je var v C#. Kde jsem psal, že var v C# == var v JS??? Ne - nepsal. Srovnej si to v palici!

Hele - ty si třeba maž hovna na vlasy, ale urážej jen lidi, které znáš.

 
Nahoru Odpovědět  -26 4.2.2013 5:55
Avatar
Odpovídá na matesax
Luboš Běhounek (Satik):

Psal jsi to tady:
"... var v JS je skoro zbytečný - jediný rozdíl mezi C# je, že v C# je 100% zbytečný ..."

Nahoru Odpovědět  +1 4.2.2013 12:09
:)
Avatar
Kit
Redaktor
Avatar
Odpovídá na Luboš Běhounek (Satik)
Kit:

Var v C# používají jen jelita, která neví, jakého typu bude výsledek operace.

Nahoru Odpovědět 4.2.2013 12:45
Vlastnosti objektů by neměly být veřejné. A to ani prostřednictvím getterů/setterů.
Avatar
Kit
Redaktor
Avatar
Nahoru Odpovědět 4.2.2013 15:22
Vlastnosti objektů by neměly být veřejné. A to ani prostřednictvím getterů/setterů.
Avatar
Odpovídá na Kit
Luboš Běhounek (Satik):

Myslím, že byl adekvátní na tvé konstatování :) .

Nahoru Odpovědět  +1 4.2.2013 15:27
:)
Avatar
David Čápka
Tým ITnetwork
Avatar
Odpovídá na Kit
David Čápka:

Var vznikl kvůli LINQu. Zaprvé z něj lezou někdy opravdu příšerné typy, zadruhé si z DB můžu vytahat data do anonymního typu. Anonymní typ samozřejmě ve finále typ také má, ale opravdu bys ho nechtěl deklarovat :)

Nahoru Odpovědět  +4 4.2.2013 15:28
Miluji svou práci a zdejší komunitu, baví mě se rozvíjet, děkuji každému členovi za to, že zde působí.
Avatar
Kit
Redaktor
Avatar
Odpovídá na David Čápka
Kit:

Tak tento argument se mi líbí mnohem víc. Nese informační hodnotu.

Nahoru Odpovědět  +1 4.2.2013 15:33
Vlastnosti objektů by neměly být veřejné. A to ani prostřednictvím getterů/setterů.
Avatar
matesax
Redaktor
Avatar
Odpovídá na Luboš Běhounek (Satik)
matesax:
:)

Bavil jsem se o významové hodnotě - ne o významu. Chytej mne za co chceš, var nepoužívám ani v LINQ - ale tam ho klidně budu akceptovat - však jinde opravdu ne.

 
Nahoru Odpovědět 4.2.2013 17:10
Avatar
lcet.m
Člen
Avatar
lcet.m:

Matýsku už ti bohužel nerozumím. Tento vybraný slovník ses naučil ve speciální škole pro předčasně vyspělé dětičky?

Pokud jsi tím svým postem nemyslel, že je var v C# totéž co var v JS, tak bohužel krom programování neumíš ještě psát.

No, jinak, může tady nějaký odpůrce keywordu "var" uvést nějaký argument proti? Teda krom toho, že ho používají jen jelimani? Ještě jsem nenarazil na situaci, kdy bych kvůli var nějak nechápal kód, a to ho používám opravdu hodně. Jak ví i Mates, normální IDE mi v nejhorším případě umí typ proměnné ukázat, takže problém je jen v odmítání všeho nového?

 
Nahoru Odpovědět  +1 4.2.2013 18:30
Avatar
David Čápka
Tým ITnetwork
Avatar
Odpovídá na lcet.m
David Čápka:

Var vzniklo hlavně kvůli anonymním typům, kde je zadat explicitně typ poněkud obtížné. Používat ho v běžném kódu je minimálně matoucí, to ostatně praví i oficiální MSDN. Všimni si, že tam ho v ukázkových kódech najdeš jen na místech, kdy je to nutné. C# je silně typovaný jazyk s určitými konvencemi, asi uznáš, že nahradit:

string s = "text";

za

var s = "text";

Není nejlepší nápad. Když to není nutné, nemá tam var co dělat.

Editováno 4.2.2013 18:38
Nahoru Odpovědět 4.2.2013 18:38
Miluji svou práci a zdejší komunitu, baví mě se rozvíjet, děkuji každému členovi za to, že zde působí.
Avatar
Kit
Redaktor
Avatar
Odpovídá na lcet.m
Kit:

Ty používáš k vývoji programů IDE? Jak odvážné!

Nahoru Odpovědět 5.2.2013 10:14
Vlastnosti objektů by neměly být veřejné. A to ani prostřednictvím getterů/setterů.
Avatar
Maxfx
Redaktor
Avatar
Maxfx:
:D :D :D
Editováno 5.2.2013 10:20
Nahoru Odpovědět 5.2.2013 10:20
Být ovládán znamená být sledován, pod dohledem, špehován, veden, uzákoněn, reglementován, ohrazen, indoktrinován, pře...
Avatar
Odpovídá na David Čápka
Luboš Běhounek (Satik):

Deklarace (definice) primitivních datových typů není asi ten nejvhodnější příklad, kde použít var, tam bych se tomu taky asi vyhnul, tam si člověk toho psaní moc neušetří.
Ale když mi třeba funkce vrací něco jako Dictionary<int, List<string>> tak v použití varu pro uložení výsledku nevidím naprosto žádný problém.

Editováno 5.2.2013 11:03
Nahoru Odpovědět  +1 5.2.2013 11:02
:)
Avatar
lcet.m
Člen
Avatar
Odpovídá na David Čápka
lcet.m:

Proč by neměl být nejlepší nápad používat místo string x = "abc"; rovnocennou variantu var x = "abc"; ? Je na to nějaký argument, krom toho, že se ti to nelíbí?

Ty používáš k vývoji programů IDE? Jak odvážné!

Nepochopil jsem...

Editováno 5.2.2013 11:33
 
Nahoru Odpovědět 5.2.2013 11:32
Avatar
Posix
Člen
Avatar
Posix:

Podle mě si var můžeš dávat kam chceš, když víš co děláš. Problém nastane, když si k programu sedne někdo jiný a má ho pak číst. Skoro nemožné, pokud tam máš skoro všude var. Celkově to pak snižuje šanci pochopit kód, když se k němu vrátíš později.

Nahoru Odpovědět 10.2.2013 18:02
Proč to dělat jednoduše, když to jde složitě.
Avatar
lcet.m
Člen
Avatar
Odpovídá na Posix
lcet.m:

Ale to je furt řečí a argument nikde... Děláme to takhle už několik let a nic takového nepozorujem. Na cestě k pochopení cizího/mého starého kódu jsou úplně jiná úskalí, než podle levé strany deklarace vidět typ proměnné. Přece já stejně jako kompiler vidím pravou stranu, tj. pokud už mám na očích deklaraci, je mi jasné, jakého typu proměnná bude. Nehledě na to, že jsem nikdy neměl ambice frajeřit v komerční sféře bez moderního IDE, takže v nejhorším vidím typ proměnné při najetí kurzorem.

Ti, kteří mají pocit, že pro přehlednost programu je klíčová takováhle zřejmost typu, by měli striktně dodržovat maďarskou notaci. A dělá to dnes někdo v C#? Moc ne. Potože to má pro zpřehlednění kódu minimální přínos, mnohdy spíš negativní.

 
Nahoru Odpovědět  +1 10.2.2013 19:14
Avatar
jackxl
Člen
Avatar
Odpovídá na lcet.m
jackxl:

Chtěl bych tě vidět, jak pomocí anonymního typu s VAR uděláš globalní proměnou.
Sice se GP nemají příliš používat kvůli šetření paměti, ale někdy jsou potřeba a s VAR se můžeš jít akorát zahrabat.
VAR používám jen u LINQu.

Nahoru Odpovědět 23.9.2014 16:09
Žádná hranice není nepřekonatelná.
Avatar
lcet.m
Člen
Avatar
Odpovídá na jackxl
lcet.m:

Zdravíčko... Co je prosím v C# globální proměnná?

 
Nahoru Odpovědět  +1 24.9.2014 7:14
Avatar
zpavlu
Redaktor
Avatar
zpavlu:

Chtěl bych taky troškou do diskuze . Myslím, že používání var , tuple přináší do kódu zmatek a hlavně nepřehlednost. Také je zdrojem velmi nepříjemných chyb .
Není totiž jedno zda napíšeme var x = 1; nebo var x = 1.0;
Pokud někdo z Vás používal ReSharper 8.0 a nejste pozorní přepíše všechny definované typy na var typy. Potom se divíte . Třída Tuple<T> vnese do programu pěkný zmatek , protože každý programátor je líný tvor málo se píší komentáře a po nějakém čase se v programu nevyzná ani autor. Lepší je typ dynamic jedná se o statický typ je zkoumán za běhu programu. Dá se s ním ušetřit dosti psaní , na příklad chceme načítat v programu Excel a neznáme verzi zákazníckého Excelu.
Zkoušel jsem Code Contracts a dostal jsem se do šílených programových konstrukcí ,
sám jsem přestal chápat co jsem napsal .
PZ

Nahoru Odpovědět  +1 24.9.2014 12:33
PZ
Avatar
jackxl
Člen
Avatar
Odpovídá na lcet.m
jackxl:

Neznáš základy ?

Globální proměnou deklaruješ přímo v třídě, mimo metody a je přístupná ve všech metodách v dané třídě, kde byla deklarovaná. V paměti zaniká až při ukončení aplikace.
Lokální proměnná je použitelná jen v metodě, kde byla deklarovaná a při ukončení metody se zruší i v paměti.

Nahoru Odpovědět  -2 24.9.2014 12:40
Žádná hranice není nepřekonatelná.
Avatar
David Čápka
Tým ITnetwork
Avatar
Odpovídá na jackxl
David Čápka:

To je field (instanční proměnná), C# nic jako globální proměnnou nemá, protože je to moderní objektový jazyk.

Nahoru Odpovědět 24.9.2014 12:58
Miluji svou práci a zdejší komunitu, baví mě se rozvíjet, děkuji každému členovi za to, že zde působí.
Avatar
lcet.m
Člen
Avatar
Odpovídá na jackxl
lcet.m:

Otazka je, zaklady ceho kdo nezna...

 
Nahoru Odpovědět 24.9.2014 13:12
Avatar
Odpovídá na jackxl
Luboš Běhounek (Satik):

U instančních proměnných var použít nelze.

Nahoru Odpovědět 24.9.2014 13:13
:)
Avatar
jackxl
Člen
Avatar
Odpovídá na lcet.m
jackxl:

Tak jí říkám globální a co ? Je to sice pojem z C, ale pro programátora má stejnou funkci. Nehraj si zase se slovíčky. Stejně jsi nevěl, že VAR jako instanční použít nejde.

Nahoru Odpovědět 24.9.2014 18:13
Žádná hranice není nepřekonatelná.
Avatar
Odpovídá na jackxl
Luboš Běhounek (Satik):

Pokud jsi myslel instanční proměnnou v C++ u třídy, tak to je něco úplně jiného než globální proměnná :)

Nahoru Odpovědět 24.9.2014 18:50
:)
Avatar
Odpovídá na jackxl
Andrej Farkaš:

Taktiež si povedal, že tvoja "globálna premenná" zaniká pri ukončení aplikácie, čo je tiež blbosť podľa mňa. Zaniká, keď na objekt danej triedy nie je žiadna referencia a spustí sa garbage collector. To čo sa používa v ne-OPP ako globálna premenná je úplne niečo iné ako premenná triedy.

Každopádne (k téme) var používam asi iba s LINQ, inicializácii WCF klientov a podobných veciach.

Nahoru Odpovědět 24.9.2014 19:47
Live. Love. Learn.
Avatar
lcet.m
Člen
Avatar
Odpovídá na jackxl
lcet.m:

Stejně jsi nevěl, že VAR jako instanční použít nejde. Opravdu? (A pokud teda mluvis o instancnich promennych - muzes nam, co jsme do tveho prichodu nic nevedeli, jeste vysvetlit, proc ze se nemaji prilis pouzivat, jaks psals?

Editováno 25.9.2014 8:23
 
Nahoru Odpovědět 25.9.2014 8:21
Avatar
zpavlu
Redaktor
Avatar
zpavlu:

Chtěl bych se ještě jednou vrátit k VAR. Zde uvedu několik příkladů. Máme jednoduchou třídu. Příklad 1

namespace ClassLibrary1
{
    public class Class1
    {
        private UserControl1 us = new UserControl1();
        private object test1()
        {
            var x = us;
            return x;
        }

        private object test2()
        {
            object x = us;
            return x;
        }
    }
}

// Dissasebler těchto funkcí :

.method private hidebysig instance object
        test1() cil managed
{
  // Code size       14 (0xe)
  .maxstack  1
  .locals init ([0] object x,
           [1] object CS$1$0000)
  IL_0000:  nop
  IL_0001:  ldarg.0
  IL_0002:  ldfld      class ClassLibrary1.UserControl1 ClassLibrary1.Class1::us
  IL_0007:  stloc.0
  IL_0008:  ldloc.0
  IL_0009:  stloc.1
  IL_000a:  br.s       IL_000c
  IL_000c:  ldloc.1
  IL_000d:  ret
} // end of method Class1::test1

.method private hidebysig instance object
        test2() cil managed
{
  // Code size       14 (0xe)
  .maxstack  1
  .locals init ([0] object x,
           [1] object CS$1$0000)
  IL_0000:  nop
  IL_0001:  ldarg.0
  IL_0002:  ldfld      class ClassLibrary1.UserControl1 ClassLibrary1.Class1::us
  IL_0007:  stloc.0
  IL_0008:  ldloc.0
  IL_0009:  stloc.1
  IL_000a:  br.s       IL_000c
  IL_000c:  ldloc.1
  IL_000d:  ret
} // end of method Class1::test2

Příklad 2

public class Class1
    {
        private int test1()
        {
            var x = 100;
            return x;
        }

        private int test2()
        {
            int x = 100;
            return x;
        }
    }

// Dissasebler těchto funkcí :

.method private hidebysig instance int32
        test1() cil managed
{
  // Code size       10 (0xa)
  .maxstack  1
  .locals init ([0] int32 x,
           [1] int32 CS$1$0000)
  IL_0000:  nop
  IL_0001:  ldc.i4.s   100
  IL_0003:  stloc.0
  IL_0004:  ldloc.0
  IL_0005:  stloc.1
  IL_0006:  br.s       IL_0008
  IL_0008:  ldloc.1
  IL_0009:  ret
} // end of method Class1::test1

.method private hidebysig instance int32
        test2() cil managed
{
  // Code size       10 (0xa)
  .maxstack  1
  .locals init ([0] int32 x,
           [1] int32 CS$1$0000)
  IL_0000:  nop
  IL_0001:  ldc.i4.s   100
  IL_0003:  stloc.0
  IL_0004:  ldloc.0
  IL_0005:  stloc.1
  IL_0006:  br.s       IL_0008
  IL_0008:  ldloc.1
  IL_0009:  ret
} // end of method Class1::test2

Příklad 3 jak vznikají chyby :

public class Class1
    {
        private object test1()
        {
            var x = 100.0;
            return x;
        }

        private object test2()
        {
            object x = 100;
            return x;
        }
    }

// Dissasebler těchto funkcí :

.method private hidebysig instance object
        test1() cil managed
{
  // Code size       22 (0x16)
  .maxstack  1
  .locals init ([0] float64 x,
           [1] object CS$1$0000)
  IL_0000:  nop
  IL_0001:  ldc.r8     100.
  IL_000a:  stloc.0
  IL_000b:  ldloc.0
  IL_000c:  box        [mscorlib]System.Double
  IL_0011:  stloc.1
  IL_0012:  br.s       IL_0014
  IL_0014:  ldloc.1
  IL_0015:  ret
} // end of method Class1::test1

.method private hidebysig instance object
        test2() cil managed
{
  // Code size       15 (0xf)
  .maxstack  1
  .locals init ([0] object x,
           [1] object CS$1$0000)
  IL_0000:  nop
  IL_0001:  ldc.i4.s   100
  IL_0003:  box        [mscorlib]System.Int32
  IL_0008:  stloc.0
  IL_0009:  ldloc.0
  IL_000a:  stloc.1
  IL_000b:  br.s       IL_000d
  IL_000d:  ldloc.1
  IL_000e:  ret
} // end of method Class1::test2

Cílem bylo ukázat, že VAR nám nezrychlí náš kód, ale zavede nepřehlednost v programu a nepatří tam.

Nahoru Odpovědět  ±0 9.10.2014 21:01
PZ
Avatar
Jan Vargovský
Redaktor
Avatar
Odpovídá na zpavlu
Jan Vargovský:

"Cílem bylo ukázat, že VAR nám nezrychlí náš kód, ale zavede nepřehlednost v programu a nepatří tam."

Proč by tam nepatřil? Když budeš mít nějakou kolekci a uvnitř další kolekci, tak je 3x rychlejší napsat var než to psát 2x. Používám ho i když je typ velmi zdlouhavý, nebo dost často, když zkouším nějaký krátký kód, který letí stejně za pár minut do pryč.

 
Nahoru Odpovědět 9.10.2014 21:37
Avatar
Odpovídá na zpavlu
sadlomaslox25:

Nevim sice co si tim MSIL chtel dokazat, ale snad nikdo nikdy netvrdil ze var zrychluje kod.

 
Nahoru Odpovědět  +1 9.10.2014 22:47
Avatar
zpavlu
Redaktor
Avatar
zpavlu:

Odpovím (paku i sadlomaslox25). Pánové, když odpovídáte čtěte pozorně o čem se ve vláknu píše. Nikde není zmínka o větě "Zakazuji používat VAR" a také nikde není zmínka o rychlosti.
Klidně VAR používej pokud ti nevadí nepřehlednost.
Co se týká MSIL dal jsem ukázku proto, že je pro každého i když se neorientuje v MSIL je jasné ,že generovaný kód je stejný. Přece nejde o rychlost.
Závěr :
Proč mám psát kód , který je hůře čitelný a nemá vliv na velikost ani na rychlost ?

Nahoru Odpovědět 10.10.2014 9:45
PZ
Avatar
Odpovídá na zpavlu
Luboš Běhounek (Satik):

Protože se to rychleji píše? :)

Přehlednost tím netrpí, pokud to používáš rozumně.
Obvykle se to používá spíš na třídy a taky je potřeba používat inteligentnější názvy tříd/metod/pro­měnných než třeba x, pak je všechno jasné i s var.

Viz třeba:

Customer customer = customers.GetByName(name);

vs

var customer = customers.GetByName(name);
Editováno 10.10.2014 10:02
Nahoru Odpovědět 10.10.2014 10:01
:)
Avatar
coells
Redaktor
Avatar
Odpovídá na zpavlu
coells:

Protože se takový kód lépe čte a je přehlednější.

Ačkoliv sám také čtu knihy často odzadu, jedinou větu čtu jako evropan obvykle zleva doprava a nerad se vracím očima. Použití var usnadňuje čtení kódu, pokud je v kontextu možné snadno odvodit výsledný typ. Narozdíl od explicitní definice typu, implicitní definice takový způsob čtení umožňuje.

var dict = new Dictionary<int, string>();
var i = 1;

Čti:
"proměnná dict obsahuje instanci Dictionary<int, string> a je stejného typu"
"proměnná i obsahuje hodnotu 1 a je typu integer"
Co je na tom nečitelného?

Jediný rozdíl mezi implicitním a explicitním zavedením typu spočívá v tom, že implicitně to za nás dělá kompilátor. A na tom není nic špatného. Typová inference je běžná věc a používáš ji častěji, než si sám uvědomuješ.

var a = new[] { 1, 2, 3 };
var b = a.First();

Na dvou řádkách kódu najdeš hned čtyři případy typové inference. Prvním je definice pole, kde kompilátor odvodí typ z jeho hodnot. Druhým je definice proměnné a, kde kompilátor odvodí typ int[] na základě implicitní hodnoty. Třetím je odvození typu funkce [int Fist<int>()], což také provede kompilátor. Čtvrtým je na základě návratové hodnoty implicitně typované funkce Fist<T> odvození typu proměnné b. A ačkoliv bys mohl napsat explicitně a.First<int>(), určitě to neděláš?

Takže otázka zní, proč tam var a nepatří, ale a.First() tam patří? Odpověď je, že tam patří, protože zjednoduší a zpřehlední kód. Problém s takovým kódem často mají programátoři uvázaní na C a podobné jazyky. Za posledních 20 let se programování hodně posunulo a jasně se ukazuje, že dynamismus v jazyku (a teď nemám na mysli přímo var, to je statický typ) zrychluje vývoj a usnadňuje práci.

 
Nahoru Odpovědět  +1 10.10.2014 10:58
Avatar
Odpovídá na zpavlu
sadlomaslox25:

klicove slovo var ma 2 duvody. prvni je ze umoznuje nahradit slozite nazvy typu slovem var. to se pouziva hlavne u linq pokud vracis objekty ktere jsou sezazene,zgrou­povane,slovni­ky. druhy duvod je ze linq metoda projekce umoznuje vytvaret anonymni tridy, se kterymi nejde pracovat jinak nez bez var.

 
Nahoru Odpovědět 10.10.2014 11:02
Avatar
coells
Redaktor
Avatar
Odpovídá na sadlomaslox25
coells:

Důvodem byly anonymní typy - a to nejen anonymní třídy, ale také uzávěry, které byly velice užitečné s příchodem EntityFrameworku.

var osoby = dbContext.Osoba.
                     Where(o => o.jmeno == "tomas").
                     Select(o => new { Jmeno = o.jmeno, Prijmeni = o,prijmeni });

Přečti si můj předchozí příspěvek a zkus si spočítat, kolik případů typové inference je na tomhle jediném řádku. Pokud nemusíš na každém místě uvádět explicitní typ, kód se drasticky zkrátí a zjednoduší.

 
Nahoru Odpovědět 10.10.2014 11:06
Avatar
jackxl
Člen
Avatar
Odpovídá na coells
jackxl:

Já vám nevím, ale kdyby se zamýšlelo používat neustále VAR, proč pak vymysleli jiné typy ?

Nahoru Odpovědět 23.2.2015 12:48
Žádná hranice není nepřekonatelná.
Avatar
coells
Redaktor
Avatar
Odpovídá na jackxl
coells:

Protože var není typ, ale deklarace proměnné s typem implicitně odvozeným?

 
Nahoru Odpovědět 23.2.2015 14:11
Avatar
Jan Vargovský
Redaktor
Avatar
Odpovídá na coells
Jan Vargovský:

var není nový datový typ. Pročti si tu celý thread.

 
Nahoru Odpovědět 23.2.2015 14:12
Avatar
jackxl
Člen
Avatar
Odpovídá na Jan Vargovský
jackxl:

Dobře. Ale vysvětlete mi, proč psát např. var promenna = 1 a nenapsat rovnou int promenna = 1 ? Nezabírá deklarace proměnné s typem implicitně odvozeným náhodou více procesorového času při překladu ?

Nahoru Odpovědět 6.3.2015 13:48
Žádná hranice není nepřekonatelná.
Avatar
coells
Redaktor
Avatar
Odpovídá na jackxl
coells:

Pominu, že to je naprosto nesmyslný argument a nebudu se rozepisovat o složitosti fází kompilace v rámci jazyka a porovnání mezi jazyky. Budu předpokládat, že by takový argument dával smysl a zeptám se, proč by měla zabírat více času? Stačí se zamyslet nad tím, co musí kompilátor udělat:

int a = 1 -- vs -- var b = 1

  1. zkontroluje se, jestli obě strany rovnosti mají stejný typ
  2. pokud je typ rozdílný, musí se provést implicitní konverze
  3. pokud nelze provést implicitní konverzi, error

Obě dvě možnosti musí provést kroky a-c, ale protože proměnná b nemá typ, dokud není známý typ pravé strany výrazu, odpadá krok (b) a typ proměnné se jednoduše uloží k proměnné.

 
Nahoru Odpovědět 6.3.2015 14:04
Avatar
hanpari
Redaktor
Avatar
hanpari:

Problém celé téhle diskuse je o tom, že někteří netuší, odkud a proč se v C# tyhle nové vymoženosti jako Tuples, LINQ nebo typová inference vzali. Ano, je to převzato z F# (konkrétně LINQ určitě), potažmo z funkcionálního programování.

Ve většině zdrojů, které jsem nedávno k C# četl, nemá nikdo problém var používat. Jednoduše proto, že dvakrát opakovat totéž je čirý masochismus. :)

Ale je na to hezké definice, opak DRY je WET, tomto pípadě Write Everything Twice:

http://cs.wikipedia.org/…eat_yourself

*
*DRY vs. WET

Chyby při používání principu DRY se často označují zkratkou WET neboli Write everything twice! (tj. „Piš vše dvakrát“), či We enjoy typing (tj. „Zbožňujeme psaní“).*

*

Editováno 6.3.2015 15:31
 
Nahoru Odpovědět 6.3.2015 15:29
Avatar
hanpari
Redaktor
Avatar
hanpari:

Abych sám sebe doplnil, podívejte se na typickou věc v F#:

    let secti x y = x + y //Nikde není uvedený jakýkoliv typ.
    printf "Vysledek je %A" (secti 10 10) //Tenhle řádek je v pořádku
    printf "Vysledek je %A" (secti 10.1 10.1) //Tento řádek skončí s chybou


Main.fs(103,36): error FS0001: This expression was expected to have type
    int
but here has type
    float

Nicméně tento kód je naprosto v pořádku:

let secti x y = x + y
//printf "Vysledek je %A" (secti 10 10)
printf "Vysledek je %A" (secti 10.1 10.1) //Vysledek je 20.2

Oproti tomu je použití var ještě slabý čajíček :)
A teď proč k tomu došlo. Zkuste nad tím zapřemýšlet :)

 
Nahoru Odpovědět 6.3.2015 15:50
Avatar
jackxl
Člen
Avatar
jackxl:

Tak si všude pište VAR, já si přehlednost mrvit nebudu.

Nahoru Odpovědět  -2 23.3.2015 8:23
Žádná hranice není nepřekonatelná.
Avatar
Odpovídá na jackxl
Luboš Běhounek (Satik):

Nikdo tě nenutí.
A užívej si LINQ bez var :)

Nahoru Odpovědět  +2 23.3.2015 9:21
:)
Avatar
hanpari
Redaktor
Avatar
Odpovídá na jackxl
hanpari:

Prijde mi, že problém je v samotném tvém příkladě.

Když například porovnáš:

HodneDlouhyNazevTridy neco = new HodneDlouhynazevTridy();

s:

var neco = new HodneDlouhyNazevTridy();

pak musíš sám uznat, že rozumné použití var nejenže kód nezpřehledňuje, ale přesně naopak. Pokud tedy si nelibuješ v tom, že čteš dvakrát totéž.

 
Nahoru Odpovědět 23.3.2015 12:05
Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zobrazeno 54 zpráv z 54.