传值与传参
Golong
func main() {
a :=
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+ // 我们改变了a的值
return *a //返回一个新值
}
func add1(a int) int {
a = a+ // 我们改变了a的值
return a //返回一个新值
}
C#
static void Main(string[] args)
{ int a = ; var r= add1(a); Console.WriteLine(r);
Console.WriteLine(a); Console.ReadKey();
} static int add(ref int a )
{
a = a + ;
return a;
}
static int add1(int a)
{
a = a + ;
return a;
}
Javascript
Javascript可以用变量作用域这块来比较,函数内部作用域以及全局作用域
var a=;
function main()
{
var r=add(a);
alert("r:"+r+"\r\n"+"a:"+a);
} function add(a){
a= a+;
return a;
}
var a=;
function main()
{
var r=add(a);
alert("r:"+r+"\r\n"+"a:"+a);
} function add(x){
a= x+;
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 = };
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 = }; 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{"黎又铭", }
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 =
var a int32 默认就是0
申明的变量都是需要使用的，不然会出现编译错误
var a bool
fmt.Print(a) -- false
var a int32
fmt.Print(a) Golang中提供了多变量申明以及简洁方式声明省略掉了 var以及类型
如： a:= 或 多个 a,b:=,
C#
int a;
int a=;
var a=;
var bol=true;
int b=,b1=; 申明的变量是可以不用的,如果使用就需要对局部变量赋值
Javascript
var a=;
var a=,b=;
var a;
javascript也是可以申明多个变量的
变参
Golang
Golang中用了 ...int 这样的形式
func main() {
sum:= Sum(,,,)
fmt.Println(sum) //
}
func Sum(arg1 ...int) int {
sum:=
for _,x := range arg1 {
sum+=x
}
return sum
}
C#
这里参数需要使用关键字 params 如下
static int Sum(params int[] a)
{
int sum = ;
foreach(var item in a)
{
sum += item;
}
return sum;
}
static void Main(string[] args)
{
var r= Sum(, , , );
Console.WriteLine(r); //
Console.ReadKey();
}
Javascript
Javascript变参可以用arguments与 apply和call 来理解，但是这里最趋近于apply,因为call还是要给个数，而apply给的是数组 function Sum()
{
var sum=;
for(var i=;i<arguments.length;i++)
{
sum+=arguments[i];
}
return sum;
}
alert(Sum.apply(this,[,,,]));
面向对象
Golang
type TestObject struct{
name string
age int
}
func main() {
test:=TestObject{name:"黎又铭",age: }
f.Println("姓名", test.name)
}
golang在这里也可以这样写：
person:=TestObject{"黎又铭", } 不用写名称，类似构造函数，但是需要注意顺序问题
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{"黎又铭", }
testb:=TestObjectB{"徐洁敏", }
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 = };
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 = };
var testb = new TestObjectB { name = "徐洁敏", age = };
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("黎又铭",);
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("黎又铭",);
test.print();
var testb=new testObjectB("徐洁敏",);
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();
}
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()
return x
}
func main() {
x:= test(testprint)
x1:= test(testprint1)
f.Println(x)
f.Println(x1)
}