精华内容
下载资源
问答
  • C语言函数返回值与参数传递

    千次阅读 2019-10-26 11:57:43
    C语言函数返回值与参数传递 一:参数传递 C语言的函数中必不可少的就是参数传递,可以采用传值和传指针两种方式。 1.传值的形式:只是将参数值的拷贝传给函数,并非参数本体如: int test(int x,int y) { x=2*y; ...

    C语言函数返回值与参数传递

    一:参数传递

    C语言的函数中必不可少的就是参数传递,可以采用传值和传指针两种方式。
    1.传值的形式:只是将参数值的拷贝传给函数,并非参数本体如:

    int test(int x,int y)
    {
        x=2*y;
        return x;
    }
    int main(void)
    { 
        int a=0,b=5;
        printf("%d,%d\n\r",test(a,b),a);
    	return 0;
    }
    

    运行结果为:
    10,0
    即传值方式只可以将实参传递给函数,不可以改变实参本身。

    2.传指针形式:直接传给函数的是变量的地址。
    如:

    int a(int b,int *c)
    {
        int i=0;
        for(i=0;i<4;i++)
            c[i]=b*i;
        return 0;
        
    }
    int main(void)
    { 
        int b=2,c[4],i;
        a(b,c);
        for(i=0;i<4;i++)
    	    printf("Data is -> %d\n\r",c[i]);
    	return 0;
    }
    

    运行结果为:
    Data is -> 0
    Data is -> 2
    Data is -> 4
    Data is -> 6

    由于被调函数在参数指针的作用域之内,此时可以直接改变变量的本体。

    二:返回值

    函数除了参数传递还有返回值,既可以返回变量值也可以返回地址。
    1.返回变量
    如:

    int a(int b)
    {
        int i=5;
        return 5*b;
    }
    int main(void)
    { 
        int b=2;
    	printf("Data is -> %d\n\r",a(b));
    	return 0;
    }
    

    运行结果

    Data is -> 10

    2.返回地址

    int *test(int b)
    {
        int i=0,buf[4];
        for(i=0;i<4;i++)
            buf[i]=b*i;
        return buf;
        
    }
    int main(void)
    { 
        int  b=2;
        int *p;
        int  i=0;
        p=test(b);
        for(i=0;i<4;i++)
        	printf("%d ,%d \n\r",p[i],test(b));
    	return 0;
    }
    

    运行结果
    0 ,1084896256
    2 ,1084896256
    4 ,1084896256
    6 ,1084896256

    另外不能返回局部变量地址。

    int *buf()
    {
    	 int dad;
    	 double buf[3][2];
    	 dad=sizeof(buf);
      	 return &dad;//error:由于dad是局部变量,函数结束后释放。
    }
    
    展开全文
  • java中的参数传递(只有值传递没有引用传递)

    万次阅读 多人点赞 2019-07-31 19:25:14
    Java中只有传值调用(值传递),没有传址调用(址传递或者引用传递)。所以在java方法中改变参数的值是不会改变原变量的值的,但为什么改变引用变量的属性值却可以呢?请看下面的解答。 java中的数据类型 Java中...

    Java中只有传值调用(值传递),没有传址调用(址传递或者引用传递)。所以在java方法中改变参数的值是不会改变原变量的值的,但为什么改变引用变量的属性值却可以呢?请看下面的解答。

    java中的数据类型

    Java中数据类型分为两大类:基本类型和引用类型。相应的,变量也分这两种类型:基本类型和引用类型。

    基本类型的变量保存原始值,即它代表的值就是数值本身;

    而引用类型的变量保存的值是引用值,"引用值"指向内存空间的地址,代表了某个对象的引用,而不是对象本身,对象本身存放在这个引用值所表示的地址的位置。

    基本类型包括:byte,short,int,long,char,float,double,Boolean,returnAddress。

    引用类型包括:类、接口类型和数组。

    java中只有值传递

    在日常编码中,会经常看到如下现象:

    1、对于基本类型参数,在方法体内对参数进行重新赋值,不会改变原有变量的值。

    2、对于引用类型参数,在方法体内对参数进行重新赋予引用,不会改变原有变量所持有的引用。

    3、方法体内对参数进行运算,不会改变原有变量的值。

    4、对于引用类型参数,方法体内对参数所指向对象的属性进行操作,将改变原有变量所指向对象的属性值。

    举个例子:

    public class Main {
    
        private static void getMiddleOne(boolean b, Boolean boo, Boolean[] arr){
    
            b = true;
    
            boo = new Boolean(true);
    
            arr[0] = true;
    
        }
    
           //测试
    
        public static void main(String[] args) {
    
            boolean b = false;
    
            Boolean boo = new Boolean(false);
    
            Boolean[] arr = new Boolean[]{false};
    
            getMiddleOne(b, boo, arr);
    
            System.out.println(b);
    
            System.out.println(boo.toString());
    
            System.out.println(arr[0]);
    
            /**
    
            * output:
    
            * false
    
            * false
    
            * true
    
            */
    
        }
    
    }

    我们只要了解了下面两点就可以解答上面的现象了:

    1、基本数据类型的值就是数值本身,所以示例中的b的值就是false;包装类因为会自动装箱拆箱,所以可以和基本类型一样处理,所以示例中boo的值就是false;数组是引用类型,所以arr的值就是指向该Boolean[]的引用。

    2、java中只有值传递没有引用传递,所以传入getMiddleOne方法的三个参数分别是b的值拷贝, boo的值拷贝, arr的值拷贝。

    通过上面两点就可以清楚了,getMiddleOne方法中执行的 b=true 和 boo = new Boolean(true) 都是把新值赋给了他们的拷贝,所以不改变原变量的值;同样,arr[0] = true 是把true复制给了arr的拷贝所指向的数组的第一个元素,arr的值和arr的拷贝的值都是该数组的引用,所以arr的拷贝所指向的数组和arr所指向的数组是同一个,所以改变arr的拷贝的数组的元素会同样影响到原变量arr。

    总结

    java中只有值传递,基本类型传递的是值的副本,引用类型传递的是引用的副本。

     

    展开全文
  • C#调用C++的dll实例,回调函数,string和int数组参数传递,在vs2010下调试通过,总结在这里,供大家参考。
  • SpringBoot前后端分离参数传递方式总结

    千次阅读 多人点赞 2020-11-26 21:39:50
    因为总是需要使用不同的参数传递方式,所以特地来总结一下SpringBoot中常用的传递参数的方式。 SpringBoot参数传递 注意:虽然Restful风格很流行,但是大部分还是主要是GET和POST的内容,所以这里只是列举GET和POST...

    前言: 因为总是需要使用不同的参数传递方式,所以特地来总结一下SpringBoot中常用的参数的绑定方式,给有需要的朋友查阅。

    SpringBoot参数传递

    在这里插入图片描述

    注意:虽然Restful风格很流行,但是大部分还是主要是GET和POST的内容,所以这里只是列举GET和POST请求为例。 而且,无论怎么样的花样传参,它都是符合上面这个报文结构的!正所谓:万变不离其宗嘛!

    GET请求方式

    注意:我这里是示例形式是:代码+Postman测试截图+Fiddler抓包截图。

    01.单个键值对参数

    /**
     * GET 方式传递参数  单个参数
     * */
    @GetMapping("/get01")
    public String get01(String comment) {
    	return comment == null ? "no parameter" : comment;
    }
    

    请求不带参数
    在这里插入图片描述

    请求报文中也没有数据,响应报文体中有数据
    在这里插入图片描述

    请求带参数
    在这里插入图片描述

    请求携带数据,数据在请求行中,注意数据被编码了
    在这里插入图片描述

    使用了@RequestParam注解,请求必须携带参数,否则就会报错,否则就是:错误码400 Bad Request

    @GetMapping("/get02")
    public String get02(@RequestParam("comment") String comment) {
    	return comment;
    }
    

    请求不携带参数,请求错误 400 Bad Reqeust
    在这里插入图片描述

    请求携带参数,接收成功
    在这里插入图片描述
    请求和响应报文
    在这里插入图片描述

    如果参数不添加 @RequestParam 注解,那么这个参数即可不传递,而使用了注解的话,默认是必须传递参数的,当然了也可以配置为false。但是,我倾向于还是显示使用注解,这样比较清晰,也可配置,更加灵活。

    在这里插入图片描述

    02.多个键值对参数

    /**
     * GET 方式传递参数  多个参数
     * */
    @GetMapping("/get03")
    public String get03(@RequestParam("id") String id,
    		@RequestParam("name") String name,
    		@RequestParam("comment") String comment) {
    	System.out.println(id + " " + name + " " + comment);		
    	return id + " " + name + " " + comment;
    }
    

    请求行携带多个参数
    在这里插入图片描述

    请求和响应报文
    在这里插入图片描述

    03.键值对映射对象

    /**
     *  使用对象对参数进行封装,这样在多个参数时,优势很明显。
     *  但是这里无法使用 @RequestParam注解,否则会出错。
     * */
    @GetMapping("/get04")
    public Comment get04(Comment comment) {
    	if (Objects.isNull(comment)) {
    		return null;  // 需要对 null 值进行处理
    	}
    	System.out.println(comment);
    	return comment;
    }
    

    请求携带多个参数,直接映射成对象,但是这里无法使用@RequestParam,同时也无法使用@RequestBody,因为参数不在请求体中,至于为什么无法使用,暂时还没明白!
    在这里插入图片描述

    请求和响应报文
    在这里插入图片描述

    因为没有使用注解,可以不携带参数
    在这里插入图片描述

    04.键值对映射Map

    /**
      * 使用对象封装参数要求必须具有一个对象,所以可以使用 Map 来封装,这样可以减少对象的数
      * 量。 
      * * */
    @GetMapping("/get05")
    public Map<String, String> get05(@RequestParam Map<String, String> map) {
    	map.forEach((k, v) -> {
    		System.out.println(k + " --> " + v);
    	});
    	System.out.println(map.size());
    	return map;
    }
    

    在这里插入图片描述

    多个键值对参数
    在这里插入图片描述

    请求和响应报文
    在这里插入图片描述

    05.路径参数

    /**
     * 参数和路径结合,适用于单个参数的情况
     * */
    @GetMapping("/get06/{id}")
    public Comment getById(@PathVariable("id") String id) {
    	Comment comment = new Comment();
    	comment.setId(id);
    	comment.setName("Alfred");
    	comment.setComment("I love you yesterday and today!");
    	return comment;
    }
    

    请求直接写在路径上,成为路径的一部分
    在这里插入图片描述

    请求和响应体

    注: 请求参数就在路径上面。
    在这里插入图片描述
    在这里插入图片描述

    06.返回值为二进制

    前面都是文本数据,现在我们尝试来获取二进制数据,注意这个方法需要下面的上传文件方法向上传文件,或者你自己在文件夹下面放入一个文件。

    /**
     * 返回值为二进制
     * 其实这里可以使用 Files.readAllBytes()这个方法,这样就简单了。这里我就不改了,我习惯了使用这种
     * 循环读取的方式,不过确实有点繁琐了。
     * */
    @GetMapping("/get07/{name}")
    public void getFile(@PathVariable("name") String name, HttpServletResponse response) {
    	try (OutputStream out = new BufferedOutputStream(response.getOutputStream())) {
    		try (InputStream in = new BufferedInputStream(new FileInputStream(new File(baseDir, name)))) {
    			int len = 0;
    			byte[] data = new byte[4*1024];
    			while ((len = in.read(data)) != -1) {
    				out.write(data, 0, len);
    			}
    		}
    	} catch (IOException e) {
    		e.printStackTrace();
    	}
    }
    

    响应体中含有图片的数据
    在这里插入图片描述

    请求体报文
    在这里插入图片描述

    响应报文,注意图片的二进制数据无法解码,会显示出乱码的效果
    在这里插入图片描述

    使用ImageView的方式查看图片
    在这里插入图片描述

    POST请求方式

    01.多个键值对参数

    /**
     * POST方式传递参数
     * @return 
     * */
    @PostMapping("/post01")
    public String post01(@RequestParam("id") String id,
    		@RequestParam("name") String name,
    		@RequestParam("comment") String comment) {
    	System.out.println(id + " " + name + " " + comment);		
    	return id + " " + name + " " + comment;
    }
    

    请求体中携带键值对参数,注意Content-Type类型
    在这里插入图片描述

    请求参数以键值对的形式放在请求体中,注意它也是被编码的
    在这里插入图片描述

    请求体中携带键值对参数,注意Content-Type类型为form-data

    在这里插入图片描述

    请求体中的数据以表单数据的形式存放,注意其形式
    在这里插入图片描述

    02.键值对映射Map

    @PostMapping("/post02")
    public Map<String, String> post02(@RequestParam Map<String, String> map) {
    	map.forEach((k, v) -> {
    		System.out.println(k + " --> " + v);
    	});
    	return map;
    }
    

    Content-Type选择:form-data
    在这里插入图片描述

    在这里插入图片描述

    Content-Type选择:x-www-form-urlencoded

    在这里插入图片描述

    在这里插入图片描述

    03.传递json数据映射对象

    @PostMapping("/post03")
    public Comment post03(@RequestBody Comment comment) {
    	System.out.println(comment);
    	return comment;
    }
    

    请求参数形式为json字符串,并且选择Content-Type选择 raw,不能选择其它形式的原因的,form-data和x-www-form-urlencoded都会改变请求参数,通过上面的对比都能看出来了。

    在这里插入图片描述

    请求体中的数据就是原始的传递数据,并不会改变
    在这里插入图片描述

    04.json数组映射对象数组

    /**
     * 传递对象数组
     * */
    @PostMapping("/post04")
    public Comment[] post04(@RequestBody Comment[] comments) {
    	return comments;
    }
    

    请求参数为一个json数组,这个东西以前可是难到我了,我去网上找了一个直接映射成List的写法,但是后来遇到这个问题我一想,既然单个json是一个对象,那么json数组,不就是一个对象数组吗?试了一下,果然是这样的!
    在这里插入图片描述
    在这里插入图片描述

    05.json数组映射List

    @PostMapping("/post05")
    public List<Comment> post05(@RequestBody List<Comment> commentList) {
    	return commentList;
    }
    

    请求参数直接映射成List
    在这里插入图片描述
    在这里插入图片描述

    06.传递二进制数据(文件)

    /**
     * 传递二进制数据
     * */
    @PostMapping("/upload")
    public String uploadFile(@RequestParam("file") MultipartFile file) {	
    	if (!file.isEmpty()) {
    		String fileName = file.getOriginalFilename();
    		try {
    			file.transferTo(new File(baseDir, fileName)); // 对于 SpringBoot 中使用路径还是懵逼!
    			return "success";
    		} catch (IllegalStateException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	} 
    	return "Fail";
    }
    

    以前使用Servlet的时候,上传文件是很复杂的,后来Servlet3.0中进行了改进,现在框架又进行了进一步的封装,使用起来更加方便了。
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    请求报文
    在这里插入图片描述
    在这里插入图片描述

    8.表单数据(文本+文件)

    /**
     *  表单数据,含文本和二进制
     * */
    @PostMapping("/submitInfo01")
    public String submitInfo(@RequestParam("id") String id,
    		@RequestParam("name") String name,
    		@RequestParam("file") MultipartFile file) {
    	
    	System.out.println("id: " + id);
    	System.out.println("name: " + name);
    	System.out.println("fileName: " + file != null ? file.getOriginalFilename() : "null");
    	
    	if (!file.isEmpty()) {
    		String fileName = file.getOriginalFilename();
    		try {
    			file.transferTo(new File(baseDir, fileName));
    			return "success";
    		} catch (IllegalStateException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	} 
    	return "Fail";
    }
    

    表单通常是可以携带不同的数据,主要是因为它的形式很适合这样做,所以可以同时接收文件和文本数据。表单数据使用一个boundary来隔开不同的数据。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    09.表单数据,进一步封装成对象

    上面那样如果表单项比较多的话,映射还是比较麻烦的,可以选择创建一个对象封装所有的属性,这样处理起来就会更加方便,并且也是面向对象思想的应用。

    /**
     *    表单数据,含文本和二进制 进一步封装!
     * */
    @PostMapping("/submitInfo02")
    public String submitInfo02(User user) {
    	
    	MultipartFile file = user.getFile();
    	System.out.println("id: " + user.getId());
    	System.out.println("name: " + user.getName());
    	System.out.println("fileName: " + user != null ? file.getOriginalFilename() : "null");
    	
    	if (!file.isEmpty()) {
    		String fileName = file.getOriginalFilename();
    		try {
    			file.transferTo(new File(baseDir, fileName));
    			return "success";
    		} catch (IllegalStateException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	} 
    	return "Fail";
    }
    

    在这里插入图片描述

    在这里插入图片描述

    10.ajax2.0传递二进制数据

    /**
     * POST以二进制形式传递文件,通常的web表单是做不到的,但是ajax2.0以后是支持的,我们来尝试一下。
     * 注意它和 Multipart的区别,Multipart实际上不只包含文件本身的数据,还有文件的其它的信息,例如刚才获取的文件名。
     * 但是如果以二进制的形式传递,它就是完全的文件数据流,不包含任何其它信息,只有文件本身的二进制数据流。
     * 
     * 使用这种形式,只能传输单个文件,无法传输多个文件,因为它只是文件本身的二进制数据,如果是多个的话,
     * 那么谁也别想从一个连续的二进制流中把图片切分出来了。
     * */
    @PostMapping("/binaryFile")
    public String binaryFile(@RequestBody byte[] fileData) {
    	try {
    		Files.write(Paths.get(baseDir, UUID.randomUUID().toString() + ".jpg"), fileData);
    		return "success";
    	} catch (IOException e) {
    		e.printStackTrace();
    		return e.getMessage();
    	}
    }
    

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    baseDir路径下的文件

    在这里插入图片描述

    增补拾遗

    GET请求方式,也是可以在映射请求体中的数据的,但是对报文的Content-Type有要求,并且不推荐这样使用!

    /**
     *  使用对象对参数进行封装,这样在多个参数时,优势很明显。
     *  但是这里无法使用 @RequestParam注解,否则会出错。
     * */
    @GetMapping("/get04")
    public Comment get04(Comment comment) {
    	if (Objects.isNull(comment)) {
    		return null;  // 需要对 null 值进行处理
    	}
    	System.out.println(comment);
    	return comment;
    }
    

    Content-Type: x-www-form-urlencoded

    注:无法接收参数
    在这里插入图片描述

    在这里插入图片描述

    Content-Type: form-data
    注:可以接收数据。
    在这里插入图片描述
    在这里插入图片描述

    /**
      * 使用对象封装参数要求必须具有一个对象,所以可以使用 Map 来封装,这样可以减少对象的数
      * 量。 
      * * */
    @GetMapping("/get05")
    public Map<String, String> get05(@RequestParam Map<String, String> map) {
    	map.forEach((k, v) -> {
    		System.out.println(k + " --> " + v);
    	});
    	System.out.println(map.size());
    	return map;
    }
    

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    GET请求,但是数据在请求体中

    这种方式违背了通常的web数据传输,因为我们通常是规定GET方式没有请求体,POST方式数据在请求体中的。但是GET方式是可以有请求体的,POST方式也可以把参数方式放到请求行中,甚至于GET和POST的请求行和请求体中都可以携带数据。但是这样的话,可就苦了前端了,因为表单的发送请求的形式基本是固定的,出了ajax可以多一些花样。所以,如果你是一个GET请求,但是使用@RequestBody来接收参数,这个可就够前端难受的了。年轻人要讲究武德,不要乱用,但是不是不能用,如果不是Web项目,那就可以随便用了。

    @GetMapping("/not_use_like_this")
    public Comment not_use_like_this(@RequestBody Comment comment) {
    	System.out.println(comment);
    	return comment;
    }
    

    在这里插入图片描述

    在这里插入图片描述

    全部代码

    目录结构

    package request_learn;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class LearnApplication {
    	
    	public static void main(String[] args) {
    		SpringApplication.run(LearnApplication.class, args);
    	}
    	
    }
    
    
    package request_learn.entity;
    
    import java.io.Serializable;
    
    public class Comment implements Serializable {
    
    	private static final long serialVersionUID = 1L;
    	
    	private String id;
    	private String name;
    	private String comment;
    	
    	// 省略getter、setter和toString方法
    }
    
    
    package request_learn.entity;
    
    import org.springframework.web.multipart.MultipartFile;
    
    public class User {
    	
    	private String id;
    	private String name;
    	private MultipartFile file;
    	
    	// 省略getter、setter和toString方法
    }
    
    
    package request_learn.controller;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    import java.util.List;
    import java.util.Map;
    import java.util.Objects;
    import java.util.UUID;
    
    import javax.servlet.http.HttpServletResponse;
    
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.multipart.MultipartFile;
    
    import request_learn.entity.Comment;
    import request_learn.entity.User;
    
    @RestController
    @RequestMapping("/test")
    public class LearnController {
    
    	private static final String baseDir = "D:/test/img/";
    	
    	/**
    	 * GET 方式传递参数  单个参数
    	 * */
    	@GetMapping("/get01")
    	public String get01(String comment) {
    		return comment == null ? "no parameter" : comment;
    	}
    	
    	
    	@GetMapping("/get02")
    	public String get02(@RequestParam("comment") String comment) {
    		return comment;
    	}
    	
    	/**
    	 * GET 方式传递参数  多个个参数
    	 * */
    	@GetMapping("/get03")
    	public String get03(@RequestParam("id") String id,
    			@RequestParam("name") String name,
    			@RequestParam("comment") String comment) {
    		System.out.println(id + " " + name + " " + comment);		
    		return id + " " + name + " " + comment;
    	}
    	
    	/**
    	 *  使用对象对参数进行封装,这样在多个参数时,优势很明显。
    	 *  但是这里无法使用 @RequestParam注解,否则会出错。
    	 * */
    	@GetMapping("/get04")
    	public Comment get04(Comment comment) {
    		if (Objects.isNull(comment)) {
    			return null;  // 需要对 null 值进行处理
    		}
    		System.out.println(comment);
    		return comment;
    	}
    	
    	/**
    	 * 使用对象封装参数要求必须具有一个对象,所以可以使用 Map 来封装,这样可以减少对象的数量。
    	 * */
    	@GetMapping("/get05")
    	public Map<String, String> get05(@RequestParam Map<String, String> map) {
    		map.forEach((k, v) -> {
    			System.out.println(k + " --> " + v);
    		});
    		System.out.println(map.size());
    		return map;
    	}
    	
    	/**
    	 * 参数和路径结合,适用于单个参数的情况
    	 * */
    	@GetMapping("/get06/{id}")
    	public Comment getById(@PathVariable("id") String id) {
    		Comment comment = new Comment();
    		comment.setId(id);
    		comment.setName("Alfred");
    		comment.setComment("I love you yesterday and today!");
    		return comment;
    	}
    	
    	/**
    	 * 返回值为二进制
    	 * */
    	@GetMapping("/get07/{name}")
    	public void getFile(@PathVariable("name") String name, HttpServletResponse response) {
    		try (OutputStream out = new BufferedOutputStream(response.getOutputStream())) {
    			try (InputStream in = new BufferedInputStream(new FileInputStream(new File(baseDir, name)))) {
    				int len = 0;
    				byte[] data = new byte[4*1024];
    				while ((len = in.read(data)) != -1) {
    					out.write(data, 0, len);
    				}
    			}
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	
    	/**
    	 * POST方式传递参数
    	 * @return 
    	 * */
    	@PostMapping("/post01")
    	public String post01(@RequestParam("id") String id,
    			@RequestParam("name") String name,
    			@RequestParam("comment") String comment) {
    		System.out.println(id + " " + name + " " + comment);		
    		return id + " " + name + " " + comment;
    	}
    	
    	@PostMapping("/post02")
    	public Map<String, String> post02(@RequestParam Map<String, String> map) {
    		map.forEach((k, v) -> {
    			System.out.println(k + " --> " + v);
    		});
    		return map;
    	}
    	
    	
    	@PostMapping("/post03")
    	public Comment post03(@RequestBody Comment comment) {
    		System.out.println(comment);
    		return comment;
    	}
    	
    	
    	/**
    	 *    传递二进制数据
    	 * */
    	@PostMapping("/upload")
    	public String uploadFile(@RequestParam("file") MultipartFile file) {	
    		if (!file.isEmpty()) {
    			String fileName = file.getOriginalFilename();
    			try {
    				file.transferTo(new File(baseDir, fileName)); // 对于 SpringBoot 中使用路径还是懵逼!
    				return "success";
    			} catch (IllegalStateException e) {
    				e.printStackTrace();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		} 
    		return "Fail";
    	}
    	
    	
    	/**
    	 * 传递对象数据
    	 * */
    	@PostMapping("/post04")
    	public Comment[] post04(@RequestBody Comment[] comments) {
    		return comments;
    	}
    	
    	@PostMapping("/post05")
    	public List<Comment> post05(@RequestBody List<Comment> commentList) {
    		return commentList;
    	}
    	
    	
    	/**
    	 *    表单数据,含文本和二进制
    	 * */
    	@PostMapping("/submitInfo01")
    	public String submitInfo(@RequestParam("id") String id,
    			@RequestParam("name") String name,
    			@RequestParam("file") MultipartFile file) {
    		
    		System.out.println("id: " + id);
    		System.out.println("name: " + name);
    		System.out.println("fileName: " + file != null ? file.getOriginalFilename() : "null");
    		
    		if (!file.isEmpty()) {
    			String fileName = file.getOriginalFilename();
    			try {
    				file.transferTo(new File(baseDir, fileName));
    				return "success";
    			} catch (IllegalStateException e) {
    				e.printStackTrace();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		} 
    		return "Fail";
    	}
    	
    	/**
    	 *    表单数据,含文本和二进制 进一步封装!
    	 * */
    	@PostMapping("/submitInfo02")
    	public String submitInfo02(User user) {
    		
    		MultipartFile file = user.getFile();
    		System.out.println("id: " + user.getId());
    		System.out.println("name: " + user.getName());
    		System.out.println("fileName: " + user != null ? file.getOriginalFilename() : "null");
    		
    		if (!file.isEmpty()) {
    			String fileName = file.getOriginalFilename();
    			try {
    				file.transferTo(new File(baseDir, fileName));
    				return "success";
    			} catch (IllegalStateException e) {
    				e.printStackTrace();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		} 
    		return "Fail";
    	}
    	
    	/**
    	 * POST以二进制形式传递文件,通常的web表单是做不到的,但是ajax2.0以后是支持的,我们来尝试一下。
    	 * 注意它和 Multipart的区别,Multipart实际上不只包含文件本身的数据,还有文件的其它的信息,例如刚才获取的文件名。
    	 * 但是如果以二进制的形式传递,它就是完全的文件数据流,不包含任何其它信息,只有文件本身的二进制数据流。
    	 * 
    	 * 使用这种形式,只能传输单个文件,无法传输多个文件,因为它只是文件本身的二进制数据,如果是多个的话,
    	 * 那么谁也别想从一个连续的二进制流中把图片切分出来了。
    	 * */
    	@PostMapping("/binaryFile")
    	public String binaryFile(@RequestBody byte[] fileData) {
    		try {
    			Files.write(Paths.get(baseDir, UUID.randomUUID().toString() + ".jpg"), fileData);
    			return "success";
    		} catch (IOException e) {
    			e.printStackTrace();
    			return e.getMessage();
    		}
    	}
    	
    	
    	@GetMapping("/not_use_like_this")
    	public Comment not_use_like_this(@RequestBody Comment comment) {
    		System.out.println(comment);
    		return comment;
    	}
    }
    
    

    总结

    通过列举多种参数传递的方式,并且实际使用Postman和Fiddler测试,我觉得自己对于大部分的参数传递方式都已经很熟练了,这确实是一种很好的学习方式。我本身是属于视觉学习型的人,所以对我来说学习一样东西,亲眼所见的效果是最好的。大家也要多探索属于自己的学习方式。

    这里只是一些具体的案例,但是关于@RequestPram和@RequestBody的实际作用,这里我还不是太了解,还需要以后多学习,这里贴一段它本身的API说明。

    In Spring MVC, “request parameters” map to query parameters, form data,
    and parts in multipart requests. This is because the Servlet API combines
    query parameters and form data into a single map called “parameters”, and
    that includes automatic parsing of the request body.

    1.query paramters
    2.from data
    3.parts in multipart

    这样看来 @RequestParam 同时适用于GET和POST方法,但是更加准确的解释应该是它
    可以处理在请求行和请求体中的参数(上面三种情况)。

    注意:虽然它适用范围很广,但是也不是说可以随便使用的,也是有限制条件的。

    PS:
    1. 上面列举的情况还是不够,如果有漏网之鱼,可以在评论区中提出来,我再增补上去。
    2. 大家可以数一下,我总共列举了多少种参数传递的情况。

    展开全文
  • python中参数传递的方法

    千次阅读 2020-08-13 14:21:15
    Python中函数传递参数的形式主要有以下五种,分别为位置传递,关键字传递,默认值传递,不定参数传递(包裹传递)和解包裹传递。 1.位置传递实例: def fun(a,b,c)  return a+b+c print(f(1,2,3)) 2.关键字...

    Python中函数传递参数的形式主要有以下五种,分别为位置传递,关键字传递,默认值传递,不定参数传递(包裹传递)和解包裹传递。

    1.位置传递实例:

    def fun(a,b,c) 
      return a+b+c 
     
    print(f(1,2,3))
    

    2.关键字传递

    关键字(keyword)传递是根据每个参数的名字传递参数。关键字并不用遵守位置的对应关系。

     '''
     遇到问题没人解答?小编创建了一个Python学习交流QQ群:778463939
     寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
     '''
    def fun(a,b,c) 
      return a+b+c
        
    print(f(1,c=3,b=2))
    

    3.参数默认值

    在定义函数的时候,使用形如c=10的方式,可以给参数赋予默认值(default)。如果该参数最终没有被传递值,将使用该默认值。

    def f(a,b,c=10):
      return a+b+c
       
    print(f(3,2))
    print(f(3,2,1))
    

    在第一次调用函数f时, 我们并没有足够的值,c没有被赋值,c将使用默认值10.第二次调用函数的时候,c被赋值为1,不再使用默认值。

    4.包裹传递

    在定义函数时,我们有时候并不知道调用的时候会传递多少个参数。这时候,包裹(packing)位置参数,或者包裹关键字参数,来进行参数传递,会非常有用。

    下面是包裹位置传递的例子:

     '''
     遇到问题没人解答?小编创建了一个Python学习交流QQ群:778463939
     寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
     '''
    def func(*name):
      print type(name)
      print name
      
     
    func(1,4,6)
    func(5,6,7,1,2,3)
    

    两次调用,尽管参数个数不同,都基于同一个func定义。在func的参数表中,所有的参数被name收集,根据位置合并成一个元组(tuple),这就是包裹位置传递。

    为了提醒Python参数,name是包裹位置传递所用的元组名,在定义func时,在name前加*号。

    下面是包裹关键字传递的例子:

    def func(**dict):
      print type(dict)
      print dict
      
     
      func((1,9))
      func("a":2,"b":1,"c":11)
    

    与上面一个例子类似,dict是一个字典,收集所有的关键字,传递给函数func。为了提醒Python,参数dict是包裹关键字传递所用的字典,在dict前加**。

    包裹传递的关键在于定义函数时,在相应元组或字典前加*或**。

    5.解包裹

    *和 **,也可以在调用的时候使用,即解包裹(unpacking), 下面为例:

     '''
     遇到问题没人解答?小编创建了一个Python学习交流QQ群:778463939
     寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
     '''
    def func(a,b,c):
      print a,b,c
      
     
    args = (1,3,4)
    func(*args)
     
    dict = {'a':1,'b':2,'c':3}
    func(**dict)
    

    在这个例子中,所谓的解包裹,就是在传递tuple时,让tuple的每一个元素对应一个位置参数。在调用func时使用 *,是为了提醒Python:我想要把args拆成分散的三个元素,分别传递给a,b,c。(设想一下在调用func时,args前面没有 *会是什么后果?)

    相应的,也存在对词典的解包裹,使用相同的func定义,然后:在传递词典dict时,让词典的每个键值对作为一个关键字传递给func。

    1.固定位置传参

    def function(a, b, c):
        print('a = %s\nb = %s\nc = %s' % (a, b, c))
        print(a+b+c)
     
     
    function(1, 2, 3)
    

    2.关键字传参
    注意:在关键字传参时需要注意的规则
    全部按照关键子传参时不需要注意参数的顺序
    但是在位置传参与关键字传参同时存在时
    位置传参的参数需要在关键字传参之前

    '''
    遇到问题没人解答?小编创建了一个Python学习交流QQ群:778463939
    寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
    '''
    def function(a, b, c):
       print('a = %s\nb = %s\nc = %s' % (a, b, c))
       print(a+b+c)
    
    
    function(1, b=2, c=1)
    

    3.默认值传参
    传参时有默认值的一项可传可不传
    若在调用时传入有默认值一项的值
    该项以新传入的值为准

    def function(a, b, c=10):
        print('a = %s\nb = %s\nc = %s' % (a, b, c))
        print(a + b + c)
     
     
    function(1, 2, 5)
    

    4.包裹传递

    • 使用*+形参传递参数的时候不需要用关键字传参, 参数传入之后以元组的形式保存。
    • 使用**+形参传递参数时需要使用关键字传参, 参数传入之后默认以字典的形式,形参名字为传入字典的键。
     '''
     遇到问题没人解答?小编创建了一个Python学习交流QQ群:778463939
     寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
     '''
    def function(*abb):
        print('数据类型: %s, 数据内容: %s' % (type(abb), abb))
     
     
    function((1, 2, 3))
    function("asdf")
    function({'1': 'asdf', '2': 'sadf'})
    function([123, 12, 3])
     
     
    def function(**a):
        print('数据类型: %s, 数据内容: %s' % (type(a), a))
     
     
    function(a=(1, 2, 3))
    function(a="asdf")
    function(a={'1': 'asdf', '2': 'sadf'})
    function(a=[123, 12, 3])
    

    5.解包裹传递
    特点:传递参数时使用字典或者元组的形式,调用时传入字典前+**,参数传入之后自动根据键来匹配形参元组前+*, 参数传入之后按位置匹配。

    def function(a, b, c):
        print(a, type(a))
        print(b, type(b))
        print(c, type(c))
     
     
    function(**{'a': 's', 'b': 2, 'c': 3})
     
    function(*(3, '23', 1))
    
    展开全文
  • JavaScript中的参数传递

    千次阅读 2019-03-28 16:28:34
    参数传递 在JavaScript中,参数都是按值传递的。也就是说,把函数外部的值复制给函数内部的参数,就和把值从一个变量复制到另一个变量一样。基本类型值的传递如同基本类型的变量复制一样,而引用类型值的传递,则...
  • C语言二维数组作为函数参数传递

    万次阅读 多人点赞 2018-06-07 21:43:37
    二维数组作为函数的参数,实参可以直接使用二维数组名,在被调用函数中可以定义形参所有维数的大小,也可以省略以为大小的说明。例如: void find(char a[3][10]); void find (char a[ ][10]); 也可以使用数组...
  • vue中参数传递(合集)

    万次阅读 2018-09-10 11:05:45
    前段时间项目用vue搭建整个前端页面,我负责的模块有个地方在页面跳转时得将参数传递到下一个页面,但是由于参数较多,用url带参数传递不是特别好,我尝试了多种方法想在页面之间传递参数都没成功,最后想到了vuex,...
  • 1.单参数传递 2.多参数传递 1 默认处理多参数传递传递 只传这四个参数,传其他的会报错找不到参数!!! 2 封装pojo类创建一个构造方法 一、 先为pojo类创建一个构造方法 二、 mapper接口中创建相应的方法,...
  • 本篇文章主要讲的是JavaScript中最正常不过的现象——函数参数传递,本篇文章篇幅不长,但一定能引发属于你自己的思考!
  • c++之指针作为函数参数传递的问题

    万次阅读 多人点赞 2018-09-30 11:23:51
    我们看到,当我们以a 作为func 函数的参数传递进去的时候,函数复制了这个指针,但这两个指针的内容是一样的,也就是说是指向同一个内存,即10 。   如果你还不了解的话,我就通过一段代码和测试再来说明...
  • 1.python中的位置传递:先用形式参数定义,然后在调用时对应位置使用实参(具体的数值)调用 def sum(a, b):  return a + b sum(5, 6)
  • 言归正传,都2020年了,居然还有人认为java的参数传递方式是引用传递,今天我就来讲一讲java的参数传递,好好看,写的不对的地方,请大声说出来,反正我也不会改,憋坏了就不好了。 基本数据类型传递 我们先来看一...
  • JAVA参数传递方式 (按值传递与引用传递区别)

    千次阅读 多人点赞 2018-09-30 22:58:30
    令大家所费解的 当对象引用作为参数时 函数为什么能修改真实的对象呢?这不是引用传递的特征吗? 尤其先学习C++再学习JAVA的同学(比如说我自己)会这样认为, 用白话解释就是: 引用传递指针时, 连函数操作的指针都是...
  • 上篇文章《c语言函数传参の结构体数组篇》提到了C语言的函数传参方式,百度了一一一大圈,有说两种的,也有说三种的,简直把我搞晕了,其中有争议的地方就是“引用传递”方式。我看好多写三种方式的都把源代码代码贴...
  • SpringBoot2 集成 xxl-job任务调度中心_参数传递
  • jQuery前端参数传递方案

    万次阅读 2020-09-28 08:24:23
    前端参数传递方案 需求 在页面之间进行传值的时候,如果遇到参数长度非常大的时候,我们直接url传值会400错误, 参数太长。我们当然可以把参数经过post后台传递,但是请求产生的网络开销呢?下面介绍几种方式好...
  • SystemVerilog中子程序调用与参数传递

    千次阅读 2019-04-13 17:11:04
    传递值是子程序传递参数的默认机制。这种传递机制将每个参数拷贝到子程序区域,如果子程序是 automatic 类型,那么子程序会在其本身的堆栈中保留一个局部的参数副本。参数在子程序内部的修改对外部不可见。 参数...
  • C++中函数调用时的三种参数传递方式详解

    万次阅读 多人点赞 2017-08-31 20:44:51
    原文地址:http://blog.csdn.net/cocohufei/article/details/6143476;  ...   在C++中,参数传递的方式是“实虚结合”。 按值传递(pass by value) 地址传递(pass by pointer) 引用传递(pass b...
  • Java中的参数传递

    万次阅读 多人点赞 2018-01-19 13:52:15
    Java中没有真正的引用传递 只有值传递! 传引用参数指的还是原来的那个引用,但是Java...指的是在方法调用时,传递参数是按值的拷贝传递。示例如下: public class TempTest { private void test1(int a){ //
  • SpringCloud Feign参数传递问题

    千次阅读 2019-03-15 20:49:26
    前言: 在SpringCloud中我们调用服务时往往会使用Feign客户端替代RestTemplate手动调用,我们只需要定义接口,接口上使用@FeignClient(“服务名”)注解即可,Feign...1.Feign不支持GET方法传递POJO 由于springMVC...
  • C语言中函数参数传递的三种方式

    万次阅读 多人点赞 2017-07-22 21:09:40
    C语言中函数参数传递的三种方式(1)传值,就是把你的变量的值传递给函数的形式参数,实际就是用变量的值来新生成一个形式参数,因而在函数里对形参的改变不会影响到函数外的变量的值。(2)传址,就是传变量的地址...
  • java中对象作为参数传递给一个方法,到底是值传递,还是引用传递? pdd:所谓java只有按值传递:基本类型 值传递;引用类型,地址值传递,所以叫值传递。  当主函数的变量,对象(主本)传递到副函数时,传递的...
  • verilog中的参数传递

    千次阅读 2018-07-29 10:05:19
    参数预定义的方法 module name#(parameter parameter1=12, parameter2=80) ( input clk, input rst_n, ...参数传递的方法 name #( parameter1, parameter2) name_inst ( .clk(clk) , // input cl...
  • MFC中对话框之间的参数传递的两种方法的两个实例。对MFC初学者会有很大帮助。
  • C语言参数传递的三种方式

    千次阅读 2020-09-04 14:11:38
    C语言中函数参数传递的三种方式 (1)传值,就是把你的变量的值传递给函数的形式参数,实际就是用变量的值来新生成一个形式参数,因而在函数里对形参的改变不会影响到函数外的变量的值。 (2)传址,就是传变量的...
  • 基本数据类型 整型:byte,short,int,long浮点型:float,double字符型:char布尔型:boolean引用数据类型 数组对象(类、接口)一般情况下,基本数据类型传递时是值传递,引用数据类型是引用传递。而String有些不...
  • postman测试接口参数传递

    千次阅读 2018-11-29 16:52:17
    postman是一个很好用的接口测试工具,我们在开发或者在测试过程中,总是会遇到一些接口在业务逻辑上相关联,需要上一个接口的返回数据的某些参数作为下一个接口的参数入参,这个时候就需要参数传递,用脚本语言来...
  • vue 参数传递的几种方法

    千次阅读 2018-08-22 23:35:01
    开发过程中参数传递 1. 通过 name 传递参数 图一 图二 我们常把页面的路由配置在图一中的 router 文件夹下的 js 文件中,图二为配置的内容。这其中的 name 属性是可以作为参数传递的,在模版中直接只用 {{$...
  • C/C++中函数参数传递详解

    千次阅读 多人点赞 2018-07-26 17:06:24
    C/C++中函数参数传递详解  昨天看了内存管理的有关内容,有一点了解,但不是很深入,发现之前写代码时有很多细节问题没有注意到,只知道这样做可以实现功能,却不知道为什么可以这样,对于采用自己的方法造成的隐患...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,974,847
精华内容 789,938
关键字:

参数传递