เกี่ยวกับตัวดำเนินการทางคณิตศาสตร์

คำอธิบายสั้น ๆ

อธิบายตัวดำเนินการที่ดำเนินการทางคณิตศาสตร์ใน PowerShell

คำอธิบายยาว

ตัวดำเนินการทางคณิตศาสตร์คำนวณค่าตัวเลข คุณสามารถใช้ตัวดำเนินการทางคณิตศาสตร์ตั้งแต่หนึ่งตัวขึ้นไปเพื่อเพิ่ม ลบ คูณ และหารค่า และคำนวณเศษ (โมดูลัส) ของการดำเนินการหาร

ตัวดำเนินการบวก (+) และตัวดำเนินการคูณ (*) ยังทำงานกับสตริง อาร์เรย์ และแฮชเทเบิลอีกด้วย ตัวดำเนินการบวกเชื่อมอินพุตเข้าด้วยกัน ตัวดำเนินการคูณจะส่งคืนสำเนาอินพุตหลายชุด คุณยังสามารถผสมประเภทอ็อบเจ็กต์ในคำสั่งทางคณิตศาสตร์ได้อีกด้วย วิธีการที่ใช้ในการประเมินคำสั่งจะถูกกำหนดโดยชนิดของวัตถุด้านซ้ายสุดในนิพจน์

เริ่มต้นใน PowerShell 2.0 ตัวดำเนินการทางคณิตศาสตร์ทั้งหมดทำงานกับตัวเลข 64 บิต

เริ่มต้นใน PowerShell 3.0 -shr (shift-right) และ -shl (shift-left) จะถูกเพิ่มเพื่อรองรับเลขคณิตระดับบิตใน PowerShell ตัวดำเนินการระดับบิตใช้ได้กับประเภทจำนวนเต็มเท่านั้น

PowerShell รองรับตัวดำเนินการทางคณิตศาสตร์ต่อไปนี้:

นอกจากนี้ (+) - เพิ่มตัวเลข เชื่อมต่อสตริง อาร์เรย์ และตารางแฮช

6 + 2                        # result = 8
"file" + "name"              # result = "filename"
@(1, "one") + @(2.0, "two")  # result = @(1, "one", 2.0, "two")
@{"one" = 1} + @{"two" = 2}  # result = @{"one" = 1; "two" = 2}

การลบ (-) - ลบหรือลบล้างตัวเลข

6 - 2   # result = 4
- -6    # result = 6
(Get-Date).AddDays(-1) # Yesterday's date

การคูณ (*) - คูณตัวเลขหรือคัดลอกสตริงและอาร์เรย์ตามจำนวนครั้งที่ระบุ
```
6 * 2       # result = 12
@("!") * 4  # result = @("!","!","!","!")
"!" * 3     # result = "!!!"
```
กอง (/) - หารตัวเลข
```
6 / 2  # result = 3
```
โมดูลัส (%) - ส่งกลับส่วนที่เหลือของการดำเนินการหาร
```
7 % 2  # result = 1
```
บิตและ (-band)
```
5 -band 3  # result = 1
```
ไม่ใช่ระดับบิต (-bnot)
```
-bnot 5  # result = -6
```
บิตหรือ (-bor)
```
5 -bor 0x03  # result = 7
```
บิตไวซ์ XOR (<รหัส>-bxor)
```
5 -bxor 3   # result = 6
```
เลื่อนบิตไปทางซ้าย (-shl)
```
102 -shl 2  # result = 408
```
เลื่อนบิตไปทางขวา (-shr)
```
102 -shr 2  # result = 25
```

ลำดับความสำคัญของตัวดำเนินการ

PowerShell ประมวลผลตัวดำเนินการทางคณิตศาสตร์ตามลำดับต่อไปนี้:

Precedence	Operator	Description
1	`()`	Parentheses
2	`-`	For a negative number or unary operator
3	`*`, `/`, `%`	For multiplication and division
4	`+`, `-`	For addition and subtraction
5	`-band`, `-bnot`	For bitwise operations
5	`-bor`, `-bxor`	For bitwise operations
5	`-shr`, `-shl`	For bitwise operations

PowerShell ประมวลผลนิพจน์จากซ้ายไปขวาตามกฎลำดับความสำคัญ ตัวอย่างต่อไปนี้แสดงผลของกฎลำดับความสำคัญ:

3+6/3*4    # result = 11
3+6/(3*4)  # result = 3.5
(3+6)/3*4  # result = 12

ลำดับที่ PowerShell ประเมินนิพจน์อาจแตกต่างจากภาษาการเขียนโปรแกรมและสคริปต์อื่นๆ ที่คุณใช้ ตัวอย่างต่อไปนี้แสดงคำสั่งการมอบหมายงานที่ซับซ้อน

$a = 0
$b = @(1,2)
$c = @(-1,-2)

$b[$a] = $c[$a++]

ในตัวอย่างนี้ นิพจน์ $a++ ได้รับการประเมินก่อน $b[$a] การประเมิน $a++ จะเปลี่ยนค่าของ $a หลังจากที่ใช้ในคำสั่ง $c[$a++] แต่ก่อนที่จะใช้ใน $b[$a]. ตัวแปร $a ใน $b[$a] เท่ากับ 1 ไม่ใช่ 0 ดังนั้น คำสั่งจะกำหนดค่าให้กับ $b[1] ไม่ใช่ $b[0]

รหัสด้านบนเทียบเท่ากับ:

$a = 0
$b = @(1,2)
$c = @(-1,-2)

$tmp = $c[$a]
$a = $a + 1
$b[$a] = $tmp

การแบ่งและการปัดเศษ

เมื่อผลหารของการดำเนินการหารเป็นจำนวนเต็ม PowerShell จะปัดเศษค่าให้เป็นจำนวนเต็มที่ใกล้ที่สุด เมื่อค่าเป็น .5 ระบบจะปัดเศษเป็นจำนวนเต็มคู่ที่ใกล้ที่สุด

ตัวอย่างต่อไปนี้แสดงผลของการปัดเศษเป็นจำนวนเต็มคู่ที่ใกล้ที่สุด

PS> [int]( 5 / 2 )  # Result is rounded down
2

PS> [int]( 7 / 2 )  # Result is rounded up
4

คุณสามารถใช้คลาส [Math] เพื่อรับพฤติกรรมการปัดเศษที่แตกต่างกัน

PS> [int][Math]::Round(5 / 2,[MidpointRounding]::AwayFromZero)
3

PS> [int][Math]::Ceiling(5 / 2)
3

PS> [int][Math]::Floor(5 / 2)
2

สำหรับข้อมูลเพิ่มเติม ให้ดูวิธี Math.Round

พิมพ์การแปลงเพื่อรองรับผลลัพธ์

PowerShell จะเลือกประเภทตัวเลข .NET ที่แสดงผลลัพธ์ได้ดีที่สุดโดยอัตโนมัติโดยไม่สูญเสียความแม่นยำ ตัวอย่างเช่น:

2 + 3.1
(2).GetType().FullName
(2 + 3.1).GetType().FullName

5.1
System.Int32
System.Double

หากผลลัพธ์ของการดำเนินการมีขนาดใหญ่เกินไปสำหรับประเภทนั้น ประเภทของผลลัพธ์จะถูกขยายให้กว้างขึ้นเพื่อรองรับผลลัพธ์ ดังตัวอย่างต่อไปนี้:

(512MB).GetType().FullName
(512MB * 512MB).GetType().FullName

System.Int32
System.Double

ประเภทของผลลัพธ์ไม่เหมือนกับหนึ่งในตัวถูกดำเนินการเสมอไป ในตัวอย่างต่อไปนี้ ไม่สามารถแปลงค่าลบเป็นจำนวนเต็มที่ไม่ได้ลงนาม และจำนวนเต็มที่ไม่ได้ลงนามมีขนาดใหญ่เกินกว่าจะแปลงเป็น Int32:

([int32]::minvalue + [uint32]::maxvalue).gettype().fullname

System.Int64

ในตัวอย่างนี้ Int64 สามารถรองรับได้ทั้งสองประเภท

ชนิด System.Decimal เป็นข้อยกเว้น หากตัวถูกดำเนินการตัวใดตัวหนึ่งมีประเภท ทศนิยม ผลลัพธ์จะเป็นประเภท ทศนิยม ผลลัพธ์ใดๆ ที่มีขนาดใหญ่เกินไปสำหรับค่า ทศนิยม ถือเป็นข้อผิดพลาด

PS> [Decimal]::maxvalue
79228162514264337593543950335

PS> [Decimal]::maxvalue + 1
RuntimeException: Value was either too large or too small for a Decimal.

การสูญเสียความแม่นยำที่อาจเกิดขึ้น

เมื่อใดก็ตามที่คุณได้ผลลัพธ์ที่เกินช่วงของประเภท คุณจะเสี่ยงต่อการสูญเสียความแม่นยำเนื่องจากการแปลงประเภท ตัวอย่างเช่น การเพิ่ม [long] และ [int] ที่มีขนาดใหญ่เพียงพอจะทำให้ตัวถูกดำเนินการถูกแปลงเป็น [double] ในตัวอย่างนี้ 9223372036854775807 คือค่าสูงสุดของจำนวนเต็ม [long] การเพิ่มค่าจะเกินช่วงของ [long]

PS> (9223372036854775807 + 2).GetType().FullName
System.Double

การร่ายผลลัพธ์เป็น [ulong] จะทำให้ได้ผลลัพธ์ที่ไม่ถูกต้อง เนื่องจากตัวถูกดำเนินการถูกบังคับให้ [double] ก่อน

PS> [ulong](9223372036854775807 + 2)
9223372036854775808

การกำหนดค่าที่มากขึ้นเป็น [ulong] ก่อนจะช่วยหลีกเลี่ยงปัญหาและให้ผลลัพธ์ที่ถูกต้อง

PS> 9223372036854775807ul + 2
9223372036854775809

อย่างไรก็ตาม หากเกินช่วงของ [ulong] จะส่งผลให้เกิด [double]

PS> ([ulong]::MaxValue + 1).GetType().FullName
System.Double

เลขคณิตใหญ่

เมื่อคุณดำเนินการทางคณิตศาสตร์กับตัวเลข [bigint] PowerShell จะใช้การแปลงตัวถูกดำเนินการทั้งหมดเป็น [bigint] ซึ่งส่งผลให้เกิดการตัดทอนค่าที่ไม่ใช่จำนวนเต็ม ตัวอย่างเช่น ค่า [double] 1.9 จะถูกตัดทอนเป็น 1 เมื่อแปลงเป็น [bigint]

PS> [bigint]1 / 1.9
1
PS> 1 / [bigint]1.9
1

ลักษณะการทำงานนี้จะแตกต่างจากลักษณะการทำงานของตัวเลขประเภทอื่นๆ ในตัวอย่างนี้ [int] หารด้วย [double] ส่งผลให้ได้ [double] การส่ง 1.9 ไปที่ [int] จะปัดเศษค่าขึ้นเป็น 2

PS> 1 / 1.9
0.526315789473684
PS> 1 / [int]1.9
0.5

การบวกและการคูณประเภทที่ไม่ใช่ตัวเลข

คุณสามารถเพิ่มตัวเลข สตริง อาร์เรย์ และตารางแฮชได้ และคุณสามารถคูณตัวเลข สตริง และอาร์เรย์ได้ อย่างไรก็ตาม คุณไม่สามารถคูณตารางแฮชได้

เมื่อคุณเพิ่มสตริง อาร์เรย์ หรือตารางแฮช องค์ประกอบจะต่อกัน เมื่อคุณเชื่อมคอลเลกชัน เช่น อาร์เรย์หรือตารางแฮชเข้าด้วยกัน ออบเจ็กต์ใหม่จะถูกสร้างขึ้นซึ่งมีออบเจ็กต์จากทั้งสองคอลเลกชัน ถ้าคุณพยายามที่จะเชื่อมตารางแฮชที่มีคีย์เดียวกัน การดำเนินการล้มเหลว

ตัวอย่างเช่น คำสั่งต่อไปนี้จะสร้างอาร์เรย์สองตัวแล้วเพิ่มเข้าไป:

$a = 1,2,3
$b = "A","B","C"
$a + $b

1
2
3
A
B
C

คุณยังสามารถดำเนินการทางคณิตศาสตร์กับออบเจ็กต์ประเภทต่างๆ ได้ การดำเนินการที่ PowerShell ดำเนินการนั้นถูกกำหนดโดยประเภท Microsoft .NET ของออบเจ็กต์ด้านซ้ายสุดในการดำเนินการ PowerShell พยายามแปลงวัตถุทั้งหมดในการดำเนินการเป็นชนิด .NET ของวัตถุแรก หากแปลงออบเจ็กต์ได้สำเร็จ ระบบจะดำเนินการที่เหมาะสมกับประเภท .NET ของออบเจ็กต์แรก หากล้มเหลวในการแปลงอ็อบเจ็กต์ใดๆ แสดงว่าการดำเนินการล้มเหลว

ตัวอย่างต่อไปนี้สาธิตการใช้ตัวดำเนินการบวกและการคูณในการดำเนินการที่มีประเภทออบเจ็กต์ที่แตกต่างกัน

$array = 1,2,3
$red = [ConsoleColor]::Red
$blue = [ConsoleColor]::Blue

"file" + 16      # result = "file16"
$array + 16      # result = 1,2,3,16
$array + "file"  # result = 1,2,3,"file"
$array * 2       # result = 1,2,3,1,2,3
"file" * 3       # result = "filefilefile"
$blue + 3        # result = Red
$red - 3         # result = Blue
$blue - $red     # result = -3
+ '123'          # result = 123

เนื่องจากวิธีการที่ใช้ในการประเมินคำสั่งถูกกำหนดโดยวัตถุด้านซ้ายสุด การบวกและการคูณใน PowerShell ไม่ใช่การสับเปลี่ยนอย่างเคร่งครัด ตัวอย่างเช่น (a + b) จะไม่เท่ากับ (b + a) เสมอไป และ (ab) ก็ไม่เท่ากับ < เสมอไป รหัส>(บริติชแอร์เวย์).

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงหลักการนี้:

PS> "file" + 16
file16

PS> 16 + "file"
InvalidArgument: can't convert value "file" to type "System.Int32". Error:
"Input string wasn't in a correct format."

ตารางแฮชเป็นกรณีที่แตกต่างกันเล็กน้อย คุณสามารถเพิ่มตารางแฮชลงในตารางแฮชอื่นได้ ตราบใดที่ตารางแฮชที่เพิ่มไม่มีคีย์ที่ซ้ำกัน

ตัวอย่างต่อไปนี้แสดงวิธีการเพิ่มตารางแฮชซึ่งกันและกัน

$hash1 = @{a=1; b=2; c=3}
$hash2 = @{c1="Server01"; c2="Server02"}
$hash1 + $hash2

Name                           Value
----                           -----
c2                             Server02
a                              1
b                              2
c1                             Server01
c                              3

ตัวอย่างต่อไปนี้แสดงข้อผิดพลาดเนื่องจากมีคีย์ใดคีย์หนึ่งซ้ำกันในตารางแฮชทั้งสอง

$hash1 = @{a=1; b=2; c=3}
$hash2 = @{c1="Server01"; c="Server02"}
$hash1 + $hash2

OperationStopped:
Line |
   3 |  $hash1 + $hash2
     |  ~~~~~~~~~~~~~~~
     | Item has already been added. Key in dictionary: 'c'  Key being added: 'c'

นอกจากนี้ คุณสามารถเพิ่มตารางแฮชลงในอาร์เรย์ได้ และตารางแฮชทั้งหมดจะกลายเป็นรายการในอาร์เรย์

$array1 = @(0, "Hello World", [datetime]::Now)
$hash1 = @{a=1; b=2}
$array2 = $array1 + $hash1
$array2

0
Hello World

Monday, June 12, 2017 3:05:46 PM

Key   : a
Value : 1
Name  : a

Key   : b
Value : 2
Name  : b

อย่างไรก็ตาม คุณไม่สามารถเพิ่มประเภทอื่นลงในตารางแฮชได้

$hash1 + 2

InvalidOperation: A hash table can only be added to another hash table.

แม้ว่าตัวดำเนินการบวกจะมีประโยชน์มาก แต่ให้ใช้ตัวดำเนินการกำหนดเพื่อเพิ่มองค์ประกอบลงในตารางแฮชและอาร์เรย์ สำหรับข้อมูลเพิ่มเติม โปรดดูที่ about_signment_operators ตัวอย่างต่อไปนี้ใช้ตัวดำเนินการกำหนด += เพื่อเพิ่มรายการลงในอาร์เรย์:

$array = @()
(0..2).foreach{ $array += $_ }
$array

0
1
2

ตัวดำเนินการทางคณิตศาสตร์และตัวแปร

คุณยังสามารถใช้ตัวดำเนินการทางคณิตศาสตร์กับตัวแปรได้ ตัวดำเนินการกระทำกับค่าของตัวแปร ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการใช้ตัวดำเนินการทางคณิตศาสตร์กับตัวแปร:

PS> $intA = 6
PS> $intB = 4
PS> $intA + $intB
10

PS> $a = "Power"
PS> $b = "Shell"
PS> $a + $b
PowerShell

ตัวดำเนินการและคำสั่งทางคณิตศาสตร์

โดยทั่วไป คุณจะใช้ตัวดำเนินการทางคณิตศาสตร์ในนิพจน์ที่มีตัวเลข สตริง และอาร์เรย์ อย่างไรก็ตาม คุณยังสามารถใช้ตัวดำเนินการทางคณิตศาสตร์กับวัตถุที่คำสั่งส่งคืนและกับคุณสมบัติของวัตถุเหล่านั้นได้

ตัวอย่างต่อไปนี้แสดงวิธีใช้ตัวดำเนินการทางคณิตศาสตร์ในนิพจน์ด้วยคำสั่ง PowerShell:

(Get-Date) + (New-TimeSpan -day 1)

ตัวดำเนินการวงเล็บบังคับให้มีการประเมิน cmdlet Get-Date และการประเมินนิพจน์ cmdlet New-TimeSpan -Day 1 ตามลำดับนั้น ผลลัพธ์ทั้งสองจะถูกเพิ่มโดยใช้ตัวดำเนินการ +

Get-Process | Where-Object { ($_.ws * 2) -gt 50mb }

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----      ----- -----   ------     -- -----------
   1896      39    50968      30620   264 1,572.55   1104 explorer
  12802      78   188468      81032   753 3,676.39   5676 OUTLOOK
    660       9    36168      26956   143    12.20    988 PowerShell
    561      14     6592      28144   110 1,010.09    496 services
   3476      80    34664      26092   234 ...45.69    876 svchost
    967      30    58804      59496   416   930.97   2508 WINWORD

ในนิพจน์ข้างต้น แต่ละพื้นที่ทำงานของกระบวนการ ($_.ws) จะถูกคูณด้วย 2; และผลลัพธ์ที่ได้จะเปรียบเทียบกับ 50mb เพื่อดูว่ามากกว่านั้นหรือไม่

ตัวดำเนินการ Bitwise

PowerShell รองรับตัวดำเนินการ bitwise-OR มาตรฐาน รวมถึง bitwise-AND (-band) ตัวดำเนินการ bitwise-OR แบบรวมและพิเศษเฉพาะ (-bor และ -bxor) และระดับบิต-NOT (-bnot)

เริ่มต้นใน PowerShell 2.0 ตัวดำเนินการระดับบิตทั้งหมดจะทำงานกับจำนวนเต็ม 64 บิต

เริ่มต้นใน PowerShell 3.0 -shr (shift-right) และ -shl (shift-left) ได้รับการแนะนำเพื่อรองรับเลขคณิตระดับบิตใน PowerShell

PowerShell รองรับตัวดำเนินการระดับบิตต่อไปนี้

Operator	Description	Expression	Result
`-band`	Bitwise AND	`10 -band 3`	2
`-bor`	Bitwise OR (inclusive)	`10 -bor 3`	11
`-bxor`	Bitwise OR (exclusive)	`10 -bxor 3`	9
`-bnot`	Bitwise NOT	`-bNot 10`	-11
`-shl`	Shift-left	`102 -shl 2`	408
`-shr`	Shift-right	`102 -shr 1`	51

ตัวดำเนินการ Bitwise ทำหน้าที่ในรูปแบบไบนารี่ของค่า ตัวอย่างเช่น โครงสร้างบิตสำหรับหมายเลข 10 คือ 00001010 (ขึ้นอยู่กับ 1 ไบต์) และโครงสร้างบิตสำหรับหมายเลข 3 คือ 00000011 เมื่อคุณใช้ตัวดำเนินการระดับบิตเพื่อเปรียบเทียบ 10 กับ 3 แต่ละบิตในแต่ละไบต์จะถูกเปรียบเทียบ .

ในการดำเนินการระดับบิต AND บิตผลลัพธ์จะถูกตั้งค่าเป็น 1 เฉพาะเมื่อบิตอินพุตทั้งสองเป็น 1

1010      (10)
0011      ( 3)
--------------  bAND
0010      ( 2)

ในการดำเนินการระดับบิตหรือ (รวม) บิตผลลัพธ์จะถูกตั้งค่าเป็น 1 เมื่อบิตอินพุตอย่างใดอย่างหนึ่งหรือทั้งสองเป็น 1 บิตผลลัพธ์จะถูกตั้งค่าเป็น 0 เฉพาะเมื่อบิตอินพุตทั้งสองถูกตั้งค่าเป็น 0

1010      (10)
0011      ( 3)
--------------  bOR (inclusive)
1011      (11)

ในการดำเนินการระดับบิตหรือ (เฉพาะ) บิตผลลัพธ์จะถูกตั้งค่าเป็น 1 เฉพาะเมื่อบิตอินพุตหนึ่งบิตเป็น 1

1010      (10)
0011      ( 3)
--------------  bXOR (exclusive)
1001      ( 9)

ตัวดำเนินการระดับบิต NOT คือตัวดำเนินการเอกภาคที่สร้างส่วนเสริมไบนารีของค่า บิตของ 1 ถูกตั้งค่าเป็น 0 และบิตของ 0 ถูกตั้งค่าเป็น 1

ตัวอย่างเช่น ส่วนเสริมไบนารีของ 0 คือ -1 จำนวนเต็มสูงสุดที่ไม่ได้ลงนาม (0xFFFFFFFF) และส่วนเสริมไบนารีของ -1 คือ 0

-bNot 10

-11

0000 0000 0000 1010  (10)
------------------------- bNOT
1111 1111 1111 0101  (-11, 0xFFFFFFF5)

ในการดำเนินการเลื่อนไปทางซ้ายในระดับบิต บิตทั้งหมดจะถูกย้ายตำแหน่ง "n" ไปทางซ้าย โดยที่ "n" คือค่าของตัวถูกดำเนินการทางขวา มีการแทรกศูนย์ไว้ในตำแหน่งที่หนึ่ง

Expression	Result	Binary Result
`21 -shl 0`	21	0001 0101
`21 -shl 1`	42	0010 1010
`21 -shl 2`	84	0101 0100

ในการดำเนินการเลื่อนไปทางขวาระดับบิต บิตทั้งหมดจะถูกย้าย "n" ไปทางด้านขวา โดยที่ "n" จะถูกระบุโดยตัวถูกดำเนินการด้านขวา ตัวดำเนินการ shift-right (-shr) จะคัดลอกบิตเครื่องหมายไปยังตำแหน่งซ้ายสุดเมื่อเปลี่ยนค่าที่เซ็นชื่อ สำหรับค่าที่ไม่ได้ลงนาม ค่าศูนย์จะถูกแทรกในตำแหน่งซ้ายสุด

Expression	Result	Binary	Hex
`21 -shr 0`	21	00010101	0x15
`21 -shr 1`	10	00001010	0x0A
`21 -shr 2`	5	00000101	0x05
`21 -shr 31`	0	00000000	0x00
`21 -shr 32`	21	00010101	0x15
`21 -shr 64`	21	00010101	0x15
`21 -shr 65`	10	00001010	0x0A
`21 -shr 66`	5	00000101	0x05
`[int]::MaxValue -shr 1`	1073741823	00111111111111111111111111111111	0x3FFFFFFF
`[int]::MinValue -shr 1`	-1073741824	11000000000000000000000000000000	0xC0000000
`-1 -shr 1`	-1	11111111111111111111111111111111	0xFFFFFFFF
`(-21 -shr 1)`	-11	11111111111111111111111111110101	0xFFFFFFF5
`(-21 -shr 2)`	-6	11111111111111111111111111111010	0xFFFFFFF4

ดูเพิ่มเติม

about_Arrays
about_Hash_Tables
about_Operators
about_Assignment_Operators
about_Comparison_Operators
about_Variables
Get-Date
New-TimeSpan