JS中Float类型加减乘除 修复
MXS&Vincene ─╄OvЁ &0000027─╄OvЁ MXS&Vincene
MXS&Vincene ─╄OvЁ：今天很残酷，明天更残酷，后天很美好，但是绝大部分人是死在明天晚上，只有那些真正的英雄才能见到后天的太阳。
MXS&Vincene ─╄OvЁ：We're here to put a dent in the universe. Otherwise why else even be here?
正文>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//浮点数加法运算
function FloatAdd(arg1,arg2){
var r1,r2,m;
try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}
try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2));
return (arg1*m+arg2*m)/m;
}
//浮点数减法运算
function FloatSub(arg1,arg2){
var r1,r2,m,n;
try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}
try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2));
//动态控制精度长度
n=(r1=r2)?r1:r2;
return ((arg1*m-arg2*m)/m).toFixed(n);
}
//浮点数乘法运算
function FloatMul(arg1,arg2)
{
var m=0,s1=arg1.toString(),s2=arg2.toString();
try{m+=s1.split(".")[1].length}catch(e){}
try{m+=s2.split(".")[1].length}catch(e){}
return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m);
}
//浮点数除法运算
function FloatDiv(arg1,arg2){
var t1=0,t2=0,r1,r2;
try{t1=arg1.toString().split(".")[1].length}catch(e){}
try{t2=arg2.toString().split(".")[1].length}catch(e){}
with(Math){
r1=Number(arg1.toString().replace(".",""));
r2=Number(arg2.toString().replace(".",""));
return (r1/r2)*pow(10,t2-t1);
}
}
JQ 操作 radio、checkbox 、select
MXS&Vincene ─╄OvЁ &0000026─╄OvЁ MXS&Vincene
MXS&Vincene ─╄OvЁ：今天很残酷，明天更残酷，后天很美好，但是绝大部分人是死在明天晚上，只有那些真正的英雄才能见到后天的太阳。
MXS&Vincene ─╄OvЁ：We're here to put a dent in the universe. Otherwise why else even be here?
正文>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
<label><input type="radio" name="sex" value="1">男</label>
<label><input type="radio" name="sex" value="0">女</label>
JQ获取被选中的值：$(':radio[name="sex"]:checked').val();
JQ设置为选中：$(':radio[name="sex"]').eq(0).attr("checked",true);
反选：(′:radio[name="sex"]′).eq(0).attr("checked",false);或(′:radio[name="sex"]′).eq(0).attr("checked",false);或(':radio[name="sex"]').eq(0).attr("checked",'');
if($(':radio[name="sex"]').attr('checked')==undefined) //判断是否已经选中
$(':radio[name="sex"]').attr("checked",'10');//设置value=10的单选按钮为选中项
下拉框select： $(':select[name="sex"]').attr("value",'1');//设置value=1的项目为选中项
扩展：
checkbox 类似；
扩展2：
获取一组radio被选中项的值
var item = $('input[@name=items][@checked]').val();
or
var item = $('input[name="控件name"]').val();
获取select被选中项的文本
var item = $("select[@name=items] option[@selected]").text();
or
var item = $('select[name="控件name"]').val();
select下拉框的第二个元素为当前选中值
$('#select_id')[0].selectedIndex = 1;
radio单选组的第二个元素为当前选中值
$('input[@name=items]').get(1).checked = true;
$('input[name="控件name"]').eq(1).checked = true;
获取值：
文本框，文本区域
$("#txt").attr("value")；
or
$("#txt").val();
多选框checkbox
$("#checkbox_id").attr("value")；
$("#checkbox_id").val();
单选组radio
$("input[@type=radio][@checked]").val();
$('input[name="控件name"]').val();
下拉框select
$('#sel').val();
控制表单元素
文本框，文本区域
$("#txt").attr("value",'');//清空内容
or
$("#txt").val('');
$("#txt").attr("value",'11');//填充内容
or
$("#txt").val('11');
多选框checkbox
$("#chk1").attr("checked",'');//不打勾
$("#chk2").attr("checked",true);//打勾
if($("#chk1").attr('checked')==undefined) //判断是否已经打勾
单选组radio
$("input[@type=radio]").attr("checked",'2');//设置value=2的项目为当前选中项
下拉框select
$("#sel").attr("value",'-sel3');//设置value=-sel3的项目为当前选中项
$("<option value='1'>1111</option><option value='2'>2222</option>").appendTo("#sel")//添加下拉框的option
$("#sel").empty()；//清空下拉框
LINQ to SQL:Where、Select/Distinct
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
|
Where 操作适用场景：实现过滤，查询等功能。简单说明：与 SQL 命令中的 Where 作用相似，都是起到范围限定也就是过滤作用的 ，而判断条件就是它后面所接的子句。Where 操作包括 3 种形式：简单形式、关系条件形式、 First()形式。1.简单形式：条件一:使用 where 筛选在名称为moxuanshang的客户
var q =
from c in db.MXSMember
where c.TrueName.Equals(“moxuanshang”)
select c;
换种方式 由实体类接收MXSMember member=db.MXSMember.Where(a=>a.TrueName.Equals(“moxuanshang”) ).FirstOrDefault();(由于MXSMember是个实体类 so 查询去第一条数据 此时FirstOrDefault()就起到了作用)条件二：筛选注册时间为2016年11月11日的会员：var q =
from e in db.MXSMember
where e.AddTime>= DateTime.Parse( DateTime.Now.ToString(“yyyy-MM-dd”))
select e;
换种方式 由实体类接收MXSMember member=db.MXSMember.Where(a=>a.AddTime>= DateTime.Parse( DateTime.Now.ToString(“yyyy-MM-dd”))).FirstOrDefault();(由于MXSMember是个实体类 so 查询去第一条数据 此时FirstOrDefault()就起到了作用)2.关系条件形式：筛选出注册时间为2016年11月11日 和 会员名为moxuanshang的会员var q =
from p in db.MXSMember
where p.AddTime>= DateTime.Parse( DateTime.Now.ToString(“yyyy-MM-dd”))&&p.TrueName.Equals("moxuanshang")
select p;
换种方式 由实体类接收MXSMember member=db.MXSMember.Where(a=>a.AddTime>= DateTime.Parse( DateTime.Now.ToString(“yyyy-MM-dd”))&&a.TrueName.Equals("moxuanshang")).FirstOrDefault();
(由于MXSMember是个实体类 so 查询去第一条数据 此时FirstOrDefault()就起到了作用)筛选出 注册时间为2016年11月11日 或 会员名为moxuanshang的会员var q =
from p in db.MXSMember
where p.AddTime>= DateTime.Parse( DateTime.Now.ToString(“yyyy-MM-dd”))||p.TrueName.Equals("moxuanshang")
select p;
换种方式 由实体类接收MXSMember member=db.MXSMember.Where(a=>a.p.AddTime>= DateTime.Parse( DateTime.Now.ToString(“yyyy-MM-dd”))||a.TrueName.Equals("moxuanshang")).FirstOrDefault();
(由于MXSMember是个实体类 so 查询去第一条数据 此时FirstOrDefault()就起到了作用) 3.FirstOrDefault()、First()形式：返回集合中的一个元素，其实质就是在 SQL 语句中加 TOP (1)。第一种写法 MXSMember member=db.MXSMember.Where(a=>a.p.AddTime>= DateTime.Parse( DateTime.Now.ToString(“yyyy-MM-dd”))||a.TrueName.Equals("moxuanshang")).FirstOrDefault();
第二种写法 MXSMember member=db.MXSMember.FirstOrDefault(a=>a.p.AddTime>= DateTime.Parse( DateTime.Now.ToString(“yyyy-MM-dd”))||a.TrueName.Equals("moxuanshang"));
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
Select/Distinct 操作符 O(∩_∩)O~„ 根据条件查询。
1.简单用法： var q =
from c in db.MXSMember
select c.TrueName;
var q =
from c in db.MXSMember
select new{c.TrueName} ;
2.匿名类型 形式： var q =
from c in db.MXSMember
select new {c.TrueName, c.Phone};
var q =
from e in db.Employees
select new
{Name = e.FirstName + " " + e.LastName,
Phone = e.HomePhone}; var q =
from p in db.Products
select new
{p.ProductID,HalfPrice = p.UnitPrice / 2}; 3.条件形式：说 明：生成 SQL 语句为： var q =
from p in db.Products
select new
{p.ProductName,Availability =p.UnitsInStock - p.UnitsOnOrder < 0 ?"Out Of Stock" : "In Stock"
}; 4.指定类 型形式：说明：该形式返回你自定义类型的对象集。var q =
from e in db.Employees
select new Name
{FirstName = e.FirstName,LastName = e.LastName}; 5.筛选形式：说明：结合 where 使用，起到过滤作 用。
var q =
from c in db.MXSMember
where c.City == "London"
select c.TrueName;
var q =
from c in db.MXSMember
select new {
c.CustomerID,CompanyInfo = new {c.CompanyName, c.City, c.Country},
ContactInfo = new {c.TrueName, c.ContactTitle}
}; var q =
from o in db.Orders
select new {
o.OrderID,DiscountedProducts =from od in o.OrderDetails
where od.Discount > 0.0
select od,
FreeShippingDiscount = o.Freight}; 6.Distinct 形式： var q = (
from c in db.MXSMember
select c.City )
.Distinct(); |
小编博客园:http://www.cnblogs.com/moxuanshang
LINQ to SQL Count/Sum/Min/Max/Avg Join
public class Linq
{
MXSICEDataContext Db = new MXSICEDataContext();
// LINQ to SQL
// Count/Sum/Min/Max/Avg
// Count
public void Count()
{
// 说明：返回集合中的元素个数，返回 INT 类型；不延迟。生成 SQL 语句为： SELECT COUNT(*) FROM
//简单形式 性能差
var count = Db.MXSMemeber.Count();
//带条件形式
var count1 = Db.MXSMemeber.Count(a => bool.Parse(a.UID));
// LongCount
//说明 ：返回集合中的元素个数，返回 LONG 类型；不延迟。对于元素个数较多的集合可 视
//情况可以选用 LongCount 来统计元素个数，它返回 long 类型，比较精确。生成 SQL 语句为：
//SELECT COUNT_BIG(*) FROM
var longcount = Db.MXSMemeber.LongCount();
}
//SUM
public void SUM()
{
///同样来个简单形式
///
var sum = Db.MXSMemeber.Select(a => a.Sex).Sum();
///映射形式
///
var sum1 = Db.MXSMemeber.Sum(a => decimal.Parse(a.UID));
}
///Min
public void Min()
{
// 说明：返回集合中元素的最小值；不延迟。 生成 SQL 语句为： SELECT MIN(„) FROM
//简单形式
var min = Db.MXSMemeber.Select(a => a.UID).Min();
//映射形式
var min1 = Db.MXSMemeber.Min(a => a.UID);
}
///Max
public void Max()
{
// 说明：返回集合中元素的最大值；不延迟。生成 SQL 语句为： SELECT MAX(„) FROM
//简单形式
var max = Db.MXSMemeber.Select(a => a.UID).Max();
//映射形式：
var max1 = Db.MXSMemeber.Max(a => a.UID);
}
//Average
public void Average()
{
// 说明：返回集合中的数值类型元素的平均值。集合应为数字类型集合，其返回 值类型为
//double；不延迟。生成 SQL 语句为： SELECT AVG(„) FROM
//简单形式
var Average = Db.MXSMemeber.Select(a => decimal.Parse(a.UID)).Average();
//映射形式
var Average1 = Db.MXSMemeber.Average(a => decimal.Parse( a.UID));
}
//Join
//适用场景：在我们表关系中有一对一关系，一对多关系， 多对多关系等。对各个表之间的
//关系，就用这些实现对多个表的操作。
//说明：在Join 操作中，分别为Join(Join 查询), SelectMany(Select 一对多选择) 和GroupJoin(分
//组Join 查询)。
//该扩展方法对两个序列中键匹配的元素进 行inner join 操作
//SelectMany
//说明：我们在写查询语句时，如果 被翻译成SelectMany 需要满足2 个条件。1：查询语句
//中没有join 和 into，2：必 须出现 EntitySet。在我们表关系中有一对一关系，一对多关系，
//多对多关系等 ，下面分别介绍一下。
//1.一对多关系(1 to Many)：
var q =
from c in Db.Customers
from o in c.Orders
where c.City == "London"
select o;
//语句描述：Customers 与Orders 是一对多关系。即Orders 在Customers 类中以 EntitySet 形
//式出现。所以第二个from 是从c.Orders 而不是Db.Orders 里进行筛选 。这个例子在From 子
//句中使用外键导航选择伦敦客户的所有订单。
var q =
from p in Db.Products
where p.Supplier.Country == "USA" && p.UnitsInStock == 0
select p;
//语句描述：这一句使用了 p.Supplier.Country 条件，间接关联了Supplier 表。这个例子在Where
//子句中使 用外键导航筛选其供应商在美国且缺货的产品。生成SQL 语句为：
SELECT [t0].[ProductID], [t0].[ProductName], [t0]. [SupplierID],
[t0].[CategoryID],[t0].[QuantityPerUnit],[t0]. [UnitPrice],
[t0].[UnitsInStock], [t0].[UnitsOnOrder],[t0]. [ReorderLevel],
[t0].[Discontinued] FROM [dbo].[Products] AS [t0]
LEFT OUTER JOIN [dbo].[Suppliers] AS [t1] ON
[t1]. [SupplierID] = [t0].[SupplierID]
WHERE ([t1].[Country] = @p0) AND ([t0].[UnitsInStock] = @p1)
-- @p0: Input NVarChar (Size = 3; Prec = 0; Scale = 0) [USA]
-- @p1: Input Int (Size = 0; Prec = 0; Scale = 0) [0]
//2.多对多关系(Many to Many)：
var q =
from e in Db.Employees
from et in e.EmployeeTerritories
where e.City == "Seattle"
select new
{
e.FirstName,
e.LastName,
et.Territory.TerritoryDescription
};
//说明：多对多关系一般会涉及三个表(如果有一个表是自关 联的，那有可能只有 2 个表)。
//这一句语句涉及Employees, EmployeeTerritories, Territories 三个表。它们的关系是1：M：1。
//Employees 和Territories 没有很明确的关系。
//语句描述：这个例子在 From 子句中使 用外键导航筛选在西雅图的雇员，同时列出其所在
//地区。这条生成SQL 语句为：
SELECT [t0].[FirstName], [t0].[LastName], [t2]. [TerritoryDescription]
FROM [dbo].[Employees] AS [t0] CROSS JOIN [dbo].[EmployeeTerritories]
AS [t1] INNER JOIN [dbo]. [Territories] AS [t2] ON
[t2].[TerritoryID] = [t1].[TerritoryID]
WHERE ([t0].[City] = @p0) AND ([t1].[EmployeeID] = [t0]. [EmployeeID])
-- @p0: Input NVarChar (Size = 7; Prec = 0; Scale = 0) [Seattle]
//3. 自联接关系：
var q =
from e1 in Db.Employees
from e2 in e1.Employees
where e1.City == e2.City
select new {
FirstName1 = e1.FirstName, LastName1 = e1.LastName,
FirstName2 = e2.FirstName, LastName2 = e2.LastName,
e1.City
};
//语句描述：这个例子在select 子句中使用外键导航筛选成 对的雇员，每对中一个雇员隶属
//于另一个雇员，且两个雇员都来自相同城市。生 成SQL 语句为：
SELECT [t0].[FirstName] AS [FirstName1], [t0].[LastName] AS
[LastName1],[t1].[FirstName] AS [FirstName2], [t1].[LastName] AS
[LastName2],[t0].[City] FROM [dbo].[Employees] AS [t0],
[dbo].[Employees] AS [t1] WHERE ([t0].[City] = [t1]. [City]) AND
([t1].[ReportsTo] = [t0].[EmployeeID])
GroupJoin
//像上面所说的，没有join 和into，被翻译成 SelectMany ，同时有join 和into 时，那么就被
//翻译为GroupJoin 。在这里into 的 概念是对其结果进行重新命名。
//1.双向联接(Two way join)：
//此 示例显式联接两个表并从这两个表投影出结果：
var q =
from c in Db.Customers
join o in Db.Orders on c.CustomerID
equals o.CustomerID into orders
select new
{
c.ContactName,
OrderCount = orders.Count ()
};
//说明：在一对多关系中，左边是1，它每条记录 为c （from c in Db.Customers ），右边是Many，
//其每条记录叫做o ( join o in Db.Orders ) ，每对应左边的一个c，就会有一组o，那这一组o，
//就叫做orders， 也就是说，我们把一组o 命名为orders，这就是into 用途。这也就是为什
//么在 select 语句中，orders 可以调用聚合函数Count。在T-SQL 中，使用其内嵌的T- SQL 返
//回值作为字段值。如图所示：
//生成SQL 语句为：
SELECT [t0].[ContactName], (
SELECT COUNT(*)
FROM [dbo].[Orders] AS [t1]
WHERE [t0].[CustomerID] = [t1].[CustomerID]
) AS [OrderCount]
FROM [dbo].[Customers] AS [t0]
//2.三向联接(There way join)：
//此示例显式联接三个表并分别从每个表投影出结果：
var q =
from c in Db.Customers
join o in Db.Orders on c.CustomerID
equals o.CustomerID into ords
join e in Db.Employees on c.City
equals e.City into emps
select new
{
c.ContactName,
ords = ords.Count(),
emps = emps.Count()
};
//生成SQL 语句为：
SELECT [t0]. [ContactName], (
SELECT COUNT(*)
FROM [dbo].[Orders] AS [t1]
WHERE [t0].[CustomerID] = [t1].[CustomerID]
) AS [ords], (
SELECT COUNT(*)
FROM [dbo].[Employees] AS [t2]
WHERE [t0].[City] = [t2].[City]
) AS [emps]
FROM [dbo].[Customers] AS [t0]
//3.左外部联接(Left Outer Join)
//此示例说明如何通过使用 此示例说明如何通过使用 DefaultIfEmpty() 获取左外部联接。在
//雇员没有订单时，DefaultIfEmpty()方 法返回null：
var q =
from e in Db.Employees
join o in Db.Orders on e equals o.Employee into ords
from o in ords.DefaultIfEmpty()
select new
{
e.FirstName,
e.LastName,
Order = o
};
//说明：以Employees 左表，Orders 右表，Orders 表中为空时， 用null 值填充。Join 的结果
//重命名 ords，使用 DefaultIfEmpty()函数对其再次查 询。其最后的结果中有个 Order，因为
//from o in ords.DefaultIfEmpty() 是对 ords 组再一次遍历，所以，最后结果中的Order 并不是
//一个集合。但是，如果没 有from o in ords.DefaultIfEmpty() 这句，最后的select 语句写成select
//new { e.FirstName, e.LastName, Order = ords }的话，那么Order 就是一个集合。
//4.投影的Let 赋值(Projected let assignment)：
//说明：let 语句 是重命名。let 位于第一个from 和select 语句之间。
//这个例子从联接投影 出最终“Let”表达式：
var q =
from c in Db.Customers
join o in Db.Orders on c.CustomerID
equals o.CustomerID into ords
let z = c.City + c.Country
from o in ords
select new
{
c.ContactName,
o.OrderID,
z
};
//5.组合键(Composite Key)：
//这个例子显示带有组合 键的联接：
var q =
from o in Db.Orders
from p in Db.Products
join d in Db.OrderDetails
on new
{
o.OrderID,
p.ProductID
} equals
new
{
d.OrderID,
d.ProductID
}
into details
from d in details
select new
{
o.OrderID,
p.ProductID,
d.UnitPrice
};
//说明：使用三个表，并且用匿名类来说明：使用三个表，并 且用匿名类来表示它们之间的
//关系。它们之间的关系不能用一个键描述清楚，所 以用匿名类，来表示组合键。还有一种
//是两个表之间是用组合键表示关系的，不 需要使用匿名类。
//6.可为null/不可为null 的键关系 (Nullable/Nonnullable Key Relationship)：
//这个实例显示如何构造一 侧可为 null 而另一侧不可为 null 的联接
var q =
from o in Db.Orders
join e in Db.Employees
on o.EmployeeID equals
(int?)e.EmployeeID into emps
from e in emps
select new
{
o.OrderID,
e.FirstName
};
}