I'm looking for a compact way to create multiple `List
```powershell
$list1 = [List[object]]::new();
$list2 = [List[object]]::new();
$list3 = [List[object]]::new();
```
However, I want a single line of code that can achieve the same result, but doesn't suffer from the pitfalls of incorrectly sharing a reference among all lists. For example, I've seen attempts where you might write something like this:
```powershell
$list1 = $list2 = $list3 = [List[object]]::new()
```
But that doesn't work as intended. Is there a trick to do this elegantly?
5 Answers
While that's a clever approach, remember you're actually just creating string variables. The correct syntax for creating the lists is:
```powershell
1..5 | %{ New-Variable -Name "list$_" -Value ([List[object]]::new()) }
```
That said, if you're handling a lot of dynamic code, consider using an array of lists or a hashtable instead—it's usually easier to manage. For example:
```powershell
$Lists = 1..5 | ForEach-Object {[System.Collections.Generic.List[System.Object]]::new()}
```
Then access it like `$Lists[0].Add("Something")`. This way, you have the objects properly instantiated without the mess of variable names.
You can definitely achieve this! Try using `New-Variable` inside a loop. Here’s a clean way to do it:
```powershell
1..5 | %{ New-Variable -Name "list$_" -Value [List[object]]::new() }
```
This method creates five separate list objects. Just keep in mind that if you're declaring new variables that already exist, you may need to add the `-Force` parameter. It’s a neat trick for keeping your code tidy!
Are you looking to work with a list of lists? If that's the case, make sure you know why you're structuring it this way!
Creating a string array of variable names and looping over them is one option, but it feels like there might be a cleaner design available. Just questioning if this complex setup is really necessary.
I appreciate the feedback! My goal is to create several lists without cluttering the code. If there's a way to streamline it as seen with arrays, that would be ideal. Ideally, I want something comparable to this array initialization:
```powershell
$a = $b = $c = @()
```
This keeps the code neat while achieving the desired functionality!
You could also create a hashtable to store the lists where the keys are the names you'd typically use. It might simplify the access later on, especially if you plan to reference these lists frequently. Just remember to choose clear keys for your hashtable!
That's a solid point! Using a hashtable can definitely keep things organized and intuitive. It lets you avoid issues with variable name conflicts as well.