java与js的return等循环控制使用

最新推荐文章于 2022-05-04 14:47:44 发布

wespten

最新推荐文章于 2022-05-04 14:47:44 发布

阅读量595

点赞数

分类专栏：全栈前端开发文章标签： java与js的return等循环控制使用

本文链接：https://blog.csdn.net/qq_35029061/article/details/83578414

版权

全栈前端开发专栏收录该内容

61 篇文章 3 订阅

订阅专栏

js

js的break与continue

continue语句只能用在while语句、do/while语句、for语句、或者for/in语句的循环体内，在其它地方使用都会引起错误！

break在循环体内，强行结束循环的执行，也就是结束整个循环过程，不在判断执行循环的条件是否成立，直接转向循环语句下面的语句。

当break出现在循环体中的switch语句体内时，其作用只是跳出该switch语句体。

   for(var i=0;i<10;i++){
	   if(i==5){
		   break; //跳出for循环
	   }
	   document.write("i="+i+"<br/>");
   }
   document.write("<hr/>");
   document.write("continue;<br/>");
   for(var j=0;j<10;j++){
	   if(j==5){
		   continue; //跳过j=5的循环，继续往下执行
	   }
	   document.write("j="+j+"<br/>");
   }

js的return

一、停止并且跳出当前的函数
1.在ruturn 语句后面的函数体内所有内容都不会输出。
2.在函数体内可以有多个return语句，但是只会执行一个。(判断语句)

二、给函数返回一个值 return [返回值];
1.返回值可以是任何的数据类型

官方定义return后面可以跟一个value，也就是说可以跟javascript中的任何数据类型，数字，字符串，对象等，当然也可是再返回一个函数

<script>
   function func1(){
      return function (){
          alert(1);
      }
     };
alert(func1());  //!func1()();   这个注释是通过自执行函数调用返回的函数
</script>

当然是函数就可以调用，我们可以写成！func1()();这里很好理解，func1();我们打印出来看了就是return后面跟的匿名函数，那么我们就可以通过自执行函数的形式来调用，这里通过！函数体();的形式来调用。

<script>
  function func1(){
     if(prompt('输入数字1')==1){
          return function (){
              alert('输对了');
              }
        }else{
             return function (){
             alert('输错了');
            }
        }
    }
    !func1()();
</script>

2.只能返回一个返回值。

可以看到我在函数里面写了一个死循环，然后在下面调用，在没有写return语句时浏览器会一直执行循环内的语句，直接卡死；

而写了return语句后，直接中断了函数，并且给函数返回了一个数值1，意思就是当函数执行后，函数体将被赋值为函数的返回值，这里会被返回1；弹出1

函数会被赋值为return的返回值

<script>
  function func1(){
     while (true){
           return 1;
        }
      };
      alert(func1());
</script>

3.如果函数没有返回值，那么这个函数的值就会自动的赋值为undefined

三、return 0，return 1，return -1

返回0一般在主函数结束时，表示逻辑为0，即停止不再执行，

返回1表示，逻辑为真，

返回-1，表示返回一个代数值，一般用在子函数结尾。

一般使用规则:

0和-1使用时：
0一般表示成功执行
-1一般表示不成功
0和1使用时：
1真
0假

对于sort的使用

 <script>
    var arr = [1,3,2,6,5];
    arr.sort(function(a,b){
        return a-b;
       });
     console.log(arr); 
 </script>

　当a-b<=0时，a在前，b在后；

　当a-b>0是，a在后，b在前；

　return a-b;升序。

return -(a-b) 降序

return false的使用

使用”return false“，它只会在你的回调函数执行结束才去取消浏览器的默认行为，但是使用e.preventDefault，我们有更多的选择，它可以随时停止浏览器执行默认动作，而不管你将它放在函数的哪个部分。

只有当你同时需要preventDefault和stopPropagation，并且你的代码可以接受直到你的回调执行完成才停止执行浏览器的默认行为，那你就可以使用”return false“。

让浏览器停止继续执行默认行为

选择使用return false还是preventDefault，stopPropagation或者stopImmediatePropagation

当你每次调用”return false“的时候，它实际上做了3件事情：

•event.preventDefault();
•event.stopPropagation();事件冒泡就被终止了，click事件不会被冒泡
•停止回调函数执行并立即返回。

这3件事中用来阻止浏览器继续执行默认行为的只有preventDefault，除非你想要停止事件冒泡，否则使用return false会为你的代码埋下很大的隐患

preventDefault()

大多数情况下，当你使用return false时，你其实真正需要的是e.preventDefault()。要使用e.preventDefault，你需要确保你传递了event参数到你的回掉函数中（在这个例子里，就是那个e）：


$("a").click(function (e) { 
  // e == our event data 
  e.preventDefault(); 
});

它会替我们完成所有工作，但不会阻止父节点继续处理事件，要记住，你放在代码中的限制越少，你的代码就越灵活，也就越易于维护。

阻止浏览器默认行为preventDefault():

我们想要在用户点击文章标题时，将文章动态载入到div.contentd中：
$(document).ready(function ($) { 
  $("div.post h2 a").click(function () { 
    var a  = $(this), 
    href = a.attr('href'), // Let jQuery normalize `href`, 
    content  = a.parent().next(); 
    content.load(href + " #content"); 
    return false; // "cancel" the default behavior of following the link 
  }); 
}); 

如果我想要在用户点击了一个div.post元素（或者任何一个它的子元素）时，给它加上一个active类，我就需要给div.post增加了一个click回调：
var posts = $("div.post"); 
posts.click(function () { 
      posts.removeClass("active"); 
      $(this).addClass("active"); 
}); 
上面这段代码不会工作，因为使用了return false所以事件冒泡就被终止了，click事件不会被冒泡到div.post上，我们为它添加的事件回调当然也就不会被调用了

stopPropagation()

但有些情况下，你有可能需要停止事件冒泡

由于事件冒泡机制，除非在事件处理过程中被主动阻止冒泡（e.stopPropagation()），否则会将事件传递到document元素上。因此，在document元素上捕获click事件，并判断触发事件的元素有没有你想要的CSS类，就可以做到，动态增加的DOM元素的相应事件也能够被正确的处理。

你点了div上除了a链接之外的地方，我们希望能发生点什么事情（比如改变下背景什么的），但是不能影响用户点击a链接的行为


$("div.post").click(function () { 
  // Do the first thing; 
}); 
 
$("div.post a").click(function (e) { 
  // Don't cancel the browser's default action 
  // and don't bubble this event! 
  e.stopPropagation(); 
});

定义：不再派发事件。

终止事件在传播过程的捕获、目标处理或起泡阶段进一步传播。调用该方法后，该节点上处理该事件的处理程序将被调用，事件不再被分派到其他节点。

该方法将停止事件的传播，阻止它被分派到其他 Document 节点。注意，虽然该方法不能阻止同一个 Document 节点上的其他事件句柄被调用，但是它可以阻止把事件分派到其他节点。

return false 只在当前函数有效，不会影响其他外部函数的执行。

function a（）{

   if（True）
       return false;
},这是没有任何问题的。

如果我改成这种

function Test（）{

   a（）;

   b（）;

   c（）;

}

即使a函数返回return false 阻止提交了，但是不影响 b（）以及 c（）函数的执行。在Test（）函数里调用a()函数，那面里面

return false 对于Test（）函数来说，只是相当于返回值。而不能阻止Test（）函数执行。

stopImmediatePropagation()

这个方法会停止一个事件继续执行，不同的widgets和plugin就有可能在同一个对象上添加事件，如果遇到这种情况，那你就很有必要理解和使用stopImmediatePropagation。

return false下面的confirm不会执行

$("#btnupload").click(function (e) {        	
$.post("security/installitcheck/queryByParentId", paras, function (data) {
        		debugger;
    			if (data.code != "0") {
    				$Core.UI.message.error("未录入设备，不可提交！");
    				return false;
    			}
    	    	$.messager.confirm('提示', '您确定提交吗?', function (r) {
    	    		
    	            if (r) {
    	            	var ids = "";
    	    			$.each(rows, function (k, j) {
    	    				ids += (ids == "" ? j[$id] : "," + j[$id]);
    	    			});
    	    			var paras = { ids: ids };
    	    			$.post(url, paras, function (data) {
    	    				if (data.code == "0") {
    	    					$Core.UI.message.success("提交成功!");
    	    					$dg.datagrid("load");
    	    				} else {
    	    					$Core.UI.message.error("服务器正忙！");
    	    				}
    	    			});
    	            }
    	        });
    		});
  });

什么时候使用return false

return false;下面的confirm会执行

    $("#btnupload").click(function (e) {       	
$.post("security/installitcheck/queryByParentId", paras, function (data) {
        		debugger;
    			if (data.code != "0") {
    				$Core.UI.message.error("未录入设备，不可提交！");
    				return false;
    			}
    	    	
    		});
        	
        	$.messager.confirm('提示', '您确定提交吗?', function (r) {
	    		
	            if (r) {
	            	var ids = "";
	    			$.each(rows, function (k, j) {
	    				ids += (ids == "" ? j[$id] : "," + j[$id]);
	    			});
	    			var paras = { ids: ids };
	    			$.post(url, paras, function (data) {
	    				if (data.code == "0") {
	    					$Core.UI.message.success("提交成功!");
	    					$dg.datagrid("load");
	    				} else {
	    					$Core.UI.message.error("服务器正忙！");
	    				}
	    			});
	            }
	        });
 });

总结:

return ：

(1) return 从当前的方法中退出,返回到该调用的方法的语句处,继续执行。

(2) return 返回一个值给调用该方法的语句，返回值的数据类型必须与方法的声明中的返回值的类型一致。

(3) return后面也可以不带参数，不带参数就是返回空，其实主要目的就是用于想中断函数执行，返回调用函数处。

java

java循环中止的命令break

break调出结束当前的for循环，如果后面有代码，则继续往下执行。

for (int i = 0;i<date.size(); i++) {
			boolean hasValue=false;
			for (IBean iBean2 : yibean) {
				String yyqlDate=iBean2.get("RBBH", "");
				String yyqlVale=iBean2.get("DCNUM", "");
				String ymonth=yyqlDate.substring(10);
				if(ymonth.equals(date.get(i))){
					ynum.add(yyqlVale);
					hasValue = true;
					break;
				}
			}
			 if(!hasValue){
				 ynum.add("0");
			 }
		}

一般break与return用法是一样的，用户循环控制判断。中断最外层的循环也既结束循环

	//for循环内层循环优化
		int arr[] = {1,2,3};
	    for(int i = 0;i<arr.length-1;i++){
	    	int flag = 0;
	    	int temp;
	    	for(int j = 0;j<arr.length-i-1;j++){
	    		if(arr[j]>arr[j+1]){
	    			temp = arr[j];
	    			arr[j]=arr[j+1];
	    			arr[j+1]=temp;
	    		    flag = 1; 
	    		}
	    	}
	    	if(flag == 0){
	    		return;
	    	}
	    }
	    
	    //for循环外层循环
	    
	   boolean flagg = false;
	   int temp1; 
	   for(int i=0;i< arr.length-1;i++){
		   for(int j=0;j<arr.length-i-1;j++){
			   if(arr[j]>arr[j+1]){
				   temp1 = arr[j];
				   arr[j] = arr[j+1];
				   arr[j+1]=temp1;
				   flagg = true;
			
			   }
		   }
		   if(!flagg){
			  break; 
		   }
	   }

中断外层循环

	outer: //ctrl+shift+/ 多行注释
		for(int i=0;i<10;i++){
			for(int j=0;j<10;j++){
				if(i==1){
					break outer;
				}
				System.out.print("i="+i+" "+"j="+j+"  ");
			}
			System.out.println();
		}
		System.out.println("执行到这里");

java的continue中断当前满足条件的这一循环，如果下个值仍满足循环条件，则继续循环。

for(int i=1;i<=10;i++){
			if(i==3 || i==6){
				continue;
			}
			System.out.print("i="+i+" ");
		}

一般continue用于去重

去重map集合中的数据

	public List<CheckAdvice> removePicExtra(List<CheckAdvice> picList,List<CheckAdvice> list) {
	List<CheckAdvice> newList= new ArrayList<CheckAdvice>();
        HashMap<String, String> hashMap = new HashMap<String, String>();
        for (CheckAdvice checkAdvice : picList) {
            if (checkAdvice == null) {
                continue;
            }
            String  adviceId = checkAdvice.getAdviceId();
            if (adviceId != null) {
                String value = hashMap.get(adviceId);
                if (StringUtil.isEmpty(value)) { //如果value是空的  说明取到的这个adviceId是第一次取到
                    hashMap.put(adviceId, adviceId);
                } else {
                    continue;
                }
            }   
        }
}

去重名称一样的题目

String questionName=questionNam;
String questionRelId = companyOrgId;
QuestionMgtQue questionMgt =questionMgtService.getQuestionByName(questionRelId,questionName);
if(null!=questionMgt) {
	String countNum = questionMgt.getCountNum();
	if(!countNum.equals("0")) {
	continue;
	}
}

<select id="getQuestionByName" resultType="com.cnten.platform.system.question.model.QuestionMgtQue"
parameterType="java.lang.String">
select count(*) as countNum from PB_QUESTION_MGT 
where 1=1 and QUESTION_MGT_ID in (select t.question_mgt_id from pb_bank_real_question t where t.bank_question_id=#{bankQuestionId,jdbcType=VARCHAR})
<if test="questionName != null and questionName != ''">
and QUESTION_NAME = #{questionName,jdbcType=VARCHAR}
</if>
</select>

java的retrun 跳出双重for循环

for(int i=0;i<10;i++){
			for(int j=0;j<10;j++){
				if(i==1){
					return;
				}
				System.out.print("i="+i+" "+"j="+j+"  ");
			}
			System.out.println();
		}
		System.out.println("执行到这里")

return退出方法函数

	public static String getValueByType(Object object, String ruleCellType) {
		String upperRuleType = ruleCellType.toUpperCase();
		if (null != object && !"".equals(object)) {
			if(upperRuleType.equals("INTEGER")||upperRuleType.equals("NUMBER")){
				return object.toString();
			}else if(upperRuleType.equals("DATE")){
					
				return "TO_DATE('" + DateUtils.formatTime((Date) object) + "', 'yyyy-MM-dd hh24:mi:ss')";
			}else{
				if (object instanceof Date){
					return "TO_DATE('" + DateUtils.formatTime((Date) object) + "', 'yyyy-MM-dd hh24:mi:ss')";
				}
				return "'" + object.toString() + "'";
			}
		} 
		
		return "null";
	}

wespten

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java与js的return等循环控制使用

jsjs的break与continue continue语句只能用在while语句、do/while语句、for语句、或者for/in语句的循环体内，在其它地方使用都会引起错误！ break在循环体内，强行结束循环的执行，也就是结束整个循环过程，不在判断执行循环的条件是否成立，直接转向循环语句下面的语句。当break出现在循环体中的switch语句体内时，其作用只是跳出该swit...
复制链接

扫一扫