V är ett nytt, öppen källkod, statiskt skrivet programmeringsspråk skapat av Alexander Medvednikov. V lovar att vara enkel, snabb och säker att bygga underhållbar programvara med. Flera språk har påverkat V: s design inklusive Oberon, Swift, Kotlin och Python.

Lär dig mer om V, dess funktioner och hur det kan jämföras med andra språk.

Saker du kan göra med V

V har mycket kraft och du kan använda den i nästan alla branscher, inklusive systemprogrammering, webbutveckling och spelutveckling. Språket är enkelt, snabbt och säkert.

V erbjuder ett brett utbud av kraftfulla grafikbibliotek för spelutveckling. Dessa bygger på GDI+/Cocoa Drawing och OpenGL för mer sofistikerade 2D/3D-applikationer.

V har en UI-modul som använder inbyggda GUI-verktygssatser för mobilappar, WinAPI/GDI+ för Windows, Cocoa för macOS och anpassad ritning för Linux.

Skäl att prova V

Även om V är ett nytt språk, gör dessa fördelar det till ett legitimt alternativ.

Enkelhet

För att bygga ditt projekt behöver du bara köra:

v .

Du behöver inte konfigurera en byggmiljö, skapa en makefile, importera rubriker eller konfigurera en virtuell miljö. Om du vill installera nya bibliotek via

instagram viewer
vpm (V-pakethanterare), bara kör

v installera <Paketnamn>

Säkerhet

Som standard har V:

  • oföränderliga variabler
  • oföränderliga strukturer
  • alternativ/resultat och obligatoriska felkontroller
  • summatyper
  • generika
  • oföränderlig funktion args

och nej:

  • null
  • variabel skuggning
  • odefinierat beteende
  • globala variabler (kan aktiveras för lågnivåappar som kärnor, via flagga)

Sammanställningshastighet

Vissa programmeringsspråk är snabbare än andra, när det gäller exekvering eller kompilering. V är lika presterande som C. Den har kompileringstider på cirka 110k loc/s med en C-backend och cirka 1 miljon loc/s med inbyggda och tcc-backends. V undviker också onödiga tilldelningar för att tillhandahålla en enkel-abstraktionsfri kodningsmetod.

Minneshantering

V använder inte en sophämtare, vilket gör det annorlunda från språk som Go och Java. Istället hanterar V minnet vid kompilering, men fungerar bara för grundläggande situationer. Du måste hantera det manuellt för mer komplexa fall.

Formatering för kodstilskonsistens

Du kan använda vfmt formatterare för att formatera din V-kod och förbättra dess läsbarhet genom att köra:

v fmt -w <ditt_filnamn>.v

Vänliga felmeddelanden

V: s felmeddelanden är detaljerade, informativa och användbara. Ta en titt på detta exempel:

användare.v:8:14:fel: "uppdateringsanvändare". parameter "användare". är föränderlig, måste du tillhandahålla `mut`: `update_user (mutanvändare)`
 7 | mut användare := Användare{}
 8 | update_user (användare)
 | ~~~~
 9 | }

Med hjälp av felmeddelandet kan du fixa denna kod:

mut användare := Användare{}
update_user (mutanvändare)

C++ vs. Gå vs. V: Jämföra de tre språken

I dessa exempel kan du se hur C++-, Go- och V-kod skiljer sig åt i specifika programmeringsanvändningsfall.

Hej världen

I C++:

#omfatta <iostream>
inthuvud(){
 std:: cout <<"Hej världen!"<< std:: endl;
}

In Go:

paket huvud
importera "fmt"
func huvud(){
 fmt. Println("Hej världen!")
}

I V:

println('Hej världen!')

I detta mycket grundläggande program—skriva ut texten "Hello World!"— Du kan se att V är mycket enklare än C++ eller Go. Du behöver inte importera eller inkludera några bibliotek för ett så enkelt program.

Vektorinitiering

I C++:

std:: vektor<int> siffror = {1, 2, 3, 4};

In Go:

siffror := []int{1, 2, 3, 4}

I V:

siffror := [1, 2, 3, 4]

I det här användningsfallet kan du se att V fortfarande producerar renare kod än de två andra. Till skillnad från Go och C++ vektorer, V kräver inte att dess vektorer håller värden av en fast typ.

Skriva ut en vektor

I C++:

std::copy (numbers.begin(), tal.slutet(),
 std:: ostream_iterator<int>(std:: cout, ""));
std:: cout << std:: endl;

In Go:

fmt.Skriv ut(tal)

I V:

println (siffror)

V: s println-funktion kan skriva ut vektorvariabeln native, precis som Gos kan, även om den senare använder fmt-paketet. C++ iostream-huvudfilerna ger liknande funktionalitet. Du måste ändå ta hand om att skriva ut de enskilda elementen i vektorn själv.

Läsa en fil

I C++:

#omfatta
#omfatta
inthuvud(){
std::sträng sökväg = "/etc/hosts";
std::ifstream f(väg);
std::sträng text;
 text.assign(std::istreambuf_iterator<röding>(f), {});
om (!f)
std::cerr << "fel vid läsning från fil" << std::endl;
}

In Go:

paket huvud
importera (
"io/ioutil"
"logga"
)


func huvud(){
 väg := "/etc/hosts"
 b, fel := ioutil. Läsfil (sökväg)


om fel != noll {
logga.Skriv ut(fela)
lämna tillbaka
 }
text := sträng (b)
}

I V:

importera os
väg := "/etc/hosts"
text := os.read_file (sökväg) eller {
 eprintln (fel)
lämna tillbaka
}

För filläsning använder V OS-modulen för att tillhandahålla vanliga OS/plattformsoberoende funktioner. Dessa hanterar uppgifter som att komma åt kommandoradsargument, läsa filer och hantera processer. I det här fallet vill vi läsa in en fil väg och returnera innehållet, så att du använder läs_fil (sökväg) fungera. read_file returnerar ett fel om det inte finns något befintligt innehåll i den givna väg. Om du vill lära dig mer om andra moduler av V, kanske du vill kolla in deras dokumentation.

Redo att prova V?

V är ett nytt programmeringsspråk som fortfarande är i sina tidiga utvecklingsstadier. Trots det har den mycket kraft och är snabb, säker, enkel och underhållsbar.

V har renare kod än C++ och Go. Detta tyder på att V kan hjälpa programmerare att följa en av de grundläggande programmeringsprinciperna. Så, är du redo att prova V?