Generieren von zufälligen Dateien in Windows

Question

Hat jemand eine Möglichkeit, Dateien von zufälligen Daten in Windows zu generieren? Ich möchte 50.000 kleine (2K) Dateien als Beispiel generieren.

Answer 1

Nun, technisch könnte man etwas schreiben, um dies für Sie zu tun.
Ich weiß nichts Bestimmtes .. aber der einfachste Weg wäre, eine TEXT-Datei einer bestimmten Größe (2K zum Beispiel) zu erstellen .. dann schreibe eine Batch-Datei, um es 50000-mal zu kopieren.

Answer 2

Sie müssen Dateien auf die normale Weise erstellen und sie dann mit zufälligen Daten füllen, wahrscheinlich von einer rand() - Funktion irgendeiner Art.

Es hängt wirklich von Ihrer Programmiersprache ab. Windows selbst wird diese Fähigkeit sicherlich nicht bieten.

Es gibt eine Reihe von Programmiersprachen, die dies jedoch problemlos tun könnten, einschließlich einfacher Windows Batch/CMD-Skripte. Welche Sprache interessiert Sie?

Answer 3

Wie wäre es etwa so: Random File Generator 1.1

Oder File generator

Answer 4

Sie können fsutil in einer Batch-Schleife laufen Dateien beliebiger Größe zu erstellen.

fsutil file createnew filename.extension 2000 

Answer 5

Da Sie keine Sprache angeben, wähle ich einfach eine zufällig aus. Hier ist ein Powershell-Skript, um es zu tun:

$rootDir = 'C:\Temp\TestRandomFiles\' 
$baseFile = $rootDir + "base.txt" 
$desiredFileSize = 2*1KB 
$fileCount = 50000 
"start" | Out-File -Filepath $baseFile 
While ($(Get-ChildItem -path $baseFile).Length -lt $desiredFileSize) 
{ 
    $(Get-ChildItem -path $baseFile).Length | Out-File $baseFile -APPEND 
} 
for($i=1;$i -lt $fileCount;$i++) 
{ 
    Copy-Item $baseFile "File$i.txt" 
} 

Sie müssen die Variablen auf die Parameter ändern, die Sie natürlich wollen.

Answer 6

Ich habe Random Data File Creator verwendet und mag es, es erstellt Binärdateien (d. H. Keine Textdateien) gefüllt mit Pseudozufallsbits, es kann schnell sehr große Dateien erstellen. Um es zu verwenden, um mehrere kleine Dateien zu erstellen, müssten Sie es skripten, was sehr einfach wäre, da es eine Befehlszeile ist.

Answer 7

Sie können Powershell verwenden für Ihre Dateien billige Zufallsdaten zu generieren:

[Byte[]] $out = @() 
0..2047 | % {$out += Get-Random -Minimum 0 -Maximum 255} 
[System.IO.File]::WriteAllBytes("myrandomfiletest", $out) 

Dieser einen Algorithmus mit einem Samen aus dem Systemtakt genommen verwendet, so kann dies nicht für jeden ernsthaften Verschlüsselungsanwendungen verwendet werden.

Beachten Sie außerdem die Leistungseinbußen von Get-Random, wenn Sie die Größe der Ausgabedatei erhöhen. Mehr zu diesem Aspekt hier:

• PowerShell random file generator too slow
• Improve Powershell Performance to Generate a Random File

Answer 8

Ja, fsutil ist groß, aber erzeugt keine Zufallsdaten, nur ASCII-Nullen.

Ich erinnere mich nicht, wo ich in diesen Tagen diese aber die Suche auf Google finden kann ich es finden noch: http://www.private-files.com/other/random.c.txt

Ich weiß nicht, wie alt dieses Programm, sondern als Frage mindestens so alt ist, wahrscheinlich etwas älter.

Wie dem auch sei hier ein Programm in C ist, die Dateien mit einem Chi-Quadrat-Testergebnis von 0 erstellt:

// ------------------------------------------------------------  
// Name: random.c (program to create random files) 
//  
// This "no-frills" program creates files with the following 
// characteristics: 
// 
// (1) Byte sequences are random (no predictability); 
// (2) Files produced are binary files; 
// (3) File sizes are multiples of 256; 
// (4) Files will have a chi-squared test result of 0 
//  (see analyze.exe by Wenger for explanation) 
// 
//    Programmer: Scott Wenger 
//       Box 802 
//       Stevens Point, WI 54481 
//       panther@wctc.net 
// 
//  Note: part of this code is from Knuth Volume II 
// 
// Enhancements and modifications of this program are left 
// to the imagination and creativity of the programmer. 
// Check your compiler for required header files. You may 
// need to include the iostream header. 
// 
// Random files are of potential use to cryptographers 
// for the purpose of encryption. 
// 
// To analyze files produced by this program, see 
// the analyze.exe program by Scott Wenger (found at 
// http://www.coredcs.com/sware.html) 
// ------------------------------------------------------------ 


// This program works in the following way: 
// The time is used to seed the random number generator. 
// Using Knuth's algorithm, random numbers are generated 
// in the range of 0 to 255 (corresponding to 256 ASCII chars.) 
// When random numbers are generated they are marked as used and 
// are not re-used until all 256 ASCII values appear. Characters 
// are written to disk and the process continues until the 
// desired file size is reached. Output is a random binary file 
// called random.bin (placed in the root directory) 
// The controlled filesize along with the placeholder feature 
// of this code forces a very high degree of randomness in 
// the output file. 

#include <time.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

void init_mm(); 
void clear_array(); 
int number_range(int minval, int maxval); 
int number_mm(); 

static int rgiState[2 + 55]; 
int place_holder[256];   // to keep track of numbers already generated 

int main() 
{ 
    mainprogram(); 
    return 0; 
} 

int mainprogram() 
{ 
    int ch; 
    int c_used = 0; // counter of chars in placeholder 
    int done = 0; 
    int random; 

    char buffer[2]; 

    long x; 
    long byte_size = 0L; 
    FILE *fp; 

    clear_array(); 
    init_mm(); // seed random number generator 

    // create a random file of length specified by user 
    printf("\nrandom.exe originally by Scott Wenger"); 
    printf("\nThis program creates a random binary file.\n"); 
    printf("\nPlease specify length of random file to create (in megabytes): "); 

    scanf("%ld", &byte_size); 

    while (byte_size > 1000 || byte_size <= 0) 
    { 
    printf("\nWill not create files larger than a gigabyte! "); 
    printf("\nPlease specify length of random file to create (in megabytes): "); 
    flushall(); 
    scanf("%ld", &byte_size); 
    } 

    byte_size = byte_size * 1024 * 1024; 

    if ((fp = fopen("random.bin", "wb")) == NULL) { 
    fprintf(stderr, "\nOutput file (random.bin) could not be created.");  
    fflush(stdout); 
    exit(1); 
    } 

    for (x = 0L; x < byte_size; x++) { 

    if (c_used == 256) { 
     clear_array(); 
     c_used = 0; 
    } 

    random = number_range(0, 255); // use all ASCII values 

    if (*(place_holder + random)) { // already used, find another 
     done = 0; 
     while (!done) { 
     random = number_range(0, 255); 
     if (*(place_holder + random) == 0) { 
      *(place_holder + random) = 1; 
      done = 1; 
     } 
     }   
    } 
    else *(place_holder + random) = 1; // use it and mark as used 

    c_used++; // found next character so increment counter 

    sprintf(buffer, "%c", random); // convert ASCII value to char 
    ch = buffer[0]; 
    fputc(ch, fp); // write to file 
    } 

    fclose(fp); 

    printf("\nDone. File \"random.bin\" was created (size: %ld bytes)", byte_size); 
    printf("\nOutput file is in the root directory (c:\\random.bin)\n"); 
    return(0); 
} 

// --------------------------------------------------------------------------------- 

void clear_array() 
{ 
    register int x; 
    for (x = 0; x < 256; x++) 
    *(place_holder + x) = 0; 
} 

// --------------------------------------------------------------------------------- 

int number_mm() 
{ 
    int *piState; 
    int iState1; 
    int iState2; 
    int iRand; 

    piState  = &rgiState[2]; 
    iState1  = piState[-2]; 
    iState2  = piState[-1]; 
    iRand  = (piState[iState1] + piState[iState2]) 
       & ((1 << 30) - 1); 
    piState[iState1] = iRand; 

    if (++iState1 == 55) iState1 = 0; 
    if (++iState2 == 55) iState2 = 0; 

    piState[-2]  = iState1; 
    piState[-1]  = iState2; 

    return(iRand >> 6); 
} 

// --------------------------------------------------------------------------------- 

// Generate a random number. 

int number_range(int minval, int maxval) 
{ 
    int power, number; 

    if ((maxval = maxval - minval + 1) <= 1) return (minval); 

    for (power = 2; power < maxval; power <<= 1) 
    ; 
    while ((number = number_mm() & (power - 1)) >= maxval) 
    ; 
    return(minval + number); 
} 

// --------------------------------------------------------------------------------- 

// Mitchell-Moore algorithm from Knuth Volume II. 

void init_mm() 
{ 
    int *piState; 
    int iState; 

    piState = &rgiState[2]; 
    piState[-2] = 55 - 55; 
    piState[-1] = 55 - 24; 
    piState[0] = ((int) time(NULL)) & ((1 << 30) - 1); 
    piState[1] = 1; 

    for (iState = 2; iState < 55; iState++) 
    { 
    piState[iState] = (piState[iState-1] + piState[iState-2]) 
         & ((1 << 30) - 1); 
    } 
} 

// -------------------- End ------------------------------------------------------- 

Answer 9

Statt Get-Random der Verwendung des Textes als pro user188737 & mguassa Vorschläge zu erzeugen, ich verbesserte sich die Geschwindigkeit durch Verwendung von GUIDs.

Function New-RandomFile { 
    Param(
     $Path = '.', 
     $FileSize = 1kb, 
     $FileName = [guid]::NewGuid().Guid + '.txt' 
     ) 
    (1..($FileSize/128)).foreach({-join ([guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid -Replace "-").SubString(1, 126) }) | set-content "$Path\$FileName" 
} 

Dies dauerte 491 Millisekunden, um eine 1 MB-Datei zu generieren. Laufen:

New-RandomFile -FileSize 1mb 

UPDATE:

Ich habe meine Funktion aktualisiert, um eine Script zu verwenden, so dass Sie die ersetzen können 'NewGuid()' Methode mit, was Sie wollen.

In diesem Szenario mache ich 1kb Chunks, da ich weiß, dass ich nie kleinere Dateien erstellen. Dies hat die Geschwindigkeit meiner Funktion drastisch verbessert!

Set-Content erzwingt am Ende eine NewLine, weshalb Sie bei jedem Schreiben in die Datei 2 Zeichen entfernen müssen. Ich habe es stattdessen mit [io.file] :: WriteAllText() ersetzt.

Function New-RandomFile_1kChunks { 
    Param(
     $Path = (Resolve-Path '.').Path, 
     $FileSize = 1kb, 
     $FileName = [guid]::NewGuid().Guid + '.txt' 
     ) 

    $Chunk = { [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid -Replace "-" } 

    $Chunks = [math]::Ceiling($FileSize/1kb) 

    [io.file]::WriteAllText("$Path\$FileName","$(-Join (1..($Chunks)).foreach({ $Chunk.Invoke() }))") 

    Write-Warning "New-RandomFile: $Path\$FileName" 

} 

Wenn Sie sich nicht interessieren, dass alle Stücke sind zufällig, können Sie einfach Invoke() die Erzeugung des 1kb Brocken einmal .. Dies verbessert die Geschwindigkeit drastisch, aber nicht die gesamte Datei zufällig machen.

Function New-RandomFile_Fast { 
    Param(
     $Path = (Resolve-Path '.').Path, 
     $FileSize = 1kb, 
     $FileName = [guid]::NewGuid().Guid + '.txt' 
     ) 

    $Chunk = { [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + 
       [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid + [guid]::NewGuid().Guid -Replace "-" } 
    $Chunks = [math]::Ceiling($FileSize/1kb) 
    $ChunkString = $Chunk.Invoke() 

    [io.file]::WriteAllText("$Path\$FileName","$(-Join (1..($Chunks)).foreach({ $ChunkString }))") 

    Write-Warning "New-RandomFile: $Path\$FileName" 

} 

Measure-Command all diese Veränderungen eine 10MB-Datei generieren:

Ausführen von New-RandomFile: 35,7688241 Sekunden.

Ausführen von New-RandomFile_1kChunks: 25.1463777 Sekunden.

Ausführen von New-RandomFile_Fast: 1.1626236 Sekunden.

Answer 10

Sie können VBA in Excel verwenden, wenn Sie auf dem Computer, auf dem Sie sich befinden, eingeschränkte Berechtigungen haben. Dies würde txt-Dateien zu der Nummer erzeugen, die mit Zufallszahlen benötigt wird. Wahrscheinlich nicht die schnellste Möglichkeit, dies zu tun.

Sub rndcreate() 

Application.ScreenUpdating = False 
Application.DisplayAlerts = False 

Dim sbook As Workbook 
Dim i As Double 
Dim upperbound, lowerbound, totalentries, totalfiles As Integer 
Dim x, folder, file As String 

'Set output location 

folder = "C:\test\" 

'Number of files created and entries in files as below 

totalfiles = 1 
totalentries = 150 
upperbound = 99999 
lowerbound = 1 

For p = 1 To totalfiles 

'Add new workbook to populate with data 

Set sbook = Workbooks.Add 

'Set file name 

file = "randomdatafile" & p 

For i = 1 To totalentries 

    'Randomly created integers between your two bounds 

    x = ((upperbound - lowerbound + 1) * Rnd + lowerbound) 

    Range("A" & i) = x 

Next 

ActiveWorkbook.SaveAs Filename:=folder & file & ".txt", FileFormat:=xlTextWindows 
ActiveWorkbook.Close 

Next 

End Sub 

Answer 11

One-Liner in Powershell:

$out = new-object byte[] 1048576; (new-object Random).NextBytes($out); [IO.File]::WriteAllBytes('d:\file.bin', $out) 

Dies ist blitzschnell, im Vergleich zu @ user188737 Lösung.