index of group（JS object里可以按key值排序吗）

本文目录

• JS object里可以按key值排序吗
• java matcher m.group（）问题
• 输入运算公式 得到结果 java
• 用iview中cell单元格组件，动态渲染了多个,当点击某个时，如何给当前选中加selected

JS object里可以按key值排序吗

可以按key值排序
代码如下：
var mobile = str.substring(1);
var conferenceId=str;
var callType=str;
//报警处理(通过预定义的+H组)
var isAlarm=false;
if(callType==’3’){ //预定义组呼入
var preGroup=this.homeU.preGroup;
var groupName=preGroup;
if(groupName && groupName.indexOf(’+H’)==0){
isAlarm=true;
}
}
console.log(groupId+"--根据组号获得组名-------》");
var aa = this.homeU.preGroup;
console.log("--根据组号获得组名-------》"+aa);
var groupName = aa.groupId;
得到的groupName 是undefined
js中想根据动态key得到某对象中相对应的value的方法有二：
一、var key = "name1";
var value = obj;
二、var key = "name1";
var value = eval("obj."+key);

java matcher m.group（）问题

while(m.find()){
System.out.println(m.group());
}

int index = matchrows.indexOf(m.group());
m.group() 应该要放在上面的while(){}循环内。
在所有 find()的之后，发生异常
Exception in thread "main" java.lang.IllegalStateException: No match found

输入运算公式 得到结果 java

通过栈实现,先用栈将中缀表达式转化为后缀表达式，然后再用栈计算后缀表达式的值的
package com.saturday;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class MyParse {
static Map《String,Integer》 optrOrder;
static {
optrOrder=new HashMap《String,Integer》();
optrOrder.put("(", 0);
optrOrder.put("*", 1);
optrOrder.put("/", 1);
optrOrder.put("%", 1);
optrOrder.put("+",2);
optrOrder.put("-",2);
optrOrder.put("^",3);
optrOrder.put("#",3);
}

public static void main(String args){
List《String》 tokens;
try{
//词法分析
tokens=lex("+2* (-2+3*4)+-5");

//中缀转后缀
tokens=toRpn(tokens);

//计算结果
System.out.println(calcRpn(tokens));

}catch(Exception ex){
ex.printStackTrace();
}
}
/**
* 将输入串转换为操作符串
* @param sExpres
* @return
*/
public static List《String》 lex(String sExpres){
List《String》 tokens=new ArrayList《String》();

//将表达式分割成符号序列
String sRegExp="(((?《=^|\\(|\\+|-|\\*|/|%)(\\+|-))?\\d+(\\.\\d+)?)"
+"|\\(|\\)|\\*|/|\\+|-";
Pattern p=Pattern.compile(sRegExp);
Matcher m=p.matcher(sExpres.replaceAll("\\s+",""));
while(m.find()){
tokens.add(m.group());
}

tokens.add("#");

return tokens;
}

/**
* 将中缀表单时转化为后缀表达式
* @param tokens
* @return
*/
public static List《String》 toRpn(List《String》 tokens)
throws Exception{
List《String》 rpnList=new ArrayList《String》();
Stack《String》 optrStack=new Stack《String》();

optrStack.add("^");
for(String token:tokens){
if(token.matches("^(\\+|-)?\\d+(\\.\\d+)?$")){
rpnList.add(token);
}else{
outputOptr(token,optrStack,rpnList);
}
}

if(!optrStack.isEmpty()
&&optrStack.lastElement().equals("#")){
return rpnList;
}else{
throw new Exception("后缀表达式转化错误!");
}
}
/**
* 计算后缀表达式的值
* @param rpnTokens
* @return
* @throws Exception
*/
public static double calcRpn(List《String》 rpnTokens)
throws Exception{
NumberFormat nf=NumberFormat.getInstance();
Stack《Double》 numStack=new Stack《Double》();
for (String token : rpnTokens) {
if (token.matches("^(\\+|-)?\\d+(.\\d+)?$")) {
token=token.indexOf(’+’)==0
?token.substring(1)
:token;
numStack.add(nf.parse(token).doubleValue());
} else {
doCalcByOptr(token, numStack);
}
}
if (!numStack.isEmpty() && numStack.size() == 1) {
return numStack.lastElement();
} else {
throw new Exception("计算错误！");
}
}

/**
* 将运算符输出到后缀表达式序列.
* @param optr
* @param optrStack
* @param rpnList
* @throws Exception
*/
public static void outputOptr(String optr,
Stack《String》 optrStack,
List《String》 rpnList)
throws Exception{
String preOptr;

if(optr.equals("(")){//处理左括号
optrStack.push(optr);
return;
}

if(optr.equals(")")){//处理右括号
while(!optrStack.isEmpty()){
preOptr=optrStack.pop();
if(!preOptr.equals("(")){
rpnList.add(preOptr);
}else{
break;
}
}

if(optrStack.isEmpty()){
throw new Exception("括号未闭合!");
}

return;
}

/*按优先级处理其他运算符，若当前运算符优先级较高
* 直接入栈，否则将栈中运算符出战直至栈顶运算符
* 低于当前运算符
*/
preOptr=optrStack.lastElement();
if(optrCmp(optr,preOptr)《0){
optrStack.push(optr);
}else{
while(!preOptr.equals("(")
&&!optrStack.isEmpty()
&&optrCmp(optr,preOptr)》=0){

preOptr=optrStack.pop();
if(!preOptr.equals("^")){
rpnList.add(preOptr);
}
}
optrStack.push(optr);
}
}
/**
* 运算符优先级比较函数,optr1优先级大于optr2返回小于0值,
* 优先级相等返回0,optr1小于optr2返回大于0值.
* @param optr1
* @param optr2
* @return
*/
public static int optrCmp(String optr1,String optr2){
int order1=optrOrder.get(optr1);
int order2=optrOrder.get(optr2);
return order1-order2;
}
/**
* 根据运算符对数据栈中的内容进行操作.
* @param optr
* @param numStack
*/
public static void doCalcByOptr(String optr,
Stack《Double》 numStack){
double n1,n2;
n2=numStack.pop();
n1=numStack.pop();

if(optr.equals("+")){
numStack.push(n1+n2);
}else if(optr.equals("-")){
numStack.push(n1-n2);
}else if(optr.equals("*")){
numStack.push(n1*n2);
}else if(optr.equals("/")){
numStack.push(n1/n2);
}else if(optr.equals("%")){
numStack.push(n1%n2);
}
}
}

用iview中cell单元格组件，动态渲染了多个,当点击某个时，如何给当前选中加selected

不知道你的需求是什么，是单选 还是多选？

如果是单选 那就按照：

《cell-group @on-click="clicks" ref="group"》
   《cell :name="index" v-for="(item,index) in " :selected="num==index"》{{item}}《/cell》
《/cell-group》
data () {
            return {
                switchValue: true,
                num: ’’
            }
        },
        methods: {
            clicks (index) {
               this.num = index
            }
       }
       
如果是多选：
《cell-group @on-click="clicks" ref="group"》
   《cell :name="index" v-for="(item,index) in " :selected="arrNum.indexOf(index)!=-1"》{{item}}《/cell》
《/cell-group》
data () {
            return {
                switchValue: true,
                num: ’’,
                arrNum:
            }
        },
        methods: {
        clicks (index) {
          var indexs = this.arrNum.indexOf(index)
         if(indexs!=-1){
         this.arrNum.splice(indexs, 1);
         }else{
          this.arrNum.push(index)
         }
          }