S.l.e!ep.￠%
S.l.e!ep.￠%

Flash AS3 封装的 BigInt

/* *
 * BigInt
 * An ActionScript 3 implementation of Big Integer (light version)
 * Copyright (c) 2009 Alex.li
 * 
 * Derived from: 
 *         BigInt.js - Arbitrary size integer math package for JavaScript
 *         Copyright (C) 2000 Masanao Izumo <[email protected]>
 * 
 * Interfaces:
 * var x:BigInt = new BigInt("1234567890123456789012345678901234567890");
 * var y:BigInt = new BigInt("0x123456789abcdef0123456789abcdef0");
 * var z:BigInt = x.clone();
 * z = x.negative();
 * z = BigInt.plus(x, y);
 * z = BigInt.minus(x, y);
 * z = BigInt.multiply(x, y);
 * z = BigInt.divide(x, y);
 * z = BigInt.mod(x, y);    
 * var compare:int = BigInt.compare(x, y); //return -1, 0, or 1
 * var num:Number = x.toNumber(); //convert to normal number 
  */

package
{    
     public   class  BigInt
    {
         // sign of BigInt, negative or not
         private  var _sign:Boolean;
         // length of BigInt
         private  var _len: int ;
         // digits of BigInt
         private  var _digits:Array;
        
         public  function BigInt(arg)
        {
            var i: * , x: * , need_init:Boolean;

             if  (arg.length  ==   0 ) 
            {
                _sign  =   true ;
                _len  =   1 ;
                _digits  =   new  Array( 1 );
                need_init  =   true ;            
            }  else   if  (arg.length  ==   1 ) 
            {
                x  =  getBigIntFromAny(arg[ 0 ]);
                 if  (x  ==  arg[ 0 ]) x  =  x.clone();                
                _sign  =  x._sign;
                _len  =  x._len;
                _digits  =  x._digits;
                need_init  =   false ;            
            }  else  
            {
                _sign  =  (arg[ 1 ]  ?   true  :  false );
                _len  =  arg[ 0 ];
                _digits  =   new  Array(_len);
                need_init  =   true ;
            }

             if  (need_init) 
            {
                 for (i  =   0 ; i  <  _len; i ++ )
                _digits[i]  =   0 ;
            }
        }
        
         public  function toString():String
        {
             return   this .toStringBase( 10 );
        }
        
         public  function toStringBase( base : int ):String
        {
            var i: * , j: * , hbase: * ;
            var t: * ;
            var ds: * ;
            var c: * ;

            i  =   this ._len;
             if  (i  ==   0 )  return   " 0 " ;
             if  (i  ==   1   &&   ! this ._digits[ 0 ])  return   " 0 " ;

             switch ( base ) {
               default :
               case   10 :
              j  =  Math.floor(( 2 * 8 * i * 241 ) / 800 ) + 2 ;
              hbase  =   10000 ;
               break ;

               case   16 :
              j  =  Math.floor(( 2 * 8 * i) / 4 ) + 2 ;
              hbase  =   0x10000 ;
               break ;

               case   8 :
              j  =  ( 2 * 8 * i) + 2 ;
              hbase  =   010000 ;
               break ;

               case   2 :
              j  =  ( 2 * 8 * i) + 2 ;
              hbase  =   020 ;
               break ;
            }

            t  =   this .clone();
            ds  =  t._digits;
            var s:String  =   "" ;

             while  (i  &&  j) 
            {
                var k: *   =  i;
                var num: *   =   0 ;

                 while  (k -- ) 
                {
                    num  =  (num << 16 )  +  ds[k];
                     if (num  <   0 ) num  +=   4294967296 ;
                    ds[k]  =  Math.floor(num  /  hbase);
                    num  %=  hbase;
                }

                 if  (ds[i - 1 ]  ==   0 )
                i -- ;
                k  =   4 ;
                 while  (k -- ) 
                {
                    c  =  (num  %   base );
                    s  =   " 0123456789abcdef " .charAt(c)  +  s;
                     -- j;
                    num  =  Math.floor(num  /   base );
                     if  (i  ==   0   &&  num  ==   0 ) 
                    {
                         break ;
                    }
                }
            }

            i  =   0 ;
             while (i  <  s.length  &&  s.charAt(i)  ==   " 0 " )
            i ++ ;
             if (i)
            s  =  s.substring(i, s.length);
             if ( ! this ._sign)
            s  =   " - "   +  s;            
             return  s;
        }
        
         public  function clone():BigInt
        {
            var x:BigInt, i: int ;

            x  =   new  BigInt( this ._len,  this ._sign);
             for  (i  =   0 ; i  <   this ._len; i ++ )
            {
                x._digits[i]  =   this ._digits[i]; 
            }            
             return  x;
        }        
        
         /* *
         * become a negative BigInt
         * @return
          */
         public  function negative():BigInt
        {
          var n:BigInt  =   this .clone();
          n._sign  =   ! n._sign;
           return  normalize(n);
        }        
        
         public  function toNumber():Number
        {
            var d: *   =   0.0 ;
            var i: *   =  _len;
            var ds: *   =  _digits;

             while  (i -- ) 
            {
                d  =  ds[i]  +   65536.0   *  d;
            }
             if  ( ! _sign) d  =   - d;
             return  d;
        }
        
         public  function  get  sign():Boolean 
        { 
             return  _sign; 
        }
        
         public  function  get  length(): int  
        { 
             return  _len; 
        }
        
         public  function  get  digits():Array 
        { 
             return  _digits; 
        }    
        
        
         /* ************  public static methods  ************* */
        
        
         public   static  function plus(x: * , y: * ):BigInt
        {
            x  =  getBigIntFromAny(x);
            y  =  getBigIntFromAny(y);
             return  add(x, y,  1 );
        }
        
         public   static  function minus(x: * , y: * ):BigInt
        {
            x  =  getBigIntFromAny(x);
            y  =  getBigIntFromAny(y);
             return  add(x, y,  0 );
        }        
        
         public   static  function multiply(x: * , y: * ):BigInt
        {
            var i: * , j: * ;
            var n: *   =   0 ;
            var z: * ;
            var zds: * , xds: * , yds: * ;
            var dd: * , ee: * ;
            var ylen: * ;

            x  =  getBigIntFromAny(x);
            y  =  getBigIntFromAny(y);

            j  =  x._len  +  y._len  +   1 ;
            z  =   new  BigInt(j, x._sign  ==  y._sign);

            xds  =  x._digits;
            yds  =  y._digits;
            zds  =  z._digits;
            ylen  =  y._len;
            
             while  (j -- ) zds[j]  =   0 ;
             for  (i  =   0 ; i  <  x._len; i ++ ) 
            {
                dd  =  xds[i]; 
                 if  (dd  ==   0 )  continue ;
                n  =   0 ;
                 for  (j  =   0 ; j  <  ylen; j ++ ) 
                {
                    ee  =  n  +  dd  *  yds[j];
                    n  =  zds[i  +  j]  +  ee;
                     if  (ee) zds[i  +  j]  =  (n  &   0xffff );
                    n  >>>=   16 ;
                }
                 if  (n) 
                {
                    zds[i  +  j]  =  n;
                }
            }
             return  normalize(z);
        }        
        
         public   static  function divide(x: * , y: * ):BigInt
        {
            x  =  getBigIntFromAny(x);
            y  =  getBigIntFromAny(y);
             return  divideAndMod(x, y,  0 );
        }
        
         public   static  function mod(x: * , y: * ):BigInt
        {
            x  =  getBigIntFromAny(x);
            y  =  getBigIntFromAny(y);
             return  divideAndMod(x, y,  1 );
        }
        
         /* *
         * compare two BigInts, if  x=y return 0, if x>y return 1, if x<y return -1.
         * @param    x
         * @param    y
         * @return
          */
         public   static  function compare(x: * , y: * ): int
        {
            var xlen: * ;

             if  (x  ==  y)  return   0 ;

            x  =  getBigIntFromAny(x);
            y  =  getBigIntFromAny(y);
            xlen  =  x._len;

             if  (x._sign  !=  y._sign) 
            {
                 if  (x._sign)  return   1 ;
                 return   - 1 ;
            }

             if  (xlen  <  y._len)  return  (x._sign)  ?   - 1  :  1 ;
             if  (xlen  >  y._len)  return  (x._sign)  ?   1  :  - 1 ;

             while  (xlen --   &&  (x._digits[xlen]  ==  y._digits[xlen]));
             if  (  - 1   ==  xlen)  return   0 ;
            
             return  (x._digits[xlen]  >  y._digits[xlen])  ?
            (x._sign  ?   1  :  - 1 ) :
            (x._sign  ?   - 1  :  1 );
        }
        
        
         /* ************  private static methods  ************* */
        
        
         private   static  function getBigIntFromAny(x: * ):BigInt
        {            
             if  ( typeof (x)  ==   " object " ) 
            {
                 if  (x  is  BigInt)  return  x;
                 return   new  BigInt( 1 ,  1 );
            }
            
             if  ( typeof (x)  ==   " string " ) 
            {
                
                 return  getBigIntFromString(x);
            }
            
             if  ( typeof (x)  ==   " number " ) 
            {                
                var i: * , x1: * , x2: * , fpt: * , np: * ;
                
                 if  (  - 2147483647   <=  x  &&  x  <=   2147483647 ) 
                {
                     return  getBigIntFromInt(x);
                }
                x  =  x  +   "" ;
                i  =  x.indexOf( " e " ,  0 );
                 if  (i  ==   - 1 )  return  getBigIntFromString(x);
                x1  =  x.substr( 0 , i);
                x2  =  x.substr(i  +   2 , x.length  -  (i  +   2 ));

                fpt  =  x1.indexOf( " . " ,  0 );
                 if  (fpt  !=   - 1 ) 
                {
                    np  =  x1.length  -  (fpt  +   1 );
                    x1  =  x1.substr( 0 , fpt)  +  x1.substr(fpt  +   1 , np);
                    x2  =  parseInt(x2)  -  np;
                }  else  
                {
                    x2  =  parseInt(x2);
                }
                 while  (x2 --   >   0 ) 
                {
                    x1  +=   " 0 " ;
                }
                 return  getBigIntFromString(x1);
            }
             return   new  BigInt( 1 ,  1 );
        }    
        
         private   static  function getBigIntFromInt(n:Number):BigInt
        {
            var sign: * , big:BigInt, i: * ;
            
             if  (n  <   0 ) 
            {
                n  =   - n;
                sign  =   false ;
            }  else
            {                
                sign  =   true ;                
            }
            n  &=   0x7FFFFFFF ;
            
             if  (n  <=   0xFFFF ) 
            {
                big  =   new  BigInt( 1 ,  1 );
                big._digits[ 0 ]  =  n;
            }  else
            {                
                big  =   new  BigInt( 2 ,  1 );                
                big._digits[ 0 ]  =  (n  &   0xffff );
                big._digits[ 1 ]  =  ((n  >>   16 )  &   0xffff );
            }
             return  big;
        }
        
         private   static  function getBigIntFromString(str:String,  base : *   =   null ):BigInt
        {
            var str_i: * ;
            var sign:Boolean  =   true ;
            var c: * ;
            var len: * ;
            var z: * ;
            var zds: * ;
            var num: * ;
            var i: * ;
            var blen: *   =   1 ;

            str  +=   " @ " ;
            str_i  =   0 ;

             if  (str.charAt(str_i)  ==   " + " ) 
            {
                str_i ++ ;
            } else   if  (str.charAt(str_i)  ==   " - " ) 
            {
                str_i ++ ;
                sign  =   false ;
            }

             if  (str.charAt(str_i)  ==   " @ " )
                 return   null ;

             if  ( ! base ) 
            {
                 if  (str.charAt(str_i)  ==   " 0 " )
                {
                    c  =  str.charAt(str_i  +   1 );
                     if  (c  ==   " x "   ||  c  ==   " X " ) 
                    {
                         base   =   16 ;
                    } else   if  (c ==   " b "   ||  c  ==   " B " ) 
                    {
                         base   =   2 ;
                    } else  
                    {
                         base   =   8 ;
                    }
                } else  
                {
                     base   =   10 ;
                }
            }

             if  ( base   ==   8 ) 
            {
                 while  (str.charAt(str_i)  ==   " 0 " )
                str_i ++ ;
                len  =   3   *  (str.length  -  str_i);
            } else  
            {
                 if  ( base   ==   16   &&  str.charAt(str_i)  ==   ' 0 '   &&  (str.charAt(str_i  +   1 )  ==   " x "   ||  str.charAt(str_i  +   1 )  ==   " X " )) 
                {
                    str_i  +=   2 ;
                }
                 if  ( base   ==   2   &&  str.charAt(str_i)  ==   ' 0 '   &&  (str.charAt(str_i  +   1 )  ==   " b "   ||  str.charAt(str_i  +   1 )  ==   " B " )) 
                {
                    str_i  +=   2 ;
                }
                 while  (str.charAt(str_i)  ==   " 0 " )
                str_i ++ ;
                 if  (str.charAt(str_i)  ==   " @ " ) str_i -- ;
                len  =   4   *  (str.length  -  str_i);
            }

            len  =  (len  >>   4 )  +   1 ;
            z  =   new  BigInt(len, sign);
            zds  =  z._digits;

             while  ( true ) 
            {
                c  =  str.charAt(str_i ++ );
                 if (c  ==   " @ " )
                 break ;
                 switch  (c) 
                {
                     case   ' 0 ' : c  =   0 ;  break ;
                     case   ' 1 ' : c  =   1 ;  break ;
                     case   ' 2 ' : c  =   2 ;  break ;
                     case   ' 3 ' : c  =   3 ;  break ;
                     case   ' 4 ' : c  =   4 ;  break ;
                     case   ' 5 ' : c  =   5 ;  break ;
                     case   ' 6 ' : c  =   6 ;  break ;
                     case   ' 7 ' : c  =   7 ;  break ;
                     case   ' 8 ' : c  =   8 ;  break ;
                     case   ' 9 ' : c  =   9 ;  break ;
                     case   ' a ' :  case   ' A ' : c  =   10 ;  break ;
                     case   ' b ' :  case   ' B ' : c  =   11 ;  break ;
                     case   ' c ' :  case   ' C ' : c  =   12 ;  break ;
                     case   ' d ' :  case   ' D ' : c  =   13 ;  break ;
                     case   ' e ' :  case   ' E ' : c  =   14 ;  break ;
                     case   ' f ' :  case   ' F ' : c  =   15 ;  break ;
                     default :
                    c  =   base ;
                     break ;
                }
                 if  (c  >=   base )  break ;

                i  =   0 ;
                num  =  c;
                 while  ( true ) 
                {
                     while  (i  <  blen) 
                    {
                        num  +=  zds[i] * base ;
                        zds[i ++ ]  =  (num  &   0xffff );
                        num  >>>=   16 ;
                    }
                     if  (num) 
                    {
                        blen ++ ;
                         continue ;
                    }
                     break ;
                }
            }
             return  normalize(z);
        }            
        
         private   static  function add(x:BigInt, y:BigInt, sign: * ):BigInt
        {
            var z: * ;
            var num: * ;
            var i: * , len: * ;

            sign  =  (sign  ==  y._sign);
             if  (x._sign  !=  sign) 
            {
                 if  (sign)  return  subtract(y, x);
                 return  subtract(x, y);
            }

             if  (x._len  >  y._len) 
            {
                len  =  x._len  +   1 ;
                z  =  x; x  =  y; y  =  z;
            }  else  
            {
                len  =  y._len  +   1 ;
            }
            z  =   new  BigInt(len, sign);

            len  =  x._len;
             for  (i  =   0 , num  =   0 ; i  <  len; i ++ ) 
            {
                num  +=  x._digits[i]  +  y._digits[i];
                z._digits[i]  =  (num  &   0xffff );
                num  >>>=   16 ;
            }
            len  =  y._len;
             while  (num  &&  i  <  len) 
            {
                num  +=  y._digits[i];
                z._digits[i ++ ]  =  (num  &   0xffff );
                num  >>>=   16 ;
            }
             while  (i  <  len) 
            {
                z._digits[i]  =  y._digits[i];
                i ++ ;
            }
            z._digits[i]  =  (num  &   0xffff );
             return  normalize(z);
        }
        
         private   static  function subtract(x:BigInt, y:BigInt):BigInt
        {
            var z: *   =   0 ;
            var zds: * ;
            var num: * ;
            var i: * ;

            i  =  x._len;
             if  (x._len  <  y._len) 
            {
                z  =  x; x  =  y; y  =  z;
            } else   if  (x._len  ==  y._len) 
            {
                 while  (i  >   0 ) 
                {
                    i -- ;
                     if  (x._digits[i]  >  y._digits[i]) 
                    {
                         break ;
                    }
                     if  (x._digits[i]  <  y._digits[i]) 
                    {
                        z  =  x; x  =  y; y  =  z;
                         break ;
                    }
                }
            }

            z  =   new  BigInt(x._len, (z  ==   0 )  ?   1  :  0 );
            zds  =  z._digits;

             for  (i  =   0 , num  =   0 ; i  <  y._len; i ++ ) 
            { 
                num  +=  x._digits[i]  -  y._digits[i];
                zds[i]  =  (num  &   0xffff );
                num  >>>=   16 ;
            } 
             while  (num  &&  i  <  x._len) 
            {
                num  +=  x._digits[i];
                zds[i ++ ]  =  (num  &   0xffff );
                num  >>>=   16 ;
            }
             while  (i  <  x._len) 
            {
                zds[i]  =  x._digits[i];
                i ++ ;
            }            
             return  normalize(z);
        }
        
         private   static  function divideAndMod(x:BigInt, y:BigInt, modulo: * ):BigInt
        {
            var nx: *   =  x._len;
            var ny: *   =  y._len;
            var i: * , j: * ;
            var yy: * , z: * ;
            var xds: * , yds: * , zds: * , tds: * ;
            var t2: * ;
            var num: * ;
            var dd: * , q: * ;
            var ee: * ;
            var mod: * , div: * ;

            yds  =  y._digits;
             if  (ny  ==   0   &&  yds[ 0 ]  ==   0 )  return   null ;

             if  (nx  <  ny  ||  nx  ==  ny  &&  x._digits[nx  -   1 ]  <  y._digits[ny  -   1 ]) 
            {
                 if  (modulo)  return  normalize(x);
                 return   new  BigIt( 1 ,  1 );
            }

            xds  =  x._digits;
             if  (ny  ==   1 ) 
            {
                dd  =  yds[ 0 ];
                z  =  x.clone();
                zds  =  z._digits;
                t2  =   0 ;
                i  =  nx;
                 while  (i -- ) 
                {
                    t2  =  t2  *   65536   +  zds[i];
                    zds[i]  =  (t2  /  dd)  &   0xffff ;
                    t2  %=  dd;
                }
                z._sign  =  (x._sign  ==  y._sign);
                 if  (modulo)
                {
                     if  ( ! x._sign) t2  =   - t2;
                     if  (x._sign  !=  y._sign)
                    {
                        t2  =  t2  +  yds[ 0 ]  *  (y._sign  ?   1  :  - 1 );
                    }
                     return  getBigIntFromInt(t2);
                }
                 return  normalize(z);
            }

            z  =   new  BigInt(nx  ==  ny  ?  nx  +   2  : nx  +   1 , x._sign  ==  y._sign);
            zds  =  z._digits;
             if  (nx  ==  ny) zds[nx  +   1 ]  =   0 ;
             while  ( ! yds[ny  -   1 ]) ny -- ;
             if  ((dd  =  (( 65536   /  (yds[ny  -   1 ]  +   1 ))  &   0xffff ))  !=   1 ) 
            {
                yy  =  y.clone();
                tds  =  yy._digits;
                j  =   0 ;
                num  =   0 ;
                 while  (j  <  ny) 
                {
                    num  +=  yds[j]  *  dd;
                    tds[j ++ ]  =  num  &   0xffff ;
                    num  >>=   16 ;
                }
                yds  =  tds;
                j  =   0 ;
                num  =   0 ;
                 while  (j  <  nx) 
                {
                    num  +=  xds[j]  *  dd;
                    zds[j ++ ]  =  num  &   0xffff ;
                    num  >>=   16 ;
                }
                zds[j]  =  num  &   0xffff ;
            } else  
            {
                zds[nx]  =   0 ;
                j  =  nx;
                 while  (j -- ) zds[j]  =  xds[j];
            }
            j  =  nx  ==  ny  ?  nx  +   1  : nx;
            
             do  
            {
                 if  (zds[j]  ==   yds[ny  -   1 ]) q  =   65535 ;
                 else  q  =  ((zds[j]  *   65536   +  zds[j  -   1 ])  /  yds[ny  -   1 ])  &   0xffff ;
                 if  (q) 
                {
                    i  =   0 ; num  =   0 ; t2  =   0 ;
                     do  
                    {
                        t2  +=  yds[i]  *  q;
                        ee  =  num  -  (t2  &   0xffff );
                        num  =  zds[j  -  ny  +  i]  +  ee;
                         if  (ee) zds[j  -  ny  +  i]  =  num  &   0xffff ;
                        num  >>=   16 ;
                        t2  >>>=   16 ;
                    }  while  ( ++ i  <  ny);
                    
                    num  +=  zds[j  -  ny  +  i]  -  t2;
                     while  (num) 
                    {
                        i  =   0 ; num  =   0 ; q -- ;
                         do  
                        {
                            ee  =  num  +  yds[i];
                            num  =  zds[j  -  ny  +  i]  +  ee;
                             if  (ee) zds[j  -  ny  +  i]  =  num  &   0xffff ;
                            num  >>=   16 ;
                        }  while  ( ++ i  <  ny);
                        num -- ;
                    }
                }
                zds[j]  =  q;
            }  while  ( -- j  >=  ny);

             if  (modulo) 
            {
                mod  =  z.clone();
                 if  (dd) 
                {
                    zds  =  mod._digits;
                    t2  =   0 ; i  =  ny;
                     while  (i -- ) 
                    {
                        t2  =  (t2 * 65536 )  +  zds[i];
                        zds[i]  =  (t2  /  dd)  &   0xffff ;
                        t2  %=  dd;
                    }
                }
                mod._len  =  ny;
                mod._sign  =  x._sign;
                 if  (x._sign  !=  y._sign) 
                {
                     return  add(mod, y,  1 );
                }
                 return  normalize(mod);
            }

            div  =  z.clone();
            zds  =  div._digits;
            j  =  (nx  ==  ny  ?  nx  +   2  : nx  +   1 )  -  ny;
             for  (i  =   0 ; i  <  j; i ++ ) zds[i]  =  zds[i  +  ny];
            div._len  =  i;
             return  normalize(div);
        }        
        
         private   static  function normalize(x:BigInt):BigInt
        {
            var len: *   =  x._len;
            var ds: *   =  x._digits;

             while  (len --   &&   ! ds[len]);
            x._len  =   ++ len;
             return  x;
        }
    }    
}

你可能感兴趣的:(Flash AS3 封装的 BigInt)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 芦花鞋一四 许叶晗
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说 造命者说
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • 随笔 | 仙一般的灵气 海思沧海
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
  • 想家 爆米花机
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 小丽成长记（四十三） 玲玲54321
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 瑶池防线 谜影梦蝶
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
  • 爬山后遗症 璃绛
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
  • java短路运算符和逻辑运算符的区别 3213213333332132 java基础
    /* * 逻辑运算符——不论是什么条件都要执行左右两边代码 * 短路运算符——我认为在底层就是利用物理电路的“并联”和“串联”实现的 * 原理很简单，并联电路代表短路或（||），串联电路代表短路与（&&）。 * * 并联电路两个开关只要有一个开关闭合，电路就会通。 * 类似于短路或（||），只要有其中一个为true（开关闭合）是
  • Java异常那些不得不说的事 白糖_ javaexception
    一、在finally块中做数据回收操作 比如数据库连接都是很宝贵的，所以最好在finally中关闭连接。 JDBCAgent jdbc = new JDBCAgent(); try{ jdbc.excute("select * from ctp_log"); }catch(SQLException e){ ... }finally{ jdbc.close();
  • utf-8与utf-8(无BOM)的区别 dcj3sjt126com PHP
    BOM——Byte Order Mark，就是字节序标记   在UCS 编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输 字符"ZERO WIDTH NO-BREAK SPACE"。这样如
  • JAVA Annotation之定义篇 周凡杨 java注解annotation入门注释
        Annotation: 译为注释或注解 An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, pa
  • tomcat的多域名、虚拟主机配置 g21121 tomcat
    众所周知apache可以配置多域名和虚拟主机，而且配置起来比较简单，但是项目用到的是tomcat，配来配去总是不成功。查了些资料才总算可以，下面就跟大家分享下经验。 很多朋友搜索的内容基本是告诉我们这么配置： 在Engine标签下增面积Host标签，如下： <Host name="www.site1.com" appBase="webapps"
  • Linux SSH 错误解析（Capistrano 的cap 访问错误 Permission ） 510888780 linuxcapistrano
    1.ssh -v [email protected] 出现 Permission denied (publickey,gssapi-keyex,gssapi-with-mic,password). 错误 运行状况如下： OpenSSH_5.3p1, OpenSSL 1.0.1e-fips 11 Feb 2013 debug1: Reading configuratio
  • log4j的用法 Harry642 javalog4j
    一、前言：     log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，     当时在log4j完成时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中
  • mysql、sqlserver、oracle分页，java分页统一接口实现 aijuans oraclejave
    定义：pageStart 起始页，pageEnd 终止页,pageSize页面容量 oracle分页： 　　　　select * from ( select mytable.*,rownum num from (实际传的SQL) where rownum<=pageEnd) where num>=pageStart sqlServer分页：  
  • Hessian 简单例子 antlove javaWebservicehessian
    hello.hessian.MyCar.java package hessian.pojo; import java.io.Serializable; public class MyCar implements Serializable { private static final long serialVersionUID = 473690540190845543
  • 数据库对象的同义词和序列 百合不是茶 sql序列同义词ORACLE权限
    回顾简单的数据库权限等命令; 解锁用户和锁定用户 alter user scott account lock/unlock; //system下查看系统中的用户 select * dba_users; //创建用户名和密码 create user wj identified by wj; identified by //授予连接权和建表权 grant connect to
  • 使用Powermock和mockito测试静态方法 bijian1013 持续集成单元测试mockitoPowermock
            实例： package com.bijian.study; import static org.junit.Assert.assertEquals; import java.io.IOException; import org.junit.Before; import org.junit.Test; import or
  • 精通Oracle10编程SQL(6)访问ORACLE bijian1013 oracle数据库plsql
    /* *访问ORACLE */ --检索单行数据 --使用标量变量接收数据 DECLARE v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; BEGIN select ename,sal into v_ename,v_sal from emp where empno=&no; dbms_output.pu
  • 【Nginx四】Nginx作为HTTP负载均衡服务器 bit1129 nginx
     Nginx的另一个常用的功能是作为负载均衡服务器。一个典型的web应用系统，通过负载均衡服务器，可以使得应用有多台后端服务器来响应客户端的请求。一个应用配置多台后端服务器，可以带来很多好处：   负载均衡的好处 增加可用资源 增加吞吐量 加快响应速度，降低延时 出错的重试验机制 Nginx主要支持三种均衡算法： round-robin l
  • jquery-validation备忘 白糖_ jquerycssF#Firebug
    留点学习jquery validation总结的代码：   function checkForm(){ validator = $("#commentForm").validate({// #formId为需要进行验证的表单ID errorElement :"span",// 使用"div"标签标记错误， 默认:&
  • solr限制admin界面访问（端口限制和http授权限制） ronin47 限定Ip访问
    solr的管理界面可以帮助我们做很多事情，但是把solr程序放到公网之后就要限制对admin的访问了。 可以通过tomcat的http基本授权来做限制，也可以通过iptables防火墙来限制。 我们先看如何通过tomcat配置http授权限制。 第一步： 在tomcat的conf/tomcat-users.xml文件中添加管理用户，比如： <userusername="ad
  • 多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 bylijinnan java多线程
    public class IncDecThread { private int j=10; /* * 题目:用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 * 两个问题： * 1、线程同步--synchronized * 2、线程之间如何共享同一个j变量--内部类 */ public static
  • 买房历程 cfyme
        2015-06-21: 万科未来城，看房子   2015-06-26: 办理贷款手续，贷款73万，贷款利率5.65=5.3675   2015-06-27: 房子首付,签完合同   2015-06-28，央行宣布降息 0.25，就2天的时间差啊，没赶上。   首付，老婆找他的小姐妹接了5万，另外几个朋友借了1-
  • [军事与科技]制造大型太空战舰的前奏 comsci 制造
           天气热了........空调和电扇要准备好..........        最近,世界形势日趋复杂化,战争的阴影开始覆盖全世界..........        所以,我们不得不关
  • dateformat dai_lm DateFormat
    "Symbol Meaning Presentation Ex." "------ ------- ------------ ----" "G era designator (Text) AD" "y year
  • Hadoop如何实现关联计算 datamachine mapreducehadoop关联计算
        选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。     以关联计算为例。     假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单列表中？   &nbs
  • 用户模型中修改用户信息时，密码是如何处理的 dcj3sjt126com yii
    当我添加或修改用户记录的时候对于处理确认密码我遇到了一些麻烦，所有我想分享一下我是怎么处理的。 场景是使用的基本的那些(系统自带)，你需要有一个数据表(user)并且表中有一个密码字段(password),它使用 sha1、md5或其他加密方式加密用户密码。 面是它的工作流程: 当创建用户的时候密码需要加密并且保存，但当修改用户记录时如果使用同样的场景我们最终就会把用户加密过的密码再次加密，这
  • 中文 iOS/Mac 开发博客列表 dcj3sjt126com Blog
      本博客列表会不断更新维护，如果有推荐的博客，请到此处提交博客信息。 本博客列表涉及的文章内容支持 定制化Google搜索，特别感谢 JeOam 提供并帮助更新。 本博客列表也提供同步更新的OPML文件（下载OPML文件），可供导入到例如feedly等第三方定阅工具中，特别感谢 lcepy 提供自动转换脚本。这里有导入教程。
  • js去除空格，去除左右两端的空格 蕃薯耀 去除左右两端的空格js去掉所有空格js去除空格
    js去除空格，去除左右两端的空格 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&g
  • SpringMVC4零配置--web.xml hanqunfeng springmvc4
    servlet3.0+规范后，允许servlet，filter，listener不必声明在web.xml中，而是以硬编码的方式存在，实现容器的零配置。 ServletContainerInitializer：启动容器时负责加载相关配置 package javax.servlet; import java.util.Set; public interface ServletContainer
  • 《开源框架那些事儿21》：巧借力与借巧力 j2eetop 框架UI
    同样做前端UI，为什么有人花了一点力气，就可以做好？而有的人费尽全力，仍然错误百出？我们可以先看看几个故事。 故事1：巧借力，乌鸦也可以吃核桃 有一个盛产核桃的村子，每年秋末冬初，成群的乌鸦总会来到这里，到果园里捡拾那些被果农们遗落的核桃。 核桃仁虽然美味，但是外壳那么坚硬，乌鸦怎么才能吃到呢？原来乌鸦先把核桃叼起，然后飞到高高的树枝上，再将核桃摔下去，核桃落到坚硬的地面上，被撞破了，于是，
  • JQuery EasyUI 验证扩展 可怜的猫 jqueryeasyui验证
      最近项目中用到了前端框架-- EasyUI，在做校验的时候会涉及到很多需要自定义的内容，现把常用的验证方式总结出来，留待后用。   以下内容只需要在公用js中添加即可。   使用类似于如下： <input class="easyui-textbox" name="mobile" id="mobile&
  • 架构师之httpurlconnection----------读取和发送(流读取效率通用类) nannan408
    1.前言.    如题. 2.代码. /* * Copyright (c) 2015, S.F. Express Inc. All rights reserved. */ package com.test.test.test.send; import java.io.IOException; import java.io.InputStream
  • Jquery性能优化 r361251 JavaScriptjquery
    一、注意定义jQuery变量的时候添加var关键字 这个不仅仅是jQuery，所有javascript开发过程中，都需要注意，请一定不要定义成如下： $loading = $('#loading'); //这个是全局定义，不知道哪里位置倒霉引用了相同的变量名，就会郁闷至死的 二、请使用一个var来定义变量 如果你使用多个变量的话，请如下方式定义： . 代码如下: var page
  • 在eclipse项目中使用maven管理依赖 tjj006 eclipsemaven
    概览: 如何导入maven项目至eclipse中 建立自有Maven  Java类库服务器 建立符合maven代码库标准的自定义类库 Maven在管理Java类库方面有巨大的优势，像白衣所说就是非常“环保”。 我们平时用IDE开发都是把所需要的类库一股脑的全丢到项目目录下，然后全部添加到ide的构建路径中，如果用了SVN/CVS，这样会很容易就 把
  • 中国天气网省市级联页面 x125858805 级联
    1、页面及级联js <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> &l
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他