"Powershell; Seriously, more powerful "
Unquestionably so. Powershell passes objects, not just text for a start. You don't have to parse text to get your data back. With Powershell you won't need the analog of Perl, sed, and awk when the built-in shell functions reveal their limitations.
Here are some more detailed advantages:
The PowerShell object pipes allow for in-memory objects to be piped without the need for serialization/deserialization. With bash the tools must serialize to text and deserialize from text at each step in the pipeline.
Object pipes allow for filters and selections to be formulated using property syntax instead of tools referencing columns, field numbers etc.
Object pipes in PowerShell are strongly typed. Datetimes are handed over from one command to the next with out text serialization. In bash, text serialization is brittle and e.g. dates, numbers etc may be subject to different interpretation by commands depending on system locale.
PowerShell object-orientation allows for more terse commands concentrating a single purpose for each command, i.e. finding or producing objects and not offering control of output format. Output formatting in PowerShell is handled by separate commands (format cmdlets). Many commands in bash have extensive options for controlling output formatting, rarely coordinated between the commands.
PowerShell includes integrated remoting. Remote control in bash is handled using SSH.
PowerShell has been designed as a "hostable" engine - i.e. an application can host PowerShell and use it's scripting capabilities to manipulate/automate it's own in-memory objects. Several general and special purpose applications are using this. Visual Studio NuGet package manager, for instance, runs inside Visual Studio. Bash runs as a monolithic process, an application can *talk to* bash but not use it to manipulate objects of it's own process.
PowerShell commands (cmdlets), functions and scripts declare parameters and other properties which can be used by the shell to discover metadata about the commands. In bash, commands are "opaque" and no metadata can be gleaned from them.
PowerShell uses command metadata to automatically support completions and (in the ISE) even autosuggestions. Bash uses externally defined completions, i.e. completions only work for those commands for which metadata has been defined.
PowerShell uses command metadata to discover type information for parameters, validations etc. PowerShell performs validation and type coercion *prior* to invoking the command. This allows command authors to *declare* validations instead of *coding* them. In bash, validation metadata does not exist and types do not exist (everything is text). Bash always invokes the commands and leaves it to each command to perform validation.
PowerShell has a module concept allowing for self-contained and isolated modules to be distributed. bash does not have a module concept. In bash you will use script files/libraries instead of modules. Script libraries does not offer the same isolation (e.g. private global variables) as modules.
PowerShell has integrated risk management. Commands that may alter system state can be invoked with -WhatIf or -Confirm for simulated execution and confirmed execution, respectively. If you build a PowerShell script and invoke it with -WhatIf this "simulation" mode is set for the scope of the script as if every command was invoked with -WhatIf. Bash does not have shell-defined risk management. Individual commands may allow something similar to simulated or confirmed execution (it's rare).
PowerShell has resilient sessions, you can disconnect from a session and reconnect later or from another computer and continue with the same session, same variable state, same jobs etc. Bash does not have resilient sessions.
PowerShell has workflows: scripts that save their execution state regularly and can be suspended and resumed, even across system restarts. When the script is resumed that state of every variable is restored and the script continues as if it was never suspended, *even* on another machine. Bash scripts cannot automatically save their state to a durable medium and cannot continue if they were stopped or killed.
PowerShell scripts can branch out and execute in parallel. Bash scripts cannot branch out. Bash can use an external command such as GNU parallel to execute commands in parallel; but it cannot execute *the script* in parallel