Golang 基礎語法介紹及對比（二）

傳值與傳參

Golong

func main() {
     a := 3

     fmt.Println("a = ", a)  // 應該輸出 "a= 3"

     a1 := add1(a)  //調用add1(x)

     fmt.Println("a+1 = ", a1) // 應該輸出"a+1 = 4"
     fmt.Println("a = ", a)    // 應該輸出"a = 3"
}

func add(a *int) int {
     *a = *a+1 // 咱們改變了a的值
     return *a //返回一個新值
}

func add1(a int) int {
     a = a+1 // 咱們改變了a的值
     return a //返回一個新值
}

C#

 static void Main(string[] args)
        {

            int a = 3;

           var r= add1(a);

            Console.WriteLine(r);
            Console.WriteLine(a);

            Console.ReadKey();
        }

    static int add(ref int a )
        {
            a = a + 1;
            return a;
        }
        static int add1(int a)
        {
            a = a + 1;
            return a;
        }

Javascript

Javascript能夠用變量做用域這塊來比較,函數內部做用域以及全局做用域

 var a=3;
function main()
{
  var r=add(a);
  alert("r:"+r+"\r\n"+"a:"+a);
}

function add(a){
  a= a+1;
  return a; 
}

 var a=3;
function main()
{
  var r=add(a);
  alert("r:"+r+"\r\n"+"a:"+a);
}

function add(x){
  a= x+1;
  return a; 
}

 這裏還有一個有不一樣的地方就是C#與Golang在Class、Struct

在C#中Class就是引用類型，C#中的Struct也是值類型的，Golang中的Struct就相似C#中的Struct，下面來看下這幾種輸出結果

C# Class

因此這裏給不給ref都是同樣的結果，都會變成引用類型

static void Main(string[] args)
        {
            var test = new TestObject { name = "黎又銘", age = 23 };
           var t=  Con(test);
         //   var t1 = Con(ref test);
            Console.WriteLine(t.name);
            Console.WriteLine(test.name);
            Console.ReadKey();
        }
static TestObject Con(TestObject testObject)
        {

            testObject.name = "張三";
            return testObject;

        }

        static TestObject Con(ref TestObject testObject)
        {
            testObject.name = "張三";
            return testObject;

        }

C# Struct

用Struct來輸入就發現其實用ref 與不用輸出的結果就不同了

public struct TestObjectB
    {
        public string name { get; set; }
        public int age { get; set; }
    }
 static TestObjectB Con(TestObjectB testObject)
        {

            testObject.name = "張三";
            return testObject;

        }

        static TestObjectB Con(ref TestObjectB testObject)
        {
            testObject.name = "張三";
            return testObject;

        }

 static void Main(string[] args)
        {
            var test = new TestObjectB { name = "黎又銘", age = 23 };
    
 

           var t=  Con(test);
         //  var t1 = Con(ref test);

            Console.WriteLine(t.name);
            Console.WriteLine(test.name);

            Console.ReadKey();
        }

Golang Struct

這裏咱們來看看Golang中的寫法，在使用TestZZ獲得的結果是不一樣的

func main() {


     test:=TestObject{"黎又銘",22 }

     t:= TestZZ1(test)
     //     t:= TestZZ(&test)
     f.Println(t.name)
     f.Println(test.name)
     
}
func TestZZ(test *TestObject) *TestObject {

test.name="zhangsan"
return test
}
func TestZZ1(test TestObject) TestObject{

     test.name="zhangsan"
     return test
}

 

函數申明

Golang

func testMethod(arg1 int) int {

方法體
}
//解析：
方法關鍵字  方法名稱(參數1 參數1類型) 返回值
{
方法體
}

Golang 返回參數能夠是多個

 

C#

public int testMethod(int arg1)
{

}

//解析：
訪問關鍵字  返回值  方法名稱（參數1類型 參數1）
{
   方法體
}

C#返回參數只能是一個，若是是多個須要用對象類定義

 

Javascript

 

function testMethod(arg1){

方法體

}
//解析：
能夠返回任意類型，弱類型語言，固然也能夠返回 function ,{} ,[]

變量聲明

Golong

var a int32 =1
var a int32  默認就是0
申明的變量都是須要使用的，否則會出現編譯錯誤
var a bool
     fmt.Print(a)  -- false
var a int32
     fmt.Print(a)  0

Golang中提供了多變量申明以及簡潔方式聲明省略掉了 var以及類型
如：    a:=1   或 多個   a,b:=1,3

 

C#

int  a;
int a=1;
var a=1;
var bol=true;
int b=3,b1=1;

申明的變量是能夠不用的,若是使用就須要對局部變量賦值

 

Javascript

var a=1;
var a=1,b=2;
var a; 
javascript也是能夠申明多個變量的

變參

Golang

Golang中用了 ...int 這樣的形式
func main() {
     sum:= Sum(1,2,3,4)
     fmt.Println(sum) //10
}
func  Sum(arg1 ...int) int {
sum:=0
for _,x := range arg1 {
     sum+=x
} 
return sum
}

 

 

C#

 

這裏參數須要使用關鍵字 params 以下
 static int Sum(params int[] a)
        {
            int sum = 0;
            foreach(var item in a)
            {
                sum += item;
            }
            return sum;
        }
static void Main(string[] args)
        {
           var r= Sum(1, 2, 3, 4);
            Console.WriteLine(r);  //10
            Console.ReadKey();
        }

 

 

Javascript

 

Javascript變參能夠用arguments與 apply和call 來理解，可是這裏最趨近於apply,由於call仍是要給個數，而apply給的是數組

function Sum()
{
  var sum=0;
  for(var i=0;i<arguments.length;i++)
{
  sum+=arguments[i];  
}
  return sum;
}
alert(Sum.apply(this,[1,2,3,4]));

 

 

面向對象 

Golang

type TestObject struct{
   name string
   age int
}

func main() {
     test:=TestObject{name:"黎又銘",age:23 }
    f.Println("姓名", test.name)
}
golang在這裏也能夠這樣寫：
person:=TestObject{"黎又銘",12 } 不用寫名稱，相似構造函數，可是須要注意順序問題

 

type TestObject struct{
   name string
   age int

}

type TestObjectB struct{
     name string
     age int
 
 }

func (test TestObject) print()   {
     f.Println(test.name) 
     

}
func (testb TestObjectB) print()   {
     f.Println( testb.name) 
     
}

func main() {


     test:=TestObject{"黎又銘",22 }
     testb:=TestObjectB{"徐潔敏",12 }
     test.print()
     testb.print()
     
}

 分別在 TestOjbect 或 TestObjectB 下添加的方法 print，而

func (test TestObject) print()

 （test TestObject） 這種語法指定了調用者，C#中就像是在類中添加方法同樣

C#

 

 public class TestObject{
        public string name { get; set; }
        public int age { get; set; }
    }
static void Main(string[] args)
        {
            var test = new TestObject { name = "黎又銘", age = 23 };
            Console.WriteLine("姓名：" + test.name);
            Console.ReadKey();
        }

 

   public class TestObject{
        public string name { get; set; }
        public int age { get; set; }
    }
    public class TestObjectB
    {
        public string name { get; set; }
        public int age { get; set; }
    }
    public static class Extensions {
        public static string print(this TestObject test)
        {
            return test.name;
        }
        public static string print(this TestObjectB testb)
        {
            return testb.name;
        }
    }
   static void Main(string[] args)
        {
            var test = new TestObject { name = "黎又銘", age = 23 };
            var testb = new TestObjectB { name = "徐潔敏", age = 21 };
            var t = test.print();
            var tb = testb.print();
            Console.WriteLine(t);
            Console.WriteLine(tb);
            Console.ReadKey();
        }

修正：可能用擴展來表達不合理，這裏就是在類中添加方法，表示這個類中的方法，這裏咱們用了擴展不合理

 

 

Javascript

 

function testObject(n,a)
{
  this.name=n;
  this.age=a;
  
}
var test=new testObject("黎又銘",23);
alert(test.name);

function testObject(n,a)
{
  this.name=n;
  this.age=a;
  
}
function testObjectB(n,a)
{
  this.name=n;
  this.age=a;
  
}
testObject.prototype.print=function(){ 
  alert(this.name);
}
testObjectB.prototype.print=function(){
  alert(this.name); 
}
var test=new testObject("黎又銘",31);
test.print();
var testb=new testObjectB("徐潔敏",31);
testb.print();

在Javascript 用原型鏈方法來對於Golang中的

 C# 函數做爲參數傳遞（委託）

delegate void TestMethod(int x);
       
        public static void mytest(int a)
        {
            Console.WriteLine(a);
        }
        public static void mytest1(int a)
        {
            Console.WriteLine("ddd"+a);
        }
        static void Main(string[] args)
        {
            TestMethod testMethod= new TestMethod(mytest);
            testMethod += new TestMethod(mytest1);
            testMethod?.Invoke(1);
        }

Golang 函數做爲值、類型

type testMethod func(int) int
func testprint(a int) int{
     f.Println(a)
     return a*a;
}
func testprint1(a int) int{

     f.Println(a)
     return a+a;
}
func test(t testMethod) int{
     x:=  t(4)
     return x
}
func main() {
          x:=  test(testprint)
          x1:=  test(testprint1)
          f.Println(x)
          f.Println(x1)
}