Создание случайных файлов в Windows

Ответ 1

Вы можете запустить fsutil в пакетном цикле для создания файлов любого размера.

fsutil file createnew filename.extension 2000

Ответ 2

Я использую Random File File Creator и по своему вкусу создает двоичные файлы (т.е. не текстовые файлы), заполненные псевдослучайным бит, он может быстро создавать очень большие файлы. Чтобы использовать его для создания нескольких небольших файлов, вам понадобится script, что было бы очень легко, так как это командная строка.

Ответ 3

Вы можете использовать PowerShell для генерации дешевых случайных данных для ваших файлов:

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

Это использует алгоритм с семенем, взятым из системных часов, поэтому не используйте его для ЛЮБЫХ серьезных криптографических приложений.

Кроме того, будьте осторожны при ухудшении производительности Get-Random при увеличении размера выходного файла. Подробнее об этом здесь:

• Генератор случайных файлов PowerShell слишком медленный
• Улучшить Powershell Производительность для создания случайного файла

Ответ 4

Поскольку вы не укажете язык, я просто возьму его в случайном порядке. Для этого сделайте это: script:

$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"
}

Вам нужно будет изменить переменные на нужные вам параметры.

Ответ 5

Вам придется создавать файлы обычным способом, а затем заполнять их рандомизированными данными, возможно, из какой-либо функции rand().

Это зависит от вашего языка программирования. Сама Windows, конечно же, не обеспечит эту возможность.

Существует ряд языков программирования, которые могли бы легко сделать это, включая базовые сценарии пакетного/CMD-окна. На каком языке вас интересует использование?

Ответ 6

Один слой в Powershell:

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

Это молниеносно, по сравнению с решением @user188737.

Ответ 7

Как насчет чего-то вроде этого: Генератор случайных файлов 1.1

Или Генератор файлов

Ответ 8

Вместо того, чтобы использовать Get-Random для генерации текста в соответствии с предложениями user188737 и mguassa, я улучшил скорость с помощью GUID.

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"
}

Это потребовало 491 миллисекунды для создания файла размером 1 МБ. Продолжительность:

New-RandomFile -FileSize 1mb

UPDATE:

Я обновил свою функцию, чтобы использовать ScriptBlock, поэтому вы можете заменить метод NewGuid() на что угодно.

В этом случае я делаю 1kb куски, так как знаю, что я никогда не создаю файлы меньшего размера. Это значительно улучшило скорость моей функции!

Set-Content заставляет NewLine в конце, поэтому вам нужно удалить 2 символа каждый раз, когда вы пишете файл. Вместо этого я заменил его на [io.file]:: WriteAllText().

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"

}

Если вы не заботитесь о том, чтобы все куски были случайными, вы можете просто вызвать() генерацию 1kb куска один раз.. это значительно улучшает скорость, но не сделает весь файл случайным.

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 все эти изменения для создания файла 10mb:

Выполнение нового-RandomFile: 35.7688241 секунд.

Выполнение New-RandomFile_1kChunks: 25.1463777 секунд.

Выполнение нового-RandomFile_Fast: 1,1626236 секунд.

Ответ 9

Ну, технически вы могли бы написать что-то для этого. Я не знаю ничего конкретного. Но самым простым способом было бы создать файл TEXT определенного размера (например, 2K). Затем напишите командный файл, чтобы скопировать его 50000 раз.

Ответ 10

Да, fsutil отлично, но не генерирует случайные данные, а только ASCII-нули.

Я не помню, где я нашел это, но искал в Google в эти дни, я все еще могу найти его по адресу: http://www.private-files.com/other/random.c.txt

Я не знаю, сколько лет эта программа, но, по крайней мере, такая же старая, как ваш вопрос, возможно, несколько старше.

В любом случае здесь программа на C, которая создает файлы с хи-квадратом результата теста 0:

// ------------------------------------------------------------     
// 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
//                           [email protected]
//
//       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 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 -------------------------------------------------------

Ответ 11

Вы можете использовать VBA в excel, если у вас ограниченные разрешения на компьютере, на котором вы находитесь. Это создало бы txt файлы для числа, необходимого для случайных чисел. Наверное, это не самый быстрый способ этого сделать.

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