解决JSP发送到Servlet的字符串产生字符转义的问题

已于 2022-12-06 20:48:16 修改
阅读量986 收藏 1
点赞数
文章标签： servlet java
于 2022-11-09 12:02:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shark_pupper/article/details/127766677
版权

现象描述：起初写了一个jsp页面，用于接收用户输入的字符串，后来发现在servlet端接收到字符串后，在传送过程中，字符产生了转义，导致不能接收到正确的内容。

在webui页面输入的字符串：

/home/hoary/backup/gitlab/keepLatestTar.sh > /home/hoary/logs/keepLatestTar.log 2>&1

在Servlet中接收到的字符串：

/home/hoary/backup/gitlab/keepLatestTar.sh > /home/hoary/logs/keepLatestTar.log 2>

由显示内容可以看到符号">" 转义成了 ">"，由此导致接收到的实际内容错误。  

分享一种解决转义的思路：使用Base64编码包含特殊字符

解决方案：

在webui页面中对输入的字符串进行Base64编码，然后在Servlet端接收到Base64编码的字符串后进行解码，即可得到正确的字符串

步骤1：在jsp页面对输入的字符串进行Base64编码

感谢大佬分析的在js函数中实现Base64编码与解码的代码，附上链接JS 实现Base64编码与解码实例详解_JavaScript技巧_积木网（gimoo.net）

本次使用中的具体代码：

function add() {
    var crontab = prompt("请输入要添加的指令：");
    if(crontab == null || crontab == "") {
        alert("请输入crontab指令！");
        return;
    }
    // 对输入的crontab指令进行Base64编码，避免符号转义
    var base = new Base64();
    var b64str = base.encode(crontab);
    var reqData = "method=add&crontab="+crontab;

    $.ajax({
        url: "modifyCrontabServlet",
        type: "post",
        data: reqData,
        dataType: "json",
        success: function (result) {
            var code = result.code;
            if (code > 0) {
                alert("增加crontab指令成功！");
                window.location.href="modifyCrontab.jsp";
            }else {
                alert("增加crontab指令失败! " + result.msg);
            }
        }
    });
}

//在js中实现Base编码与解码
function Base64() {

    // private property
    _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

    // public method for encoding
    this.encode = function (input) {
        var output = "";
        var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
        var i = 0;
        input = _utf8_encode(input);
        while (i < input.length) {
            chr1 = input.charCodeAt(i++);
            chr2 = input.charCodeAt(i++);
            chr3 = input.charCodeAt(i++);
            enc1 = chr1 >> 2;
            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
            enc4 = chr3 & 63;
            if (isNaN(chr2)) {
                enc3 = enc4 = 64;
            } else if (isNaN(chr3)) {
                enc4 = 64;
            }
            output = output +
                _keyStr.charAt(enc1) + _keyStr.charAt(enc2) +
                _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
        }
        return output;
    }

    // public method for decoding
    this.decode = function (input) {
        var output = "";
        var chr1, chr2, chr3;
        var enc1, enc2, enc3, enc4;
        var i = 0;
        input = input.replace(/[^A-Za-z0-9+/=]/g, "");
        while (i < input.length) {
            enc1 = _keyStr.indexOf(input.charAt(i++));
            enc2 = _keyStr.indexOf(input.charAt(i++));
            enc3 = _keyStr.indexOf(input.charAt(i++));
            enc4 = _keyStr.indexOf(input.charAt(i++));
            chr1 = (enc1 << 2) | (enc2 >> 4);
            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
            chr3 = ((enc3 & 3) << 6) | enc4;
            output = output + String.fromCharCode(chr1);
            if (enc3 != 64) {
                output = output + String.fromCharCode(chr2);
            }
            if (enc4 != 64) {
                output = output + String.fromCharCode(chr3);
            }
        }
        output = _utf8_decode(output);
        return output;
    }

    // private method for UTF-8 encoding
    _utf8_encode = function (string) {
        string = string.replace(/rn/g,"n");
        var utftext = "";
        for (var n = 0; n < string.length; n++) {
            var c = string.charCodeAt(n);
            if (c < 128) {
                utftext += String.fromCharCode(c);
            } else if((c > 127) && (c < 2048)) {
                utftext += String.fromCharCode((c >> 6) | 192);
                utftext += String.fromCharCode((c & 63) | 128);
            } else {
                utftext += String.fromCharCode((c >> 12) | 224);
                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                utftext += String.fromCharCode((c & 63) | 128);
            }

        }
        return utftext;
    }

    // private method for UTF-8 decoding
    _utf8_decode = function (utftext) {
        var string = "";
        var i = 0;
        var c = c1 = c2 = 0;
        while ( i < utftext.length ) {
            c = utftext.charCodeAt(i);
            if (c < 128) {
                string += String.fromCharCode(c);
                i++;
            } else if((c > 191) && (c < 224)) {
                c2 = utftext.charCodeAt(i+1);
                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                i += 2;
            } else {
                c2 = utftext.charCodeAt(i+1);
                c3 = utftext.charCodeAt(i+2);
                string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                i += 3;
            }
        }
        return string;
    }

}

步骤2：在Servlet中接收到Base64编码后进行解码，得到原字符串

@WebServlet("/modifyCrontabServlet")
public class ModifyCrontabServlet extends HttpServlet { 
    String crontabStr = request.getParameter("crontab").trim();
    String crontabAdd = new String(Base64.decode(crontabStr));
}

此处附上使用Java实现Base64编码的代码

public class Base64 {
    private static final char[] CA = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
			.toCharArray();

    static {
		Arrays.fill( IA , -1 );
		for( int i = 0 , iS = CA.length ; i < iS ; i++ )
			IA[ CA[ i ] ] = i;
		IA[ '=' ] = 0;
	}
    
    public final static String encode( byte[] sArr ) {
		return new String( encodeToString( sArr , false ) );
	}
    
    private final static char[] encodeToChar( byte[] sArr , boolean lineSep ) {
		// Check special case
		int sLen = sArr != null ? sArr.length : 0;
		if( sLen == 0 )
			return new char[ 0 ];

		int eLen = ( sLen / 3 ) * 3; // Length of even 24-bits.
		int cCnt = ( ( sLen - 1 ) / 3 + 1 ) << 2; // Returned character count
		int dLen = cCnt + ( lineSep ? ( cCnt - 1 ) / 76 << 1 : 0 ); // Length of
		// returned
		// array
		char[] dArr = new char[ dLen ];

		// Encode even 24-bits
		for( int s = 0 , d = 0 , cc = 0 ; s < eLen ; ) {
			// Copy next three bytes into lower 24 bits of int, paying attension to
			// sign.
			int i = ( sArr[ s++ ] & 0xff ) << 16 | ( sArr[ s++ ] & 0xff ) << 8
					| ( sArr[ s++ ] & 0xff );

			// Encode the int into four chars
			dArr[ d++ ] = CA[ ( i >>> 18 ) & 0x3f ];
			dArr[ d++ ] = CA[ ( i >>> 12 ) & 0x3f ];
			dArr[ d++ ] = CA[ ( i >>> 6 ) & 0x3f ];
			dArr[ d++ ] = CA[ i & 0x3f ];

			// Add optional line separator
			if( lineSep && ++cc == 19 && d < dLen - 2 ) {
				dArr[ d++ ] = '\r';
				dArr[ d++ ] = '\n';
				cc = 0;
			}
		}

		// Pad and encode last bits if source isn't even 24 bits.
		int left = sLen - eLen; // 0 - 2.
		if( left > 0 ) {
			// Prepare the int
			int i = ( ( sArr[ eLen ] & 0xff ) << 10 )
					| ( left == 2 ? ( ( sArr[ sLen - 1 ] & 0xff ) << 2 ) : 0 );

			// Set last four chars
			dArr[ dLen - 4 ] = CA[ i >> 12 ];
			dArr[ dLen - 3 ] = CA[ ( i >>> 6 ) & 0x3f ];
			dArr[ dLen - 2 ] = left == 2 ? CA[ i & 0x3f ] : '=';
			dArr[ dLen - 1 ] = '=';
		}
		return dArr;
	}
    
    public final static byte[] decode( char[] sArr ) {
		char[] tmp = new char[ sArr.length ];
		int t = 0;
		for( int i = 0 , length = sArr.length ; i < length ; i++ ) {
			if( ( ( sArr[i] >= 'A' ) && ( sArr[i] <= 'Z' ) ) 
					|| ( ( sArr[i] >= 'a' ) && ( sArr[i] <= 'z' ) )
					|| ( ( sArr[i] >= '0' ) && ( sArr[i] <= '9' ) )
					|| ( sArr[i] == '+' )
					|| ( sArr[i] == '/' )
					|| ( sArr[i] == '=' ) ){
				tmp[ t ] = sArr[ i ];
				t += 1;
			}else if( sArr[i] == '-' ){
				tmp[t] = '+' ;
				t += 1;
			}else if( sArr[i] == '_' ){
				tmp[t] = '/' ;
				t += 1;
			}
		}
		char[] tmp2 = new char[ t ];
		System.arraycopy( tmp , 0 , tmp2 , 0 , t );
		tmp = null;
		// System.out.println( new String( tmp2 ) ) ;
		return decodeFast( tmp2 );
	}

    private final static byte[] decodeFast( char[] sArr ) {
		// Check special case
		int sLen = sArr.length;
		if( sLen == 0 )
			return new byte[ 0 ];

		int sIx = 0 , eIx = sLen - 1; // Start and end index after trimming.

		// Trim illegal chars from start
		while ( sIx < eIx && IA[ sArr[ sIx ] ] < 0 )
			sIx++ ;

		// Trim illegal chars from end
		while ( eIx > 0 && IA[ sArr[ eIx ] ] < 0 )
			eIx-- ;

		// get the padding count (=) (0, 1 or 2)
		int pad = sArr[ eIx ] == '=' ? ( sArr[ eIx - 1 ] == '=' ? 2 : 1 ) : 0; // Count
		// '='
		// at
		// end.
		int cCnt = eIx - sIx + 1; // Content count including possible separators
		int sepCnt = sLen > 76 ? ( sArr[ 76 ] == '\r' ? cCnt / 78 : 0 ) << 1 : 0;

		int len = ( ( cCnt - sepCnt ) * 6 >> 3 ) - pad; // The number of decoded
		// bytes
		byte[] dArr = new byte[ len ]; // Preallocate byte[] of exact length

		// Decode all but the last 0 - 2 bytes.
		int d = 0;
		for( int cc = 0 , eLen = ( len / 3 ) * 3 ; d < eLen ; ) {
			// Assemble three bytes into an int from four "valid" characters.
			int i = IA[ sArr[ sIx++ ] ] << 18 | IA[ sArr[ sIx++ ] ] << 12
					| IA[ sArr[ sIx++ ] ] << 6 | IA[ sArr[ sIx++ ] ];

			// Add the bytes
			dArr[ d++ ] = ( byte ) ( i >> 16 );
			dArr[ d++ ] = ( byte ) ( i >> 8 );
			dArr[ d++ ] = ( byte ) i;

			// If line separator, jump over it.
			if( sepCnt > 0 && ++cc == 19 ) {
				sIx += 2;
				cc = 0;
			}
		}

		if( d < len ) {
			// Decode last 1-3 bytes (incl '=') into 1-3 bytes
			int i = 0;
			for( int j = 0 ; sIx <= eIx - pad ; j++ )
				i |= IA[ sArr[ sIx++ ] ] << ( 18 - j * 6 );

			for( int r = 16 ; d < len ; r -= 8 )
				dArr[ d++ ] = ( byte ) ( i >> r );
		}

		return dArr;
	}
    
    private final static byte[] encodeToByte( byte[] sArr , boolean lineSep ) {
		// Check special case
		int sLen = sArr != null ? sArr.length : 0;
		if( sLen == 0 )
			return new byte[ 0 ];

		int eLen = ( sLen / 3 ) * 3; // Length of even 24-bits.
		int cCnt = ( ( sLen - 1 ) / 3 + 1 ) << 2; // Returned character count
		int dLen = cCnt + ( lineSep ? ( cCnt - 1 ) / 76 << 1 : 0 ); // Length of
		// returned
		// array
		byte[] dArr = new byte[ dLen ];

		// Encode even 24-bits
		for( int s = 0 , d = 0 , cc = 0 ; s < eLen ; ) {
			// Copy next three bytes into lower 24 bits of int, paying attension to
			// sign.
			int i = ( sArr[ s++ ] & 0xff ) << 16 | ( sArr[ s++ ] & 0xff ) << 8
					| ( sArr[ s++ ] & 0xff );

			// Encode the int into four chars
			dArr[ d++ ] = ( byte ) CA[ ( i >>> 18 ) & 0x3f ];
			dArr[ d++ ] = ( byte ) CA[ ( i >>> 12 ) & 0x3f ];
			dArr[ d++ ] = ( byte ) CA[ ( i >>> 6 ) & 0x3f ];
			dArr[ d++ ] = ( byte ) CA[ i & 0x3f ];

			// Add optional line separator
			if( lineSep && ++cc == 19 && d < dLen - 2 ) {
				dArr[ d++ ] = '\r';
				dArr[ d++ ] = '\n';
				cc = 0;
			}
		}

		// Pad and encode last bits if source isn't an even 24 bits.
		int left = sLen - eLen; // 0 - 2.
		if( left > 0 ) {
			// Prepare the int
			int i = ( ( sArr[ eLen ] & 0xff ) << 10 )
					| ( left == 2 ? ( ( sArr[ sLen - 1 ] & 0xff ) << 2 ) : 0 );

			// Set last four chars
			dArr[ dLen - 4 ] = ( byte ) CA[ i >> 12 ];
			dArr[ dLen - 3 ] = ( byte ) CA[ ( i >>> 6 ) & 0x3f ];
			dArr[ dLen - 2 ] = left == 2 ? ( byte ) CA[ i & 0x3f ] : ( byte ) '=';
			dArr[ dLen - 1 ] = '=';
		}
		return dArr;
	}

    public final static byte[] decode( byte[] sArr ) {
		byte[] tmp = new byte[ sArr.length ];
		int t = 0;
		for( int i = 0 , length = sArr.length ; i < length ; i++ ) {
			if( ( ( sArr[i] >=65 ) && ( sArr[i] <= 90 ) )
					|| ( ( sArr[i] >=97 ) && ( sArr[i] <= 122 ) ) 
					|| ( ( sArr[i] >= 48) && ( sArr[i] <= 57 ) ) 
					|| ( sArr[i] == 43 ) 
					|| ( sArr[i] == 47 ) 
					|| ( sArr[i] == 61 ) )
			{
				tmp[ t ] = sArr[ i ];
				t += 1;
			}
		}
		byte[] tmp2 = new byte[ t ];
		System.arraycopy( tmp , 0 , tmp2 , 0 , t );
		tmp = null;
		return decodeFast( tmp2 );
	}
    
    private final static byte[] decodeFast( byte[] sArr ) {
		// Check special case
		int sLen = sArr.length;
		if( sLen == 0 )
			return new byte[ 0 ];

		int sIx = 0 , eIx = sLen - 1; // Start and end index after trimming.

		// Trim illegal chars from start
		while ( sIx < eIx && IA[ sArr[ sIx ] & 0xff ] < 0 )
			sIx++ ;

		// Trim illegal chars from end
		while ( eIx > 0 && IA[ sArr[ eIx ] & 0xff ] < 0 )
			eIx-- ;

		// get the padding count (=) (0, 1 or 2)
		int pad = sArr[ eIx ] == '=' ? ( sArr[ eIx - 1 ] == '=' ? 2 : 1 ) : 0; // Count
		// '='
		// at
		// end.
		int cCnt = eIx - sIx + 1; // Content count including possible separators
		int sepCnt = sLen > 76 ? ( sArr[ 76 ] == '\r' ? cCnt / 78 : 0 ) << 1 : 0;

		int len = ( ( cCnt - sepCnt ) * 6 >> 3 ) - pad; // The number of decoded
		// bytes
		byte[] dArr = new byte[ len ]; // Preallocate byte[] of exact length

		// Decode all but the last 0 - 2 bytes.
		int d = 0;
		for( int cc = 0 , eLen = ( len / 3 ) * 3 ; d < eLen ; ) {
			// Assemble three bytes into an int from four "valid" characters.
			int i = IA[ sArr[ sIx++ ] ] << 18 | IA[ sArr[ sIx++ ] ] << 12
					| IA[ sArr[ sIx++ ] ] << 6 | IA[ sArr[ sIx++ ] ];

			// Add the bytes
			dArr[ d++ ] = ( byte ) ( i >> 16 );
			dArr[ d++ ] = ( byte ) ( i >> 8 );
			dArr[ d++ ] = ( byte ) i;

			// If line separator, jump over it.
			if( sepCnt > 0 && ++cc == 19 ) {
				sIx += 2;
				cc = 0;
			}
		}

		if( d < len ) {
			// Decode last 1-3 bytes (incl '=') into 1-3 bytes
			int i = 0;
			for( int j = 0 ; sIx <= eIx - pad ; j++ )
				i |= IA[ sArr[ sIx++ ] ] << ( 18 - j * 6 );

			for( int r = 16 ; d < len ; r -= 8 )
				dArr[ d++ ] = ( byte ) ( i >> r );
		}

		return dArr;
	}
    
    private final static String encodeToString( byte[] sArr , boolean lineSep ) {
		// Reuse char[] since we can't create a String incrementally anyway and
		// StringBuffer/Builder would be slower.
		return new String( encodeToChar( sArr , lineSep ) );
	}
    
    public final static byte[] decode( String sArr ) {
		return decode( sArr.getBytes() );
	} 

    private final static byte[] decodeFast( String s ) {
		// Check special case
		int sLen = s.length();
		if( sLen == 0 )
			return new byte[ 0 ];

		int sIx = 0 , eIx = sLen - 1; // Start and end index after trimming.

		// Trim illegal chars from start
		while ( sIx < eIx && IA[ s.charAt( sIx ) & 0xff ] < 0 )
			sIx++ ;

		// Trim illegal chars from end
		while ( eIx > 0 && IA[ s.charAt( eIx ) & 0xff ] < 0 )
			eIx-- ;

		// get the padding count (=) (0, 1 or 2)
		int pad = s.charAt( eIx ) == '=' ? ( s.charAt( eIx - 1 ) == '=' ? 2 : 1 )
				: 0; // Count '=' at end.
		int cCnt = eIx - sIx + 1; // Content count including possible separators
		int sepCnt = sLen > 76 ? ( s.charAt( 76 ) == '\r' ? cCnt / 78 : 0 ) << 1
				: 0;

		int len = ( ( cCnt - sepCnt ) * 6 >> 3 ) - pad; // The number of decoded
		// bytes
		byte[] dArr = new byte[ len ]; // Preallocate byte[] of exact length

		// Decode all but the last 0 - 2 bytes.
		int d = 0;
		for( int cc = 0 , eLen = ( len / 3 ) * 3 ; d < eLen ; ) {
			// Assemble three bytes into an int from four "valid" characters.
			int i = IA[ s.charAt( sIx++ ) ] << 18 | IA[ s.charAt( sIx++ ) ] << 12
					| IA[ s.charAt( sIx++ ) ] << 6 | IA[ s.charAt( sIx++ ) ];

			// Add the bytes
			dArr[ d++ ] = ( byte ) ( i >> 16 );
			dArr[ d++ ] = ( byte ) ( i >> 8 );
			dArr[ d++ ] = ( byte ) i;

			// If line separator, jump over it.
			if( sepCnt > 0 && ++cc == 19 ) {
				sIx += 2;
				cc = 0;
			}
		}

		if( d < len ) {
			// Decode last 1-3 bytes (incl '=') into 1-3 bytes
			int i = 0;
			for( int j = 0 ; sIx <= eIx - pad ; j++ )
				i |= IA[ s.charAt( sIx++ ) ] << ( 18 - j * 6 );

			for( int r = 16 ; d < len ; r -= 8 )
				dArr[ d++ ] = ( byte ) ( i >> r );
		}

		return dArr;
	}
    
    public static void main( String[] args ) {
		String a = "abcabc";
		String b64 = encode( a.getBytes() );
		System.out.println( b64 );
		b64 = "YWJj\r\nYWJj\r\nYWJj\r\n";
		byte[] x = decode( b64.getBytes() );
		System.out.println( encode( x ) );
	}       

}

此处获得的字符串为：

/home/hoary/backup/gitlab/keepLatestTar.sh > /home/hoary/logs/keepLatestTar.log 2>&1

通过Base的编码和解码很好的避免了jsp发送的内容到servlet端字符产生转义

赵补拙
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JSP与Servlet之间传值
weixin_34038293的博客
11-20 2128
JSP与Servlet之间传值     Jsp与Servlet之间的传值有两种，一种是Jsp传值给Sevlet，另一种是Servlet传值给Jsp；使用request、response对象完成传值，具体实现如下： 1.JSP传值给Servlet JSP传值给Servlet有几种形式：Form表单传值，url传值，其他方式传值 a、form表单传值： JSP页面有：&lt;input ...
jsp与Servlet的编译原理、过程、区别及使用
05-24
深入解析jsp与Servlet的编译原理、过程、区别及使用。
JSP中的转义字符
stklway的专栏
03-25 2363
JSP中的转义字符： > ：&gt; < ：&lt; ' ：&quot;
服务器渲染技术jsp
Al_tair的博客
05-27 712
服务器渲染技术服务器渲染技术JSP基本介绍运行原理常用指令和标签常用脚本JSP 注释JSP 内置对象JSP 域对象pageContextrequestsessionapplication代码示例EL 表达式概述常用输出形式运算操作empty运算内置对象JSTL概述核心标签库 大家好呀，我是小笙，我和大家分享下我学习Javaweb的笔记 服务器渲染技术 JSP基本介绍 JSP 全称是 Java Server Pages，Java 的服务器页面,jsp 本质也是实现了Servlet接口 相比 html 而
《JSP极简教程》如何在JSP页面输出HTML文本而不被转义
禅与计算机程序设计艺术
04-02 8902
讲3种情况： innerHTML与value /** * Created by jack on 2017/3/29. */ define(function (require) { "use strict"; require('meditor'); $(function () { var parser = ne...
jsp页面特殊字符展示处理
叔叔有糖吃的专栏
02-14 6978
fn:escapeXml用法 当在jsp页面中的标签中有诸如（“,\,’...）的特殊符号时，这个时候如果直接采用下面的形式会发生展示上的错误：   input class="search_input_ctx" name="name" type="text" id="search_input "value="${XXX}" >   比如，如果此时searchConte
注解Servlet+jsp+mysql5.6的登录
02-22
- SQL注入防护：防止恶意用户通过输入特定的SQL字符串来执行未授权的操作。使用PreparedStatement能有效避免SQL注入，因为它会自动转义特殊字符。 6. **会话管理**： 登录成功后，可以使用HttpSession对象来创建...
JSP向MYSQL插入单引号内容出错的解决方法.pdf
10-10
该问题的出现是由于 SQL 语句中使用单引号作为字符串的标志，而单引号在 SQL 对参数中的特殊字符较敏感所致。在本文中，我们将分析该问题的原因并提供两种解决方法。 问题的提出 在 Web 开发中，数据库交互是非常...
jsp中常见的乱码问题
05-15
10. **JDBC操作**：在插入或查询包含中文的数据库记录时，确保SQL语句中的字符串使用正确的转义方式，避免乱码。 11. **配置服务器**：在应用服务器（如Tomcat）的配置文件中，如`server.xml`或`web.xml`，设置全局...
jsp+oracle动态网站开发案列代码大全
11-23
在实际应用中，需要注意SQL注入、跨站脚本攻击等问题，可以通过预编译SQL、转义用户输入和使用安全的API来预防。 10. **性能优化** - 使用连接池管理数据库连接，避免频繁创建和关闭连接。 - 缓存经常访问的数据...
jsp传参特殊字符
07-26
jsp url传参 ， 可以传#等特殊字符的处理
防止单引号,双引号在接受页面转义
anjichan4261的博客
09-23 446
PHP页面中如果不希望出现以下情况: 单引号被转义为/' 双引号被转义为/" 那么可以进行如下设置以防止: 方法一:在PHP.ini中设置:magic_quotes_gpc=Off 方法二:$str=stripcslashes($str) 转载于:https://www.cnblogs.com/ajuanabc/archive/2008/09/23/246359...
JSP中大于号小于号的转义字符
热门推荐
迪士尼公主的专栏
08-18 3万+
<br />JSP 中大于号、小于号、单引号   分别为: <br />>   <   "  
jsp中的双引号（""）和单引号（''）以及转义字符（\）区别总结
兔的骄傲
07-31 1万+
一，当双引号出现在js的<>内需要遵循如下规则： 　　1、 双引号” ”要变为单引号’ ’ 　　2、 单引号中的单引号’ ’用实体符号&quot;代替 　　3、 单引号中的转义字符\ 用 \\ 代替 双引号： 　　ASP中处在双引号中的可以是任意的字符、字符串，HTML代码。 　　比如 　　产生的页面效果分别是：默认文字和加粗文字“cnbruce here” 　　1，一般文字...
jsp页面特殊字符，比如双引号，前后台转换
蚍蜉撼树
04-26 926
jsp 特殊字符处理
jsp页面如何转义字符--(使用反斜杠转义)\"
Only the heart peace will be prosperity
05-20 3560
实用displaytag时，有个需求，需要给table头加一个checkbox，点击实现全选！ 下面红色的部分，title里加了一个&lt;input type='checkbox' &gt;,onclick事件的双引号需要转义才能紧接成功， \"是将双引号转义的意思。。。      &lt;table border=1 width="100%"&gt;    &lt;tr&gt;  ...
字符串中如何使用转义字符
最新发布
06-12
在Python中，使用转义字符`\`可以在字符串中插入一些特殊字符，例如换行符、制表符等。常见的转义字符包括： - `\n`：换行符 - `\t`：制表符 - `\'`：单引号 - `\"`：双引号 - `\\`：反斜杠 使用转义字符的语法为，在需要插入特殊字符的位置前加上反斜杠`\`。例如： ``` python str1 = "Hello\nWorld" # 插入换行符 str2 = "I\'m a student" # 插入单引号 str3 = "The file is saved in C:\\User\\Documents" # 插入反斜杠 ``` 需要注意的是，在字符串中插入反斜杠时，要使用两个反斜杠`\\`，因为单个反斜杠在Python中也是一个转义字符。如果只写一个反斜杠，可能会导致语法错误。 另外，如果不想使用转义字符，也可以使用原始字符串的写法，在字符串前加上一个`r`或`R`，表示这是一个原始字符串。例如： ``` python str4 = r'The file is saved in C:\User\Documents' # 原始字符串，不使用转义字符 ``` 这样，字符串中的反斜杠就不会被解释为转义字符，而是作为普通字符处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值