Lección 2: Variables

En Emacs Lisp (Elisp), puedes definir y usar cualquier número de variables. Sin embargo, es importante tener en cuenta que algunas variables son utilizadas internamente por Emacs y no deben ser modificadas por el usuario. Algunas de las variables más comunes que puedes encontrar al programar en Elisp son:

• Variables globales: pueden ser accedidas desde cualquier parte del programa
• Variables locales: solo pueden ser accedidas en el ámbito actual
• Variables dinámicas: pueden ser vinculadas y desvinculadas dinámicamente en el ámbito actual
• Constantes: son similares a las variables, pero no pueden ser modificadas una vez definidas

Además, Emacs Lisp también tiene algunas variables predefinidas que proporcionan información sobre la ejecución del programa, como buffer-file-name (nombre del archivo en el búfer actual), emacs-version (versión de Emacs instalada) y load-path (lista de rutas donde Emacs busca archivos Elisp).

• defvar: se utiliza para definir una variable global y opcionalmente le asigna un valor inicial si aún no está definida. Por ejemplo:

   (defvar my-global-variable "initial value")
  

  Esta expresión define la variable my-global-variable con el valor "initial value" si no había sido definida previamente.

• setq: se utiliza para asignar un nuevo valor a una variable existente. Por ejemplo:

  (setq my-global-variable "new value")
  

  Esta expresión cambia el valor de my-global-variable de "initial value" a "new value".

• defconst: se utiliza para definir una constante global y debe tener un valor inicial. Por ejemplo:

  (defconst pi 3.1415926)
  

  Esta expresión define la constante pi con el valor 3.1415926.

• let: se utiliza para definir variables locales dentro de un ámbito determinado. Por ejemplo:

  (let ((my-local-variable 42))
    (message "The value is %s" my-local-variable))
  

  Esta expresión define my-local-variable con el valor 42 dentro del ámbito de la expresión let, y luego muestra el mensaje "The value is 42".

Ten en cuenta que el uso de defvar y setq para variables globales debe ser cuidadoso, ya que puede ser fácil sobreescribir accidentalmente las variables de otro paquete o biblioteca de terceros. Es importante evitar asignar valores a variables globales sin necesidad y siempre utilizar nombres distintivos para evitar conflictos. Si solo necesitas una variable temporal o local puedes usar let para evitar colisiones en nombres de varibles.

provide en un archivo de Emacs Lisp puede ayudar a prevenir la sobrescritura accidental de variables globales o funciones en otros paquetes o bibliotecas.

Cuando un paquete se carga con require, Emacs comprueba si el archivo del paquete contiene una llamada al comando provide. Si es así, el nombre proporcionado por provide se registra internamente en Emacs como el identificador del paquete actual, de modo que otros paquetes puedan comprobar si el paquete actual ya ha sido cargado. Además, esto también sirve como una señal para otros paquetes de que el paquete actual proporciona ciertas funcionalidades y no debe intentar sobrescribirlas.

Por ejemplo, si en tu archivo de Emacs Lisp my-package.el defines la función my-function y la variable my-variable, podrías utilizar provide de la siguiente manera:

(defvar my-variable "initial value")

(defun my-function ()
  (interactive)
  ;; Implementación de my-function
  )

(provide 'my-package)

En este caso, provide indica que el paquete proporciona las funcionalidades definidas en el archivo my-package.el y que no deben ser sobrescritas por otros paquetes. De esta manera, puedes evitar conflictos en nombres de variables y funciones entre paquetes y bibliotecas.

Tipos

;; bool
(stringp "Am I a string?") ;; t es True y nil es False

;; Obtener tipo
(type-of 12)

eq ;; Son el mismo objeto?
eql ;; Son el mismo objeto o número
equal ;; Son parámetros equivalentes

(setq mi-valor '(1 2 3))

(eq 1 1) ;; t
(eq 3.1 3.1) ;; nil, no son iguales a nivel binario
(eq "texto" "texto") ;; nil
(eq '(1 2 3) '(1 2 3)) ;; nil
(eq mi-valor mi-valor) ;; t

(eql 1 1) ;; t
(eql 3.1 3.1) ;; t
(eql "texto" "texto") ;; nil
(eql '(1 2 3) '(1 2 3)) ;; nil
(eql mi-valor mi-valor) ;; t

(equal 1 1) ;; t
(equal 3.1 3.1) ;; t
(equal "texto" "texto") ;; t
(equal '(1 2 3) '(1 2 3)) ;; t
(equal mi-valor mi-valor) ;; t

;; Dos tipos de números

;; Enteros
1

;; Decimal
3.1415

Predicates

(integerp 1) ; t
(integerp 1.0) ; nil
(integerp "Juan") ; nil

(floatp 1.0) ; t
(floatp 1) ; nil
(floatp "Juan") ; nil

(stringp "Juan") ; t
(stringp 1) ; nil
(stringp 1.0) ; nil

(numberp 1) ; t
(numberp 1.0) ; t
(numberp "Juan") ; nil

(zerop 0) ; t
(zerop 1) ; nil

Caracteres

Son solo números.

?A ;; 65
?a ;; 97

?\n ;; 10
?\C-a ;; 1
?\M-a ;; 225

;; Unicode characters

?\u00e4 ;; 228

;; Character equals

(= ?a ?a) ;; t
(= ?a ?b) ;; nil
(= ?a 97) ;; t

(char-equal ?a ?a) ;; t
(char-equal ?a ?b) ;; nil

;; Ignore case
;; case-fold-search
(setq case-fold-search nil)

(= ?a ?A) ;; nil

(setq case-fold-search t)

(= ?a ?A) ;; t

Comentarios

{{ comments.length }} comentarios

Nuevo comentario

Nueva replica  {{ formatEllipsisAuthor(replyComment.author) }}

Acepto la política de Protección de Datos.

Publicar ¡Publicado! ¡Ups! Algo ha fallado, ¿Reintentamos? Enviando...

Escribe el primer comentario