Följande artikel hjälper dig: Google Carbon-språkhandledning med syntax, exempel [Beginner guide]
Google introducerade Carbon language som nästa generations programmeringsspråk med målet att ersätta C++ som en efterföljare. Det är ett projekt med öppen källkod som fortfarande befinner sig i experimentfasen. Ursprungligen demonstrerad av Chandler Carruth i CppNorth-konferensen, ser Carbon-språket ut som ett bra alternativ till C++. Utgivningsdatum för kolspråk är 19 juli 2022
I den här handledningen kommer vi att lära oss om olika aspekter av kolspråk och hoppa in i kolspråkets grundläggande syntax tillsammans med exempelkod som du kan använda för att prova språket efter att ha läst igenom slutet av denna dokumentation.
Låt oss dyka in.
Introduktion till Carbon Language
Kolspråk kan ersätta C++ när saker och ting utvecklas. C++ är redan ett bra språk att arbeta med. Det kan ge hög prestanda och används ofta i många produktionssystem. Det kan köras med flera plattformar, hårdvaruarkitektur och många operativsystem. Men några av problemen med C++ är det
- Ackumulerad teknisk skuld (t.ex.: Heltalskampanjregler) över olika funktioner. Bakåtkompatibilitet med C gör det ännu svårare att fixa tekniska skulder och göra kodändringar svåra att implementera.
- Evolutionsprocessen för att lägga till nya funktioner till C++ är mycket svår eftersom den måste följa ISO-processoverhead, förhindra experiment etc.
Så C++ når inte några av sina mål som prestandakritisk programvara; Programvara och språkutveckling; Kod som är lätt att förstå och skriva; Snabb och skalbar utveckling och så vidare.
Eftersom det är väldigt svårt att lösa dessa problem med C++, efter en djupgående forskning och utvärdering på flera språk av Googles ingenjörer, Carbon programmeringsspråk införs. Så det är som en efterföljare till C++ liknande
- C -> C++
- JavaScript -> TypeScript
- Objective-C -> Swift
- Java -> Kotlin
- C++ -> Carbon Language
där den vänstra delen av pilen är originalspråket och den högra delen är det ersättande språket.
Några av de viktigaste aspekterna av efterföljande språk inkluderar – att bygga på befintliga ekosystem, dubbelriktad interoperabilitet, optimera inlärningskurvan, moderna verktygssystem som pakethanterare etc.
Carbon-språk ärvs inte från äldre C eller C++. Den är byggd från grunden med moderna språkgrunder som Generics, Modular code, Consistent, Simple syntax.
Nyckelfunktioner i Carbon-språket
- Snabb prestanda matcha C++ med hjälp av LLVM (virtuell dator på låg nivå), med tillgång på låg nivå till bitar och adresser.
- Dubbelriktad interoperabilitet indikerar att du kan anropa C++-språkkod från Carbon-språk och Carbon-språkkod från C++.
- Migration Ger stöd för att migrera kod från C++.
- Modernt och utvecklande funktioner som snabba och skalbara builds som kan fungera med befintliga C++-byggen, lättare att lära sig.
- Byggd med öppen källkod med tydliga mål och prioriteringar med batterier inkluderade tillvägagångssätt som kompilatorer, bibliotek, dokumentation, pakethanterare mm.
Jämförelse av kolspråk vs rost
Som en del av kolspråksutvecklingen beaktas många faktorer. Några av dem inkluderar att ta en titt på sopsamlade språk (som Java), mer moderna språk som Rust , swift , Kotlin och så vidare.
Rost är noggrant utvärderad som en ersättning till C++. Infact Carbon language insisterar på att använda Rust och ignorera Carbon om möjligt eftersom Rust är ett tekniskt och ekonomiskt mer hållbart språk.
Men för organisationer som redan använder C++ är det mycket svårt att migrera till Rust. Programvara skriven i Rust har egenskaper och moduler som inte av språken som C++ eller Carbon har. Att anpassa till Rust för stora C++-kodbaser är nästan inte praktiskt med tanke på att det inte finns någon interoperabilitet. Vi kommer att prata på djupet om detta i en separat artikel snart. Om du fortfarande är nyfiken kan du lära dig mer om det här om varför Rust inte är en ersättning för C++.
Här är en detaljerad jämförelse mellan Carbon language vs Rust. Jämförelse med rost och kol
Nu när vi vet vad Carbon-språk är och varför vi behöver använda det, låt oss dyka in i själva installationen/installationen, syntaxen, exemplen.
OK! Låt oss hoppa in i kolspråk.
Så här ställer du in och installerar Carbon Language:
Att komma igång med Carbon language innebär installation av
- Homebrew: är ett paketinstallationsverktyg. Om du inte har homebrew installerat kan du följa dessa instruktioner. I MacOs kan du installera homebrew med /bin/bash -c “$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)”
- Bazel : Bazel är ett bygg- och testverktyg med öppen källkod som kan stödja flera språk, plattformar.
- LLVM: LLVM är en virtuell maskin på låg nivå som Carbon-språket använder för att köra. Du kanske inte behöver ha full kunskap om LLVM för att följa denna handledning.
- Carbon Explorer: Carbon Explorer är som ett implementeringsverktyg för Carbon-språket. För att köra alla program i Carbon lang kommer vi att använda carbon explorer.
För syftet med denna handledning kommer vi att använda MacOS för att installera. Men instruktioner för andra operativsystem som Linux eller Windows kan vara liknande. Om du har några frågor om installation eller om carbon language inte fungerar av någon anledning, kan du lämna en kommentar till det här inlägget. Ska försöka lösa problemet.
För att installera carbon lang, kör dessa kommandon i din terminal.
Steg 1: Installera Bazel
För att installera Bazel kan du köra
| 1 | $ brew installera bazelisk |
Detta bör automatiskt installera och ställa in Bazel som är redo att användas. Om du har några fel relaterade till behörigheter, kommer felmeddelandet från Bazel att ha ett användbart kommando att köra. Försök att köra det kommandot med sudo
Steg 2: Installera LLVM
LLVM är den virtuella kärnmaskinen på vilken carbon language körs. För att installera den
| 1 2 | $ brew installera llvm $ export PATH=”$(brew –prefix llvm)/bin:${PATH}” |
En sak att notera är att MacOS har en standard llvm. Så att använda brew install llvm kan ge ett meddelande som att llvm endast är fat, vilket betyder att det inte var symboliskt länkat …. För att lösa det här problemet, gå till avsnittet om felsökning av installationsfel i Carbon i slutet av denna artikel för att lösa detta problem.
Steg 3: Ställ in Carbon-språkkod
Detta steg är att ladda ner carbon lang-kod som också har några exempel.
| 1 2 | $ git klon https://github.com/carbon-language/carbon-lang $ cd carbon-lang |
Steg 4: Hej världen med kolspråk
Nu när vi har ställt in Carbon-språket, låt oss göra en snabbkörning för Hello world. För att göra det kommer vi att använda Carbon Explorer för att köra. För att köra din första kod i Carbon, se till att du är i carbon-lang-katalogen som du klonade från git och kör sedan under kommandot.
| 1 | $ bazel run //explorer — ./explorer/testdata/print/format_only.carbon |
Vad den här raden gör är att anropa Bazels byggverktyg för att utlösa utforskarkod som i sin tur kör den faktiska koden som finns i filen ./explorer/testdata/print/format_only.carbon.
När du väl har kört detta bör du se en Hello world i Carbon-utgång som denna
| 1 2 3 4 5 6 7 8 9 10 | tipseason$ bazel run //explorer — ./explorer/testdata/print/format_only.carbon INFO: Anrops-ID: aa36a266-cb55-4433-9bed-907e393c0605 VARNING: ….. . . INFO: Bygget har slutförts, totalt 390 åtgärder . . Hej världen! resultat: 0 |
Som du kan se “Hello World!” skrivs ut och returtyp av main är int32 vilket resulterar i 0. Koden som ligger bakom detta hello world-program är
Filsökväg: ./explorer/testdata/print/format_only.carbon
| 1 2 3 4 5 6 7 | paket ExplorerTest api; fn Main() -> i32 { var s: auto = “Hej värld!”; Grafik); returnera 0; } |
För Windows stöds inte Carbon-språket ännu. Men du kan installera wsl vilket är som att installera Linux ovanpå Windows. Du kan göra det med wsl –install och sedan utföra ovanstående steg.
Filtillägget för Carbon-språkkoden är .carbon. Så om du skriver en ny carbon-språkfil måste du ha en fil som slutar med förlängningen .carbon. Exempel: demo.carbon .
Nu när vi har konfigurerat kolspråk, låt oss titta på några av de grundläggande syntaxerna som kan användas dagligen för kolspråk.
Video handledning
Om du föredrar att titta på videoversionen av denna handledning inklusive livedemos + genomgångsinstallation och fungerande exempel, kan du också följa den här YouTube-videon.
Låt oss hoppa in i Carbon-språkets grundläggande syntax.
Carbon Language Basic Syntax med exempel:
Kolspråk är fortfarande i experimentella faser. Även om de flesta av designvalen redan är gjorda, kan en del av syntaxen och användningen ändras när saker och ting utvecklas. Så tänk på det när du arbetar med Carbon-lang. En bra sak med Carbon är att syntaxen ska vara C/C++ utvecklarvänlig och lätt att förstå.
För bästa användning av denna handledning, för att följa med vart och ett av dessa exempel, kan du köra exemplen nedan med hjälp av Carbon Language Explorer som du installerade i föregående steg. Om du kör i din egen maskin kan du skapa nya filer varje gång du kör ett program eller ändra filen ./explorer/testdata/print/format_only.carbon för att kontrollera exemplen.
Varje gång du ändrar koden kör du bazel run //explorer — ./explorer/testdata/print/format_only.carbon för att se resultatet.
Obs: format_only.carbon är bara en exempelfil. Ändra det till vilket filnamn du skapat.
Alternativt kan du också använda Carbon online explorer IDE för att köra igenom exemplen nedan.
Bara kopiera och klistra in nedanstående exempel i online-IDE så kan du se liveresultat.
Länk för online carbon explorer IDE finns på Carbon Godbolt eller Carbon online explorer
Låt oss komma igång med hur man använder kolspråk.
Deklarationer i kolspråk:
- Metoder/funktioner deklareras med nyckelordet fn.
- Variabler deklareras med nyckelordet var.
- Variabelnamn ska sluta med : följt av mellanslag, t.ex.: var x:
- Konstanter kan deklareras med nyckelordet let.
- Paket deklareras med paketnyckelord.
- Kommentarer på Carbon-språket kan deklareras med två snedstreck //
- auto kan användas för att automatiskt härleda variabeltypen. Den kan användas i kombination av let eller var eller som funktionsreturtyper.
Exempel/ Demokod:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | paket ExplorerTest api; //fn är funktionsdeklaration //returtyp är i32 dvs int. fn Main() -> i32 { //Jag är en kommentar. var s: auto = “Hej värld!”; // Autovariabel låt x: i32 = 20; // Konstant var y: i32 = 3; // Heltalsvariabel Utskrift(er); // Skriv ut retur 0; //Returvärde } |
Funktioner/metoder i kol
Funktioner kan deklareras med nyckelordet fn. Syntaxen är fn MethodName(var param: typ … ) -> returtyp . För tomma eller tomma returtyper kan du ignorera delen efter ->
Exempel:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | paket ExplorerTest api; //Heltalsreturtyp fn Sum(var a: i32, var b: i32) -> i32 { return a + b; } //Tom eller ogiltig returtyp. fn PrintCount(var count: i32) { Print(“Antalet är {0}”, count); } fn Main() -> i32 { Print(“Summa är {0}”, Sum(4, 6)); PrintCount(10); returnera 0; } |
Numeriska variabler i kolspråk:
Variabler i kolspråk kan vara
- bool för booleskt sant eller falskt
- i8, i16, i32, i64, i128, i256 för heltalstyper.
- u8, u16, u32, u128, u256 för heltalstyper utan tecken.
- f16, f32, f64 och f128 för flyttyper.
- _ kan användas för sifferavgränsare. T.ex.: 1_000_000 är fortfarande ett heltal om det deklareras utan citattecken.
Exempel:
| 1 2 3 4 5 6 7 8 | paket ExplorerTest api; fn Main() -> i32 { var a: i32 = 1; var b: i32 = 2; Skriv ut(a + b); returnera 0; } |
Strängar på kolspråk:
Strängar kan deklareras med hjälp av
- Sträng för bytesekvens
- StringView som en skrivskyddad referens för utf-8 bytesekvens.
Strängorderaler kan deklareras på två sätt.
- Enkel rad: Använd dubbla citattecken(“) för en rad.
- Flerradssträng: Använd (“””) för deklaration av flerradssträngar
Exempel:
| 1 2 3 4 5 6 7 8 9 10 | paket ExplorerTest api; fn Main() -> i32 { var singleLine: String = “Hej värld!”; var multiLine: String = “””hej rad 1 TipSeason demo rad 2 TipSeason demo rad 3 “””; //Slutet av multiblock return 0; } |
Tuples i kollang:
Tuples representerar värden med flera koordinater. De kan deklareras med parentes ( )
**Exempel / Exempelkod **
| 1 2 3 4 5 6 7 8 | paket ExplorerTest api; fn Main() -> i32 { var x: auto = (0, 1); Skriv ut(“{0}”, x[1]); tillbaka x[0]; } |
Här (x,y,z) är en tupel med flera koordinater. De kan nås med hjälp av indexet.
Pekare på kolspråk:
Det finns inga nollpekare i Carbon. För att representera en pekare som kanske inte refererar till ett giltigt objekt, använd typen Optional(T*) där T är typen.
* representerar värde. & representerar adress.
**Exempel: **
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | paket ExplorerTest api; fn Main() -> i32 { var x: i32 = 5; // ändrar x till 10 x = 10; Skriva ut(“—“); Print(“x = {0}”, x); var y: i32* = &x; // ändrar x till 7 *y = 7; Skriva ut(“—“); Print(“x = {0}”, x); Print(“y = {0}”, *y); var z: i32* = &*y; // ändrar x till 0 *z = 0; Skriva ut(“—“); Print(“x = {0}”, x); Print(“y = {0}”, *y); Print(“z = {0}”, *z); var w: i32 = *y; returnera w; } |
Arrayer i kol:
Matriser deklareras med hjälp av matristyp och storlek. Syntax är [type; size]Till exempel: var xarray: [i32; 4] = (1,2,3,4);
Exempel
| 1 2 3 4 5 6 7 8 9 10 | paket ExplorerTest api; fn Main() -> i32 { var xarray: [i32; 4] = (0, 1, 5, 6); // Heltalsmatris var index: i32 = 1; röntgenbild[index] = 0; Print(“{0}”, xarray[0]); Print(“{1}”, xarray[0]); returnera xarray[0] + röntgenbild[1]; } |
Villkorligt styrflöde med kol
Kombination av if , else kan användas för att styra det villkorade flödet i Carbon.
**om annat: **
| 1 2 3 4 5 | if(villkor) { //doSomething } else { //doSomething } |
om-annat-om
| 1 2 3 4 5 6 7 8 | if(condition) { //doSomething } else if (condition) { //doSomething } else { //doSomething } |
Exempel:
| 1 2 3 4 5 6 7 8 9 10 11 12 | paket ExplorerTest api; fn Main() -> i32 { var x: i32 = 5; if(x == 5) { Print(“{0} till ordet är FEM”, x); } else { Print(“{0} är inte känd”, x); } returnera 0; } |
Slingor på kolspråk
Standard looping uttalanden stöds.
Medan loop
While loop kan deklareras med while(condition){ }
Exempel:
| 1 2 3 4 5 6 7 8 9 10 | paket ExplorerTest api; fn Main() -> i32 { var x: auto = 5; medan (inte (x == 0)) { x = x – 1; Print(“{0}”, x); } returnera x; } |
För Loop
For loop kan deklareras med för (loopvillkor) { } . I skrivande stund fick den här artikeln inte fullt fungerande exempel. Men här är den föreslagna syntaxen.
| 1 2 3 4 5 6 7 8 9 10 11 | paket ExplorerTest api; fn Main() -> i32 { var names: [String; 4] = (“a”, “b”); for (var namn: Sträng i namn) { Console.Print(name); } returnera x; } |
Matcha flera villkor som liknar Switch
Carbon har matchande sökord som liknar switch i C/C++. Syntax för matchning är
| 1 2 3 4 5 6 7 8 | match(condition) { case (condition) => { //doSomething; } default => { //doSomething; } } |
Exempel:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | paket ExplorerTest api; fn Matcher(var num: i32) -> i32 { var nummer: auto = 10; match (nummer) { case 5 => { Print(“Got 5”); returnummer; } fall 10 => { Print(“Fick 10”); returnummer; } default => { Print(“Standard”); returnummer; } } } fn Main() -> i32 { Matcher(5); Matcher(10); Matcher(2); returnera 0; } |
Klasser i Carbon Lang:
Klass i kolspråk kan deklareras med klass nyckelord. Klassen kan ha medlemmar och metoder. Här är ett exempel på klassimplementering.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | paket ExplorerTest api; klass Sum { var a: i32; fn Lägg till[me: Self](var num: i32) -> i32 { var total: i32 = me.a + num; avkastning totalt; } } fn Main() -> i32 { var p1: Sum = {.a = 5}; var totalt: i32 = p1. Add(5); Print(“Total summa {0}” , totalt); returnera 0; } |
Strukturer i Googles kolspråk:
Strukturtyper hjälper dig att identifiera medlemmar med namnet istället för deras index/position. De deklareras inom klamrar var name: auto = {.name1 = value1, .name2 = value2, … } och kan nås med namn.namn1 etc.
Exempel:
| 1 2 3 4 5 6 7 8 9 | paket ExplorerTest api; fn Main() -> i32 { var punkt: auto = {.x_axis = 0, .y_axis = 1}; punkt = {.x_axis = 5, .y_axis = -5}; var resultat: i32 = point.x_axis * point.x_axis + point.y_axis * point.y_axis; Print(“Resultat: {0}”, resultat); returnera 0; } |
Generics i Carbon programmeringsspråk:
Generika kan ses på många moderna språk. De definierar ett sätt att framkalla kontroller av kompileringstidstyp och hjälper till att definiera renare typvariabler. De kan deklareras med hjälp av T-parametertyperna visas nedan.
Exempel:
| 1 2 3 4 5 6 7 8 9 10 11 | paket ExplorerTest api; fn GenericExample[T:! Type](x: T) -> T { returnera x; } fn Main() -> i32 { Print(“Generisk heltalstyp {0}”, GenericExample(0)); Print(GenericExample(“Detta är en generisk sträng”)); returnera 0; } |
Minnessäkerhet i Carbon-språk:
Carbon language har ett stort fokus på minneshantering, särskilt när det kommer till minnessäkerhet. På en mycket hög nivå planerar kolspråk för att uppnå minnessäkerhet med hjälp av
Carbon language Felsökning av installationsfel
Carbon llvm-ar felfix:
| 1 2 3 4 5 6 7 8 9 10 11 | llvm är bara fat, vilket betyder att det inte var symboliskt länkat till /usr/local, eftersom macOS redan tillhandahåller denna programvara och att installera en annan version parallellt kan orsaka alla typer av problem. Om du behöver ha llvm först i din PATH, kör: echo ‘export PATH=”/usr/local/opt/llvm/bin:$PATH”‘ >> /Users/pramodnanduri/.bash_profile För att kompilatorer ska hitta llvm kan du behöver ställa in: export LDFLAGS=”-L/usr/local/opt/llvm/lib” export CPPFLAGS=”-I/usr/local/opt/llvm/include” |
För att lösa detta problem konfigurera filen ~/.bash_profile så att den har följande variabler
| 1 2 3 4 | export PATH=”/usr/local/opt/llvm/bin:$PATH” export LDFLAGS=”-L/usr/local/opt/llvm/lib” export CPPFLAGS=”-I/usr/local/opt/llvm/ inkluderar” export CC=$(vilket klingar) |
När du har sparat den, se till att köra källan ~/.bash_profile
Om du har andra fel, skriv en kommentar nedan. Ska kolla och svara tillbaka.
Utgivningsdatum för Carbon Language:
Även om kolspråk fortfarande är i experimentfasen, är det fortfarande oklart när det kommer att vara tillgängligt för allmänt bruk. Många grundläggande användningsexempel stöds fortfarande inte. Hoppas att det här kommer snart för att komma igång.
Slutsats:
Hoppas den här handledningen hjälper dig att leka och förstå de grundläggande begreppen, syntaxexempel med google carbon language. Även om detta inte är den fullständiga listan över syntax som stöds, medan vi experimenterar mer med funktionerna i Carbon, kommer vi att täcka det som en del av framtida artiklar. För alla typer av frågor eller kommentarer, skriv en kommentar nedan.
Vad kommer härnäst?
- Ett verkligt projekt byggt ovanpå stödda Carbon-språkfunktioner.
- Vi kommer att täcka Carbon-språkuppdateringar mycket noggrant med en free nyhetsbrev och detaljerade artiklar. Om du är intresserad av att lära dig mer om Carbon, skicka din e-post till vårt nyhetsbrev för att hålla koll på Carbon och de senaste förbättringarna.
Föreslagna artiklar:
Topp 10 mest älskade programmeringsspråk 2022 och vilka företag som använder dem
dbt (databyggverktyg) i ett verkligt scenario, dbt-handledning för nybörjare
PostgreSQL vs MySQL Syntax – En nybörjarguide för att använda postgres och mysql med jämförelse och exempel
Referenser:
Carbon language officiell github
Carbon language lansering på CppNorth Video
Vi hoppas att du gillar det här inlägget. Om du har några frågor eller förslag eller behöver annan ytterligare information, vänligen kommentera nedan.
