V (lenguaje de programación)

V tiene políticas para facilitar la seguridad de la memoria, la velocidad y el código seguro, ^{[ 14 ] [ 20 ] [ 6 ]} incluyendo varias características predeterminadas para una mayor seguridad del programa. ^{[ 7 ] [ 14 ] [ 12 ]} Emplea comprobación de límites , para protegerse contra el uso fuera de límites de variables . Se utilizan tipos de opción/resultado , donde el tipo de datos de opción ( ?) puede representarse por none(entre las opciones posibles) y el tipo de resultado ( !) puede manejar cualquier error devuelto. Para garantizar una mayor seguridad, la comprobación de errores es obligatoria. Por defecto, los siguientes son inmutables : variables, estructuras y argumentos de función . Esto incluye valores de cadena que son inmutables, por lo que los elementos no pueden ser mutados. Otras protecciones, que son el valor predeterminado del lenguaje, son: no usar valores indefinidos , sombra de variables , punteros nulos (a menos que estén marcados como inseguros) o variables globales (a menos que estén habilitadas mediante un indicador).

V utiliza tipos de valor y búferes de cadena para reducir las asignaciones de memoria. ^{[ 21 ] [ 22 ] [ 14 ]} El lenguaje se puede compilar a C legible por humanos , ^{[ 7 ] [ 4 ]} y en ejecución y compilación, se considera rápido. ^{[ 14 ] [ 15 ] [ 12 ]}

V admite cuatro opciones de administración de memoria: ^{[ 23 ] [ 6 ] [ 12 ] [ 4 ]}

1. Un recolector de basura . Esta es la opción predeterminada.
2. Gestión manual de la memoria mediante la desactivación del recolector de basura.
3. Autofree, que es experimental, sirve para invocar las llamadas necesarias para liberar automáticamente los objetos durante la compilación.
4. Asignación de arena .

V admite un compilador de código fuente a código fuente (transpilador) y puede traducir código C a V. ^{[ 15 ] [ 24 ] [ 10 ]}

También se están desarrollando traductores funcionales para Go, JavaScript y WebAssembly . ^{[ 25 ] [ 26 ] [ 4 ]}

El programa "Hola, mundo!" en V: ^{[ 14 ] [ 27 ]}

fn main () { println ( "Hola, mundo!" ) }

Las variables son inmutables por defecto y se definen usando :=y un valor. Use la mutpalabra reservada (palabra clave) para hacerlas mutables. Las variables mutables se pueden asignar usando =: ^{[ 28 ] [ 27 ]}

x : = 1 mut y : = 2 y = 3

No está permitido volver a declarar una variable, ya sea en un ámbito interno o en el mismo ámbito: ^{[ 28 ] [ 27 ]}

x : = 1 { x : = 3 // error: redefinición de x } x : = 2 // error: redefinición de x

Ejemplo de estructura: ^{[ 9 ] [ 7 ] [ 27 ]}

struct Foo { número int nombre cadena puntuación f32 }// Los campos de la estructura se pueden inicializar por nombre var1 : = Foo { number : 21 name : "baz" score : 2.5 }// o por posición var2 : = Foo { 50 , "taz" , 3.14 }

Por defecto, las estructuras se asignan mediante asignación de memoria basada en la pila (en la pila). Cuando las estructuras se referencian mediante el prefijo &o tienen el [heap]atributo, se asignan mediante asignación de memoria basada en el montón (en el montón) en su lugar: ^{[ 4 ] [ 27 ]}

struct Foo { número int }@ [ montón ] struct Baz { número f32 }// Las estructuras a las que se hace referencia se asignan en el montón var1 : = & Foo { 2 }// Baz siempre se asigna en el montón debido a su atributo [heap] var2 : = Baz { 4.5 }

En V, los métodos son funciones definidas con un argumento receptor . El receptor aparece en su propia lista de argumentos, entre la fnpalabra clave y el nombre del método. Los métodos deben estar en el mismo módulo que el tipo de receptor.

El método enrolled_status (abajo) tiene un receptor de tipo Clientllamado x. La convención es no usar nombres de receptor como self o this, sino preferiblemente un nombre corto. Por ejemplo: ^{[ 9 ] [ 10 ] [ 27 ]}

struct Cliente { inscrito bool }fn ( x Cliente ) estado_inscrito () bool { return x . inscrito }cliente_1 : = Cliente { verdadero } cliente_2 : = Cliente { falso }println ( cliente_1.estado_inscrito ()) // "verdadero" println ( cliente_2.estado_inscrito ( ) ) // "falso "

Los tipos de resultado pueden representar un error devuelto por una función. Los tipos de resultado se declaran anteponiendo !:!Type

Los tipos opcionales pueden representar none. Los tipos opcionales anteponen ?al nombre del tipo: ?Type. ^{[ 9 ] [ 7 ] [ 23 ] [ 27 ]}

fn algo ( t cadena ) ! cadena { si t == "foo" { devolver "foo" } devolver error ( "inválido" ) }x : = algo ( "foo" ) o { "default" } // x será "foo" y : = algo ( "baz" ) o { "default" } // y será "default" z : = algo ( "baz" ) o { panic ( "{err}" ) } // z saldrá con un errorprintln ( x ) println ( y )