1.自己写一个计算器demo
知识点：
1.System.Math.Pow() 实现乘方
2.实现计算器的运算优先级，依次调用的流程
问题：
还未实现“()”功能
解决方案
UI:
aaarticlea/png;base64,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" alt="" />aaarticlea/png;base64,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" alt="" />
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms; namespace CaculationTest
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
} private void button_Click(object sender, EventArgs e)
{
var text=((Button)sender).Text;
if (text == "=")
{
Evaluate();
}
else
{
txtExpression.Text = txtExpression.Text + text;
}
} private void Evaluate()
{
txtExpression.Text = new Caculator().Evaluate(txtExpression.Text).ToString();
} private void button16_Click(object sender, EventArgs e)
{
txtExpression.Clear();
} }
}
Form1.cs
using System;
using System.Collections.Generic;
using System.Text; namespace CaculationTest
{
enum TokenType
{
Add,Sub,
Mul,Div,
Int,
Expo,
Start,End
} class Token
{
public TokenType Type;
public object Value; public Token(TokenType type , object value = null)
{
Type = type;
Value = value;
}
}
}
Token.cs
using System;
using System.Collections.Generic;
using System.Text; namespace CaculationTest
{
/// <summary> </summary>
abstract class Expression
{
public abstract int GetValue();
} class UnaryExpress : Expression
{
int _value; public UnaryExpress(int value)
{
_value = value;
} public override int GetValue()
{
return _value;
}
} class BinaryExpression : Expression
{
TokenType _tokenType;
int _left;
int _right; public BinaryExpression(TokenType tokenType, Expression left, Expression right)
{
_tokenType = tokenType;
_left = left.GetValue();
_right = right.GetValue();
} public override int GetValue()
{
switch (_tokenType)
{
case TokenType.Add:
return _left + _right;
case TokenType.Sub:
return _left - _right;
case TokenType.Mul:
return _left * _right;
case TokenType.Div:
return _left / _right;
case TokenType.Expo:
return Convert.ToInt32(Math.Pow(_left,_right));
default:
throw new Exception("unexceptional token!");
}
}
}
}
Expression.cs
using System;
using System.Collections.Generic;
using System.Text; namespace CaculationTest
{
/// <summary> </summary>
class Caculator
{
string _exp; int _pos;
Token _token;
int _len; public int Evaluate(string expression)
{
_exp = expression;
_len = expression.Length;
var exp = ParseExpression();
return exp.GetValue();
} Expression ParseExpression()
{
//先解析一次，解析内容存在_token中
ParseToken();
return ParseAddSub();
} //解析加减
Expression ParseAddSub()
{
//左操作数为优先级理高的运算符
var l = ParseMulDiv();
while (_token.Type == TokenType.Add || _token.Type == TokenType.Sub)
{
var t = _token.Type;
ParseToken();
var r = ParseMulDiv();//解析右操作数
l = new BinaryExpression(t, l, r);
}
return l;
} #region 老逻辑
////解析乘除
//Expression ParseMulDiv()
//{
// var l = ParseUnary();
// while (_token.Type == TokenType.Mul || _token.Type == TokenType.Div)
// {
// var t = _token.Type;
// ParseToken();
// var r=ParseUnary();
// l = new BinaryExpression(t, l, r);
// }
// return l;
//}
#endregion //解析乘除
Expression ParseMulDiv()
{
var l = ParseExpo();
while (_token.Type == TokenType.Mul || _token.Type == TokenType.Div)
{
var t = _token.Type;
ParseToken();
var r = ParseExpo();
l = new BinaryExpression(t, l, r);
}
return l;
} //解析乘方
Expression ParseExpo()
{
var l = ParseUnary();
while (_token.Type==TokenType.Expo)
{
var t = _token.Type;
ParseToken();
var r = ParseUnary();
l = new BinaryExpression(t, l, r);
}
return l;
} //解析一元表达式（目前只有单个整数）
Expression ParseUnary()
{
Expression ret = null;
if (_token.Type == TokenType.Int)
{
ret= new UnaryExpress((int)_token.Value);
} //解析完int后，移到下一个token处，即+-*/
ParseToken();
return ret;
} void ParseToken()
{
//已结束
if (_pos >= _len)
{
_token= new Token(TokenType.End);
return;
} //跳过空格
while (_exp[_pos] == ' ')
{
_pos++;
} //如果以数字开头，解析整数
if (_exp[_pos] >= '' && _exp[_pos] <= '')
{
for (int i = ; i + _pos <= _len; i++)
{
//如果以数字结尾，或者到达了数字的边界
if( i+_pos==_len||(_exp[_pos + i] < '' || _exp[_pos + i] > ''))
{
var intStr = _exp.Substring(_pos, i);
var value = int.Parse(intStr);
_token= new Token(TokenType.Int, value);
_pos += i; //解析成功后，更新当前位置
break;
}
}
}
else
{
switch (_exp[_pos])
{
case '+':
_token=new Token(TokenType.Add);
break;
case '-':
_token = new Token(TokenType.Sub);
break;
case '*':
_token=new Token(TokenType.Mul);
break;
case '/':
_token = new Token(TokenType.Div);
break;
case '^':
_token=new Token(TokenType.Expo);
break;
default:
throw new Exception("unexpected token: " + _exp[_pos]);
}
_pos++;//解析成功后，更新当前位置
}
} }
}
Calculator.cs
验证结果
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAWYAAAD7CAIAAADWy6loAAAU/ElEQVR4nO2d729b5d2H7z8if0GkpzCtINnsSFMFlC2sdC9o13WKawrJ+JUXe7HH2nRmqVZKJzmuNRVsAy8gTQoTCDlrxZ6qo0/bBANb+ogEl9LSlmIvqHgWM66zntQ/JI4t8bxw7DiOk/j+3j7n3Ofkc+n74tTx7XPpzjlX0zQ/2PcNfgQAAJvBWpPxPQAAbEh7MibOXsFgMJj1pj0Zr793BYPBYNYbJAODwXBMezLGz17FYDCY9aY9GZPnrmEwGMx6g2RgMBiOaU/GGxeuYzAYzHrTnow/T3+BwWAw6017Mt5KfInBYJw9x145+dRDjw/09a83Tz30+LFXTnZci2RgMFtu9m5TLowfL32eXG8ujB/fu03puLY9Ge98kF5nZp76IVvmh4HIuk/rZiYGmOuptzd72tuB/+rmaW0TPsAIqzCYrTQDff3aJ7PZN15eb7RPZgf6+juubU9G/KOFDvPO6DbGHv3Tyh+H/9Tpad3O5KPMPfwO75s2ncTwdsYe9wq8AgazJWagr//Oxx99/fqxl373h/2DI/sHR1oPvn792J2PPxro6++4tptkJIa3t/SiB2NQMnr1ChiMw2egr39x9v2vXg7uHxyp3/6tB1+9HFycfb/bZPxl9qv2iY9uY95Dax+f/erQnsY/VfacaDz4wa+3Lz/26LGv/jJ74lHm/nW8/qbm8cqDq1/hxKOs7Y+NtfHRbaz1ZRsv8ltv/cFtv/2gIdB6RgwG02EG+vq/HH/p3MD20b17mrGo92J0755zA9u/HH9poK+/49r2ZJy6eKt9pg7fs/3wK2sfX5k3fsbcT0/dOnXxo6e3s3v++6NOb2o9bn1wgze1Psh+9mJDpuVBtueNUxdvnXrxCcaeCHQ4IwaD6TADff2pydiFn7sv/Nx9eN++ejX2D44c3rev/mBqMjbQ199xbXfJWLkhV8+LTzT+7nc/PdXxmZslo+0VOj5/9csG9tTz0fGVbyEZGMymM9DXv/DWax/8aueRwcH9gyP/bLB/cOTI4OAHv9q58NZr3Sbjfz7OrJm/P3sf2xVZ8/ipI/ewg4eXn/DAs6daH2nOn3exB5491XbcOFj7Ch2fv/plD++ry3R85bZjDAbTYQb6+m+dfPPiM3ubvWg9uPjM3lsn3xzo6++4tj0Zp+ezHSZ2kDH2WKzxx3ePPBfLno4dZPcdeW0+e/rdI/eyB557N3t6fva5+9i9v5ttWTv73H2NhbGDbPlpbz1WP+jwCo03zbcev/VY8+zvHrmXHXxhfr1nth1jMJgOM9DXn/3byUu/f3bsmefr/1HSenDp989m/3ZyoK+/49r2ZJxJftN5/vrHe5ufm7z/j+PJb84kLz5/f/2PT+6+/0fP/7X+zLd3N561O/bNmeQ3Z2JPLv/5l0/uZvWnvd046PAKR35Zf/LbLU9rPXvridqOG6+2ShKDwbTPQF9/7v33ro/9Yb3Jvf/eQF9/x7VdJwODwThlfvGDH8+MHy/834frzcz48V/84Mcd17Yn471Pv8FgMM6e106c2btN2eB7TPZuU147cabj2vZk/O/lHAaDwaw3SAYGg+GY9mSc/yyHwWAw683mydAAAFsYJAMAwAGSAQDgAMkAAHCAZAAAOEAyAAAcIBkAAA6QDAAAB0gGAIADJAMAwAGSAQDgAMkAAHAgYzIuXU/Fz82++s5ZDAazwcTPzV66njLhlmxFxmSkvr79r/zS9wCADflXfunKP/9twi3ZiqTJsO69AICdQDI0DckAoGuQDE1DMsCWJh3dwdiOaLq7ZyMZmoZkAPtwdqTxWy9GzhJWrV2Uju4YOfv992dH1kaj47mQDE1DMoBNSEd3NO7elsNNOTvS+CDi7MjqRWdHVnLQerzBuZAMTUMygA1JR3d0/Y8JsUWrlyEZmoZkAPvR+aOMTZLA86HJesuQDE1DMoDdSEd3dPyE5QbJSEd3cH4CpPO5kAxNQzKArejYi5VPVW70yVHuDzPWngvJ0DQkA9iH9T6+aL51489VcH0yo+O5kAxNQzKAXWj7X401dCwC/f9ZOj0XydA0JAPYhLZ/fXT/8UJzIWFJ20IkQ9OQDAC6BsnQNCQDgK5BMjQNyQCga5AMTUMyAOgaJEPT8CN2AOgO/IidZXL5/6T/rWEwmE0nl/+PCbdkKzImAwAgLUgGAIADJAMAwAGSAQDgAMkAAHCAZAAAOEAyAAAcIBkAAA6QDAAAB0gGAIADJAMAwIG8yYhGo36/32cufr8/Go3ShN9MXBuMXHjwhdNmzmDkwpuJa1tkh2UWNt9NZCdFkDQZR8PhWCyWy+Vq5pLL5WKx2NFwmFf4xMznO1/9+65PlnbfrJo5uz5Z2vnq30/MfO74HZZZ2BI38k4KImkyVFXN5/O6rt81F13X8/m8qqq8wvtfOr8rufSbhe9MFv7Nwne7kkv7Xzrv+B2WWdgSN/JOCiJpMnw+X61WM/Md0KRWq/l8Pl7hB184vfuLqiXCu7+oPvjCacfvsMzCVrnRdlIQeZNRrVaXrKBarZKTYYkwORn22mGZha1yo+2kIFInw5xztSGSDAN0NkckGUb4bIpIMgzQ2Zwuk2GWzgpIxgoyXx8dQTK6B8noFUjGCvX3wR0rICfjsRu6JcKP3dDJybBEWCQZcgpT3T4NKYwpoU8NEzMCeZOh6/oikalhNjxFXazrOjkZNNdlqMrkZNB2uClM3mLaDotdEkJsKkxzS44pw1OLi1PDyljSIDEjcFgykmOK4PVsajKSY0rDtOWQE1OTMTXMli9wepeRjMV6eRv713rcWzEjkDoZBSLxITYUpy4mJ2PXje+o5ywUCoX5oKIE5wkLd934jpwMK3yJOywsTKfLZEgoZgRSJ+M2kfgQG4pTF9OTcf076jlv3749F1SI0ruu05NhhS9xh0WE54KKEpyjre1GWHQzDRMzAnmTUalUFohMepl3krq4UqnQkvHTK2XqORcSo27mHk2Q1v70SpmWDPIOJ0bdjNG3mLbDgsLU3e1KWOxypUPbSUGQjN68G0SSIdKLBSuS0bSm7bKZyZj0slWQjJGMVqRORprIxAF2YIK6mJyMn3xWIpxuJuBirsAM1TadTv/ksxI5GQKnTc8EXDRxkWSYrNqlsPhmGiRmBFInI0VkwsM8E9TFIsmgmAqo1hFJBu+5pgOuhm/LISciyaCcL5WaDrhcgWna2m6ExS5XOkjGCj6fr1wu3yQy7mGecericrlMS8YjnxUJoq24Dp0nCD/yWZGWDNoON51ptjepOyx2SQixqbBVbrSdFMSRybDg3UBLRk8wORniIBmmiRmB1Mm4YQX0ZFwuWiL8yGV6MiwRFkmGnMJWuSEZK/h8vlKpdM0KSqUSLRk7P71rifDOT+/SkmGvHZZZ2Co32k4KgmT05t2AZHQPkmGamBFInYyrViCSDEuERZJhibBIMuQUtsoNyVjB5/MVi8UrVlAsFmnJePjSkiXCD19aoiXDXjsss7BVbrSdFETSZKiqmslkCoXCZXMpFAqZTIb244If/se3By/lTRY+eCn/8D++pf24YHvtsMzClriRd1IQSZMRDocjkUg2my2aSzabjUQiYdIvJXgw9uFDs98+dEkzdWa/fTD2IeGXEthuh2UWtsSNvJOCSJoMTdNCoZCqqj5zUVU1FArRhI9PX9137JzJv/po37Fzx6evbpEdllnYfDeRnRRB3mQAACQEyQAAcIBkAAA4QDIAABwgGQAADpAMAAAHSAYAgAMkAwDAgbzJiEajfr/fzK+N8fl8fr8/Go1CWE5hmzo7DEmTcTQcjsViuVyuZi65XC4Wix3l/yJcCBstbFNn5yFpMlRVzefzuq7fNRdd1/P5PO2bpiBsqLBNnZ2HpMnw+Xy1Ws3kK6NOrVbzkb41G8KGCtvU2XnIm4xqtbpkBdVqlXYHQthQYZs6Ow+pk2HOudoQuQMN0NmcLSKs2dPZeSAZ7WyRO9B2wpo9nZ2H1Mm4YwUidyCEjRO2qbPzkDcZuq4vUpkaZspYkrZW13XaHUgSnhpe+WVpRGVzhVuUh6coy6nCQs7CkJ2dhxOTkRxTyPefBcmg3nmWCS8bk7uMZNgaqZNRoDAfVJShIUUJzpOWF0TuQJIsVdQS4fgQs0iY7twLkIwmUifjNoH4EBuKzwUVJThHWX77tsgdyH2yuaDS/GeJHYTnggobitM8BYXpm9wLkIwm8iajUqkscDPpZd7JhYXEqNs9muBfvrCwsFCpVGh3IEV40suWRROjbuadlF04Mep2e73ueuRoulRh+ib3ArKz83BUMpqlsE0yOsnLLJwYdVvVOJFNnvQKNU7E2XlInYw0HzMBF2vFFZjhfIV0Op0WuQMJp2u1t4HwxIGmpMnCPdlkMkhGE6mTkaIyHXC5AtO0tSJ3IMGTeSZSqVQqNeFhRGUzhVOpCc+ycYu7KcICzj0AyWgibzLK5fJNKucPuVyHztPWlstl2h1IEx73ND4msonwirFn3ExhIWdhyM7Ow5nJMP/igLDRwjZ1dh5SJ+OGFYjcgRA2Ttimzs5D3mSUSqVrVlAqlWh3IIQNFbaps/NAMnpzcUDYaGGbOjsPqZNx1QpE7kAIGydsU2fnIW8yisXiFSsoFou0OxDChgrb1Nl5SJoMVVUzmUyhULhsLoVCIZPJ0H76LoQNFbaps/OQNBnhcDgSiWSz2aK5ZLPZSCQS5v/x8xA2Wtimzs5D0mRomhYKhVRV9ZmLqqqhUAjCcgrb1NlhyJsMAICEIBkAAA6QDAAAB0gGAIADJAMAwAGSAQDgAMkAAHCAZAAAOJA3GdFo1O/3m/xFO36/PxqNQlhOYZs6OwxJk3E0HI7FYrlcrmYuuVwuFosd5f/SYAgbLWxTZ+chaTJUVc3n87qu3zUXXdfz+Tztu7wgbKiwTZ2dh6TJ8Pl8tVrN5CujTq1W85G+lxzChgrb1Nl5yJuMarW6ZAXVapV2B0LYUGGbOjsPqZNhzrnaELkDDdDZnC0irNnT2XkgGe1skTvQdsKaPZ2dh9TJuGMFIncghI0Ttqmz85A3GbquL3KSHFNW/VJWNjzF+xKLi7qu0+5AgnCrszKWJCw3X3hqWGBzBYRFnOve5B0WcXYejkrGKpJjCumiNvUOTI4py7fe1DA1GqYKr2hODVOjYXoyWv4qoWYDyWgidTIKAsSHlOA8ZaHIHch9svmg0tCMD7GhuOzCLb6F+aBipjB9kwvLm0veYRFn5yF1Mm6TmQsqSnCOtFTkDhQQjQ+xobj8wvEhtryxc0GF0fZYMBmEM4qDZDSRNxmVSmWBSmLU7Z0krq1UKrQ7kCicGHUzxph7NGEP4Ulv/UN8t9frpknThIU2WRiys/NwZDImvYxcDHPvwMRo47ZbOZJauIVJL7FzSIatkToZaRIzAZcrMENbm06nRe5AEVWytpnCq93ZgQnKSsFkCDjTQTKaSJ2MFIXpgMsVmCYtTaVSqZTIHch9sgkPW5adDriYZ0J24RXLCQ8j+hKF6ZvcC5CMJvImo1wu3yQw7mGeccrCBuVymXYH0oTHPY3//6NqWyVM3maasIizOGRn5+G4ZFh0cUDYaGGbOjsPqZNxwwpE7kAIGydsU2fnIW8ySqXSNSsolUq0OxDChgrb1Nl5IBm9uTggbLSwTZ2dh9TJuGoFIncghI0Ttqmz85A3GcVi8YoVFItF2h0IYUOFbersPCRNhqqqmUymUChcNpdCoZDJZGg/fRfChgrb1Nl5SJqMcDgciUSy2WzRXLLZbCQSCfP/+HkIGy1sU2fnIWkyNE0LhUKqqvrMRVXVUCgEYTmFbersMORNBgBAQpAMAAAHSAYAgAMkAwDAAZIBAOAAyQAAcIBkAAA4QDIAABzIm4xoNOr3+03+oh2/3x+NRiEM4Z4IOxJJk3E0HI7FYrlcrmYuuVwuFosd5f/SYAhDeIsgaTJUVc3n87qu3zUXXdfz+Tztu7wgDOGtgKTJ8Pl8tVrN5IujTq1W85G+lxzCEN4KyJuMarW6ZAXVapV2QUMYwlsBqZNhzrnaELmgDdDZHAgbDZLRCpLRzha5oCHcPUhGK1In444ViFzQEIaw45E3GbquL/IzNdz45WPDU4Tli4uLuq7TLujuhZNjCmvTbH2IU98E4d5ikXByTCFeEzRhp+KsZCTHFGUsufrInOuje+HkmMJW1KaG63Wg+yIZ3TE1TN1gJGMVUiejwEt8iA3F1xzyIXJBd/Hy80FFCc53+7AEwr3HCuH5oEK7HOjCTkXqZNzmZC6oKMG5tcdciFzQfIrdPG65sAFYIBwfou4uXdipyJuMSqWywEli1O0eTaw95qJSqdAu6K6E19NKjLpXfSrDOymJcBuTXqKlVcILCwsLiVE3zVRI2KkgGb25PnqQDJquBXegKGYLT3qpWysk7FSkTkaal4kD7MDEmkM+RC7oLl5+JuByBWa6fVgC4dVMHGj9KEPKHW5jJuCiaYoKOxWpk5HiZTrgcgWmVx/xInJBd+nIVtQmPIx5JkR8DRfuOaYKT3io+yoq7FTkTUa5XL7Jz7in8TegZ5yw/ObNm+VymXZBdy98/pCLtWm2PsQYY8x16Lw8wr3FROFxD/k6EBZ2Kk5Lhji4AyHcE2GnInUybliByAUNYQg7HnmTUSqVrllBqVSiXdAQhvBWAMnozfUBYQhvEaROxlUrELmgIQxhxyNvMorF4hUrKBaLtAsawhDeCkiaDFVVM5lMoVC4bC6FQiGTydB+mC2EIbwVkDQZ4XA4Eolks9miuWSz2UgkEub/CfQQhvAWQdJkaJoWCoVUVfWZi6qqoVAIwhDuibAjkTcZAAAJQTIAABwgGQAADpAMAAAHSAYAgAMkAwDAAZIBAOAAyQAAcIBkAAA4QDIAABwgGQAADpAMAAAHSAYAgAMkAwDAAZIBAOAAyQAAcIBkAAA4QDIAABwgGQAADpAMAAAHSAYAgAMkAwDAAZIBAOAAyQAAcIBkAAA4QDIAABwgGQAADpAMAAAHSAYAgAMkAwDAAZIBAOAAyQAAcIBkAAA4QDIAABwgGQAADpAMAAAHSAYAgAMkAwDAAZIBAOAAyQAAcIBkAAA4QDIAABwgGQAADpAMAAAHSAYAgAMkAwDAAXcyMBgMpjlIBgaD4RgkA4PBcAySgcFgOAbJwGAwHINkYDAYjlmVjGe+KGEwGMwGsyoZAACwMf8PzlirNtKoi44AAAAASUVORK5CYII=" alt="" />aaarticlea/png;base64,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" alt="" />
1.自己写一个计算器demo的更多相关文章
- 用VBA写一个计算器
着急的 玩家 可以 跳过“============”部分 ======================================可以跳过的 部分 开始==================== ...
- 如何用Python写一个计算器软件 附带效果图
该计算器使用Python tkinter模块开发 效果如下图 import tkinter #导入tkinter模块 root = tkinter.Tk() root.minsize(280,500 ...
- 使用JS写一个计算器
先上效果图: 简单的加减乘除功能还是有的,所以我们就考虑怎么来实现这个功能. 根据预期效果,可以确定页面中的布局要用到table tr td. 所以先放上页面布局,table的边框宽度border,c ...
- 写一个小demo过程中遇到的各种问题 学生管理考勤系统（网页模拟）
添加与新增一些小玩意的1.0.3版本:传送门 各位带哥,这不是你们要的c++.java.c#作业哈 课上要求做个小作业,学生管理考勤系统,原本想着是个练手的好机会,结果只证实了我还是个弟中弟. 设想的 ...
- 用JS写一个计算器（兼容手机端）
先看成果:1.PC端2. 首先确立html,有哪些东西我们要知道.布局大概的样子在心里有个数 <!DOCTYPE html> <html> <head> <m ...
- 模仿Masonary写一个计算器
1.CaculatorMaker @interface CaculatorMaker : NSObject @property(nonatomic,assign)int result; -(Cacul ...
- 手写一个死锁Demo
相互持有对方锁,导致死锁 package jesse.test04; public class DeadLockSample extends Thread{ private String first; ...
- css写一个计算器叭
显示效果如图,emoji可替换为数字.
- 写一个Python的windows服务
1. 安装pywin32和pyinstaller pip install pywin32 pip install pyinstaller 2.写一个服务Demo # -*- coding: utf-8 ...
随机推荐
- SQL 设计心得、逗号分隔列表
第一: 在开始编码前.主要关注数据库里要保存什么样的数据,以级最佳的数据组织方式和内在关联方式. 第二: 使用你所知的数据库特性尽可能高效的实现数据管理.如正确的索引.数据库类型.高效的select! ...
- 测试linux和window下 jdk最大能使用多大内存
在命令行下用 java -XmxXXXXM -version 命令来进行测试,然后逐渐的增大XXXX的值,如果执行正常就表示指定的内存大小可用,否则会打印错误信息. 发现在linux先 最多用java ...
- 常用CSS HACK
常用CSS HACK IE6 3像素bug和双边距bug一样的经典 现象: IE6下浮动元素和不浮动元素之间会有3px间隙(3px bug,div.float-left + div.float-non ...
- LBA（逻辑区块地址）及PBA（物理区块地址）
LBA,全称为Logical Block Address,是PC数据存储装置上用来表示数据所在位置的通用机制,我们最常见到使用它的装置就是硬盘.LBA可以指某个数据区块的地址或者某个地址上所指向的数据 ...
- 使用自定义脚本扩展程序自动执行 VM 自定义任务
在 Build 开发者大会上推出VM 扩展程序的其中一个称为"自定义脚本扩展程序",它支持 PowerShell.如果这是您第一次访问这些博客,可能需要查看以前的博客,请单击 ...
- Ubuntu下lamp（PHP+Mysql+Apache）搭建+完全卸载卸载方法
安装apache2 sudo apt-get install apache2 安装完成,运行如下命令重启下: sudo /etc/init.d/apache2 restart 在浏览器里输入http: ...
- Windows下Oracle服务介绍
如图,截取的是11gR2下RAC其中一个节点的Oracle服务列表. oracle在处理一般事务时并不需要全部启动其后台的所有服务由于oracle服务所占用系统资源比较大,一般情况下,对于单实例的OR ...
- DataSet - DataTable - DataRow 读取 xml 文件 + 搜索
DataSet ds = XmlHelper.GetDataSetByXml(AppDomain.CurrentDomain.BaseDirectory + "/Config/ConfigN ...
- 上一篇下一篇 排序 (非ID字段排序)
网上看了很多关于"上一篇下篇"的文章,可大都是按ID排序. 实际上,很少有按ID排序的. 分享下我的单独排序字段的写法,主要分为ms sql2000 和 ms 2005及以上版本. ...
- Web Service 入门例子
在网上很常见的一个列子,实现计算器,看完总得自己练练,不然一段时间不接触又忘了 新建一个空网页,因为.net framework 4.0 不能直接建web 服务,只能在项目中添加 然后在项目中添加We ...