Манипуляция струной силовой оболочки

PowerShell String Manipulation

When working with a string of characters, PowerShell has a number of built in methods that allow for them to be easily manipulated.

When working with the console, a string can be displayed using the ‘Write-Host’ cmdlet.

 "Hello world!"

If it is necessary to incorporate the value of a variable into this message it can be done in a number of different ways.

$fname = "Fred"
$sname = "Bloggs"# Variables directly in a string. "Hello $fname $sname!"# Plus symbol used to concatenate a string.$message = "Hello " + $fname + " " + $sname + "!" $message# .NET string format string.$message = [string]::Format("Hello {0} {1}!", $fname, $sname) $message# PowerShell format string.$message = 'Hello {0} {1}!' -f $fname, $sname $message

All four of the above examples display the same message in the console, ‘Hello Fred Bloggs!’.

Variables in PowerShell have their own properties and methods, for example, string variables have a method to convert them to upper case. In order to utilise these in a larger string, the variable needs to be enclosed in brackets, with a dollar sign before the opening bracket.

$fname = "Fred"
$sname = "Bloggs" "Hello $($fname.ToUpper()) $($sname.ToUpper())!"

Here, the first and last name variables are converted to upper case using the ‘ToUpper’ method, to produce a message, ‘Hello FRED BLOGGS!’.

Similarly, in order to run commands as part of a string, they also need to be enclosed in brackets and preceded by a dollar sign.

 "Today's date is: $(Get-Date -Format 'dd/MM/yyyy')."

The above example displays the current date as part of a string.

Today's date is: 27/08/2023.

Index Value

Every character in a string has an index value, which can be used to reference it. The first character has an index value of zero, the second has an index of one and so on.

$example = "This is a string." $example[3]

Here, the index value of three in square brackets is used to output the fourth character of the string to the console.

It is also possible to find the index position of a character in a string using the ‘IndexOf’ method.

 $example.IndexOf("i")

Note that, the ‘IndexOf’ method will return the index position of the first occurrence of a character, if more than one exists in the string. There is also a ‘LastIndexOf’ method that can be used to return the index position of the last occurrence of a particular character.

 $example.LastIndexOf("i")

If the character does not exist in the string, then a ‘-1’ is returned.

Substring

Using the ‘Substring’ method, it is possible to return a portion of a string by specifying the index position to start from, together with the number of characters that are required.

$example = "This is a string." $example.Substring(5,4)

The above example starts at index position five and displays four characters.

is a

If only the index position to start from is specified, without the number of characters to include, then the whole of the rest of the string is shown.

 $example.Substring(5)

The result from this is shown below.

is a string.

Upper and Lower Case

In order to change a string to upper or lower case, there are two methods that can be used, ‘ToUpper’ and ‘ToLower’.

$example = "This is a string." $example.ToUpper() $example.ToLower()

The first will change the whole string to upper case and the latter will convert it to lower case.

THIS IS A STRING.
this is a string.

Trim

If a string has extra spacing at the start, end, or both, it’s possible to remove this using the ‘Trim’ method as demonstrated below. If it is only required to remove the extra spacing from the start or end, then the ‘TrimStart’, or ‘TrimEnd’ methods can be used.

$example = " This is a string. " $example.Trim() $example.TrimStart() $example.TrimEnd()

Length

Sometimes it is necessary to find the size or length of a string. This can be done using the ‘Length’ property.

$example = "This is a string." $example.Length

Insert, Remove and Replace

In order to manipulate the contents of a string the ‘Insert’, ‘Remove’ and ‘Replace’ methods can be used.

The ‘Insert’ method can be used to insert a string, into an existing string at the specified index position.

$example = "This is a string." $example.Insert(9, " short")

Here a space and the word ‘short’ is inserted into the string at index position nine, just after the ‘a’, to produce the string, ‘This is a short string.’.

The ‘Remove’ method can be used to delete a part of a string, by specifying the index position to start the deletion from, as well as the number of characters to delete. Note that, if the number of characters to delete is omitted then all characters from the index position to start from, to the end of the string, will be removed.

$example = "This is a short string." $example.Remove(9, 6)

In the above example, the deletion starts at index position nine, just after the ‘a’, and removes six characters, to produce the string, ‘This is a string.’.

Finally, the ‘Replace’ method can be used to replace a specified part of a string with some other text.

$example = "This is a short string." $example.Replace("short", "small")

Here, the word ‘short’ is replaced with the word ‘small’ to produce the string, ‘This is a small string.’.

The properties and methods discussed above are by no means exhaustive. There are many others available.

Almost all the PowerShell scripts I have worked on, especially those related to strings, always require converting strings to lowercase or uppercase. So, I thought of writing a complete tutorial on this. In this tutorial, I will show you how to convert strings to lowercase or uppercase in PowerShell using various methods.

To convert strings to lowercase or uppercase in PowerShell, you can use the ToLower() and ToUpper() methods, which are part of the System.String .NET class. For example, $string = “Hello World”; $lowercaseString = $string.ToLower(); $uppercaseString = $string.ToUpper().

Let us check it using various methods and examples.

I will show you how to convert strings to lowercase in PowerShell using different methods.

Method 1: Using ToLower() Method

You can use the PowerShell’s built-in ToLower() method to convert all characters in a string to lowercase.

Here is an example.

Let’s take the name “WASHINGTON DC” and convert it to lowercase. Below is the complete and simple PowerShell script.

# Original string
$city = "WASHINGTON DC"
# Convert to lowercase
$lowercaseCity = $city.ToLower()
# Output the result
Write-Output $lowercaseCity

This script will output:

washington dc

I executed the above PowerShell script using the popular VS code editor, and you can see the output in the screenshot below.

Method 2: Using ForEach-Object with ToLower() Method

Here is another advanced example where, instead of a string, you might need to convert an array of strings to lowercase using PowerShell.

For this kind of requirement, you can use the ForEach-Object cmdlet to apply the ToLower() method to each element in an array of strings.

Here is a PowerShell script to convert an array of names to lowercase.

Let’s take an array of state names and convert them to lowercase.

# Array of state names
$states = @("California", "TEXAS", "Florida", "NEW JERSEY")
# Convert each state name to lowercase
$lowercaseStates = $states | ForEach-Object { $_.ToLower() }
# Output the result
$lowercaseStates

This script will output:

california
texas
florida
new jersey

If you execute the above PowerShell script, you will see the exact output according to the requirement, check the screenshot below:

Method 3: Using -replace Operator for Partial String Manipulation

Sometimes, you just need to convert a part of a string to lowercase in PowerShell. This is possible using the replace operator with the ToLower() method.

Here is a complete example.

Let’s take the name “Los Angeles, CALIFORNIA” and convert only “CALIFORNIA” to lowercase.

# Original string
$location = "Los Angeles, CALIFORNIA"
# Convert "CALIFORNIA" to lowercase
$updatedLocation = $location -replace "CALIFORNIA", "CALIFORNIA".ToLower()
# Output the result
Write-Output $updatedLocation

This script will output:

Los Angeles, california

Convert Strings to Uppercase in PowerShell

Now, let us see how to convert strings to uppercase in PowerShell using various methods.

All these methods are similar to the above.

Method 1: Using ToUpper() Method

Like the ToLower() method, you can also use the ToUpper() method to convert all characters in a string to uppercase in PowerShell.

Here is an example and the complete script.

Let’s take the name “new york” and convert it to uppercase.

# Original string
$city = "new york"
# Convert to uppercase
$uppercaseCity = $city.ToUpper()
# Output the result
Write-Output $uppercaseCity

This script will output:

NEW YORK

Look at the screenshot below. I executed the above PowerShell script using VS code and it is showing the exact required output:

Method 2: Using ForEach-Object with ToUpper() Method

You can use the ForEach-Object cmdlet to apply the ToUpper() method to each element in an array of strings in PowerShell. This is best suited if you are required to convert an array of strings to uppercase in PowerShell.

Let’s take an array of state abbreviations and convert them to uppercase.

# Array of state abbreviations
$stateAbbreviations = @("ca", "tx", "fl", "nj")
# Convert each abbreviation to uppercase
$uppercaseAbbreviations = $stateAbbreviations | ForEach-Object { $_.ToUpper() }
# Output the result
$uppercaseAbbreviations

This script will output:

CA
TX
FL
NJ

Method 3: Using -replace Operator for Partial String Manipulation

If you need to convert only a part of a string to uppercase in PowerShell, you can use the -replace operator combined with the ToUpper() method.

Here is a complete example of converting a part of a string to uppercase using PowerShell.

Let’s take the name “miami, florida” and convert only “miami” to uppercase.

# Original string
$location = "miami, florida"
# Convert "miami" to uppercase
$updatedLocation = $location -replace "miami", "miami".ToUpper()
# Output the result
Write-Output $updatedLocation

This script will output:

MIAMI, florida

Conclusion

In this tutorial, we checked various methods to convert strings to lowercase or uppercase in PowerShell. We used the ToLower() and ToUpper() methods for direct conversion, ForEach-Object for arrays, and the -replace operator for partial string manipulation.

I hope you have a complete idea of converting strings to lowercase and uppercase using PowerShell.

Let us know if you still have any questions or requirements; I would love to write a program for you.

Key Takeaways:

• Strings are a fundamental data type in PowerShell scripting.
• PowerShell supports several types of strings, including single-quoted strings, double-quoted strings, and here-strings.
• PowerShell offers powerful string manipulation capabilities, such as concatenation, splitting, formatting, and replacing characters.
• Understanding how to work with strings is essential for mastering PowerShell scripting.

Understanding PowerShell Strings

A string is a sequence of characters enclosed in quotation marks. They represent text and can be applied to any object in PowerShell, enhancing their applicability in your scripting toolbox. In fact, a string object can be a versatile element in your scripts, and working with multiple string objects can further expand your scripting capabilities. In this comprehensive guide, we will demystify PowerShell string operations and how to work with them effectively. Whether you’re a seasoned scripter or just starting out, understanding how to work with strings in PowerShell effectively is essential for mastering the art of scripting.

PowerShell Strings are indicated with single or double quotes and can be easily manipulated using various operations. For instance, you can replace characters or entire words, concatenate strings to form a new string, or even split one string into multiple strings. This makes them a powerful asset when dealing with large datasets or complex scripting tasks.

Types of PowerShell Strings

PowerShell strings are a fundamental data type used to store and manipulate textual data. In PowerShell, there are three types of strings: single-quoted strings, double-quoted strings, and here-strings. Although they appear alike, their purposes vary and can significantly alter your script’s output. The primary difference is in the way they manage variables and expressions.

Single-Quoted Strings

Single-quoted strings are denoted by enclosing the string in single quotes ('). They are the simplest type of string and do not support any special characters or escape sequences. Single-quoted strings are useful when you need to specify a string value exactly as it is written.

$filePath = 'C:\Users\JohnDoe\Documents\file.txt'

Double-Quoted Strings

Double-quoted strings are denoted by enclosing the string in double quotes ("). They support escape sequences and variable expansion. Escape sequences are special characters that are interpreted by PowerShell to represent a particular character or sequence of characters.

$message = "Hello`nWorld!"

In this example, the escape sequence `n represents a newline character.

Here-Strings

$message = @"
Hello,
World!
This is a multi-line message.
"@

In this example, the message is defined on multiple lines, and the original formatting is preserved when the string is printed.

Single-Quote vs. Double Quote Strings

Understanding the different types of PowerShell strings is essential for effective string manipulation. A double-quoted string facilitates variable substitution, meaning that any variable within the string is replaced with its value before execution. On the other hand, a single quoted string does not perform variable substitution, treating the entire string as literal text. For example, consider the below example:

$name = "John"
Write-Output "Hello, $name!"
# Output: Hello, John!

Here, a variable $name with a “John” value will substitute. However, If we put $name in a single quoted string, the output will be exactly as written: “Hello, $name!”.

$name = 'John'
Write-Output 'Hello, $name!'
# Output: Hello, $name!

PowerShell provides numerous ways to manipulate strings, making it a powerful tool for working with text data. This section will explore some of the most common string operations in PowerShell, including techniques for replacing, concatenating, and formatting strings. Additionally, we will discuss methods for handling multiline strings and removing characters from a string.

Replacing Strings

$string = "Hello, world!"
$newString = $string.Replace("world", "universe")

This will create a new string variable $newString that contains the string “Hello, universe!” with the original substring “world” replaced with “universe”. This method performs a case-sensitive replacement by default.

To perform a case-insensitive replacement, you can use the -replace operator.

$string = "Hello, world!"
$newString = $string -Replace "World", "universe"
$newString

Remove Characters from string

Removal of characters from a string is another frequent string manipulation task in PowerShell. The Remove() method, which enables specification of the starting position and number of characters to be removed from the string, can achieve this.

"Hello World".Remove(6, 5)

This will output the modified string “Hello “. The first argument (6) specifies the starting position of the characters to remove, and the second argument (5) specifies the number of characters to remove. You can also use the Replace() method or the -Replace operator with an empty string to remove a specific character or word from a string.

"Hello World".Replace("World", "")

This method provides a flexible and efficient way to remove characters from a string in your PowerShell scripts. More information here: How to Remove Characters/Words from a String in PowerShell?

PowerShell trim string

In PowerShell, trimming strings involves removing unnecessary characters, usually whitespace, from the start (left) or end (right) of a string. This operation is common in text processing, where extra spaces could lead to problems.

• Trim(): removes whitespace from both ends of a string
• TrimStart(): removes whitespace from the beginning of a string
• TrimEnd(): removes whitespace from the end of a string

$originalString = " Hello, World! "
# Trimming the string
$originalString.Trim() # Output: "Hello World!"
$originalString.TrimStart() # Output: "Hello, World! "
$originalString.TrimEnd() # Output " Hello, World!"

Concatenating Strings

String concatenation is one of the most frequently used methods of string manipulation in PowerShell. PowerShell string concatenation joins two or more strings together to form a new concatenated string. This feature is exceedingly helpful when generating dynamic strings based on variable data or merging multiple data pieces into a single string.

$firstName = "John"
$lastName = "Doe"
$fullName = $firstName + " " + $lastName

This will create a new string variable $fullName that contains the concatenated value of $firstName and $lastName. In addition to the concatenation operator, PowerShell provides the += operator for concatenating strings to an existing variable. This can be useful when building strings dynamically within a loop or iterating over a collection of strings.

Similarly, you can use the -join operator or the concat method to join strings and concatenate string elements in an array, with an optional delimiter inserted between each string.

# Define an array of strings
$stringArray = @("Hello", "World", "from", "PowerShell")
# Use the -join operator to concatenate them
$concatenatedString = $stringArray -join " "
# Display the result
Write-Output $concatenatedString
#Output: Hello World from PowerShell

More on string concatenation in PowerShell: How to Concatenate String in PowerShell?

String Interpolation

PowerShell string interpolation enables you to incorporate variable values straight within a string, crafting a fresh string that encompasses the variable’s contents. This function is incredibly beneficial when generating dynamic strings based on variable information. To use string interpolation in PowerShell, simply enter the variable with the $ symbol inside a double-quoted string.

Here is an example:

$name = "John"
$age = 30
Write-Output "$name is $age years old."
# Output: John is 30 years old.

On complex Expressions, use: $() syntax. For example,

$a = 5
$b = 10
$result = "The sum of $a and $b is $($a + $b)."
Write-Output $result
#Output: The sum of 5 and 10 is 15.

The expressions inside the $() syntax will be evaluated before the string is output. This makes string interpolation a flexible and efficient tool for creating dynamic strings in your scripts.

PowerShell string contains

Another common task when working with strings in PowerShell is checking if a string contains a specific substring. This can be useful when you need to filter strings based on their contents, or when you need to perform a certain operation if a string contains a certain value.

In PowerShell, you can check if a string contains a specific substring using the Contains() method or the -like operator. The Contains() method returns true if the string contains the specified substring and false otherwise. For example,

"Hello World".Contains("World")

will return true.

On the other hand, the -like operator allows you to use wildcards in your search, making it more flexible. For example,

"Hello World" -like "*World"

will also return true.

Sometimes, you may need to extract a specific part of a string, also known as a substring. This can be done in PowerShell using the Substring method, which allows you to specify the starting position and length of the substring you want to extract.

"Hello World".Substring(6, 5)

This will output the substring “World”. The first argument (6) specifies the starting position of the substring, and the second argument (5) specifies the length of the substring.

Converting Strings

Converting strings to other data types, or converting other data types to strings, is another common task in PowerShell. This is often necessary when you need to perform operations that require a certain type of data, or when you need to display a non-string value as a string.

# Define an integer
$integer = 123
# Convert to string
$stringValue = $integer.ToString()
#Also works: [string]$integer
# Output
$stringValue # Outputs: "123"

This will return the string “123”.

# Define a string
$stringValue = "123"
# Convert to integer using type casting
$integerValue = [int]$stringValue
#Also works: [Convert]::ToInt32($stringValue)

This will return the integer 123.

PowerShell append string

Appending or supplementing an existing string is another frequent string manipulation task in PowerShell. The += operator, which enables you to add a string to the end of an existing string, effectively lengthening the original string with the new text, can accomplish this.

$string = "Hello"
$string += " World"

This will modify the original string $string to become “Hello World”.

This method provides a simple and efficient way to append text to an existing string in your PowerShell scripts.

PowerShell String Length

Another important aspect of working with strings in PowerShell is determining their length. The length of a string represents the number of characters it contains. To find the length of a string, you can use the “String.Length” property. For example:

$string = "Hello, World!"
$length = $string.Length

The variable $length will now contain the length of the string, which is 13 in this example. Knowing the length of a string can be useful for various operations, such as validating input, manipulating substrings, or extracting specific portions of a string.

Formatting Strings with the Format Operator

$name = "John"
$age = 30
$string = "My name is {0} and I am {1} years old" -f $name, $age
#Output: My name is John and I am 30 years old

String Format Method

# Define variables
$name = "John"
$age = 30
$city = "New York"
# Using String.Format to create a formatted string
$formattedString = [String]::Format("Name: {0}, Age: {1}, City: {2}", $name, $age, $city)
$formattedString

This will output: Name: John, Age: 30, City: New York

Working with Special Characters

PowerShell strings can contain special characters that may require special handling when working with them. Here are some common special characters and how to work with them in PowerShell:

Escape Characters

Escape characters are used to indicate that the next character should be treated differently than it normally would be. For example, the backtick (`) is used as an escape character in PowerShell. If you want to include a double quote (“) in a string, you can use the escape character like this:

PS C:\> "She said, `"Hello!`""
She said, "Hello!"

In this example, the backslash tells PowerShell to treat the double quote as a literal character, rather than as the end of the string.

Special Characters

Some characters have special meaning in PowerShell, and may need to be escaped or handled differently. Here are a few examples:

• $: The dollar sign is used to indicate variables in PowerShell. If you want to include a literal dollar sign in a string, you can use the backtick (`) as an escape character.
• @: The at symbol is used to indicate arrays and hash tables in PowerShell. If you want to include a literal @ symbol in a string, you can use the backtick (`) as an escape character.
• ( and ): Parentheses are used for grouping in PowerShell. If you want to include literal parentheses in a string, you can use the backtick (`) as an escape character.
• { and }: Curly braces are used for script blocks in PowerShell. If you want to include literal curly braces in a string, you can use the backtick (`) as an escape character.

Case-Sensitivity in PowerShell Strings

PowerShell strings are case-sensitive, meaning that uppercase and lowercase letters are treated differently. This can have implications when working with strings, as it can affect the results of string comparisons and searches.

To avoid this issue, it is important to be consistent with the case used in strings throughout the script. This can be achieved by using the ToLower() or ToUpper() methods to convert all strings to a consistent case before performing comparisons or searches.

It is also important to note that PowerShell provides the -cmatch and -cnotmatch operators, which perform case-sensitive regular expression matching. These operators can be useful when working with complex string patterns that require case sensitivity.

In summary, when working with PowerShell strings, it is important to be aware of their case-sensitivity and to use consistent casing throughout the script to avoid unexpected results.

String Comparison in PowerShell

Comparing strings in PowerShell is very useful for checking if two pieces of text are equivalent. Here are some common methods used for string comparison in PowerShell, along with real-world examples:

PowerShell’s comparison operators like -eq (equals) and -ne (not equals) are case-insensitive by default.

$enteredUsername = "JohnDoe"
$actualUsername = "johndoe"
$isValidUser = $enteredUsername -eq $actualUsername
# Outputs: True

For case-Sensitive Comparison, use: -ceq, -cne operators. The Compare method of the String class can compare two strings and is useful for sorting or understanding the order of strings.

$string1 = "apple"
$string2 = "banana"
# Compare strings (case-sensitive)
$result = [string]::Compare($string1, $string2)
$result # Outputs: -1 (meaning $string1 is less than $string2)

We can also use the String.Equals Method:

$string1 = "PowerShell"
$string2 = "powershell"
# Case-insensitive equality check
$result = $string1.Equals($string2, [StringComparison]::OrdinalIgnoreCase)
$result # Outputs: True

In the next section, we will explore the use of regular expressions in PowerShell for advanced string pattern matching and manipulation.

Working with Regular Expressions in PowerShell

Regular expressions are a powerful tool for pattern matching and manipulating strings in PowerShell. They allow us to search for specific patterns within a string, split strings into substrings based on a defined pattern, and replace parts of a string with new values. In PowerShell, regular expressions are implemented through the use of the -match, -replace, and -split operators, as well as the Select-String cmdlet. Let’s explore some common scenarios where regular expressions can be useful.

RegEx for Matching Strings

$email = "john@example.com"
if ($email -match "^[\w\.-]+@[\w\.-]+\.\w+$") { Write-Host "Valid email format"
}
else { Write-Host "Invalid email format"
}

This script checks the specified email address against this pattern, and then outputs a message indicating whether the email address is valid or not.

Splitting Strings with Regular Expressions

String splitting is another vital string manipulation technique in PowerShell. It enables dividing a single string into multiple substrings based on a specified delimiter or pattern. This technique is helpful when breaking down a large string into smaller, more manageable pieces, or extracting specific parts of a string.

This will output an array of strings “Hello” and “World”

Similarly, you can use the -split operator to split a string based on a regular expression or a string pattern. The -split operator allows us to split a string into an array of substrings based on a specified pattern. For instance, if we have a string that contains a list of names separated by different characters, we can use the -split operator with the pattern like this:

$string = "apples, oranges; bananas grapes"
# Split the string using the pattern
$fruitList = $string -split "\W+"
# Output the result
$fruitList

Using Replace Operator with RegEx

The -replace operator enables us to replace parts of a string that match a specified pattern with new values. For example, Here is a PowerShell script to replace all digits in a string with ‘#’ using regular expressions:

# Example: Replace all digits in a string with '#'
$string = "The date today is 12/13/2023 and my phone number is 123-456-7890."
$replacedString = $string -replace '\d', '#'
$replacedString

By mastering these techniques, you will have the necessary tools to format and manipulate strings in PowerShell, making your scripts more efficient and readable. Remember to experiment with different methods and explore the vast capabilities of PowerShell to further enhance your scripting skills.

Conclusion

In this comprehensive guide, we have covered the key aspects of PowerShell string operations, from basic manipulation to advanced techniques. Throughout this guide, we have explored the power of PowerShell in working with strings, including replacing, concatenating, formatting, and manipulating them. We have also delved into advanced operations such as joining multiple strings, combining strings with specific delimiters, and removing characters based on different criteria.

With the knowledge gained from this guide, you will be well-equipped to navigate the world of PowerShell scripting with confidence. Whether you are a beginner looking to enhance your skills or an experienced scripter seeking to master PowerShell, this guide has provided the information and techniques you need to succeed. By mastering PowerShell string operations and other concepts covered in this guide, you will elevate your scripting skills and become an expert in using PowerShell for automation and management tasks.

How do I get the parts of a string in PowerShell?

You can extract a substring after a specific character in PowerShell by using the Substring() method with the IndexOf() method. For example, you can use $FullString = “Hello, World!” to start extracting from character 5 and extract all characters from the given string.

How do I remove a substring from a string in PowerShell?

You can easily remove a substring from a string with “Replace()” method. E.g.,
$originalString = "Hello, World!"
$newString = $originalString.Replace("World", "")
If you need a case-sensitive replacement, you can use the -replace operator instead.

What is the difference between single and double quotes in PowerShell strings?

Double quoted strings in PowerShell allow variables to be substituted within them, whereas single quoted strings do not.

How can I work with regular expressions in PowerShell?

Regular expressions provide a powerful way to match and manipulate strings in PowerShell. You can use them for pattern matching, string splitting, and replacing by utilizing the appropriate PowerShell commands.

How to extract string in PowerShell?

How do you check a string contains a word in PowerShell?

How to concatenate strings in PowerShell?

How to replace a string in PowerShell?

How do I convert a string to an int in PowerShell?

Похожее:

Как найти файл по имя в power shell Освоение командной строки Как использовать регулярное выражение в power shell Power shell и его возможности в уходящем году